454 lines
16 KiB
Java
454 lines
16 KiB
Java
/*
|
|
* 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.net.*;
|
|
|
|
/**
|
|
* An abstraction that identifies a target Java Virtual Machine.
|
|
* The VmIdentifier, or vmid, provides a convenient string representation
|
|
* of the information needed to locate and communicate with a target
|
|
* Java Virtual Machine. The string, based on a {@link URI}, may specify
|
|
* the communications protocol, host name, local vm identifier, and protocol
|
|
* specific information for a target Java Virtual Machine. The format for
|
|
* a VmIdentifier string is:
|
|
* <pre>
|
|
* [<I>protocol</I>:][<I>//</I>]<I><B>lvmid</B></I>[<I>@hostname</I>][<I>:port</I>][<I>/servername</I>]
|
|
* </pre>
|
|
* The only required component of this string is the Local Virtual Machine
|
|
* Identifier, or <tt>lvmid</tt>, which uniquely identifies the target
|
|
* Java Virtual Machine on a host. The optional components of the VmIdentifier
|
|
* include:
|
|
* <ul>
|
|
* <li><p><tt>protocol</tt> - The communications protocol. A VmIdentifier
|
|
* omitting the protocol must be resolved against a HostIdentifier
|
|
* using {@link HostIdentifier#resolve}.
|
|
* </p></li>
|
|
* <li><p><tt>hostname</tt> - A hostname or IP address indicating the target
|
|
* host. A VmIdentifier omitting the protocol must be resolved
|
|
* against a HostIdentifier using {@link HostIdentifier#resolve}.
|
|
* </p></li>
|
|
* <li><p><tt>port</tt> - The port for the communications protocol.
|
|
* Treatment of the <tt>port</tt> parameter is implementation
|
|
* (protocol) specific. A VmIdentifier omitting the protocol should
|
|
* be resolved against a HostIdentifier using
|
|
* {@link HostIdentifier#resolve}.
|
|
* </p></li>
|
|
* <li><p><tt>servername</tt> - The treatment of the Path, Query, and
|
|
* Fragment components of the VmIdentifier are implementation
|
|
* (protocol) dependent. A VmIdentifier omitting the protocol should
|
|
* be resolved against a HostIdentifier using
|
|
* {@link HostIdentifier#resolve}.
|
|
* </p></li>
|
|
* </ul>
|
|
* <p>
|
|
* All VmIdentifier instances are constructed as absolute, hierarchical URIs.
|
|
* The constructors will accept relative (and even some malformed,
|
|
* though convenient) URI strings. Such strings are transformed into
|
|
* legitimate, absolute URI strings.
|
|
* </p>
|
|
* <p>
|
|
* With the exception of <em>file:</em> based VmIdentifier strings, all
|
|
* VmIdentifier strings must include a <tt>lvmid</tt>. Attempting to construct
|
|
* a non-file based VmIdentifier that doesn't include a <tt>lvmid</tt>
|
|
* component will result in a <tt>MonitorException</tt>.
|
|
* </p>
|
|
* <p>
|
|
* Here are some examples of VmIdentifier strings.
|
|
* <ul>
|
|
* <li><p>Relative URIs</p></li>
|
|
* <ul>
|
|
* <li><p><em>1234</em> - Specifies the Java Virtual Machine
|
|
* identified by lvmid <em>1234</em> on an unnamed host.
|
|
* This string is transformed into the absolute form
|
|
* <em>//1234</em>, which must be resolved against a
|
|
* HostIdentifier.
|
|
* </p></li>
|
|
* <li><p><em>1234@hostname</em> - Specifies the Java Virtual
|
|
* Machine identified by lvmid <em>1234</em> on host
|
|
* <em>hostname</em> with an unnamed protocol.
|
|
* This string is transformed into the absolute form
|
|
* <em>//1234@hostname</em>, which must be resolved against
|
|
* a HostIdentifier.
|
|
* </p></li>
|
|
* <li><p><em>1234@hostname:2099</em> - Specifies the Java Virtual
|
|
* Machine identified by lvmid <em>1234</em> on host
|
|
* <em>hostname</em> with an unnamed protocol, but with
|
|
* port <em>2099</em>. This string is transformed into
|
|
* the absolute form <em>//1234@hostname:2099</em>, which
|
|
* must be resolved against a HostIdentifier.
|
|
* </p></li>
|
|
* </ul>
|
|
* <li><p>Absolute URIs</p></li>
|
|
* <ul>
|
|
* <li><p><em>rmi://1234@hostname:2099/remoteobjectname</em> -
|
|
* Specifies the Java Virtual Machine identified by lvmid
|
|
* <em>1234</em> on host <em>hostname</em> accessed
|
|
* using the <em>rmi:</em> protocol through the rmi remote
|
|
* object named <em>remoteobjectname</em> as registered with
|
|
* the <em>rmiserver</em> on port <em>2099</em> on host
|
|
* <em>hostname</em>.
|
|
* </p></li>
|
|
* <li><p><em>file:/path/file</em> - Identifies a Java Virtual Machine
|
|
* through accessing a special file based protocol to use as
|
|
* the communications mechanism.
|
|
* </p></li>
|
|
* </ul>
|
|
* </ul>
|
|
* </p>
|
|
*
|
|
* @see URI
|
|
* @see HostIdentifier
|
|
* @author Brian Doherty
|
|
* @since 1.5
|
|
*/
|
|
public class VmIdentifier {
|
|
private URI uri;
|
|
|
|
/**
|
|
* creates a canonical representation of the uriString. This method
|
|
* performs certain translations depending on the type of URI generated
|
|
* by the string.
|
|
*/
|
|
private URI canonicalize(String uriString) throws URISyntaxException {
|
|
if (uriString == null) {
|
|
uriString = "local://0@localhost";
|
|
return new URI(uriString);
|
|
}
|
|
|
|
URI u = new URI(uriString);
|
|
|
|
if (u.isAbsolute()) {
|
|
if (u.isOpaque()) {
|
|
/*
|
|
* rmi:1234@hostname/path#fragment converted to
|
|
* rmi://1234@hostname/path#fragment
|
|
*/
|
|
u = new URI(u.getScheme(), "//" + u.getSchemeSpecificPart(),
|
|
u.getFragment());
|
|
}
|
|
} else {
|
|
/*
|
|
* make the uri absolute, if possible. A relative URI doesn't
|
|
* specify the scheme part, so it's safe to prepend a "//" and
|
|
* try again.
|
|
*/
|
|
if (!uriString.startsWith("//")) {
|
|
if (u.getFragment() == null) {
|
|
u = new URI("//" + u.getSchemeSpecificPart());
|
|
} else {
|
|
u = new URI("//" + u.getSchemeSpecificPart() + "#"
|
|
+ u.getFragment());
|
|
}
|
|
}
|
|
}
|
|
return u;
|
|
}
|
|
|
|
/**
|
|
* check that the VmIdentifier includes a unique numerical identifier
|
|
* for the target JVM.
|
|
*/
|
|
private void validate() throws URISyntaxException {
|
|
// file:// uri, which is a special case where the lvmid is not required.
|
|
String s = getScheme();
|
|
if ((s != null) && (s.compareTo("file") == 0)) {
|
|
return;
|
|
}
|
|
if (getLocalVmId() == -1) {
|
|
throw new URISyntaxException(uri.toString(), "Local vmid required");
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Create a VmIdentifier instance from a string value.
|
|
*
|
|
* @param uriString a string representing a target Java Virtual Machine.
|
|
* The syntax of the string must conforms to the rules
|
|
* specified in the class documentation.
|
|
* @throws URISyntaxException Thrown when the uriString or its canonical
|
|
* form is poorly formed.
|
|
*/
|
|
public VmIdentifier(String uriString) throws URISyntaxException {
|
|
URI u;
|
|
try {
|
|
u = canonicalize(uriString);
|
|
} catch (URISyntaxException e) {
|
|
/*
|
|
* a vmid of the form 1234@hostname:1098 causes an exception,
|
|
* so try again with a leading "//"
|
|
*/
|
|
if (uriString.startsWith("//")) {
|
|
throw e;
|
|
}
|
|
u = canonicalize("//"+uriString);
|
|
}
|
|
|
|
uri = u;
|
|
|
|
// verify that we have a valid lvmid
|
|
validate();
|
|
}
|
|
|
|
/**
|
|
* Create a VmIdentifier instance from a URI object.
|
|
*
|
|
* @param uri a well formed, absolute URI indicating the
|
|
* target Java Virtual Machine.
|
|
* @throws URISyntaxException Thrown if the URI is missing some
|
|
* required component.
|
|
*/
|
|
public VmIdentifier(URI uri) throws URISyntaxException {
|
|
this.uri = uri;
|
|
validate();
|
|
}
|
|
|
|
/**
|
|
* Return the corresponding HostIdentifier for this VmIdentifier.
|
|
* <p>
|
|
* This method constructs a HostIdentifier object from the VmIdentifier.
|
|
* If the VmIdentifier is not specific about the protocol or other
|
|
* components of the URI, then the resulting HostIdentifier will
|
|
* be constructed based on this missing information. Typically, the
|
|
* missing components will have result in the HostIdentifier assigning
|
|
* assumed defaults that allow the VmIdentifier to be resolved according
|
|
* to those defaults.
|
|
* </p>
|
|
* <p>
|
|
* For example, a VmIdentifier that specifies only a <tt>lvmid</tt>
|
|
* will result in a HostIdentifier for <em>localhost</em> utilizing
|
|
* the default local protocol, <em>local:</em>. A VmIdentifier that
|
|
* specifies both a <tt>vmid</tt> and a <tt>hostname</tt> will result
|
|
* in a HostIdentifier for the specified host with the default remote
|
|
* protocol, <em>rmi:</em>, using the protocol defaults for the
|
|
* <tt>port</tt> and <tt>servername</tt> components.
|
|
* </p>
|
|
*
|
|
* @return HostIdentifier - the host identifier for the host containing
|
|
* the Java Virtual Machine represented by this
|
|
* VmIdentifier.
|
|
* @throws URISyntaxException Thrown if a bad host URI is constructed.
|
|
* This exception may get encapsulated into
|
|
* a MonitorException in a future version.
|
|
*/
|
|
public HostIdentifier getHostIdentifier() throws URISyntaxException {
|
|
StringBuffer sb = new StringBuffer();
|
|
if (getScheme() != null) {
|
|
sb.append(getScheme()).append(":");
|
|
}
|
|
sb.append("//").append(getHost());
|
|
if (getPort() != -1) {
|
|
sb.append(":").append(getPort());
|
|
}
|
|
if (getPath() != null) {
|
|
sb.append(getPath());
|
|
}
|
|
return new HostIdentifier(sb.toString());
|
|
}
|
|
|
|
/**
|
|
* Return the Scheme, or protocol, portion of this VmIdentifier.
|
|
*
|
|
* @return String - the scheme for this VmIdentifier.
|
|
* @see URI#getScheme()
|
|
*/
|
|
public String getScheme() {
|
|
return uri.getScheme();
|
|
}
|
|
|
|
/**
|
|
* Return the Scheme Specific Part of this VmIdentifier.
|
|
*
|
|
* @return String - the Scheme Specific Part for this VmIdentifier.
|
|
* @see URI#getSchemeSpecificPart()
|
|
*/
|
|
public String getSchemeSpecificPart() {
|
|
return uri.getSchemeSpecificPart();
|
|
}
|
|
|
|
/**
|
|
* Return the UserInfo part of this VmIdentifier.
|
|
*
|
|
* @return String - the UserInfo part for this VmIdentifier.
|
|
* @see URI#getUserInfo()
|
|
*/
|
|
public String getUserInfo() {
|
|
return uri.getUserInfo();
|
|
}
|
|
|
|
/**
|
|
* Return the Host part of this VmIdentifier.
|
|
*
|
|
* @return String - the Host part for this VmIdentifier.
|
|
* @see URI#getHost()
|
|
*/
|
|
public String getHost() {
|
|
return uri.getHost();
|
|
}
|
|
|
|
/**
|
|
* Return the Port part of this VmIdentifier.
|
|
*
|
|
* @return int - the Port part for this VmIdentifier.
|
|
* @see URI#getPort()
|
|
*/
|
|
public int getPort() {
|
|
return uri.getPort();
|
|
}
|
|
|
|
/**
|
|
* Return the Authority part of this VmIdentifier.
|
|
*
|
|
* @return String - the Authority part for this VmIdentifier.
|
|
* @see URI#getAuthority()
|
|
*/
|
|
public String getAuthority() {
|
|
return uri.getAuthority();
|
|
}
|
|
|
|
/**
|
|
* Return the Path part of this VmIdentifier.
|
|
*
|
|
* @return String - the Path part for this VmIdentifier.
|
|
* @see URI#getPath()
|
|
*/
|
|
public String getPath() {
|
|
return uri.getPath();
|
|
}
|
|
|
|
/**
|
|
* Return the Query part of this VmIdentifier.
|
|
*
|
|
* @return String - the Query part for this VmIdentifier.
|
|
* @see URI#getQuery()
|
|
*/
|
|
public String getQuery() {
|
|
return uri.getQuery();
|
|
}
|
|
|
|
/**
|
|
* Return the Fragment part of this VmIdentifier.
|
|
*
|
|
* @return String - the Fragment part for this VmIdentifier.
|
|
* @see URI#getFragment()
|
|
*/
|
|
public String getFragment() {
|
|
return uri.getFragment();
|
|
}
|
|
|
|
/**
|
|
* Return the Local Virtual Machine Identifier for this VmIdentifier.
|
|
* The Local Virtual Machine Identifier is also known as the
|
|
* <em>lvmid</em>.
|
|
*
|
|
* @return int - the lvmid for this VmIdentifier.
|
|
*/
|
|
public int getLocalVmId() {
|
|
int result = -1;
|
|
try {
|
|
if (uri.getUserInfo() == null) {
|
|
result = Integer.parseInt(uri.getAuthority());
|
|
} else {
|
|
result = Integer.parseInt(uri.getUserInfo());
|
|
}
|
|
} catch (NumberFormatException e) { }
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* Return the mode indicated in this VmIdentifier.
|
|
*
|
|
* @return String - the mode string. If no mode is specified, then "r"
|
|
* is returned. otherwise, the specified mode is returned.
|
|
*/
|
|
public String getMode() {
|
|
String query = getQuery();
|
|
if (query != null) {
|
|
String[] queryArgs = query.split("\\+");
|
|
for (int i = 0; i < queryArgs.length; i++) {
|
|
if (queryArgs[i].startsWith("mode=")) {
|
|
int index = queryArgs[i].indexOf('=');
|
|
return queryArgs[i].substring(index+1);
|
|
}
|
|
}
|
|
}
|
|
return "r";
|
|
}
|
|
|
|
/**
|
|
* Return the URI associated with the VmIdentifier.
|
|
*
|
|
* @return URI - the URI.
|
|
* @see URI
|
|
*/
|
|
public URI getURI() {
|
|
return uri;
|
|
}
|
|
|
|
/**
|
|
* Return the hash code for this VmIdentifier. The hash code is
|
|
* identical to the hash code for the contained URI.
|
|
*
|
|
* @return int - the hashcode.
|
|
* @see URI#hashCode()
|
|
*/
|
|
public int hashCode() {
|
|
return uri.hashCode();
|
|
}
|
|
|
|
/**
|
|
* Test for quality with other objects.
|
|
*
|
|
* @param object the object to be test for equality.
|
|
* @return boolean - returns true if the given object is of type
|
|
* VmIdentifier and its URI field is equal to
|
|
* this object's URI field. Otherwise, return false.
|
|
*
|
|
* @see URI#equals(Object)
|
|
*/
|
|
public boolean equals(Object object) {
|
|
if (object == this) {
|
|
return true;
|
|
}
|
|
if (!(object instanceof VmIdentifier)) {
|
|
return false;
|
|
}
|
|
return uri.equals(((VmIdentifier)object).uri);
|
|
}
|
|
|
|
/**
|
|
* Convert to a string representation. Conversion is identical to
|
|
* calling getURI().toString(). This may change in a future release.
|
|
*
|
|
* @return String - a String representation of the VmIdentifier.
|
|
*
|
|
* @see URI#toString()
|
|
*/
|
|
public String toString() {
|
|
return uri.toString();
|
|
}
|
|
}
|