/*

 * Copyright (c) 2012, 2015, 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.

 */

import java.io.File;

import java.io.IOException;

import java.lang.reflect.InvocationTargetException;

import java.lang.reflect.Method;

import java.net.BindException;

import java.net.ConnectException;

import java.net.ServerSocket;

import java.rmi.RemoteException;

import java.rmi.registry.LocateRegistry;

import java.rmi.registry.Registry;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.List;

import java.util.Objects;

import java.util.Random;

import java.util.Set;

import java.util.concurrent.TimeUnit;

import java.util.concurrent.TimeoutException;

import java.util.concurrent.atomic.AtomicBoolean;

import java.util.function.Consumer;

import java.util.stream.Collectors;

import javax.management.*;

import javax.management.remote.*;

import javax.net.ssl.SSLHandshakeException;

import jdk.testlibrary.ProcessTools;

import jdk.testlibrary.JDKToolLauncher;

import sun.management.Agent;

import sun.management.AgentConfigurationError;

/**

 * @test

 * @bug 7110104

 * @library /lib/testlibrary

 * @build jdk.testlibrary.* JMXStartStopTest JMXStartStopDoSomething

 * @run main/othervm/timeout=600 -XX:+UsePerfData JMXStartStopTest

 * @summary Makes sure that enabling/disabling the management agent through JCMD

 *          achieves the desired results

 */

public class JMXStartStopTest {

    private static final String TEST_SRC = System.getProperty("test.src");

    private static final boolean verbose = false;

    /**

     * Dynamically allocates distinct ports from the ephemeral range 49152-65535

     */

    private static class PortAllocator {

        private final static int LOWER_BOUND = 49152;

        private final static int UPPER_BOUND = 65535;

        private final static Random RND = new Random(System.currentTimeMillis());

        private static int[] allocatePorts(final int numPorts) {

            int[] ports = new int[numPorts];

            for (int i = 0; i < numPorts; i++) {

                int port = -1;

                while (port == -1) {

                    port = RND.nextInt(UPPER_BOUND - LOWER_BOUND + 1) + LOWER_BOUND;

                    for (int j = 0; j < i; j++) {

                        if (ports[j] == port) {

                            port = -1;

                            break;

                        }

                    }

                }

                ports[i] = port;

            }

            return ports;

        }

    }

    private static void dbg_print(String msg) {

        if (verbose) {

            System.out.println("DBG: " + msg);

        }

    }

    private static int listMBeans(MBeanServerConnection server,

            ObjectName pattern,

            QueryExp query)

            throws Exception {

        Set<ObjectName> names = server.queryNames(pattern,query);

        for (ObjectName name : names) {

            MBeanInfo info = server.getMBeanInfo(name);

            dbg_print("Got MBean: " + name);

            MBeanAttributeInfo[] attrs = info.getAttributes();

            if (attrs == null)

                continue;

            for (MBeanAttributeInfo attr : attrs) {

                if (attr.isReadable()) {

                    server.getAttribute(name, attr.getName());

                }

            }

        }

        return names.size();

    }

    private static void testConnectLocal(long pid)

            throws Exception {

        String jmxUrlStr = null;

        try {

            jmxUrlStr = sun.management.ConnectorAddressLink.importFrom((int)pid);

            dbg_print("Local Service URL: " +jmxUrlStr);

            if ( jmxUrlStr == null ) {

                throw new Exception("No Service URL. Local agent not started?");

            }

            JMXServiceURL url = new JMXServiceURL(jmxUrlStr);

            JMXConnector c = JMXConnectorFactory.connect(url, null);

            MBeanServerConnection conn = c.getMBeanServerConnection();

            ObjectName pattern = new ObjectName("java.lang:type=Memory,*");

            int count = listMBeans(conn,pattern,null);

            if (count == 0)

                throw new Exception("Expected at least one matching "+

                                    "MBean for "+pattern);

        } catch (IOException e) {

            dbg_print("Cannot find process : " + pid);

            throw e;

        }

    }

    private static void testNoConnect(int port) throws Exception {

        testNoConnect(port, 0);

    }

    private static void testNoConnect(int port, int rmiPort) throws Exception {

        try {

            testConnect(port, rmiPort);

            throw new Exception("Didn't expect the management agent running");

        } catch (Exception e) {

            Throwable t = e;

            while (t != null) {

                if (t instanceof RemoteException ||

                    t instanceof SSLHandshakeException ||

                    t instanceof ConnectException) {

                    break;

                }

                t = t.getCause();

            }

            if (t == null) {

                throw new Exception("Unexpected exception", e);

            }

        }

    }

