/*

 * Copyright (c) 2002, 2018, Oracle and/or its affiliates. All rights reserved.

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

 *

 * This code is free software; you can redistribute it and/or modify it

 * under the terms of the GNU General Public License version 2 only, as

 * published by the Free Software Foundation.

 *

 * This code is distributed in the hope that it will be useful, but WITHOUT

 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

 * version 2 for more details (a copy is included in the LICENSE file that

 * accompanied this code).

 *

 * You should have received a copy of the GNU General Public License version

 * 2 along with this work; if not, write to the Free Software Foundation,

 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

 *

 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

 * or visit www.oracle.com if you need additional information or have any

 * questions.

 */

package nsk.share;

import java.io.*;

import java.lang.reflect.Method;

import java.util.*;

/**

 * Class used as an agent for Java serviceability reliability testing (RAS).

 * It sets different RAS options and/or modes for a special agent which

 * actually performs the specified RAS testing.<br>

 * The agent recognizes arguments, started with ''<code>-ras.</code>''. They

 * may be as follows:<p>

 * <li><code>-ras.help</code> - print usage message and exit

 * <li><code>-ras.verbose</code> - verbose mode

 * <li><code>-ras.invoke_run</code> - invoke the method <i>run(String[],PrintStream)</i>

 * of the test instead of <i>main(String[])</i> which is invoked by default.

 * <li><code>-ras.hotswap=&lt;stress_level&gt;</code> - enable JVMTI hotswap of

 * the currently running test classes. Here are the possible HotSwap stress

 * levels:<br>

 * 0 - HotSwap off<br>

 * 2 - HotSwap tested class in every JVMTI method entry event of running test

 * (default mode)<br>

 * 20 - HotSwap tested class in every JVMTI method entry event of every class<br>

 * 3 - HotSwap tested class in every JVMTI single step event of running test<br>

 * 4 - HotSwap tested class in every JVMTI exception event of running test<br>

 * 40 - HotSwap tested class in every JVMTI exception event of every class<p>

 */

public class RASagent {

    static final int HOTSWAP_OFF = 0;

    static final int HOTSWAP_EVERY_METHOD_ENTRY = 2;

    static final int HOTSWAP_EVERY_METHOD_ENTRY_FOR_EVERY_CLASS = 20;

    static final int HOTSWAP_EVERY_SINGLE_STEP = 3;

    static final int HOTSWAP_EVERY_EXCEPTION = 4;

    static final int HOTSWAP_EVERY_EXCEPTION_FOR_EVERY_CLASS = 40;

    // path to the directory with class files of the invoked test

    static String clfBasePath = null;

    private static boolean verbose = false;

    private static PrintStream out;

    native static int setHotSwapMode(boolean vrb, int stress_lev,

        String shortName);

    public static void main(String argv[]) {

        System.exit(run(argv, System.out) + Consts.JCK_STATUS_BASE);

    }

    public static int run(String argv[], PrintStream out) {

        return new RASagent().runThis(argv, out);

    }

