1 /*
   2  * Copyright (c) 2003, 2017, Oracle and/or its affiliates. All rights reserved.
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * This code is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 only, as
   7  * published by the Free Software Foundation.  Oracle designates this
   8  * particular file as subject to the "Classpath" exception as provided
   9  * by Oracle in the LICENSE file that accompanied this code.
  10  *
  11  * This code is distributed in the hope that it will be useful, but WITHOUT
  12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  14  * version 2 for more details (a copy is included in the LICENSE file that
  15  * accompanied this code).
  16  *
  17  * You should have received a copy of the GNU General Public License version
  18  * 2 along with this work; if not, write to the Free Software Foundation,
  19  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  20  *
  21  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  22  * or visit www.oracle.com if you need additional information or have any
  23  * questions.
  24  */
  25 package jdk.internal.agent;
  26 
  27 import java.io.BufferedInputStream;
  28 import java.io.File;
  29 import java.io.FileInputStream;
  30 import java.io.FileNotFoundException;
  31 import java.io.IOException;
  32 import java.io.InputStream;
  33 import java.lang.management.ManagementFactory;
  34 import java.lang.reflect.Method;
  35 import java.net.InetAddress;
  36 import java.net.MalformedURLException;
  37 import java.net.UnknownHostException;
  38 import java.security.AccessController;
  39 import java.security.PrivilegedAction;
  40 import java.text.MessageFormat;
  41 import java.util.HashMap;
  42 import java.util.Map;
  43 import java.util.MissingResourceException;
  44 import java.util.Properties;
  45 import java.util.ResourceBundle;
  46 import java.util.ServiceLoader;
  47 import java.util.function.Function;
  48 import java.util.function.Predicate;
  49 
  50 import javax.management.remote.JMXConnectorServer;
  51 import javax.management.remote.JMXServiceURL;
  52 
  53 import static jdk.internal.agent.AgentConfigurationError.*;
  54 import jdk.internal.agent.spi.AgentProvider;
  55 import jdk.internal.vm.VMSupport;
  56 import sun.management.jdp.JdpController;
  57 import sun.management.jdp.JdpException;
  58 import sun.management.jmxremote.ConnectorBootstrap;
  59 
  60 /**
  61  * This Agent is started by the VM when -Dcom.sun.management.snmp or
  62  * -Dcom.sun.management.jmxremote is set. This class will be loaded by the
  63  * system class loader. Also jmx framework could be started by jcmd
  64  */
  65 public class Agent {
  66     /**
  67      * Agent status collector strategy class
  68      */
  69     private static abstract class StatusCollector {
  70         protected static final Map<String, String> DEFAULT_PROPS = new HashMap<>();
  71 
  72         static {
  73             DEFAULT_PROPS.put(ConnectorBootstrap.PropertyNames.PORT,
  74                               ConnectorBootstrap.DefaultValues.PORT);
  75             DEFAULT_PROPS.put(ConnectorBootstrap.PropertyNames.USE_LOCAL_ONLY,
  76                               ConnectorBootstrap.DefaultValues.USE_LOCAL_ONLY);
  77             DEFAULT_PROPS.put(ConnectorBootstrap.PropertyNames.USE_AUTHENTICATION,
  78                               ConnectorBootstrap.DefaultValues.USE_AUTHENTICATION);
  79             DEFAULT_PROPS.put(ConnectorBootstrap.PropertyNames.USE_SSL,
  80                               ConnectorBootstrap.DefaultValues.USE_SSL);
  81             DEFAULT_PROPS.put(ConnectorBootstrap.PropertyNames.USE_REGISTRY_SSL,
  82                               ConnectorBootstrap.DefaultValues.USE_REGISTRY_SSL);
  83             DEFAULT_PROPS.put(ConnectorBootstrap.PropertyNames.SSL_NEED_CLIENT_AUTH,
  84                               ConnectorBootstrap.DefaultValues.SSL_NEED_CLIENT_AUTH);
  85             DEFAULT_PROPS.put(ConnectorBootstrap.PropertyNames.CONFIG_FILE_NAME,
  86                               ConnectorBootstrap.DefaultValues.CONFIG_FILE_NAME);
  87             DEFAULT_PROPS.put(ConnectorBootstrap.PropertyNames.PASSWORD_FILE_NAME,
  88                               ConnectorBootstrap.DefaultValues.PASSWORD_FILE_NAME);
  89             DEFAULT_PROPS.put(ConnectorBootstrap.PropertyNames.ACCESS_FILE_NAME,
  90                               ConnectorBootstrap.DefaultValues.ACCESS_FILE_NAME);
  91 
  92         }
  93 
  94         final protected StringBuilder sb = new StringBuilder();
  95         final public String collect() {
  96             Properties agentProps = VMSupport.getAgentProperties();
  97             String localConnAddr = (String)agentProps.get(LOCAL_CONNECTOR_ADDRESS_PROP);
  98             if (localConnAddr != null || jmxServer != null) {
  99                 addAgentStatus(true);
 100                 appendConnections(localConnAddr);
 101             } else {
 102                 addAgentStatus(false);
 103             }
 104             return sb.toString();
 105         }
 106 
 107         private void appendConnections(String localConnAddr) {
 108             appendConnectionsHeader();
 109             if (localConnAddr != null) {
 110                 try {
 111                     JMXServiceURL u = new JMXServiceURL(localConnAddr);
 112                     addConnection(false, u);
 113                 } catch (MalformedURLException e) {
 114                     // will never happen
 115                 }
 116 
 117             }
 118             if (jmxServer != null) {
 119                 addConnection(true, jmxServer.getAddress());
 120             }
 121             appendConnectionsFooter();
 122         }
 123 
 124         private void addConnection(boolean remote, JMXServiceURL u) {
 125             appendConnectionHeader(remote);
 126             addConnectionDetails(u);
 127             addConfigProperties();
 128             appendConnectionFooter(remote);
 129         }
 130 
 131         private void addConfigProperties() {
 132             appendConfigPropsHeader();
 133 
 134             Properties remoteProps = configProps != null ?
 135                                         configProps : getManagementProperties();
 136             Map<Object, Object> props = new HashMap<>(DEFAULT_PROPS);
 137 
 138             if (remoteProps == null) {
 139                 // local connector only
 140                 String loc_only = System.getProperty(
 141                     ConnectorBootstrap.PropertyNames.USE_LOCAL_ONLY
 142                 );
 143 
 144                 if (loc_only != null &&
 145                     !ConnectorBootstrap.DefaultValues.USE_LOCAL_ONLY.equals(loc_only)) {
 146                     props.put(
 147                         ConnectorBootstrap.PropertyNames.USE_LOCAL_ONLY,
 148                         loc_only
 149                     );
 150                 }
 151             } else {
 152                 props.putAll(remoteProps);
 153             }
 154 
 155             props.entrySet().stream()
 156                 .filter(preprocess(Map.Entry::getKey, StatusCollector::isManagementProp))
 157                 .forEach(this::addConfigProp);
 158 
 159             appendConfigPropsFooter();
 160         }
 161 
 162         private static boolean isManagementProp(Object pName) {
 163             return pName != null && pName.toString().startsWith("com.sun.management.");
 164         }
 165 
 166         private static <T, V> Predicate<T> preprocess(Function<T, V> f, Predicate<V> p) {
 167             return (T t) -> p.test(f.apply(t));
 168         }
 169 
 170         abstract protected void addAgentStatus(boolean enabled);
 171         abstract protected void appendConnectionsHeader();
 172         abstract protected void appendConnectionsFooter();
 173         abstract protected void addConnectionDetails(JMXServiceURL u);
 174         abstract protected void appendConnectionHeader(boolean remote);
 175         abstract protected void appendConnectionFooter(boolean remote);
 176         abstract protected void appendConfigPropsHeader();
 177         abstract protected void appendConfigPropsFooter();
 178         abstract protected void addConfigProp(Map.Entry<?, ?> prop);
 179     }
 180 
 181     /**
 182      * Free-text status collector strategy implementation
 183      */
 184     final private static class TextStatusCollector extends StatusCollector {
 185 
 186         @Override
 187         protected void addAgentStatus(boolean enabled) {
 188             sb.append("Agent: ").append(enabled ? "enabled" : "disabled").append('\n');
 189         }
 190 
 191         @Override
 192         protected void appendConnectionsHeader() {
 193             sb.append('\n');
 194         }
 195 
 196         @Override
 197         protected void addConnectionDetails(JMXServiceURL u) {
 198             sb.append("Protocol       : ").append(u.getProtocol()).append('\n')
 199               .append("Host           : ").append(u.getHost()).append('\n')
 200               .append("URL            : ").append(u).append('\n');
 201         }
 202 
 203         @Override
 204         protected void appendConnectionHeader(boolean remote) {
 205             sb.append("Connection Type: ").append(remote ? "remote" : "local").append('\n');
 206         }
 207 
 208         @Override
 209         protected void appendConfigPropsHeader() {
 210             sb.append("Properties     :\n");
 211         }
 212 
 213         @Override
 214         protected void addConfigProp(Map.Entry<?, ?> prop) {
 215             sb.append("  ").append(prop.getKey()).append(" = ")
 216               .append(prop.getValue());
 217             Object defVal = DEFAULT_PROPS.get(prop.getKey());
 218             if (defVal != null && defVal.equals(prop.getValue())) {
 219                 sb.append(" [default]");
 220             }
 221             sb.append("\n");
 222         }
 223 
 224         @Override
 225         protected void appendConnectionsFooter() {}
 226 
 227         @Override
 228         protected void appendConnectionFooter(boolean remote) {
 229             sb.append('\n');
 230         }
 231 
 232         @Override
 233         protected void appendConfigPropsFooter() {}
 234     }
 235 
 236     // management properties
 237 
 238     private static Properties mgmtProps;
 239     private static ResourceBundle messageRB;
 240     private static final String CONFIG_FILE =
 241             "com.sun.management.config.file";
 242     private static final String SNMP_PORT =
 243             "com.sun.management.snmp.port";
 244     private static final String JMXREMOTE =
 245             "com.sun.management.jmxremote";
 246     private static final String JMXREMOTE_PORT =
 247             "com.sun.management.jmxremote.port";
 248     private static final String RMI_PORT =
 249             "com.sun.management.jmxremote.rmi.port";
 250     private static final String ENABLE_THREAD_CONTENTION_MONITORING =
 251             "com.sun.management.enableThreadContentionMonitoring";
 252     private static final String LOCAL_CONNECTOR_ADDRESS_PROP =
 253             "com.sun.management.jmxremote.localConnectorAddress";
 254     private static final String SNMP_AGENT_NAME =
 255             "SnmpAgent";
 256 
 257     private static final String JDP_DEFAULT_ADDRESS = "224.0.23.178";
 258     private static final int JDP_DEFAULT_PORT = 7095;
 259 
 260     // The only active agent allowed
 261     private static JMXConnectorServer jmxServer = null;
 262     // The properties used to configure the server
 263     private static Properties configProps = null;
 264 
 265     // Parse string com.sun.management.prop=xxx,com.sun.management.prop=yyyy
 266     // and return property set if args is null or empty
 267     // return empty property set
 268     private static Properties parseString(String args) {
 269         Properties argProps = new Properties();
 270         if (args != null && !args.trim().equals("")) {
 271             for (String option : args.split(",")) {
 272                 String s[] = option.split("=", 2);
 273                 String name = s[0].trim();
 274                 String value = (s.length > 1) ? s[1].trim() : "";
 275 
 276                 if (!name.startsWith("com.sun.management.")) {
 277                     error(INVALID_OPTION, name);
 278                 }
 279 
 280                 argProps.setProperty(name, value);
 281             }
 282         }
 283 
 284         return argProps;
 285     }
 286 
 287     // invoked by -javaagent or -Dcom.sun.management.agent.class
 288     public static void premain(String args) throws Exception {
 289         agentmain(args);
 290     }
 291 
 292     // invoked by attach mechanism
 293     public static void agentmain(String args) throws Exception {
 294         if (args == null || args.length() == 0) {
 295             args = JMXREMOTE;           // default to local management
 296         }
 297 
 298         Properties arg_props = parseString(args);
 299 
 300         // Read properties from the config file
 301         Properties config_props = new Properties();
 302         String fname = arg_props.getProperty(CONFIG_FILE);
 303         readConfiguration(fname, config_props);
 304 
 305         // Arguments override config file
 306         config_props.putAll(arg_props);
 307         startAgent(config_props);
 308     }
 309 
 310     // jcmd ManagementAgent.start_local entry point
 311     // Also called due to command-line via startAgent()
 312     private static synchronized void startLocalManagementAgent() {
 313         Properties agentProps = VMSupport.getAgentProperties();
 314 
 315         // start local connector if not started
 316         if (agentProps.get(LOCAL_CONNECTOR_ADDRESS_PROP) == null) {
 317             JMXConnectorServer cs = ConnectorBootstrap.startLocalConnectorServer();
 318             String address = cs.getAddress().toString();
 319             // Add the local connector address to the agent properties
 320             agentProps.put(LOCAL_CONNECTOR_ADDRESS_PROP, address);
 321 
 322             try {
 323                 // export the address to the instrumentation buffer
 324                 ConnectorAddressLink.export(address);
 325             } catch (Exception x) {
 326                 // Connector server started but unable to export address
 327                 // to instrumentation buffer - non-fatal error.
 328                 warning(EXPORT_ADDRESS_FAILED, x.getMessage());
 329             }
 330         }
 331     }
 332 
 333     // jcmd ManagementAgent.start entry point
 334     // This method starts the remote JMX agent and starts neither
 335     // the local JMX agent nor the SNMP agent
 336     // @see #startLocalManagementAgent and also @see #startAgent.
 337     private static synchronized void startRemoteManagementAgent(String args) throws Exception {
 338         if (jmxServer != null) {
 339             throw new RuntimeException(getText(INVALID_STATE, "Agent already started"));
 340         }
 341 
 342         try {
 343             Properties argProps = parseString(args);
 344             configProps = new Properties();
 345 
 346             // Load the management properties from the config file
 347             // if config file is not specified readConfiguration implicitly
 348             // reads <java.home>/conf/management/management.properties
 349 
 350             String fname = System.getProperty(CONFIG_FILE);
 351             readConfiguration(fname, configProps);
 352 
 353             // management properties can be overridden by system properties
 354             // which take precedence
 355             Properties sysProps = System.getProperties();
 356             synchronized (sysProps) {
 357                 configProps.putAll(sysProps);
 358             }
 359 
 360             // if user specifies config file into command line for either
 361             // jcmd utilities or attach command it overrides properties set in
 362             // command line at the time of VM start
 363             String fnameUser = argProps.getProperty(CONFIG_FILE);
 364             if (fnameUser != null) {
 365                 readConfiguration(fnameUser, configProps);
 366             }
 367 
 368             // arguments specified in command line of jcmd utilities
 369             // override both system properties and one set by config file
 370             // specified in jcmd command line
 371             configProps.putAll(argProps);
 372 
 373             // jcmd doesn't allow to change ThreadContentionMonitoring, but user
 374             // can specify this property inside config file, so enable optional
 375             // monitoring functionality if this property is set
 376             final String enableThreadContentionMonitoring =
 377                     configProps.getProperty(ENABLE_THREAD_CONTENTION_MONITORING);
 378 
 379             if (enableThreadContentionMonitoring != null) {
 380                 ManagementFactory.getThreadMXBean().
 381                         setThreadContentionMonitoringEnabled(true);
 382             }
 383 
 384             String jmxremotePort = configProps.getProperty(JMXREMOTE_PORT);
 385             if (jmxremotePort != null) {
 386                 jmxServer = ConnectorBootstrap.
 387                         startRemoteConnectorServer(jmxremotePort, configProps);
 388 
 389                 startDiscoveryService(configProps);
 390             } else {
 391                 throw new AgentConfigurationError(INVALID_JMXREMOTE_PORT, "No port specified");
 392             }
 393         } catch (JdpException e) {
 394             error(e);
 395         } catch (AgentConfigurationError err) {
 396             error(err.getError(), err.getParams());
 397         }
 398     }
 399 
 400     private static synchronized void stopRemoteManagementAgent() throws Exception {
 401 
 402         JdpController.stopDiscoveryService();
 403 
 404         if (jmxServer != null) {
 405             ConnectorBootstrap.unexportRegistry();
 406             ConnectorAddressLink.unexportRemote();
 407 
 408             // Attempt to stop already stopped agent
 409             // Don't cause any errors.
 410             jmxServer.stop();
 411             jmxServer = null;
 412             configProps = null;
 413         }
 414     }
 415 
 416     private static synchronized String getManagementAgentStatus() throws Exception {
 417         return new TextStatusCollector().collect();
 418     }
 419 
 420     private static void startAgent(Properties props) throws Exception {
 421         String snmpPort = props.getProperty(SNMP_PORT);
 422         String jmxremote = props.getProperty(JMXREMOTE);
 423         String jmxremotePort = props.getProperty(JMXREMOTE_PORT);
 424 
 425         // Enable optional monitoring functionality if requested
 426         final String enableThreadContentionMonitoring =
 427                 props.getProperty(ENABLE_THREAD_CONTENTION_MONITORING);
 428         if (enableThreadContentionMonitoring != null) {
 429             ManagementFactory.getThreadMXBean().
 430                     setThreadContentionMonitoringEnabled(true);
 431         }
 432 
 433         try {
 434             if (snmpPort != null) {
 435                 loadSnmpAgent(props);
 436             }
 437 
 438             /*
 439              * If the jmxremote.port property is set then we start the
 440              * RMIConnectorServer for remote M&M.
 441              *
 442              * If the jmxremote or jmxremote.port properties are set then
 443              * we start a RMIConnectorServer for local M&M. The address
 444              * of this "local" server is exported as a counter to the jstat
 445              * instrumentation buffer.
 446              */
 447             if (jmxremote != null || jmxremotePort != null) {
 448                 if (jmxremotePort != null) {
 449                     jmxServer = ConnectorBootstrap.
 450                             startRemoteConnectorServer(jmxremotePort, props);
 451                     startDiscoveryService(props);
 452                 }
 453                 startLocalManagementAgent();
 454             }
 455 
 456         } catch (AgentConfigurationError e) {
 457             error(e.getError(), e.getParams());
 458         } catch (Exception e) {
 459             error(e);
 460         }
 461     }
 462 
 463     private static void startDiscoveryService(Properties props)
 464             throws IOException, JdpException {
 465         // Start discovery service if requested
 466         String discoveryPort = props.getProperty("com.sun.management.jdp.port");
 467         String discoveryAddress = props.getProperty("com.sun.management.jdp.address");
 468         String discoveryShouldStart = props.getProperty("com.sun.management.jmxremote.autodiscovery");
 469 
 470         // Decide whether we should start autodicovery service.
 471         // To start autodiscovery following conditions should be met:
 472         // autodiscovery==true OR (autodicovery==null AND jdp.port != NULL)
 473 
 474         boolean shouldStart = false;
 475         if (discoveryShouldStart == null){
 476             shouldStart = (discoveryPort != null);
 477         }
 478         else{
 479             try{
 480                shouldStart = Boolean.parseBoolean(discoveryShouldStart);
 481             } catch (NumberFormatException e) {
 482                 throw new AgentConfigurationError(AGENT_EXCEPTION, "Couldn't parse autodiscovery argument");
 483             }
 484         }
 485 
 486         if (shouldStart) {
 487             // port and address are required arguments and have no default values
 488             InetAddress address;
 489             try {
 490                 address = (discoveryAddress == null) ?
 491                         InetAddress.getByName(JDP_DEFAULT_ADDRESS) : InetAddress.getByName(discoveryAddress);
 492             } catch (UnknownHostException e) {
 493                 throw new AgentConfigurationError(AGENT_EXCEPTION, e, "Unable to broadcast to requested address");
 494             }
 495 
 496             int port = JDP_DEFAULT_PORT;
 497             if (discoveryPort != null) {
 498                try {
 499                   port = Integer.parseInt(discoveryPort);
 500                } catch (NumberFormatException e) {
 501                  throw new AgentConfigurationError(AGENT_EXCEPTION, "Couldn't parse JDP port argument");
 502                }
 503             }
 504 
 505             // Get service URL to broadcast it
 506             Map<String,String> remoteProps = ConnectorAddressLink.importRemoteFrom(0);
 507             String jmxUrlStr = remoteProps.get("sun.management.JMXConnectorServer.0.remoteAddress");
 508 
 509             String instanceName = props.getProperty("com.sun.management.jdp.name");
 510 
 511             JdpController.startDiscoveryService(address, port, instanceName, jmxUrlStr);
 512         }
 513     }
 514 
 515     public static Properties loadManagementProperties() {
 516         Properties props = new Properties();
 517 
 518         // Load the management properties from the config file
 519 
 520         String fname = System.getProperty(CONFIG_FILE);
 521         readConfiguration(fname, props);
 522 
 523         // management properties can be overridden by system properties
 524         // which take precedence
 525         Properties sysProps = System.getProperties();
 526         synchronized (sysProps) {
 527             props.putAll(sysProps);
 528         }
 529 
 530         return props;
 531     }
 532 
 533     public static synchronized Properties getManagementProperties() {
 534         if (mgmtProps == null) {
 535             String configFile = System.getProperty(CONFIG_FILE);
 536             String snmpPort = System.getProperty(SNMP_PORT);
 537             String jmxremote = System.getProperty(JMXREMOTE);
 538             String jmxremotePort = System.getProperty(JMXREMOTE_PORT);
 539 
 540             if (configFile == null && snmpPort == null
 541                     && jmxremote == null && jmxremotePort == null) {
 542                 // return if out-of-the-management option is not specified
 543                 return null;
 544             }
 545             mgmtProps = loadManagementProperties();
 546         }
 547         return mgmtProps;
 548     }
 549 
 550     private static void loadSnmpAgent(Properties props) {
 551         /*
 552          * Load the jdk.snmp service
 553          */
 554         AgentProvider provider = AccessController.doPrivileged(
 555             (PrivilegedAction<AgentProvider>) () -> {
 556                 for (AgentProvider aProvider : ServiceLoader.loadInstalled(AgentProvider.class)) {
 557                     if (aProvider.getName().equals(SNMP_AGENT_NAME))
 558                         return aProvider;
 559                 }
 560                 return null;
 561             },  null
 562         );
 563 
 564         if (provider != null) {
 565             provider.startAgent(props);
 566          } else { // snmp runtime doesn't exist - initialization fails
 567             throw new UnsupportedOperationException("Unsupported management property: " + SNMP_PORT);
 568         }
 569     }
 570 
 571     // read config file and initialize the properties
 572     private static void readConfiguration(String fname, Properties p) {
 573         if (fname == null) {
 574             String home = System.getProperty("java.home");
 575             if (home == null) {
 576                 throw new Error("Can't find java.home ??");
 577             }
 578             StringBuilder defaultFileName = new StringBuilder(home);
 579             defaultFileName.append(File.separator).append("conf");
 580             defaultFileName.append(File.separator).append("management");
 581             defaultFileName.append(File.separator).append("management.properties");
 582             // Set file name
 583             fname = defaultFileName.toString();
 584         }
 585         final File configFile = new File(fname);
 586         if (!configFile.exists()) {
 587             error(CONFIG_FILE_NOT_FOUND, fname);
 588         }
 589 
 590         InputStream in = null;
 591         try {
 592             in = new FileInputStream(configFile);
 593             BufferedInputStream bin = new BufferedInputStream(in);
 594             p.load(bin);
 595         } catch (FileNotFoundException e) {
 596             error(CONFIG_FILE_OPEN_FAILED, e.getMessage());
 597         } catch (IOException e) {
 598             error(CONFIG_FILE_OPEN_FAILED, e.getMessage());
 599         } catch (SecurityException e) {
 600             error(CONFIG_FILE_ACCESS_DENIED, fname);
 601         } finally {
 602             if (in != null) {
 603                 try {
 604                     in.close();
 605                 } catch (IOException e) {
 606                     error(CONFIG_FILE_CLOSE_FAILED, fname);
 607                 }
 608             }
 609         }
 610     }
 611 
 612     public static void startAgent() throws Exception {
 613         String prop = System.getProperty("com.sun.management.agent.class");
 614 
 615         // -Dcom.sun.management.agent.class not set so read management
 616         // properties and start agent
 617         if (prop == null) {
 618             // initialize management properties
 619             Properties props = getManagementProperties();
 620             if (props != null) {
 621                 startAgent(props);
 622             }
 623             return;
 624         }
 625 
 626         // -Dcom.sun.management.agent.class=<agent classname>:<agent args>
 627         String[] values = prop.split(":");
 628         if (values.length < 1 || values.length > 2) {
 629             error(AGENT_CLASS_INVALID, "\"" + prop + "\"");
 630         }
 631         String cname = values[0];
 632         String args = (values.length == 2 ? values[1] : null);
 633 
 634         if (cname == null || cname.length() == 0) {
 635             error(AGENT_CLASS_INVALID, "\"" + prop + "\"");
 636         }
 637 
 638         if (cname != null) {
 639             try {
 640                 // Instantiate the named class.
 641                 // invoke the premain(String args) method
 642                 Class<?> clz = ClassLoader.getSystemClassLoader().loadClass(cname);
 643                 Method premain = clz.getMethod("premain",
 644                         new Class<?>[]{String.class});
 645                 premain.invoke(null, /* static */
 646                         new Object[]{args});
 647             } catch (ClassNotFoundException ex) {
 648                 error(AGENT_CLASS_NOT_FOUND, "\"" + cname + "\"");
 649             } catch (NoSuchMethodException ex) {
 650                 error(AGENT_CLASS_PREMAIN_NOT_FOUND, "\"" + cname + "\"");
 651             } catch (SecurityException ex) {
 652                 error(AGENT_CLASS_ACCESS_DENIED);
 653             } catch (Exception ex) {
 654                 String msg = (ex.getCause() == null
 655                         ? ex.getMessage()
 656                         : ex.getCause().getMessage());
 657                 error(AGENT_CLASS_FAILED, msg);
 658             }
 659         }
 660     }
 661 
 662     public static void error(String key) {
 663         String keyText = getText(key);
 664         System.err.print(getText("agent.err.error") + ": " + keyText);
 665         throw new RuntimeException(keyText);
 666     }
 667 
 668     public static void error(String key, String[] params) {
 669         if (params == null || params.length == 0) {
 670             error(key);
 671         } else {
 672             StringBuilder message = new StringBuilder(params[0]);
 673             for (int i = 1; i < params.length; i++) {
 674                 message.append(' ').append(params[i]);
 675             }
 676             error(key, message.toString());
 677         }
 678     }
 679 
 680     public static void error(String key, String message) {
 681         String keyText = getText(key);
 682         System.err.print(getText("agent.err.error") + ": " + keyText);
 683         System.err.println(": " + message);
 684         throw new RuntimeException(keyText + ": " + message);
 685     }
 686 
 687     public static void error(Exception e) {
 688         e.printStackTrace();
 689         System.err.println(getText(AGENT_EXCEPTION) + ": " + e.toString());

















 690         throw new RuntimeException(e);
 691     }
 692 
 693     public static void warning(String key, String message) {
 694         System.err.print(getText("agent.err.warning") + ": " + getText(key));
 695         System.err.println(": " + message);
 696     }
 697 
 698     private static void initResource() {
 699         try {
 700             messageRB =
 701                 ResourceBundle.getBundle("jdk.internal.agent.resources.agent");
 702         } catch (MissingResourceException e) {
 703             throw new Error("Fatal: Resource for management agent is missing");
 704         }
 705     }
 706 
 707     public static String getText(String key) {
 708         if (messageRB == null) {
 709             initResource();
 710         }
 711         try {
 712             return messageRB.getString(key);
 713         } catch (MissingResourceException e) {
 714             return "Missing management agent resource bundle: key = \"" + key + "\"";
 715         }
 716     }
 717 
 718     public static String getText(String key, String... args) {
 719         if (messageRB == null) {
 720             initResource();
 721         }
 722         String format = messageRB.getString(key);
 723         if (format == null) {
 724             format = "missing resource key: key = \"" + key + "\", "
 725                     + "arguments = \"{0}\", \"{1}\", \"{2}\"";
 726         }
 727         return MessageFormat.format(format, (Object[]) args);
 728     }
 729 }
--- EOF ---