| /* |
| * Copyright (c) 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. Oracle designates this |
| * particular file as subject to the "Classpath" exception as provided |
| * by Oracle in the LICENSE file that accompanied this code. |
| * |
| * This code is distributed in the hope that it will be useful, but WITHOUT |
| * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or |
| * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License |
| * version 2 for more details (a copy is included in the LICENSE file that |
| * accompanied this code). |
| * |
| * You should have received a copy of the GNU General Public License version |
| * 2 along with this work; if not, write to the Free Software Foundation, |
| * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. |
| * |
| * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
| * or visit www.oracle.com if you need additional information or have any |
| * questions. |
| */ |
| |
| package sun.jvmstat.monitor; |
| |
| import java.util.*; |
| import java.net.*; |
| import java.lang.reflect.*; |
| |
| import sun.jvmstat.monitor.event.HostListener; |
| |
| /** |
| * An abstraction for a host that contains instrumented Java Virtual |
| * Machines. The class provides abstract factory methods for creating |
| * concrete instances of this class and factory methods for creating |
| * {@link MonitoredVm} instances. Concrete implementations of this class |
| * provide methods for managing the communications protocols and provide |
| * for event notification. |
| * |
| * @author Brian Doherty |
| * @since 1.5 |
| * |
| * @see HostIdentifier |
| * @see VmIdentifier |
| * @see MonitoredVm |
| * @see HostListener |
| */ |
| public abstract class MonitoredHost { |
| private static Map<HostIdentifier, MonitoredHost> monitoredHosts = |
| new HashMap<HostIdentifier, MonitoredHost>(); |
| |
| /* |
| * The monitoring implementation override mechanism. The value of |
| * this property is used as the class name for the concrete MonitoredHost |
| * subclass that implements the monitoring APIs. Setting this property |
| * will cause the remaining override mechanisms to be ignored. When |
| * this mechanism is used, the HostIdentifier scheme name, which |
| * indicates the communications protocol, is not used to locate a |
| * the protocol specific package. However, the HostIdentifier is |
| * still passed to the corresponding single arg constructor. |
| * This property is not expected to be set in normal circumstances. |
| */ |
| private static final String IMPL_OVERRIDE_PROP_NAME = |
| "sun.jvmstat.monitor.MonitoredHost"; |
| |
| /* |
| * The monitoring package name override mechanism. The value |
| * the this property is used as base package name for the |
| * monitoring implementation package. This property is not |
| * expected to be set under normal circumstances. |
| */ |
| private static final String IMPL_PKG_PROP_NAME = |
| "sun.jvmstat.monitor.package"; |
| private static final String IMPL_PACKAGE = |
| System.getProperty(IMPL_PKG_PROP_NAME, "sun.jvmstat.perfdata"); |
| |
| /* |
| * The default optimized local protocol override mechanism. The value |
| * of this property is used to construct the default package name |
| * for the default optimized local protocol as follows: |
| * <IMPL_PACKAGE>.monitor.<LOCAL_PROTOCOL> |
| * This property is not expected to be set under normal circumstances. |
| */ |
| private static final String LOCAL_PROTOCOL_PROP_NAME = |
| "sun.jvmstat.monitor.local"; |
| private static final String LOCAL_PROTOCOL = |
| System.getProperty(LOCAL_PROTOCOL_PROP_NAME, "local"); |
| |
| /* |
| * The default remote protocol override mechanism. The value of |
| * this property is used to construct the default package name |
| * for the default remote protocol protocol as follows: |
| * <IMPL_PACKAGE>.monitor.protocol.<REMOTE_PROTOCOL> |
| * This property is not expected to be set under normal circumstances. |
| */ |
| private static final String REMOTE_PROTOCOL_PROP_NAME = |
| "sun.jvmstat.monitor.remote"; |
| private static final String REMOTE_PROTOCOL = |
| System.getProperty(REMOTE_PROTOCOL_PROP_NAME, "rmi"); |
| |
| /* |
| * The default class name of the MonitoredHost implementation subclass. |
| * There is no override mechanism for this variable, other than the |
| * IMPL_OVERRIDE_PROP_NAME override, which is larger in scope. A concrete |
| * instance of this class is expected to be found in: |
| * <IMPL_PACKAGE>.monitor.protocol.<protocol>.<MONITORED_HOST_CLASS> |
| */ |
| private static final String MONITORED_HOST_CLASS = "MonitoredHostProvider"; |
| |
| /** |
| * The HostIdentifier for this MonitoredHost instance. |
| */ |
| protected HostIdentifier hostId; |
| |
| /** |
| * The polling interval, in milliseconds, for this MonitoredHost instance. |
| */ |
| protected int interval; |
| |
| /** |
| * The last Exception encountered while polling this MonitoredHost. |
| */ |
| protected Exception lastException; |
| |
| /** |
| * Factory method to construct MonitoredHost instances to manage |
| * connections to the host indicated by <tt>hostIdString</tt> |
| * |
| * @param hostIdString a String representation of a {@link HostIdentifier} |
| * @return MonitoredHost - the MonitoredHost instance for communicating |
| * with the indicated host using the protocol |
| * specified in hostIdString. |
| * @throws MonitorException Thrown if monitoring errors occur. |
| * @throws URISyntaxException Thrown when the hostIdString is poorly |
| * formed. This exception may get encapsulated |
| * into MonitorException in a future revision. |
| */ |
| public static MonitoredHost getMonitoredHost(String hostIdString) |
| throws MonitorException, URISyntaxException { |
| HostIdentifier hostId = new HostIdentifier(hostIdString); |
| return getMonitoredHost(hostId); |
| } |
| |
| /** |
| * Factory method to construct a MonitoredHost instance to manage the |
| * connection to the Java Virtual Machine indicated by <tt>vmid</tt>. |
| * |
| * This method provide a convenient short cut for attaching to a specific |
| * instrumented Java Virtual Machine. The information in the VmIdentifier |
| * is used to construct a corresponding HostIdentifier, which in turn is |
| * used to create the MonitoredHost instance. |
| * |
| * @param vmid The identifier for the target Java Virtual Machine. |
| * @return MonitoredHost - The MonitoredHost object needed to attach to |
| * the target Java Virtual Machine. |
| * |
| * @throws MonitorException Thrown if monitoring errors occur. |
| */ |
| public static MonitoredHost getMonitoredHost(VmIdentifier vmid) |
| throws MonitorException { |
| // use the VmIdentifier to construct the corresponding HostIdentifier |
| HostIdentifier hostId = new HostIdentifier(vmid); |
| return getMonitoredHost(hostId); |
| } |
| |
| /** |
| * Factory method to construct a MonitoredHost instance to manage the |
| * connection to the host indicated by <tt>hostId</tt>. |
| * |
| * @param hostId the identifier for the target host. |
| * @return MonitoredHost - The MonitoredHost object needed to attach to |
| * the target host. |
| * |
| * @throws MonitorException Thrown if monitoring errors occur. |
| */ |
| public static MonitoredHost getMonitoredHost(HostIdentifier hostId) |
| throws MonitorException { |
| /* |
| * determine the class name to load. If the system property is set, |
| * use the indicated class. otherwise, use the default class. |
| */ |
| String classname = System.getProperty(IMPL_OVERRIDE_PROP_NAME); |
| MonitoredHost mh = null; |
| |
| synchronized(monitoredHosts) { |
| mh = monitoredHosts.get(hostId); |
| if (mh != null) { |
| if (mh.isErrored()) { |
| monitoredHosts.remove(hostId); |
| } else { |
| return mh; |
| } |
| } |
| } |
| |
| hostId = resolveHostId(hostId); |
| |
| if (classname == null) { |
| // construct the class name |
| classname = IMPL_PACKAGE + ".monitor.protocol." |
| + hostId.getScheme() + "." + MONITORED_HOST_CLASS; |
| } |
| |
| try { |
| // run the constructor taking a single String parameter. |
| Class<?> c = Class.forName(classname); |
| |
| Constructor cons = c.getConstructor( |
| new Class[] { hostId.getClass() } |
| ); |
| |
| mh = (MonitoredHost)cons.newInstance(new Object[] { hostId } ); |
| |
| synchronized(monitoredHosts) { |
| monitoredHosts.put(mh.hostId, mh); |
| } |
| return mh; |
| } catch (ClassNotFoundException e) { |
| // from Class.forName(); |
| throw new IllegalArgumentException("Could not find " + classname |
| + ": " + e.getMessage(), e); |
| } catch (NoSuchMethodException e) { |
| // from Class.getConstructor(); |
| throw new IllegalArgumentException( |
| "Expected constructor missing in " + classname + ": " |
| + e.getMessage(), e); |
| } catch (IllegalAccessException e) { |
| // from Constructor.newInstance() |
| throw new IllegalArgumentException( |
| "Unexpected constructor access in " + classname + ": " |
| + e.getMessage(), e); |
| } catch (InstantiationException e) { |
| throw new IllegalArgumentException(classname + "is abstract: " |
| + e.getMessage(), e); |
| } catch (InvocationTargetException e) { |
| Throwable cause = e.getCause(); |
| if (cause instanceof MonitorException) { |
| throw (MonitorException)cause; |
| } |
| throw new RuntimeException("Unexpected exception", e); |
| } |
| } |
| |
| /** |
| * Method to resolve unspecified components of the given HostIdentifier |
| * by constructing a new HostIdentifier that replaces the unspecified |
| * components with the default values. |
| * |
| * @param hostId the unresolved HostIdentifier. |
| * @return HostIdentifier - a resolved HostIdentifier. |
| * |
| * @throws MonitorException Thrown if monitoring errors occur. |
| */ |
| protected static HostIdentifier resolveHostId(HostIdentifier hostId) |
| throws MonitorException { |
| String hostname = hostId.getHost(); |
| String scheme = hostId.getScheme(); |
| StringBuffer sb = new StringBuffer(); |
| |
| assert hostname != null; |
| |
| if (scheme == null) { |
| if (hostname.compareTo("localhost") == 0) { |
| scheme = LOCAL_PROTOCOL; |
| } else { |
| scheme = REMOTE_PROTOCOL; |
| } |
| } |
| |
| sb.append(scheme).append(":").append(hostId.getSchemeSpecificPart()); |
| |
| String frag = hostId.getFragment(); |
| if (frag != null) { |
| sb.append("#").append(frag); |
| } |
| |
| try { |
| return new HostIdentifier(sb.toString()); |
| } catch (URISyntaxException e) { |
| // programming error - HostIdentifier was valid. |
| assert false; |
| throw new IllegalArgumentException("Malformed URI created: " |
| + sb.toString()); |
| } |
| } |
| |
| /** |
| * Return the resolved HostIdentifier for this MonitoredHost. |
| * |
| * @return HostIdentifier - the resolved HostIdentifier. |
| */ |
| public HostIdentifier getHostIdentifier() { |
| return hostId; |
| } |
| |
| /* ---- Methods to support polled MonitoredHost Implementations ----- */ |
| |
| /** |
| * Set the polling interval for this MonitoredHost. |
| * |
| * @param interval the polling interval, in milliseconds |
| */ |
| public void setInterval(int interval) { |
| this.interval = interval; |
| } |
| |
| /** |
| * Get the polling interval. |
| * |
| * @return int - the polling interval in milliseconds for this MonitoredHost |
| */ |
| public int getInterval() { |
| return interval; |
| } |
| |
| /** |
| * Set the last exception encountered while polling this MonitoredHost. |
| * |
| * @param lastException the last exception encountered; |
| */ |
| public void setLastException(Exception lastException) { |
| this.lastException = lastException; |
| } |
| |
| /** |
| * Get the last exception encountered while polling this MonitoredHost. |
| * |
| * @return Exception - the last exception occurred while polling this |
| * MonitoredHost, or <tt>null</tt> if no exception |
| * has occurred or the exception has been cleared, |
| */ |
| public Exception getLastException() { |
| return lastException; |
| } |
| |
| /** |
| * Clear the last exception. |
| */ |
| public void clearLastException() { |
| lastException = null; |
| } |
| |
| /** |
| * Test if this MonitoredHost is in the errored state. If this method |
| * returns true, then the Exception returned by getLastException() |
| * indicates the Exception that caused the error condition. |
| * |
| * @return boolean - true if the MonitoredHost instance has experienced |
| * an error, or false if it hasn't or if any past |
| * error has been cleared. |
| */ |
| public boolean isErrored() { |
| return lastException != null; |
| } |
| |
| /** |
| * Get the MonitoredVm for the given Java Virtual Machine. The default |
| * sampling interval is used for the MonitoredVm instance. |
| * |
| * @param id the VmIdentifier specifying the target Java Virtual Machine. |
| * @return MonitoredVm - the MonitoredVm instance for the target Java |
| * Virtual Machine. |
| * @throws MonitorException Thrown if monitoring errors occur. |
| */ |
| public abstract MonitoredVm getMonitoredVm(VmIdentifier id) |
| throws MonitorException; |
| |
| /** |
| * Get the MonitoredVm for the given Java Virtual Machine. The sampling |
| * interval is set to the given interval. |
| * |
| * @param id the VmIdentifier specifying the target Java Virtual Machine. |
| * @param interval the sampling interval for the target Java Virtual Machine. |
| * @return MonitoredVm - the MonitoredVm instance for the target Java |
| * Virtual Machine. |
| * @throws MonitorException Thrown if monitoring errors occur. |
| */ |
| public abstract MonitoredVm getMonitoredVm(VmIdentifier id, int interval) |
| throws MonitorException; |
| |
| /** |
| * Detach from the indicated MonitoredVm. |
| * |
| * @param vm the monitored Java Virtual Machine. |
| * @throws MonitorException Thrown if monitoring errors occur. |
| */ |
| public abstract void detach(MonitoredVm vm) throws MonitorException; |
| |
| /** |
| * Add a HostListener. The given listener is added to the list |
| * of HostListener objects to be notified of MonitoredHost related events. |
| * |
| * @param listener the HostListener to add. |
| * @throws MonitorException Thrown if monitoring errors occur. |
| */ |
| public abstract void addHostListener(HostListener listener) |
| throws MonitorException; |
| |
| /** |
| * Remove a HostListener. The given listener is removed from the list |
| * of HostListener objects to be notified of MonitoredHost related events. |
| * |
| * @param listener the HostListener to add. |
| * @throws MonitorException Thrown if monitoring errors occur. |
| */ |
| public abstract void removeHostListener(HostListener listener) |
| throws MonitorException; |
| |
| /** |
| * Return the current set of active Java Virtual Machines for this |
| * MonitoredHost. The returned Set contains {@link Integer} instances |
| * holding the local virtual machine identifier, or <em>lvmid</em> |
| * for each instrumented Java Virtual Machine currently available. |
| * |
| * @return Set - the current set of active Java Virtual Machines associated |
| * with this MonitoredHost, or the empty set of none. |
| * @throws MonitorException Thrown if monitoring errors occur. |
| */ |
| public abstract Set<Integer> activeVms() throws MonitorException; |
| } |