    private int runThis(String argv[], PrintStream out) {

        int skipArgs = 1; // number of arguments which must be skipped

                          // for the invoked test

        boolean invokeRun = false; // invoke the method "main" by default

        int hotSwapMode = HOTSWAP_EVERY_METHOD_ENTRY; // HotSwap default stress level

        int res;

        String hotSwapModeName = "HOTSWAP_EVERY_METHOD_ENTRY";

        RASagent.out = out;

        if (argv.length != 0) {

            // parse arguments for the RASagent and then skip them

            while(argv[skipArgs-1].startsWith("-ras.")) {

                if (argv[skipArgs-1].equals("-ras.verbose")) {

                    verbose = true;

                } else if (argv[skipArgs-1].equals("-ras.help")) {

                    printHelp();

                    return Consts.TEST_FAILED;

                } else if (argv[skipArgs-1].equals("-ras.invoke_run")) {

                    invokeRun = true;

                } else if (argv[skipArgs-1].startsWith("-ras.hotswap=")) {

                    try {

                        hotSwapMode = Integer.parseInt(

                           argv[skipArgs-1].substring(argv[skipArgs-1].lastIndexOf("=")+1));

                    } catch (NumberFormatException e) {

                        e.printStackTrace();

                        out.println("\nERROR: RASagent: specified HotSwap mode \""

                            + hotSwapMode + "\" is not an integer");

                        printHelp();

                        return Consts.TEST_FAILED;

                    }

                    switch(hotSwapMode) {

                        case HOTSWAP_EVERY_METHOD_ENTRY:

                            hotSwapModeName = "HOTSWAP_EVERY_METHOD_ENTRY";

                            break;

                        case HOTSWAP_EVERY_METHOD_ENTRY_FOR_EVERY_CLASS:

                            hotSwapModeName = "HOTSWAP_EVERY_METHOD_ENTRY_FOR_EVERY_CLASS";

                            break;

                        case HOTSWAP_EVERY_SINGLE_STEP:

                            hotSwapModeName = "HOTSWAP_EVERY_SINGLE_STEP";

                            break;

                        case HOTSWAP_EVERY_EXCEPTION:

                            hotSwapModeName = "HOTSWAP_EVERY_EXCEPTION";

                            break;

                        case HOTSWAP_EVERY_EXCEPTION_FOR_EVERY_CLASS:

                            hotSwapModeName = "HOTSWAP_EVERY_EXCEPTION_FOR_EVERY_CLASS";

                            break;

                        default:

                            out.println("\nERROR: RASagent: specified HotSwap mode \""

                                + hotSwapMode + "\" is unrecognized");

                            printHelp();

                            return Consts.TEST_FAILED;

                    }

                }

                skipArgs++;

            }

            String shortTestName = getTestNameAndPath(argv[skipArgs-1]);

            display("\n#### RASagent: setting hotswap mode \""

                + hotSwapModeName + "\" for class \""

                + shortTestName + "\" ...");

            if ((res = setHotSwapMode(verbose, hotSwapMode, shortTestName)) != 0) {

                out.println("\nERROR: RASagent: unable to set HotSwap stress level for \""

                    + shortTestName + "\", exiting");

                return Consts.TEST_FAILED;

            }

            display("\n#### RASagent: ... setting hotswap mode done");

            try {

                Class testCls = Class.forName(argv[skipArgs-1]);

                display("\n#### RASagent: main class \""

                    + testCls.toString() + "\" loaded");

                // copy arguments for the invoked test

                String args[] = new String[argv.length-skipArgs];

                System.arraycopy(argv, skipArgs, args, 0, args.length);

                // invoke the test

                if (invokeRun)

                    return invokeRunMethod(testCls, args);

                else

                    return invokeMainMethod(testCls, args);

            } catch(ClassNotFoundException e) {

                // just pass: the invoked test is already a RAS specific one

                out.println("\nWARNING: the test was not really run due to the following error:"

                    + "\n\tunable to get the Class object for \""

                    + argv[skipArgs-1] + "\"\n\tcaught: " + e);

                return Consts.TEST_PASSED;

            }

        } else {

            out.println("\nERROR: RASagent: required test name is absent in parameters list");

            return Consts.TEST_FAILED;

        }

    }

    /**

     * Verify that test's class file exists with a path given as a parameter

     * and, if so, store that path in the static field "clfBasePath".

     */

    private boolean pathValid(String pathToCheck, String testName) {

        String fullPath = pathToCheck + File.separator

            + testName.replace('.', File.separatorChar) + ".class";

        File classFile = null;

        display("\n#### RASagent: verifying class path\n<RASagent>\t"

            + pathToCheck + " ...");

        try {

            classFile = new File(fullPath);

        } catch (NullPointerException e) {

            e.printStackTrace();

            out.println("\nERROR: RASagent: verification of class file "

                + fullPath + " failed: caught " + e);

            System.exit(Consts.JCK_STATUS_BASE + Consts.TEST_FAILED);

        }

        if (classFile.exists()) {

            clfBasePath = pathToCheck;

            display("<RASagent>\tthe class file exists:\n<RASagent>\t\t"

                + fullPath + "\n<RASagent>\tclass file base directory found:\n"

                + "<RASagent>\t\t" + clfBasePath

                + "\n#### RASagent: ... class path verification done\n");

            return true;

        }

        else {

            display("<RASagent>\tno class file at location :\n\t\t"

                + fullPath

                + "\n#### RASagent: ... class path verification done\n");

            return false;

        }

    }

    /**

     * Get short name of an invoked test (i.e. without package name) and

     * store path to the directory with the test's class files.

     */

    private String getTestNameAndPath(String testName) {

        String shortTestName = testName;

        String packageName = "";

        // if '.' occurs, it means that current test is inside a package

        if (testName.lastIndexOf(".") != -1) {

            shortTestName = testName.substring(testName.lastIndexOf(".")+1);

            packageName = testName.substring(0, testName.lastIndexOf("."));

        }

        StringTokenizer clPathes = new StringTokenizer(

            System.getProperty("java.class.path"), File.pathSeparator);

        while(clPathes.hasMoreTokens()) {

            String clPath = clPathes.nextToken();

            // trying to load a class file defining the current test from

            // this entry of "java.class.path": the class file may locate

            // at the test's work directory or if it's already compiled,

            // at any directory in classpath

            if (pathValid(clPath, testName))

                return shortTestName;

        }

        // directory with the test's class files was not found.

        // Actually, it means that the invoked test has own Java

        // options such as, for example, "-verify"

        out.println("\nWARNING: the test was not really run due to the following reason:"

            + "\n\tthe invoked test has the own Java option: "

            + testName);

        System.exit(Consts.JCK_STATUS_BASE + Consts.TEST_PASSED);

        return null; // fake return for too smart javac

    }