    private static void testConnect(int port) throws Exception {

        testConnect(port, 0);

    }

    private static void testConnect(int port, int rmiPort) throws Exception {

        dbg_print("RmiRegistry lookup...");

        dbg_print("Using port: " + port);

        dbg_print("Using rmi port: " + rmiPort);

        Registry registry = LocateRegistry.getRegistry(port);

        // "jmxrmi"

        String[] relist = registry.list();

        for (int i = 0; i < relist.length; ++i) {

            dbg_print("Got registry: " + relist[i]);

        }

        String jmxUrlStr = (rmiPort != 0) ?

            String.format(

                        "service:jmx:rmi://localhost:%d/jndi/rmi://localhost:%d/jmxrmi",

                        rmiPort,

                port) :

            String.format(

                        "service:jmx:rmi:///jndi/rmi://localhost:%d/jmxrmi",

                        port);

        JMXServiceURL url = new JMXServiceURL(jmxUrlStr);

        JMXConnector c = JMXConnectorFactory.connect(url, null);

        MBeanServerConnection conn = c.getMBeanServerConnection();

        ObjectName pattern = new ObjectName("java.lang:type=Memory,*");

        int count = listMBeans(conn,pattern,null);

        if (count == 0)

            throw new Exception("Expected at least one matching " +

                                "MBean for " + pattern);

    }

    private static class Failure {

        private final Throwable cause;

        private final String msg;

        public Failure(Throwable cause, String msg) {

            this.cause = cause;

            this.msg = msg;

        }

        public Failure(String msg) {

            this(null, msg);

        }

        public Throwable getCause() {

            return cause;

        }

        public String getMsg() {

            return msg;

        }

        @Override

        public int hashCode() {

            int hash = 7;

            hash = 97 * hash + Objects.hashCode(this.cause);

            hash = 97 * hash + Objects.hashCode(this.msg);

            return hash;

        }

        @Override

        public boolean equals(Object obj) {

            if (obj == null) {

                return false;

            }

            if (getClass() != obj.getClass()) {

                return false;

            }

            final Failure other = (Failure) obj;

            if (!Objects.equals(this.cause, other.cause)) {

                return false;

            }

            if (!Objects.equals(this.msg, other.msg)) {

                return false;

            }

            return true;

        }

        @Override

        public String toString() {

            if (cause != null) {

                return msg + "\n" + cause;

            } else {

                return msg;

            }

        }

    }

    private static List<Failure> failures = new ArrayList<>();

    public static void main(String args[]) throws Exception {

        for (Method m : JMXStartStopTest.class.getDeclaredMethods()) {

            if (m.getName().startsWith("test_")) {

                long t1 = System.currentTimeMillis();

                try {

                    boolean retry = false;

                    do {

                        try {

                            m.invoke(null);

                            retry = false;

                        } catch (InvocationTargetException e) {

                            if (e.getCause() instanceof BindException ||

                                e.getCause() instanceof java.rmi.ConnectException) {

                                System.out.println("Failed to allocate ports. Retrying ...");

                                retry = true;

                            } else {

                                throw e;

                            }

                        }

                    } while (retry);

                    System.out.println("=== PASSED");

                } catch (Throwable e) {

                    failures.add(new Failure(e, m.getName() + " failed"));

                } finally {

                    System.out.println("(took " + (System.currentTimeMillis() - t1) + "ms)\n");

                }

            }

        }

        if (!failures.isEmpty()) {

            for(Failure f : failures) {

                System.err.println(f.getMsg());

                f.getCause().printStackTrace(System.err);

            }

            throw new Error();

        }

    }

    private static class Something {

        private Process p;

        private final ProcessBuilder pb;

        private final String name;

        private final AtomicBoolean started = new AtomicBoolean(false);

        private volatile long pid = -1;

        public Something(ProcessBuilder pb, String name) {

            this.pb = pb;

            this.name = name;

        }

