| /* |
| * Copyright (c) 2003, 2004, 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 sun.management.jmxremote.ConnectorBootstrap; |
| |
| import java.io.File; |
| import java.io.FileInputStream; |
| import java.io.InputStream; |
| import java.io.FilenameFilter; |
| import java.io.IOException; |
| |
| import java.util.Properties; |
| import java.util.Iterator; |
| import java.util.Set; |
| import java.util.Arrays; |
| import java.util.ArrayList; |
| import java.util.HashMap; |
| import java.util.Map; |
| import java.util.Enumeration; |
| |
| import javax.management.remote.*; |
| import javax.management.*; |
| |
| import sun.management.AgentConfigurationError; |
| |
| import util.TestLogger; |
| |
| /** |
| * <p>This class implements unit test for RMI Bootstrap. |
| * When called with no arguments main() looks in the directory indicated |
| * by the "test.src" system property for files called management*ok.properties |
| * or management*ko.properties. The *ok.properties files are assumed to be |
| * valid Java M&M config files for which the bootstrap should succeed. |
| * The *ko.properties files are assumed to be configurations for which the |
| * bootstrap & connection test will fail.</p> |
| * |
| * <p>The rmi port number can be specified with the "rmi.port" system property. |
| * If not, this test will use 12424</p> |
| * |
| * <p>When called with some argument, the main() will interprete its args to |
| * be Java M&M configuration file names. The filenames are expected to end |
| * with ok.properties or ko.properties - and are interpreted as above.</p> |
| * |
| * <p>Note that a limitation of the RMI registry (bug 4267864) prevent |
| * this test from succeeding if more than 1 configuration is used. |
| * As long as 4267864 isn't fix, this test must be called as many times |
| * as needed but with a single argument (no arguments, or several arguments |
| * will fail).</p> |
| * |
| * <p>Debug traces are logged in "sun.management.test"</p> |
| **/ |
| public class RmiBootstrapTest { |
| |
| static TestLogger log = |
| new TestLogger("RmiBootstrapTest"); |
| |
| /** |
| * When launching several registries, we increment the port number |
| * to avoid falling into "port number already in use" problems. |
| **/ |
| static int testPort = 0; |
| |
| /** |
| * Default values for RMI configuration properties. |
| **/ |
| public static interface DefaultValues { |
| public static final String PORT="0"; |
| public static final String CONFIG_FILE_NAME="management.properties"; |
| public static final String USE_SSL="true"; |
| public static final String USE_AUTHENTICATION="true"; |
| public static final String PASSWORD_FILE_NAME="jmxremote.password"; |
| public static final String ACCESS_FILE_NAME="jmxremote.access"; |
| public static final String KEYSTORE="keystore"; |
| public static final String KEYSTORE_PASSWD="password"; |
| public static final String TRUSTSTORE="truststore"; |
| public static final String TRUSTSTORE_PASSWD="trustword"; |
| public static final String SSL_NEED_CLIENT_AUTH="false"; |
| } |
| |
| /** |
| * Names of RMI configuration properties. |
| **/ |
| public static interface PropertyNames { |
| public static final String PORT= |
| "com.sun.management.jmxremote.port"; |
| public static final String CONFIG_FILE_NAME= |
| "com.sun.management.config.file"; |
| public static final String USE_SSL= |
| "com.sun.management.jmxremote.ssl"; |
| public static final String USE_AUTHENTICATION= |
| "com.sun.management.jmxremote.authenticate"; |
| public static final String PASSWORD_FILE_NAME= |
| "com.sun.management.jmxremote.password.file"; |
| public static final String ACCESS_FILE_NAME= |
| "com.sun.management.jmxremote.access.file"; |
| public static final String INSTRUMENT_ALL= |
| "com.sun.management.instrumentall"; |
| public static final String CREDENTIALS = |
| "jmx.remote.credentials"; |
| public static final String KEYSTORE= |
| "javax.net.ssl.keyStore"; |
| public static final String KEYSTORE_PASSWD= |
| "javax.net.ssl.keyStorePassword"; |
| public static final String TRUSTSTORE= |
| "javax.net.ssl.trustStore"; |
| public static final String TRUSTSTORE_PASSWD= |
| "javax.net.ssl.trustStorePassword"; |
| public static final String SSL_ENABLED_CIPHER_SUITES = |
| "com.sun.management.jmxremote.ssl.enabled.cipher.suites"; |
| public static final String SSL_ENABLED_PROTOCOLS = |
| "com.sun.management.jmxremote.ssl.enabled.protocols"; |
| public static final String SSL_NEED_CLIENT_AUTH = |
| "com.sun.management.jmxremote.ssl.need.client.auth"; |
| } |
| |
| /** |
| * A filter to find all filenames who match <prefix>*<suffix>. |
| * Note that <prefix> and <suffix> can overlap. |
| **/ |
| private static class ConfigFilenameFilter implements FilenameFilter { |
| final String suffix; |
| final String prefix; |
| ConfigFilenameFilter(String prefix, String suffix) { |
| this.suffix=suffix; |
| this.prefix=prefix; |
| } |
| public boolean accept(File dir, String name) { |
| return (name.startsWith(prefix) && name.endsWith(suffix)); |
| } |
| } |
| |
| /** |
| * Get all "management*ok.properties" files in the directory |
| * indicated by the "test.src" management property. |
| **/ |
| private static File[] findConfigurationFilesOk() { |
| final String testSrc = System.getProperty("test.src"); |
| final File dir = new File(testSrc); |
| final FilenameFilter filter = |
| new ConfigFilenameFilter("management_test","ok.properties"); |
| return dir.listFiles(filter); |
| } |
| |
| /** |
| * Get all "management*ko.properties" files in the directory |
| * indicated by the "test.src" management property. |
| **/ |
| private static File[] findConfigurationFilesKo() { |
| final String testSrc = System.getProperty("test.src"); |
| final File dir = new File(testSrc); |
| final FilenameFilter filter = |
| new ConfigFilenameFilter("management_test","ko.properties"); |
| return dir.listFiles(filter); |
| } |
| |
| /** |
| * List all MBeans and their attributes. Used to test communication |
| * with the Java M&M MBean Server. |
| * @return the number of queried MBeans. |
| */ |
| public static int listMBeans(MBeanServerConnection server) |
| throws IOException { |
| return listMBeans(server,null,null); |
| } |
| |
| /** |
| * List all matching MBeans and their attributes. |
| * Used to test communication with the Java M&M MBean Server. |
| * @return the number of matching MBeans. |
| */ |
| public static int listMBeans(MBeanServerConnection server, |
| ObjectName pattern, QueryExp query) |
| throws IOException { |
| |
| final Set names = server.queryNames(pattern,query); |
| for (final Iterator i=names.iterator(); i.hasNext(); ) { |
| ObjectName name = (ObjectName)i.next(); |
| log.trace("listMBeans","Got MBean: "+name); |
| try { |
| MBeanInfo info = |
| server.getMBeanInfo((ObjectName)name); |
| MBeanAttributeInfo[] attrs = info.getAttributes(); |
| if (attrs == null) continue; |
| for (int j=0; j<attrs.length; j++) { |
| if (attrs[j].isReadable()) { |
| try { |
| Object o = |
| server.getAttribute(name,attrs[j].getName()); |
| if (log.isDebugOn()) |
| log.debug("listMBeans","\t\t" + |
| attrs[j].getName() + |
| " = "+o); |
| } catch (Exception x) { |
| log.trace("listMBeans","JmxClient failed to get " + |
| attrs[j].getName() + ": " + x); |
| final IOException io = |
| new IOException("JmxClient failed to get " + |
| attrs[j].getName()); |
| io.initCause(x); |
| throw io; |
| } |
| } |
| } |
| } catch (Exception x) { |
| log.trace("listMBeans", |
| "JmxClient failed to get MBeanInfo: " + x); |
| final IOException io = |
| new IOException("JmxClient failed to get MBeanInfo: "+x); |
| io.initCause(x); |
| throw io; |
| } |
| } |
| return names.size(); |
| } |
| |
| /** |
| * Compute the full path name for a default file. |
| * @param basename basename (with extension) of the default file. |
| * @return ${JRE}/lib/management/${basename} |
| **/ |
| private static String getDefaultFileName(String basename) { |
| final String fileSeparator = File.separator; |
| final StringBuffer defaultFileName = |
| new StringBuffer(System.getProperty("java.home")). |
| append(fileSeparator).append("lib").append(fileSeparator). |
| append("management").append(fileSeparator). |
| append(basename); |
| return defaultFileName.toString(); |
| } |
| |
| /** |
| * Compute the full path name for a default file. |
| * @param basename basename (with extension) of the default file. |
| * @return ${JRE}/lib/management/${basename} |
| **/ |
| private static String getDefaultStoreName(String basename) { |
| final String fileSeparator = File.separator; |
| final StringBuffer defaultFileName = |
| new StringBuffer(System.getProperty("test.src")). |
| append(fileSeparator).append("ssl").append(fileSeparator). |
| append(basename); |
| return defaultFileName.toString(); |
| } |
| |
| |
| /** |
| * Parses the password file to read the credentials. |
| * Returns an ArrayList of arrays of 2 string: |
| * {<subject>, <password>}. |
| * If the password file does not exists, return an empty list. |
| * (File not found = empty file). |
| **/ |
| private ArrayList readCredentials(String passwordFileName) |
| throws IOException { |
| final Properties pws = new Properties(); |
| final ArrayList result = new ArrayList(); |
| final File f = new File(passwordFileName); |
| if (!f.exists()) return result; |
| FileInputStream fin = new FileInputStream(passwordFileName); |
| try {pws.load(fin);}finally{fin.close();} |
| for (Enumeration en=pws.propertyNames();en.hasMoreElements();) { |
| final String[] cred = new String[2]; |
| cred[0]=(String)en.nextElement(); |
| cred[1]=pws.getProperty(cred[0]); |
| result.add(cred); |
| } |
| return result; |
| } |
| |
| |
| /** |
| * Connect with the given url, using all given credentials in turn. |
| * A null entry in the useCredentials arrays indicate a connection |
| * where no credentials are used. |
| * @param url JMXServiceURL of the server. |
| * @param useCredentials An array of credentials (a credential |
| * is a two String array, so this is an array of arrays |
| * of strings: |
| * useCredentials[i][0]=subject |
| * useCredentials[i][1]=password |
| * if useCredentials[i] == null means no credentials. |
| * @param expectConnectOk true if connection is expected to succeed |
| * Note: if expectConnectOk=false and the test fails to connect |
| * the number of failure is not incremented. Conversely, |
| * if expectConnectOk=false and the test does not fail to |
| * connect the number of failure is incremented. |
| * @param expectReadOk true if communication (listMBeans) is expected |
| * to succeed. |
| * Note: if expectReadOk=false and the test fails to read MBeans |
| * the number of failure is not incremented. Conversely, |
| * if expectReadOk=false and the test does not fail to |
| * read MBeans the number of failure is incremented. |
| * @return number of failure. |
| **/ |
| public int connectAndRead(JMXServiceURL url, |
| Object[] useCredentials, |
| boolean expectConnectOk, |
| boolean expectReadOk) |
| throws IOException { |
| |
| int errorCount = 0; |
| |
| for (int i=0 ; i<useCredentials.length ; i++) { |
| final Map m = new HashMap(); |
| final String[] credentials = (String[])useCredentials[i]; |
| final String crinfo; |
| if (credentials != null) { |
| crinfo = "{"+credentials[0] + ", " + credentials[1] + "}"; |
| m.put(PropertyNames.CREDENTIALS,credentials); |
| } else { |
| crinfo="no credentials"; |
| } |
| log.trace("testCommunication","using credentials: " + crinfo); |
| |
| final JMXConnector c; |
| try { |
| c = JMXConnectorFactory.connect(url,m); |
| } catch (IOException x ) { |
| if (expectConnectOk) { |
| final String err = "Connection failed for " + crinfo + |
| ": " + x; |
| System.out.println(err); |
| log.trace("testCommunication",err); |
| log.debug("testCommunication",x); |
| errorCount++; |
| continue; |
| } else { |
| System.out.println("Connection failed as expected for " + |
| crinfo + ": " + x); |
| continue; |
| } |
| } catch (RuntimeException x ) { |
| if (expectConnectOk) { |
| final String err = "Connection failed for " + crinfo + |
| ": " + x; |
| System.out.println(err); |
| log.trace("testCommunication",err); |
| log.debug("testCommunication",x); |
| errorCount++; |
| continue; |
| } else { |
| System.out.println("Connection failed as expected for " + |
| crinfo + ": " + x); |
| continue; |
| } |
| } |
| try { |
| MBeanServerConnection conn = |
| c.getMBeanServerConnection(); |
| if (log.isDebugOn()) { |
| log.debug("testCommunication","Connection is:" + conn); |
| log.debug("testCommunication","Server domain is: " + |
| conn.getDefaultDomain()); |
| } |
| final ObjectName pattern = |
| new ObjectName("java.lang:type=Memory,*"); |
| final int count = listMBeans(conn,pattern,null); |
| if (count == 0) |
| throw new Exception("Expected at least one matching "+ |
| "MBean for "+pattern); |
| if (expectReadOk) { |
| System.out.println("Communication succeeded " + |
| "as expected for "+ |
| crinfo + ": found " + count |
| + ((count<2)?"MBean":"MBeans")); |
| } else { |
| final String err = "Expected failure didn't occur for " + |
| crinfo; |
| System.out.println(err); |
| errorCount++; |
| } |
| } catch (IOException x ) { |
| if (expectReadOk) { |
| final String err = "Communication failed with " + crinfo + |
| ": " + x; |
| System.out.println(err); |
| log.trace("testCommunication",err); |
| log.debug("testCommunication",x); |
| errorCount++; |
| continue; |
| } else { |
| System.out.println("Communication failed as expected for "+ |
| crinfo + ": " + x); |
| continue; |
| } |
| } catch (RuntimeException x ) { |
| if (expectReadOk) { |
| final String err = "Communication failed with " + crinfo + |
| ": " + x; |
| System.out.println(err); |
| log.trace("testCommunication",err); |
| log.debug("testCommunication",x); |
| errorCount++; |
| continue; |
| } else { |
| System.out.println("Communication failed as expected for "+ |
| crinfo + ": " + x); |
| } |
| } catch (Exception x) { |
| final String err = "Failed to read MBeans with " + crinfo + |
| ": " + x; |
| System.out.println(err); |
| log.trace("testCommunication",err); |
| log.debug("testCommunication",x); |
| errorCount++; |
| continue; |
| } finally { |
| c.close(); |
| } |
| } |
| return errorCount; |
| } |
| |
| |
| private void setSslProperties() { |
| final String defaultKeyStore = |
| getDefaultStoreName(DefaultValues.KEYSTORE); |
| final String defaultTrustStore = |
| getDefaultStoreName(DefaultValues.TRUSTSTORE); |
| |
| final String keyStore = |
| System.getProperty(PropertyNames.KEYSTORE, defaultKeyStore); |
| System.setProperty(PropertyNames.KEYSTORE,keyStore); |
| log.trace("setSslProperties",PropertyNames.KEYSTORE+"="+keyStore); |
| |
| final String password = |
| System.getProperty(PropertyNames.KEYSTORE_PASSWD, |
| DefaultValues.KEYSTORE_PASSWD); |
| System.setProperty(PropertyNames.KEYSTORE_PASSWD,password); |
| log.trace("setSslProperties", |
| PropertyNames.KEYSTORE_PASSWD+"="+password); |
| |
| final String trustStore = |
| System.getProperty(PropertyNames.TRUSTSTORE, |
| defaultTrustStore); |
| System.setProperty(PropertyNames.TRUSTSTORE,trustStore); |
| log.trace("setSslProperties", |
| PropertyNames.TRUSTSTORE+"="+trustStore); |
| |
| final String trustword = |
| System.getProperty(PropertyNames.TRUSTSTORE_PASSWD, |
| DefaultValues.TRUSTSTORE_PASSWD); |
| System.setProperty(PropertyNames.TRUSTSTORE_PASSWD,trustword); |
| log.trace("setSslProperties", |
| PropertyNames.TRUSTSTORE_PASSWD+"="+trustword); |
| } |
| |
| private void checkSslConfiguration() { |
| try { |
| final String defaultConf = |
| getDefaultFileName(DefaultValues.CONFIG_FILE_NAME); |
| final String confname = |
| System.getProperty(PropertyNames.CONFIG_FILE_NAME,defaultConf); |
| |
| final Properties props = new Properties(); |
| final File conf = new File(confname); |
| if (conf.exists()) { |
| FileInputStream fin = new FileInputStream(conf); |
| try {props.load(fin);} finally {fin.close();} |
| } |
| |
| // Do we use SSL? |
| final String useSslStr = |
| props.getProperty(PropertyNames.USE_SSL, |
| DefaultValues.USE_SSL); |
| final boolean useSsl = |
| Boolean.valueOf(useSslStr).booleanValue(); |
| |
| log.debug("checkSslConfiguration", |
| PropertyNames.USE_SSL+"="+useSsl+ |
| ": setting SSL"); |
| // Do we use SSL client authentication? |
| final String useSslClientAuthStr = |
| props.getProperty(PropertyNames.SSL_NEED_CLIENT_AUTH, |
| DefaultValues.SSL_NEED_CLIENT_AUTH); |
| final boolean useSslClientAuth = |
| Boolean.valueOf(useSslClientAuthStr).booleanValue(); |
| |
| log.debug("checkSslConfiguration", |
| PropertyNames.SSL_NEED_CLIENT_AUTH+"="+useSslClientAuth); |
| |
| // Do we use customized SSL cipher suites? |
| final String sslCipherSuites = |
| props.getProperty(PropertyNames.SSL_ENABLED_CIPHER_SUITES); |
| |
| log.debug("checkSslConfiguration", |
| PropertyNames.SSL_ENABLED_CIPHER_SUITES + "=" + |
| sslCipherSuites); |
| |
| // Do we use customized SSL protocols? |
| final String sslProtocols = |
| props.getProperty(PropertyNames.SSL_ENABLED_PROTOCOLS); |
| |
| log.debug("checkSslConfiguration", |
| PropertyNames.SSL_ENABLED_PROTOCOLS + "=" + |
| sslProtocols); |
| |
| if (useSsl) setSslProperties(); |
| } catch (Exception x) { |
| System.out.println("Failed to setup SSL configuration: " + x); |
| log.debug("checkSslConfiguration",x); |
| } |
| } |
| |
| /** |
| * Tests the server bootstraped at the given URL. |
| * Uses the system properties to determine which config file is used. |
| * Loads the config file to determine which password file is used. |
| * Loads the password file to find out wich credentials to use. |
| * Also checks that unregistered user/passwords are not allowed to |
| * connect when a password file is used. |
| * |
| * This method calls connectAndRead(). |
| **/ |
| public void testCommunication(JMXServiceURL url) |
| throws IOException { |
| |
| final String defaultConf = |
| getDefaultFileName(DefaultValues.CONFIG_FILE_NAME); |
| final String confname = |
| System.getProperty(PropertyNames.CONFIG_FILE_NAME,defaultConf); |
| |
| final Properties props = new Properties(); |
| final File conf = new File(confname); |
| if (conf.exists()) { |
| FileInputStream fin = new FileInputStream(conf); |
| try {props.load(fin);} finally {fin.close();} |
| } |
| |
| // Do we use authentication? |
| final String useAuthenticationStr = |
| props.getProperty(PropertyNames.USE_AUTHENTICATION, |
| DefaultValues.USE_AUTHENTICATION); |
| final boolean useAuthentication = |
| Boolean.valueOf(useAuthenticationStr).booleanValue(); |
| |
| // Get Password File |
| final String defaultPasswordFileName = Utils.convertPath( |
| getDefaultFileName(DefaultValues.PASSWORD_FILE_NAME)); |
| final String passwordFileName = Utils.convertPath( |
| props.getProperty(PropertyNames.PASSWORD_FILE_NAME, |
| defaultPasswordFileName)); |
| |
| // Get Access File |
| final String defaultAccessFileName = Utils.convertPath( |
| getDefaultFileName(DefaultValues.ACCESS_FILE_NAME)); |
| final String accessFileName = Utils.convertPath( |
| props.getProperty(PropertyNames.ACCESS_FILE_NAME, |
| defaultAccessFileName)); |
| |
| if (useAuthentication) { |
| System.out.println("PasswordFileName: " + passwordFileName); |
| System.out.println("accessFileName: " + accessFileName); |
| } |
| |
| final Object[] allCredentials; |
| final Object[] noCredentials = { null }; |
| if (useAuthentication) { |
| final ArrayList l = readCredentials(passwordFileName); |
| if (l.size() == 0) allCredentials = null; |
| else allCredentials = l.toArray(); |
| } else allCredentials = noCredentials; |
| |
| int errorCount = 0; |
| if (allCredentials!=null) { |
| // Tests that the registered user/passwords are allowed to |
| // connect & read |
| // |
| errorCount += connectAndRead(url,allCredentials,true,true); |
| } else { |
| // Tests that no one is allowed |
| // connect & read |
| // |
| final String[][] someCredentials = { |
| null, |
| { "modify", "R&D" }, |
| { "measure", "QED" } |
| }; |
| errorCount += connectAndRead(url,someCredentials,false,false); |
| } |
| |
| if (useAuthentication && allCredentials != noCredentials) { |
| // Tests that the registered user/passwords are not allowed to |
| // connect & read |
| // |
| final String[][] badCredentials = { |
| { "bad.user", "R&D" }, |
| { "measure", "bad.password" } |
| }; |
| errorCount += connectAndRead(url,badCredentials,false,false); |
| } |
| if (errorCount > 0) { |
| final String err = "Test " + confname + " failed with " + |
| errorCount + " error(s)"; |
| log.debug("testCommunication",err); |
| throw new RuntimeException(err); |
| } |
| } |
| |
| |
| /** |
| * Test the configuration indicated by `file'. |
| * Sets the appropriate System properties for config file and |
| * port and then calls ConnectorBootstrap.initialize(). |
| * eventually cleans up by calling ConnectorBootstrap.terminate(). |
| * @return null if the test succeeds, an error message otherwise. |
| **/ |
| private String testConfiguration(File file,int port) { |
| |
| final String path; |
| try { |
| path=(file==null)?null:file.getCanonicalPath(); |
| } catch(IOException x) { |
| final String err = "Failed to test configuration " + file + |
| ": " + x; |
| log.trace("testConfiguration",err); |
| log.debug("testConfiguration",x); |
| return err; |
| } |
| final String config = (path==null)?"Default config file":path; |
| |
| System.out.println("***"); |
| System.out.println("*** Testing configuration (port=" + port + "): " |
| + path); |
| System.out.println("***"); |
| |
| System.setProperty("com.sun.management.jmxremote.port", |
| Integer.toString(port)); |
| if (path != null) |
| System.setProperty("com.sun.management.config.file", path); |
| else |
| System.getProperties().remove("com.sun.management.config.file"); |
| |
| log.trace("testConfiguration","com.sun.management.jmxremote.port="+port); |
| if (path != null && log.isDebugOn()) |
| log.trace("testConfiguration", |
| "com.sun.management.config.file="+path); |
| |
| checkSslConfiguration(); |
| |
| final JMXConnectorServer cs; |
| try { |
| cs = ConnectorBootstrap.initialize(); |
| } catch (AgentConfigurationError x) { |
| final String err = "Failed to initialize connector:" + |
| "\n\tcom.sun.management.jmxremote.port=" + port + |
| ((path!=null)?"\n\tcom.sun.management.config.file="+path: |
| "\n\t"+config) + |
| "\n\tError is: " + x; |
| log.trace("testConfiguration",err); |
| log.debug("testConfiguration",x); |
| return err; |
| } catch (Exception x) { |
| log.debug("testConfiguration",x); |
| return x.toString(); |
| } |
| |
| try { |
| JMXServiceURL url = |
| new JMXServiceURL("rmi",null,0,"/jndi/rmi://localhost:"+ |
| port+"/jmxrmi"); |
| |
| try { |
| testCommunication(url); |
| } catch (Exception x) { |
| final String err = "Failed to connect to agent {url="+url+ |
| "}: " + x; |
| log.trace("testConfiguration",err); |
| log.debug("testConfiguration",x); |
| return err; |
| } |
| } catch (Exception x) { |
| final String err = "Failed to test configuration "+config+ |
| ": "+x; |
| log.trace("testConfiguration",err); |
| log.debug("testConfiguration",x); |
| return err; |
| } finally { |
| try { |
| cs.stop(); |
| } catch (Exception x) { |
| final String err = "Failed to terminate: "+x; |
| log.trace("testConfiguration",err); |
| log.debug("testConfiguration",x); |
| } |
| } |
| System.out.println("Configuration " + config + " successfully tested"); |
| return null; |
| } |
| |
| /** |
| * Test a configuration file which should make the bootstrap fail. |
| * The test is assumed to have succeeded if the bootstrap fails. |
| * @return null if the test succeeds, an error message otherwise. |
| **/ |
| private String testConfigurationKo(File conf,int port) { |
| final String errStr = testConfiguration(conf,port+testPort++); |
| if (errStr == null) { |
| return "Configuration " + |
| conf + " should have failed!"; |
| } |
| System.out.println("Configuration " + |
| conf + " failed as expected"); |
| log.debug("runko","Error was: " + errStr); |
| return null; |
| } |
| |
| /** |
| * Test a configuration file. Determines whether the bootstrap |
| * should succeed or fail depending on the file name: |
| * *ok.properties: bootstrap should succeed. |
| * *ko.properties: bootstrap or connection should fail. |
| * @return null if the test succeeds, an error message otherwise. |
| **/ |
| private String testConfigurationFile(String fileName) { |
| File file = new File(fileName); |
| final String portStr = System.getProperty("rmi.port","12424"); |
| final int port = Integer.parseInt(portStr); |
| |
| if (fileName.endsWith("ok.properties")) { |
| return testConfiguration(file,port+testPort++); |
| } |
| if (fileName.endsWith("ko.properties")) { |
| return testConfigurationKo(file,port+testPort++); |
| } |
| return fileName + |
| ": test file suffix must be one of [ko|ok].properties"; |
| } |
| |
| /** |
| * Find all *ko.property files and test them. |
| * (see findConfigurationFilesKo() and testConfigurationKo()) |
| * @throws RuntimeException if the test fails. |
| **/ |
| public void runko() { |
| final String portStr = System.getProperty("rmi.port","12424"); |
| final int port = Integer.parseInt(portStr); |
| final File[] conf = findConfigurationFilesKo(); |
| if ((conf == null)||(conf.length == 0)) |
| throw new RuntimeException("No configuration found"); |
| |
| String errStr; |
| for (int i=0;i<conf.length;i++) { |
| errStr = testConfigurationKo(conf[i],port+testPort++); |
| if (errStr != null) { |
| throw new RuntimeException(errStr); |
| } |
| } |
| |
| } |
| |
| /** |
| * Find all *ok.property files and test them. |
| * (see findConfigurationFilesOk() and testConfiguration()) |
| * @throws RuntimeException if the test fails. |
| **/ |
| public void runok() { |
| final String portStr = System.getProperty("rmi.port","12424"); |
| final int port = Integer.parseInt(portStr); |
| final File[] conf = findConfigurationFilesOk(); |
| if ((conf == null)||(conf.length == 0)) |
| throw new RuntimeException("No configuration found"); |
| |
| String errStr; |
| for (int i=0;i<conf.length;i++) { |
| errStr = testConfiguration(conf[i],port+testPort++); |
| if (errStr != null) { |
| throw new RuntimeException(errStr); |
| } |
| } |
| |
| // FIXME: No jmxremote.password is not installed in JRE by default. |
| // - disable the following test case. |
| // |
| // Test default config |
| // |
| // errStr = testConfiguration(null,port+testPort++); |
| // if (errStr != null) { |
| // throw new RuntimeException(errStr); |
| // } |
| } |
| |
| /** |
| * Finds all configuration files (*ok.properties and *ko.properties) |
| * and tests them. |
| * (see runko() and runok()). |
| * @throws RuntimeException if the test fails. |
| **/ |
| public void run() { |
| runok(); |
| runko(); |
| } |
| |
| /** |
| * Tests the specified configuration files. |
| * If args[] is not empty, each element in args[] is expected to be |
| * a filename ending either by ok.properties or ko.properties. |
| * Otherwise, the configuration files will be automatically determined |
| * by looking at all *.properties files located in the directory |
| * indicated by the System property "test.src". |
| * @throws RuntimeException if the test fails. |
| **/ |
| public void run(String args[]) { |
| if (args.length == 0) { |
| run() ; return; |
| } |
| for (int i=0; i<args.length; i++) { |
| final String errStr =testConfigurationFile(args[i]); |
| if (errStr != null) { |
| throw new RuntimeException(errStr); |
| } |
| } |
| } |
| |
| /** |
| * Calls run(args[]). |
| * exit(1) if the test fails. |
| **/ |
| public static void main(String args[]) { |
| RmiBootstrapTest manager = new RmiBootstrapTest(); |
| try { |
| manager.run(args); |
| } catch (RuntimeException r) { |
| System.out.println("Test Failed: "+ r.getMessage()); |
| System.exit(1); |
| } catch (Throwable t) { |
| System.out.println("Test Failed: "+ t); |
| t.printStackTrace(); |
| System.exit(2); |
| } |
| System.out.println("**** Test RmiBootstrap Passed ****"); |
| } |
| |
| } |