    /**

     * Invoke the method <i>main(String[])</i> of the test.

     */

    private int invokeMainMethod(Class testCls, String args[]) {

        Class[] methType = { String[].class };

        Object[] methArgs = { args };

        return invokeMethod(testCls, "main", methType, methArgs);

    }

    /**

     * Invoke the method <i>run(String[], PrintStream)</i> of the test.

     */

    private int invokeRunMethod(Class testCls, String args[]) {

        Class[] methType = { String[].class, PrintStream.class };

        Object[] methArgs = { args, out };

        return invokeMethod(testCls, "run", methType, methArgs);

    }

    /**

     * Low level invocation of the test.

     */

    private int invokeMethod(Class<?> testCls, String methodName,

            Class methType[], Object methArgs[]) {

        try {

            Method testMeth = testCls.getMethod(methodName, methType);

            display("\n#### RASagent: invoking method \""

                + testMeth.toString() + "\" ...");

            Object result = testMeth.invoke(null, methArgs);

            display("\n#### RASagent: ... invocation of \""

                + testMeth.toString() + "\" done");

            if (result instanceof Integer) {

                Integer retCode = (Integer) result;

                return retCode.intValue();

            }

        } catch(NoSuchMethodException e) {

            e.printStackTrace();

            out.println("\nFAILURE: RASagent: unable to get method \""

                + methodName + "\" in class "

                + testCls + "\n\tcaught " + e);

            return Consts.TEST_FAILED;

        } catch(Exception e) {

            e.printStackTrace();

            out.println("\nFAILURE: RASagent: caught during invokation of the test class "

                + testCls + " " + e);

            return Consts.TEST_FAILED;

        }

        return -1;

    }

    /**

     * Load class bytes for HotSwap.

     */

    static byte[] loadFromClassFile(String signature) {

        String testPath = clfBasePath + File.separator + signature.substring(

                1, signature.length()-1).replace('/', File.separatorChar) + ".class";

        File classFile = null;

        display("\n#### RASagent: looking for class file\n<RASagent>\t"

            + testPath + " ...");

        try {

            classFile = new File(testPath);

        } catch (NullPointerException e) {

            out.println("\nFAILURE: RASagent: path name to the redefining class file is null");

        }

        display("\n#### RASagent: loading " + classFile.length()

            + " bytes from class file "+ testPath + " ...");

        byte[] buf = new byte[(int) classFile.length()];

        try {

            InputStream in = new FileInputStream(classFile);

            in.read(buf);

            in.close();

        } catch(FileNotFoundException e) {

            e.printStackTrace();

            out.println("\nFAILURE: RASagent: loadFromClassFile: file " +

                classFile.getName() + " not found");

            System.exit(Consts.JCK_STATUS_BASE + Consts.TEST_FAILED);

        } catch (Exception e) {

            e.printStackTrace();

            out.println("\nFAILURE: RASagent: unable to load bytes from the file:\n");

            out.println("\t" + testPath + ": caught " + e);

            System.exit(Consts.JCK_STATUS_BASE + Consts.TEST_FAILED);

        }

        display("\n#### RASagent: ... " + classFile.length() + " bytes loaded");

        return buf;

    }

    /**

     * This method is used in verbose mode. It prints paramter string only

     * in case of verbose mode.

     */

    private static void display(String msg) {

        if (verbose)

            out.println(msg);

    }

    /**

     * This method prints out RASagent usage message.

     */

    private static void printHelp() {

        out.println("\nRASagent usage: RASagent [option, ...] test" +

            "\n\t-ras.help                 print this message and exit" +

            "\n\t-ras.verbose              verbose mode (off by default)" +

            "\n\t-ras.hotswap=mode         enable HotSwap of the running test classes" +

            "\n\t\twhere mode is:" +

            "\n\t\t\t" + HOTSWAP_EVERY_METHOD_ENTRY

                + " - hotswap tested class in its every method entry event" +

            "\n\t\t\t" + HOTSWAP_EVERY_METHOD_ENTRY_FOR_EVERY_CLASS

                + " - hotswap tested class in every method entry event for every class" +

            "\n\t\t\t" + HOTSWAP_EVERY_SINGLE_STEP

                + " - hotswap tested class in its every single step event" +

            "\n\t\t\t" + HOTSWAP_EVERY_EXCEPTION

                + " - hotswap tested class in its every exception event" +

            "\n\t\t\t" + HOTSWAP_EVERY_EXCEPTION_FOR_EVERY_CLASS

                + " - hotswap tested class in every exception event for every class\n" +

            "\n\t-ras.invoke_run           invoke the method run() of the test" +

            "\n\t\tinstead of main() by default");

    }

}