jdk/test/sun/management/jmxremote/startstop/JMXStartStopTest.java - platform/libcore - Git at Google

 /*
  * Copyright (c) 2012, 2017, 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.EOFException;
 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.Set;
 import java.util.concurrent.TimeoutException;
 import java.util.concurrent.atomic.AtomicBoolean;

 import javax.management.*;
 import javax.management.remote.*;
 import javax.net.ssl.SSLHandshakeException;

 import jdk.testlibrary.ProcessTools;
 import jdk.testlibrary.Utils;
 import jdk.internal.agent.Agent;
 import jdk.internal.agent.AgentConfigurationError;
 import jdk.internal.agent.ConnectorAddressLink;

 /**
  * @test
  * @bug 7110104
  * @key randomness intermittent
  * @summary Makes sure that enabling/disabling the management agent through JCMD
  *          achieves the desired results
  *
  * @library /lib/testlibrary
  * @modules java.management
  *          java.rmi
  *          jdk.management.agent/jdk.internal.agent
  *
  * @build jdk.testlibrary.* JMXStartStopTest PortAllocator TestApp ManagementAgentJcmd
  * @run main/othervm/timeout=600 -XX:+UsePerfData JMXStartStopTest
  */
 public class JMXStartStopTest {
     private static final String TEST_APP_NAME = "TestApp";

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

     private static final boolean verbose = false;

     private static ManagementAgentJcmd jcmd = new ManagementAgentJcmd(TEST_APP_NAME, verbose);

     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 = 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 {
         EOFException lastException = null;
         // factor adjusted timeout (5 seconds) for the RMI to become available
         long timeout = System.currentTimeMillis() + Utils.adjustTimeout(5000);
         do {
             try {
                 doTestConnect(port, rmiPort);
                 lastException = null;
             } catch (EOFException e) {
                 lastException = e;
                 System.out.println("Error establishing RMI connection. Retrying in 500ms.");
                 Thread.sleep(500);
             }
         } while (lastException != null && System.currentTimeMillis() < timeout);

         if (lastException != null) {
             // didn't manage to get the RMI running in time
             // rethrow the exception
             throw lastException;
         }
     }

     private static void doTestConnect(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 TestAppRun {
         private Process p;
         private final ProcessBuilder pb;
         private final String name;
         private final AtomicBoolean started = new AtomicBoolean(false);
         private volatile long pid = -1;

         public TestAppRun(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(
                             TEST_APP_NAME + "{" + name + "}",
                             pb,
                             (line) -> {
                                 boolean ok = line.equals("main enter");
                                 error.set(line.contains("BindException"));

                                 return ok || error.get();
                             }
                     );
                     if (error.get()) {
                         throw new BindException("Starting process failed due to " +
                                                 "the requested port not being available");
                     }
                     pid = p.pid();
                 } catch (TimeoutException e) {
                     if (p != null) {
                         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 "TestApp"
      * @param name Test run name
      * @param args Additional arguments
      * @return Returns a {@linkplain TestAppRun} instance representing the run
      * @throws IOException
      * @throws InterruptedException
      * @throws TimeoutException
      */
     private static TestAppRun doTest(String name, String ... args)
             throws Exception {
         List<String> pbArgs = new ArrayList<>(Arrays.asList(
                 "-cp",
                 System.getProperty("test.class.path"),
                 "-XX:+UsePerfData"
         ));
         pbArgs.addAll(Arrays.asList(args));
         pbArgs.add(TEST_APP_NAME);

         ProcessBuilder pb = ProcessTools.createJavaProcessBuilder(
                 pbArgs.toArray(new String[pbArgs.size()])
         );
         TestAppRun s = new TestAppRun(pb, name);
         s.start();
         return s;
     }

     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);

         TestAppRun s = doTest(
                 "test_01",
                 "-Dcom.sun.management.jmxremote.port=" + ports[0],
                 "-Dcom.sun.management.jmxremote.authenticate=false",
                 "-Dcom.sun.management.jmxremote.ssl=false");

         try {
             testConnect(ports[0]);

             jcmd.stop();
             testNoConnect(ports[0]);

             jcmd.start("jmxremote.port=" + ports[1]);
             testConnect(ports[1]);
         } finally {
             s.stop();
         }
     }

     static void test_02() throws Exception {
         // Run an app without JMX enabled
         // start JMX by jcmd

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

         int[] ports = PortAllocator.allocatePorts(1);
         TestAppRun s = doTest("test_02");
         try {
             jcmd.start(
                 "jmxremote.port=" + ports[0],
                 "jmxremote.authenticate=false",
                 "jmxremote.ssl=false"
             );

             testConnect(ports[0]);
         } finally {
 //            debugPortUsage(pa);
             s.stop();
         }
     }

     static void test_03() throws Exception {
         // Run an app without JMX enabled
         // start JMX by jcmd on one port than on other one

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

         int[] ports = PortAllocator.allocatePorts(2);
         TestAppRun s = doTest("test_03");
         try {
             jcmd.start(
                 "jmxremote.port=" + ports[0],
                 "jmxremote.authenticate=false",
                 "jmxremote.ssl=false"
             );

             // Second agent shouldn't start
             jcmd.start(
                 "jmxremote.port=" + ports[1],
                 "jmxremote.authenticate=false",
                 "jmxremote.ssl=false"
             );

             // First agent should connect
             testConnect(ports[0]);

             // Second agent should not connect
             testNoConnect(ports[1]);
         } finally {
             s.stop();
         }
     }

     static void test_04() throws Exception {
         // Run an app without JMX enabled
         // start JMX by jcmd on one port, specify rmi port explicitly

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

         int[] ports = PortAllocator.allocatePorts(2);
         TestAppRun s = doTest("test_04");
         try {
             jcmd.start(
                 "jmxremote.port=" + ports[0],
                 "jmxremote.rmi.port=" + ports[1],
                 "jmxremote.authenticate=false",
                 "jmxremote.ssl=false"
             );

             testConnect(ports[0], ports[1]);
         } finally {
             s.stop();
         }
     }

     static void test_05() throws Exception {
         // Run an app without JMX enabled, it will enable local server
         // but should leave remote server disabled

         System.out.println("**** Test five ****");
         int[] ports = PortAllocator.allocatePorts(1);
         TestAppRun s = doTest("test_05");
         try {
             jcmd.startLocal();

             testNoConnect(ports[0]);
             testConnectLocal(s.getPid());
         } finally {
             s.stop();
         }
     }

     static void test_06() throws Exception {
         // Run an app without JMX enabled
         // start JMX by jcmd on one port, specify rmi port explicitly
         // attempt to start it again with the same port
         // Check for valid messages in the output

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

         int[] ports = PortAllocator.allocatePorts(2);
         TestAppRun s = doTest("test_06");
         try {
             jcmd.start(
                 "jmxremote.port=" + ports[0],
                 "jmxremote.authenticate=false",
                 "jmxremote.ssl=false"
             );

             testConnect(ports[0], ports[1]);

             final AtomicBoolean checks = new AtomicBoolean(false);
             jcmd.start(
                 line -> {
                     if (line.contains("java.lang.RuntimeException: Invalid agent state")) {
                         checks.set(true);
                     }
                 },
                 "jmxremote.port=" + ports[0],
                 "jmxremote.authenticate=false",
                 "jmxremote.ssl=false"
             );

             if (!checks.get()) {
                 throw new Exception("Starting agent on port " + ports[0] + " should "
                         + "report an invalid agent state");
             }
         } finally {
             s.stop();
         }
     }

     static void test_07() throws Exception {
         // Run an app without JMX enabled
         // start JMX by jcmd on one port, specify rmi port explicitly
         // attempt to start it again with other port
         // Check for valid messages in the output

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

         int[] ports = PortAllocator.allocatePorts(2);
         TestAppRun s = doTest("test_07");
         try {
             jcmd.start(
                 "jmxremote.port=" + ports[0],
                 "jmxremote.authenticate=false",
                 "jmxremote.ssl=false"
             );

             testConnect(ports[0], ports[1]);

             final AtomicBoolean checks = new AtomicBoolean(false);

             jcmd.start(
                 line -> {
                     if (line.contains("java.lang.RuntimeException: Invalid agent state")) {
                         checks.set(true);
                     }
                 },
                 "jmxremote.port=" + ports[1],
                 "jmxremote.authenticate=false",
                 "jmxremote.ssl=false"
             );

             if (!checks.get()) {
                 throw new Exception("Starting agent on poprt " + ports[1] + " should "
                         + "report an invalid agent state");
             }
         } finally {
             s.stop();
         }
     }

     static void test_08() throws Exception {
         // Run an app without JMX enabled
         // start JMX by jcmd on one port, specify rmi port explicitly
         // attempt to stop it twice
         // Check for valid messages in the output

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

         int[] ports = PortAllocator.allocatePorts(2);
         TestAppRun s = doTest("test_08");
         try {
             jcmd.start(
                 "jmxremote.port=" + ports[0],
                 "jmxremote.authenticate=false",
                 "jmxremote.ssl=false"
             );

             testConnect(ports[0], ports[1]);

             jcmd.stop();
             jcmd.stop();
         } finally {
             s.stop();
         }
     }

     static void test_09() throws Exception {
         // Run an app without JMX enabled
         // attempt to start JMX using a non-available port
         // Check for valid messages in the output

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

         TestAppRun s = doTest("test_09");

         try (ServerSocket ss = new ServerSocket(0)) {
             int localPort = ss.getLocalPort();
             int[] ports;
             do {
                 ports = PortAllocator.allocatePorts(1);
             } while (localPort == ports[0]);

             final AtomicBoolean checks = new AtomicBoolean(false);

             int retryCntr = 1;
             do {
                 final AtomicBoolean retry = new AtomicBoolean(false);

                 try {
                     jcmd.start(
                         line -> {
                             if (line.contains(Agent.getText(AgentConfigurationError.AGENT_EXCEPTION))) {
                                 retry.set(true);
                             }
                         },
                         "jmxremote.port=" + ports[0],
                         "jmxremote.rmi.port=" + localPort,
                         "jmxremote.authenticate=false",
                         "jmxremote.ssl=false"
                     );
                 } catch (BindException e) {
                     checks.set(true);
                 }
                 if (!retry.get()) {
                     break;
                 }
                 System.out.println("Attempt " + retryCntr + " >>>");
                 System.out.println("Unexpected reply from the agent. Retrying in 500ms ...");
                 Thread.sleep(500);
             } while (retryCntr++ < 10);

             if (!checks.get()) {
                 throw new Exception("Starting agent on port " + ports[0] + " should "
                         + "report port in use");
             }
         } finally {
             s.stop();
         }

     }

     static void test_10() throws Exception {
         // Run an app without JMX enabled, but with some properties set
         // in command line.
         // make sure these properties overridden corectly

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

         int[] ports = PortAllocator.allocatePorts(2);
         TestAppRun s = doTest(
                 "test_10",
                 "-Dcom.sun.management.jmxremote.authenticate=false",
                 "-Dcom.sun.management.jmxremote.ssl=true");

         try {
             testNoConnect(ports[0]);
             jcmd.start(
                 "jmxremote.port=" + ports[1],
                 "jmxremote.authenticate=false",
                 "jmxremote.ssl=false"
             );
             testConnect(ports[1]);
         } finally {
             s.stop();
         }
     }

     static void test_11() throws Exception {
         // Run an app with JMX enabled and with some properties set
         // in command line.
         // stop JMX agent and then start it again with different property values
         // make sure these properties overridden corectly

         System.out.println("**** Test eleven ****");
         int[] ports = PortAllocator.allocatePorts(2);
         TestAppRun s = doTest(
                 "test_11",
                 "-Dcom.sun.management.jmxremote.port=" + ports[0],
                 "-Dcom.sun.management.jmxremote.authenticate=false",
                 "-Dcom.sun.management.jmxremote.ssl=true");

         try {
             testNoConnect(ports[0]);

             jcmd.stop();

             testNoConnect(ports[0]);

             jcmd.start(
                 "jmxremote.port=" + ports[1],
                 "jmxremote.authenticate=false",
                 "jmxremote.ssl=false"
             );

             testConnect(ports[1]);
         } finally {
             s.stop();
         }
     }

     static void test_12() throws Exception {
         // Run an app with JMX enabled and with some properties set
         // in command line.
         // stop JMX agent and then start it again with different property values
         // specifing some property in management config file and some of them
         // in command line
         // make sure these properties overridden corectly

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

         int[] ports = PortAllocator.allocatePorts(2);
         TestAppRun s = doTest("test_12",
                 "-Dcom.sun.management.config.file="
                 + TEST_SRC + File.separator + "management_cl.properties",
                 "-Dcom.sun.management.jmxremote.authenticate=false"
         );

         try {
             testNoConnect(ports[0]);

             jcmd.stop();

             testNoConnect(ports[0]);

             jcmd.start(
                 "config.file=" + TEST_SRC + File.separator
                 + "management_jcmd.properties",
                 "jmxremote.authenticate=false",
                 "jmxremote.port=" + ports[1]
             );

             testConnect(ports[1]);
         } finally {
             s.stop();
         }
     }

     static void test_13() throws Exception {
         // Run an app with JMX enabled and with some properties set
         // in command line.
         // stop JMX agent and then start it again with different property values
         // stop JMX agent again and then start it without property value
         // make sure these properties overridden corectly

         System.out.println("**** Test thirteen ****");
         int[] ports = PortAllocator.allocatePorts(1);
         TestAppRun s = doTest(
                 "test_13",
                 "-Dcom.sun.management.jmxremote.port=" + ports[0],
                 "-Dcom.sun.management.jmxremote.authenticate=false",
                 "-Dcom.sun.management.jmxremote.ssl=true");

         try {
             testNoConnect(ports[0]);

             jcmd.stop();
             jcmd.start(
                 "jmxremote.ssl=false",
                 "jmxremote.port=" + ports[0]
             );
             testConnect(ports[0]);

             jcmd.stop();
             jcmd.start(
                 "jmxremote.port=" + ports[0]
             );

             testNoConnect(ports[0]);
         } finally {
             s.stop();
         }
     }

     static void test_14() throws Exception {
         // Run an app with JMX enabled
         // stop remote agent
         // make sure local agent is not affected

         System.out.println("**** Test fourteen ****");
         int[] ports = PortAllocator.allocatePorts(1);
         TestAppRun s = doTest(
                 "test_14",
                 "-Dcom.sun.management.jmxremote.port=" + ports[0],
                 "-Dcom.sun.management.jmxremote.authenticate=false",
                 "-Dcom.sun.management.jmxremote.ssl=false");
         try {
             testConnect(ports[0]);
             jcmd.stop();
             testConnectLocal(s.getPid());
         } finally {
             s.stop();
         }
     }

     static void test_15() throws Exception {
         // Run an app with JMX disabled
         // start local agent only

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

         int[] ports = PortAllocator.allocatePorts(1);
         TestAppRun s = doTest("test_15");

         try {
             testNoConnect(ports[0]);
             jcmd.startLocal();

             testConnectLocal(s.getPid());

         } finally {
             s.stop();
         }
     }

 }
	/*
	* Copyright (c) 2012, 2017, 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.EOFException;
	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.Set;
	import java.util.concurrent.TimeoutException;
	import java.util.concurrent.atomic.AtomicBoolean;

	import javax.management.*;
	import javax.management.remote.*;
	import javax.net.ssl.SSLHandshakeException;

	import jdk.testlibrary.ProcessTools;
	import jdk.testlibrary.Utils;
	import jdk.internal.agent.Agent;
	import jdk.internal.agent.AgentConfigurationError;
	import jdk.internal.agent.ConnectorAddressLink;

	/**
	* @test
	* @bug 7110104
	* @key randomness intermittent
	* @summary Makes sure that enabling/disabling the management agent through JCMD
	* achieves the desired results
	*
	* @library /lib/testlibrary
	* @modules java.management
	* java.rmi
	* jdk.management.agent/jdk.internal.agent
	*
	* @build jdk.testlibrary.* JMXStartStopTest PortAllocator TestApp ManagementAgentJcmd
	* @run main/othervm/timeout=600 -XX:+UsePerfData JMXStartStopTest
	*/
	public class JMXStartStopTest {
	private static final String TEST_APP_NAME = "TestApp";

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

	private static final boolean verbose = false;

	private static ManagementAgentJcmd jcmd = new ManagementAgentJcmd(TEST_APP_NAME, verbose);

	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 = 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 {
	EOFException lastException = null;
	// factor adjusted timeout (5 seconds) for the RMI to become available
	long timeout = System.currentTimeMillis() + Utils.adjustTimeout(5000);
	do {
	try {
	doTestConnect(port, rmiPort);
	lastException = null;
	} catch (EOFException e) {
	lastException = e;
	System.out.println("Error establishing RMI connection. Retrying in 500ms.");
	Thread.sleep(500);
	}
	} while (lastException != null && System.currentTimeMillis() < timeout);

	if (lastException != null) {
	// didn't manage to get the RMI running in time
	// rethrow the exception
	throw lastException;
	}
	}

	private static void doTestConnect(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 TestAppRun {
	private Process p;
	private final ProcessBuilder pb;
	private final String name;
	private final AtomicBoolean started = new AtomicBoolean(false);
	private volatile long pid = -1;

	public TestAppRun(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(
	TEST_APP_NAME + "{" + name + "}",
	pb,
	(line) -> {
	boolean ok = line.equals("main enter");
	error.set(line.contains("BindException"));

	return ok \|\| error.get();
	}
	);
	if (error.get()) {
	throw new BindException("Starting process failed due to " +
	"the requested port not being available");
	}
	pid = p.pid();
	} catch (TimeoutException e) {
	if (p != null) {
	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 "TestApp"
	* @param name Test run name
	* @param args Additional arguments
	* @return Returns a {@linkplain TestAppRun} instance representing the run
	* @throws IOException
	* @throws InterruptedException
	* @throws TimeoutException
	*/
	private static TestAppRun doTest(String name, String ... args)
	throws Exception {
	List<String> pbArgs = new ArrayList<>(Arrays.asList(
	"-cp",
	System.getProperty("test.class.path"),
	"-XX:+UsePerfData"
	));
	pbArgs.addAll(Arrays.asList(args));
	pbArgs.add(TEST_APP_NAME);

	ProcessBuilder pb = ProcessTools.createJavaProcessBuilder(
	pbArgs.toArray(new String[pbArgs.size()])
	);
	TestAppRun s = new TestAppRun(pb, name);
	s.start();
	return s;
	}

	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);

	TestAppRun s = doTest(
	"test_01",
	"-Dcom.sun.management.jmxremote.port=" + ports[0],
	"-Dcom.sun.management.jmxremote.authenticate=false",
	"-Dcom.sun.management.jmxremote.ssl=false");

	try {
	testConnect(ports[0]);

	jcmd.stop();
	testNoConnect(ports[0]);

	jcmd.start("jmxremote.port=" + ports[1]);
	testConnect(ports[1]);
	} finally {
	s.stop();
	}
	}

	static void test_02() throws Exception {
	// Run an app without JMX enabled
	// start JMX by jcmd

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

	int[] ports = PortAllocator.allocatePorts(1);
	TestAppRun s = doTest("test_02");
	try {
	jcmd.start(
	"jmxremote.port=" + ports[0],
	"jmxremote.authenticate=false",
	"jmxremote.ssl=false"
	);

	testConnect(ports[0]);
	} finally {
	// debugPortUsage(pa);
	s.stop();
	}
	}

	static void test_03() throws Exception {
	// Run an app without JMX enabled
	// start JMX by jcmd on one port than on other one

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

	int[] ports = PortAllocator.allocatePorts(2);
	TestAppRun s = doTest("test_03");
	try {
	jcmd.start(
	"jmxremote.port=" + ports[0],
	"jmxremote.authenticate=false",
	"jmxremote.ssl=false"
	);

	// Second agent shouldn't start
	jcmd.start(
	"jmxremote.port=" + ports[1],
	"jmxremote.authenticate=false",
	"jmxremote.ssl=false"
	);

	// First agent should connect
	testConnect(ports[0]);

	// Second agent should not connect
	testNoConnect(ports[1]);
	} finally {
	s.stop();
	}
	}

	static void test_04() throws Exception {
	// Run an app without JMX enabled
	// start JMX by jcmd on one port, specify rmi port explicitly

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

	int[] ports = PortAllocator.allocatePorts(2);
	TestAppRun s = doTest("test_04");
	try {
	jcmd.start(
	"jmxremote.port=" + ports[0],
	"jmxremote.rmi.port=" + ports[1],
	"jmxremote.authenticate=false",
	"jmxremote.ssl=false"
	);

	testConnect(ports[0], ports[1]);
	} finally {
	s.stop();
	}
	}

	static void test_05() throws Exception {
	// Run an app without JMX enabled, it will enable local server
	// but should leave remote server disabled

	System.out.println("** Test five **");
	int[] ports = PortAllocator.allocatePorts(1);
	TestAppRun s = doTest("test_05");
	try {
	jcmd.startLocal();

	testNoConnect(ports[0]);
	testConnectLocal(s.getPid());
	} finally {
	s.stop();
	}
	}

	static void test_06() throws Exception {
	// Run an app without JMX enabled
	// start JMX by jcmd on one port, specify rmi port explicitly
	// attempt to start it again with the same port
	// Check for valid messages in the output

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

	int[] ports = PortAllocator.allocatePorts(2);
	TestAppRun s = doTest("test_06");
	try {
	jcmd.start(
	"jmxremote.port=" + ports[0],
	"jmxremote.authenticate=false",
	"jmxremote.ssl=false"
	);

	testConnect(ports[0], ports[1]);

	final AtomicBoolean checks = new AtomicBoolean(false);
	jcmd.start(
	line -> {
	if (line.contains("java.lang.RuntimeException: Invalid agent state")) {
	checks.set(true);
	}
	},
	"jmxremote.port=" + ports[0],
	"jmxremote.authenticate=false",
	"jmxremote.ssl=false"
	);

	if (!checks.get()) {
	throw new Exception("Starting agent on port " + ports[0] + " should "
	+ "report an invalid agent state");
	}
	} finally {
	s.stop();
	}
	}

	static void test_07() throws Exception {
	// Run an app without JMX enabled
	// start JMX by jcmd on one port, specify rmi port explicitly
	// attempt to start it again with other port
	// Check for valid messages in the output

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

	int[] ports = PortAllocator.allocatePorts(2);
	TestAppRun s = doTest("test_07");
	try {
	jcmd.start(
	"jmxremote.port=" + ports[0],
	"jmxremote.authenticate=false",
	"jmxremote.ssl=false"
	);

	testConnect(ports[0], ports[1]);

	final AtomicBoolean checks = new AtomicBoolean(false);

	jcmd.start(
	line -> {
	if (line.contains("java.lang.RuntimeException: Invalid agent state")) {
	checks.set(true);
	}
	},
	"jmxremote.port=" + ports[1],
	"jmxremote.authenticate=false",
	"jmxremote.ssl=false"
	);

	if (!checks.get()) {
	throw new Exception("Starting agent on poprt " + ports[1] + " should "
	+ "report an invalid agent state");
	}
	} finally {
	s.stop();
	}
	}

	static void test_08() throws Exception {
	// Run an app without JMX enabled
	// start JMX by jcmd on one port, specify rmi port explicitly
	// attempt to stop it twice
	// Check for valid messages in the output

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

	int[] ports = PortAllocator.allocatePorts(2);
	TestAppRun s = doTest("test_08");
	try {
	jcmd.start(
	"jmxremote.port=" + ports[0],
	"jmxremote.authenticate=false",
	"jmxremote.ssl=false"
	);

	testConnect(ports[0], ports[1]);

	jcmd.stop();
	jcmd.stop();
	} finally {
	s.stop();
	}
	}

	static void test_09() throws Exception {
	// Run an app without JMX enabled
	// attempt to start JMX using a non-available port
	// Check for valid messages in the output

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

	TestAppRun s = doTest("test_09");

	try (ServerSocket ss = new ServerSocket(0)) {
	int localPort = ss.getLocalPort();
	int[] ports;
	do {
	ports = PortAllocator.allocatePorts(1);
	} while (localPort == ports[0]);

	final AtomicBoolean checks = new AtomicBoolean(false);

	int retryCntr = 1;
	do {
	final AtomicBoolean retry = new AtomicBoolean(false);

	try {
	jcmd.start(
	line -> {
	if (line.contains(Agent.getText(AgentConfigurationError.AGENT_EXCEPTION))) {
	retry.set(true);
	}
	},
	"jmxremote.port=" + ports[0],
	"jmxremote.rmi.port=" + localPort,
	"jmxremote.authenticate=false",
	"jmxremote.ssl=false"
	);
	} catch (BindException e) {
	checks.set(true);
	}
	if (!retry.get()) {
	break;
	}
	System.out.println("Attempt " + retryCntr + " >>>");
	System.out.println("Unexpected reply from the agent. Retrying in 500ms ...");
	Thread.sleep(500);
	} while (retryCntr++ < 10);

	if (!checks.get()) {
	throw new Exception("Starting agent on port " + ports[0] + " should "
	+ "report port in use");
	}
	} finally {
	s.stop();
	}

	}

	static void test_10() throws Exception {
	// Run an app without JMX enabled, but with some properties set
	// in command line.
	// make sure these properties overridden corectly

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

	int[] ports = PortAllocator.allocatePorts(2);
	TestAppRun s = doTest(
	"test_10",
	"-Dcom.sun.management.jmxremote.authenticate=false",
	"-Dcom.sun.management.jmxremote.ssl=true");

	try {
	testNoConnect(ports[0]);
	jcmd.start(
	"jmxremote.port=" + ports[1],
	"jmxremote.authenticate=false",
	"jmxremote.ssl=false"
	);
	testConnect(ports[1]);
	} finally {
	s.stop();
	}
	}

	static void test_11() throws Exception {
	// Run an app with JMX enabled and with some properties set
	// in command line.
	// stop JMX agent and then start it again with different property values
	// make sure these properties overridden corectly

	System.out.println("** Test eleven **");
	int[] ports = PortAllocator.allocatePorts(2);
	TestAppRun s = doTest(
	"test_11",
	"-Dcom.sun.management.jmxremote.port=" + ports[0],
	"-Dcom.sun.management.jmxremote.authenticate=false",
	"-Dcom.sun.management.jmxremote.ssl=true");

	try {
	testNoConnect(ports[0]);

	jcmd.stop();

	testNoConnect(ports[0]);

	jcmd.start(
	"jmxremote.port=" + ports[1],
	"jmxremote.authenticate=false",
	"jmxremote.ssl=false"
	);

	testConnect(ports[1]);
	} finally {
	s.stop();
	}
	}

	static void test_12() throws Exception {
	// Run an app with JMX enabled and with some properties set
	// in command line.
	// stop JMX agent and then start it again with different property values
	// specifing some property in management config file and some of them
	// in command line
	// make sure these properties overridden corectly

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

	int[] ports = PortAllocator.allocatePorts(2);
	TestAppRun s = doTest("test_12",
	"-Dcom.sun.management.config.file="
	+ TEST_SRC + File.separator + "management_cl.properties",
	"-Dcom.sun.management.jmxremote.authenticate=false"
	);

	try {
	testNoConnect(ports[0]);

	jcmd.stop();

	testNoConnect(ports[0]);

	jcmd.start(
	"config.file=" + TEST_SRC + File.separator
	+ "management_jcmd.properties",
	"jmxremote.authenticate=false",
	"jmxremote.port=" + ports[1]
	);

	testConnect(ports[1]);
	} finally {
	s.stop();
	}
	}

	static void test_13() throws Exception {
	// Run an app with JMX enabled and with some properties set
	// in command line.
	// stop JMX agent and then start it again with different property values
	// stop JMX agent again and then start it without property value
	// make sure these properties overridden corectly

	System.out.println("** Test thirteen **");
	int[] ports = PortAllocator.allocatePorts(1);
	TestAppRun s = doTest(
	"test_13",
	"-Dcom.sun.management.jmxremote.port=" + ports[0],
	"-Dcom.sun.management.jmxremote.authenticate=false",
	"-Dcom.sun.management.jmxremote.ssl=true");

	try {
	testNoConnect(ports[0]);

	jcmd.stop();
	jcmd.start(
	"jmxremote.ssl=false",
	"jmxremote.port=" + ports[0]
	);
	testConnect(ports[0]);

	jcmd.stop();
	jcmd.start(
	"jmxremote.port=" + ports[0]
	);

	testNoConnect(ports[0]);
	} finally {
	s.stop();
	}
	}

	static void test_14() throws Exception {
	// Run an app with JMX enabled
	// stop remote agent
	// make sure local agent is not affected

	System.out.println("** Test fourteen **");
	int[] ports = PortAllocator.allocatePorts(1);
	TestAppRun s = doTest(
	"test_14",
	"-Dcom.sun.management.jmxremote.port=" + ports[0],
	"-Dcom.sun.management.jmxremote.authenticate=false",
	"-Dcom.sun.management.jmxremote.ssl=false");
	try {
	testConnect(ports[0]);
	jcmd.stop();
	testConnectLocal(s.getPid());
	} finally {
	s.stop();
	}
	}

	static void test_15() throws Exception {
	// Run an app with JMX disabled
	// start local agent only

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

	int[] ports = PortAllocator.allocatePorts(1);
	TestAppRun s = doTest("test_15");

	try {
	testNoConnect(ports[0]);
	jcmd.startLocal();

	testConnectLocal(s.getPid());

	} finally {
	s.stop();
	}
	}

	}