        public synchronized void start() throws InterruptedException, IOException, TimeoutException {

            if (started.compareAndSet(false, true)) {

                try {

                    AtomicBoolean error = new AtomicBoolean(false);

                    p = ProcessTools.startProcess(

                            "JMXStartStopDoSomething{" + name + "}",

                            pb,

                            (line) -> {

                                boolean ok = line.equals("main enter");

                                error.set(line.contains("BindException"));

                                return ok || error.get();

                            },

                            5,

                            TimeUnit.SECONDS

                    );

                    if (error.get()) {

                        throw new BindException("Starting process failed due to " +

                                                "the requested port not being available");

                    }

                    pid = p.getPid();

                } catch (TimeoutException e) {

                    p.destroy();

                    p.waitFor();

                    throw e;

                }

            }

        }

        public long getPid() {

            return pid;

        }

        public synchronized void stop()

                throws IOException, InterruptedException {

            if (started.compareAndSet(true, false)) {

                p.getOutputStream().write(0);

                p.getOutputStream().flush();

                int ec = p.waitFor();

                if (ec != 0) {

                    StringBuilder msg = new StringBuilder();

                    msg.append("Test application '").append(name);

                    msg.append("' failed with exit code: ");

                    msg.append(ec);

                    failures.add(new Failure(msg.toString()));

                }

            }

        }

    }

    /**

     * Runs the test application "JMXStartStopDoSomething"

     * @param name Test run name

     * @param args Additional arguments

     * @return Returns a {@linkplain Something} instance representing the run

     * @throws IOException

     * @throws InterruptedException

     * @throws TimeoutException

     */

    private static Something doSomething(String name, String ... args)

            throws Exception {

        List<String> pbArgs = new ArrayList<>(Arrays.asList(

                "-cp",

                System.getProperty("test.class.path")

        ));

        pbArgs.addAll(Arrays.asList(args));

        pbArgs.add("JMXStartStopDoSomething");

        ProcessBuilder pb = ProcessTools.createJavaProcessBuilder(

                pbArgs.toArray(new String[pbArgs.size()])

        );

        Something s = new Something(pb, name);

        s.start();

        return s;

    }

    /**

     * Run the "jcmd" command

     *

     * @param command Command with parameters; space separated string

     * @throws IOException

     * @throws InterruptedException

     */

    private static void jcmd(String ... command) throws IOException, InterruptedException {

        if (command.length == 0) {

            jcmd(null, c->{});

        } else {

            jcmd(null, command);

        }

    }

    /**

     * Run the "jcmd" command

     *

     * @param c {@linkplain Consumer} instance

     * @param command Command with parameters; space separated string

     * @throws IOException

     * @throws InterruptedException

     */

    private static void jcmd(Consumer<String> c, String ... command) throws IOException, InterruptedException {

        jcmd("JMXStartStopDoSomething", c, command);

    }

    /**

     * Run the "jcmd" command

     *

     * @param target The target application name (or PID)

     * @param c {@linkplain Consumer} instance

     * @param command Command with parameters; space separated string

     * @throws IOException

     * @throws InterruptedException

     */

    private static void jcmd(String target, final Consumer<String> c, String ... command) throws IOException, InterruptedException {

        dbg_print("[jcmd] " + (command.length > 0 ? command[0] : "list"));

        JDKToolLauncher l = JDKToolLauncher.createUsingTestJDK("jcmd");

        l.addToolArg(target);

        for (String cmd : command) {

            l.addToolArg(cmd);

        }

        AtomicBoolean portUnavailable = new AtomicBoolean(false);

        Process p = ProcessTools.startProcess(

            "jcmd",

            new ProcessBuilder(l.getCommand()),

            line -> {

                if (line.contains("BindException") ||

                    line.contains(Agent.getText(AgentConfigurationError.CONNECTOR_SERVER_IO_ERROR))) {

                    portUnavailable.set(true);

                } else {

                    c.accept(line);

                }

            }

        );

        p.waitFor();

        dbg_print("[jcmd] --------");

        if (portUnavailable.get()) {

            String cmd = Arrays.asList(l.getCommand()).stream()

                    .collect(

                            Collectors.joining(" ", "", ": Unable to bind address")

                    );

            throw new BindException(cmd);

        }

    }

    private static final String CMD_STOP = "ManagementAgent.stop";

    private static final String CMD_START = "ManagementAgent.start";

    private static final String CMD_START_LOCAL = "ManagementAgent.start_local";

    static void test_01() throws Exception {

        // Run an app with JMX enabled stop it and

        // restart on other port

        System.out.println("**** Test one ****");

        int ports[] = PortAllocator.allocatePorts(2);

        Something s = doSomething(

                "test_01",

                "-Dcom.sun.management.jmxremote.port=" + ports[0],

                "-Dcom.sun.management.jmxremote.authenticate=false",