/* * Copyright (c) 2002, 2018, 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 javax.management.remote; import com.sun.jmx.mbeanserver.Util; import java.io.IOException; import java.io.UncheckedIOException; import java.net.MalformedURLException; import java.util.Collections; import java.util.HashMap; import java.util.Map; import java.util.ServiceLoader; import java.util.ServiceLoader.Provider; import java.util.StringTokenizer; import java.util.function.Predicate; import java.util.stream.Stream; import java.security.AccessController; import java.security.PrivilegedAction; import com.sun.jmx.remote.util.ClassLogger; import com.sun.jmx.remote.util.EnvHelp; import sun.reflect.misc.ReflectUtil; /** *
Factory to create JMX API connector clients. There * are no instances of this class.
* *Connections are usually made using the {@link * #connect(JMXServiceURL) connect} method of this class. More * advanced applications can separate the creation of the connector * client, using {@link #newJMXConnector(JMXServiceURL, Map) * newJMXConnector} and the establishment of the connection itself, using * {@link JMXConnector#connect(Map)}.
* *Each client is created by an instance of {@link
* JMXConnectorProvider}. This instance is found as follows. Suppose
* the given {@link JMXServiceURL} looks like
* "service:jmx:protocol:remainder"
.
* Then the factory will attempt to find the appropriate {@link
* JMXConnectorProvider} for protocol
. Each
* occurrence of the character +
or -
in
* protocol
is replaced by .
or
* _
, respectively.
A provider package list is searched for as follows:
* *environment
parameter to {@link
* #newJMXConnector(JMXServiceURL, Map) newJMXConnector} contains the
* key jmx.remote.protocol.provider.pkgs
then the
* associated value is the provider package list.
*
* jmx.remote.protocol.provider.pkgs
exists, then its value
* is the provider package list.
*
* The provider package list is a string that is interpreted as a
* list of non-empty Java package names separated by vertical bars
* (|
). If the string is empty, then so is the provider
* package list. If the provider package list is not a String, or if
* it contains an element that is an empty string, a {@link
* JMXProviderException} is thrown.
If the provider package list exists and is not empty, then for
* each element pkg
of the list, the factory
* will attempt to load the class
*
*
* pkg.protocol.ClientProvider
*
* If the environment
parameter to {@link
* #newJMXConnector(JMXServiceURL, Map) newJMXConnector} contains the
* key jmx.remote.protocol.provider.class.loader
then the
* associated value is the class loader to use to load the provider.
* If the associated value is not an instance of {@link
* java.lang.ClassLoader}, an {@link
* java.lang.IllegalArgumentException} is thrown.
If the jmx.remote.protocol.provider.class.loader
* key is not present in the environment
parameter, the
* calling thread's context class loader is used.
If the attempt to load this class produces a {@link * ClassNotFoundException}, the search for a handler continues with * the next element of the list.
* *Otherwise, a problem with the provider found is signalled by a * {@link JMXProviderException} whose {@link * JMXProviderException#getCause() cause} indicates the underlying * exception, as follows:
* *ClassNotFoundException
, that is the
* cause;
*
* If no provider is found by the above steps, including the
* default case where there is no provider package list, then the
* implementation will use its own provider for
* protocol
, or it will throw a
* MalformedURLException
if there is none. An
* implementation may choose to find providers by other means. For
* example, it may support service providers,
* where the service interface is JMXConnectorProvider
.
Every implementation must support the RMI connector protocol with
* the default RMI transport, specified with string rmi
.
*
Once a provider is found, the result of the
* newJMXConnector
method is the result of calling {@link
* JMXConnectorProvider#newJMXConnector(JMXServiceURL,Map) newJMXConnector}
* on the provider.
The Map
parameter passed to the
* JMXConnectorProvider
is a new read-only
* Map
that contains all the entries that were in the
* environment
parameter to {@link
* #newJMXConnector(JMXServiceURL,Map)
* JMXConnectorFactory.newJMXConnector}, if there was one.
* Additionally, if the
* jmx.remote.protocol.provider.class.loader
key is not
* present in the environment
parameter, it is added to
* the new read-only Map
. The associated value is the
* calling thread's context class loader.
Name of the attribute that specifies the default class
* loader. This class loader is used to deserialize return values and
* exceptions from remote MBeanServerConnection
* calls. The value associated with this attribute is an instance
* of {@link ClassLoader}.
Name of the attribute that specifies the provider packages
* that are consulted when looking for the handler for a protocol.
* The value associated with this attribute is a string with
* package names separated by vertical bars (|
).
Name of the attribute that specifies the class * loader for loading protocol providers. * The value associated with this attribute is an instance * of {@link ClassLoader}.
*/ public static final String PROTOCOL_PROVIDER_CLASS_LOADER = "jmx.remote.protocol.provider.class.loader"; private static final String PROTOCOL_PROVIDER_DEFAULT_PACKAGE = "com.sun.jmx.remote.protocol"; private static final ClassLogger logger = new ClassLogger("javax.management.remote.misc", "JMXConnectorFactory"); /** There are no instances of this class. */ private JMXConnectorFactory() { } /** *Creates a connection to the connector server at the given * address.
* *This method is equivalent to {@link * #connect(JMXServiceURL,Map) connect(serviceURL, null)}.
* * @param serviceURL the address of the connector server to * connect to. * * @return aJMXConnector
whose {@link
* JMXConnector#connect connect} method has been called.
*
* @exception NullPointerException if serviceURL
is null.
*
* @exception IOException if the connector client or the
* connection cannot be made because of a communication problem.
*
* @exception SecurityException if the connection cannot be made
* for security reasons.
*/
public static JMXConnector connect(JMXServiceURL serviceURL)
throws IOException {
return connect(serviceURL, null);
}
/**
* Creates a connection to the connector server at the given * address.
* *This method is equivalent to:
* ** JMXConnector conn = JMXConnectorFactory.newJMXConnector(serviceURL, * environment); * conn.connect(environment); ** * @param serviceURL the address of the connector server to connect to. * * @param environment a set of attributes to determine how the * connection is made. This parameter can be null. Keys in this * map must be Strings. The appropriate type of each associated * value depends on the attribute. The contents of *
environment
are not changed by this call.
*
* @return a JMXConnector
representing the newly-made
* connection. Each successful call to this method produces a
* different object.
*
* @exception NullPointerException if serviceURL
is null.
*
* @exception IOException if the connector client or the
* connection cannot be made because of a communication problem.
*
* @exception SecurityException if the connection cannot be made
* for security reasons.
*/
public static JMXConnector connect(JMXServiceURL serviceURL,
MapCreates a connector client for the connector server at the * given address. The resultant client is not connected until its * {@link JMXConnector#connect(Map) connect} method is called.
* * @param serviceURL the address of the connector server to connect to. * * @param environment a set of attributes to determine how the * connection is made. This parameter can be null. Keys in this * map must be Strings. The appropriate type of each associated * value depends on the attribute. The contents of *environment
are not changed by this call.
*
* @return a JMXConnector
representing the new
* connector client. Each successful call to this method produces
* a different object.
*
* @exception NullPointerException if serviceURL
is null.
*
* @exception IOException if the connector client cannot be made
* because of a communication problem.
*
* @exception MalformedURLException if there is no provider for the
* protocol in serviceURL
.
*
* @exception JMXProviderException if there is a provider for the
* protocol in serviceURL
but it cannot be used for
* some reason.
*/
public static JMXConnector newJMXConnector(JMXServiceURL serviceURL,
Map* Parses the list of JMXConnectorProvider services that can be loaded * from the given loader, only retaining those that satisfy the given filter. * Then for each provider, attempts to create a new JMXConnector. * The first JMXConnector successfully created is returned. *
* The filter predicate is usually used to either exclude system providers
* or only retain system providers (see isSystemProvider(...) above).
*
* @param loader The ClassLoader to use when looking up an implementation
* of the service. If null, then only installed services will be
* considered.
*
* @param url The JMXServiceURL of the connector for which a provider is
* requested.
*
* @param filter A filter used to exclude or return provider
* implementations. Typically the filter will either exclude
* system services (system default implementations) or only
* retain those.
* This can allow to first look for custom implementations (e.g.
* deployed on the CLASSPATH with META-INF/services) and
* then only default to system implementations.
*
* @throws IOException if no connector could not be instantiated, and
* at least one provider threw an exception that wasn't a
* {@code MalformedURLException} or a {@code JMProviderException}.
*
* @throws JMXProviderException if a provider for the protocol in
* {
public C apply(P provider) throws Exception;
}
/**
* An instance of ProviderFinder is used to traverse a
* {@code Stream
* The pair (P,C) will be either one of:
* The first connector successfully created while traversing the stream
* is stored in the ProviderFinder instance. After that, the
* ProviderFinder::test method, if called, will always return false, skipping
* the remaining providers.
*
* An instance of ProviderFinder is always expected to be used in conjunction
* with Stream::findFirst, so that the stream traversal is stopped as soon
* as a matching provider is found.
*
* At the end of the stream traversal, the ProviderFinder::get method can be
* used to obtain the connector instance (an instance of C) that was created.
* If no connector could be created, and an exception was encountered while
* traversing the stream and attempting to create the connector, then that
* exception will be thrown by ProviderFinder::get, wrapped, if needed,
* inside an IOException.
*
* If any JMXProviderException is encountered while traversing the stream and
* attempting to create the connector, that exception will be wrapped in an
* UncheckedIOException and thrown immediately within the stream, thus
* interrupting the traversal.
*
* If no matching provider was found (no provider found or attempting
* factory.apply always returned null or threw a MalformedURLException,
* indicating the provider didn't support the protocol asked for by
* the JMXServiceURL), then ProviderFinder::get will simply return null.
*/
private static final class ProviderFinder implements Predicate factory;
final JMXServiceURL url;
private IOException exception = null;
private C connection = null;
ProviderFinder(ConnectorFactory factory, JMXServiceURL url) {
this.factory = factory;
this.url = url;
}
/**
* Returns {@code true} for the first provider {@code sp} that can
* be used to obtain an instance of {@code C} from the given
* {@code factory}.
*
* @param sp a candidate provider for instantiating {@code C}.
*
* @throws UncheckedIOException if {@code sp} throws a
* JMXProviderException. The JMXProviderException is set as the
* root cause.
*
* @return {@code true} for the first provider {@code sp} for which
* {@code C} could be instantiated, {@code false} otherwise.
*/
public boolean test(Provider sp) {
if (connection == null) {
P provider = sp.get();
try {
connection = factory.apply(provider);
return connection != null;
} catch (JMXProviderException e) {
throw new UncheckedIOException(e);
} catch (Exception e) {
if (logger.traceOn())
logger.trace("getConnectorAsService",
"URL[" + url +
"] Service provider exception: " + e);
if (!(e instanceof MalformedURLException)) {
if (exception == null) {
if (e instanceof IOException) {
exception = (IOException) e;
} else {
exception = EnvHelp.initCause(
new IOException(e.getMessage()), e);
}
}
}
}
}
return false;
}
/**
* Returns an instance of {@code C} if a provider was found from
* which {@code C} could be instantiated.
*
* @throws IOException if {@code C} could not be instantiated, and
* at least one provider threw an exception that wasn't a
* {@code MalformedURLException} or a {@code JMProviderException}.
*
* @return an instance of {@code C} if a provider was found from
* which {@code C} could be instantiated, {@code null} otherwise.
*/
C get() throws IOException {
if (connection != null) return connection;
else if (exception != null) throw exception;
else return null;
}
}
/**
* Creates a connector from a provider loaded from the ServiceLoader.
*
* The pair (P,C) will be either one of: C getConnectorAsService(Class providerClass,
ClassLoader loader,
JMXServiceURL url,
Predicate factory)
throws IOException {
// sanity check
if (JMXConnectorProvider.class != providerClass
&& JMXConnectorServerProvider.class != providerClass) {
// should never happen
throw new InternalError("Unsupported service interface: "
+ providerClass.getName());
}
ServiceLoader serviceLoader = loader == null
? ServiceLoader.loadInstalled(providerClass)
: ServiceLoader.load(providerClass, loader);
Stream finder = new ProviderFinder<>(factory, url);
try {
stream.filter(finder).findFirst();
return finder.get();
} catch (UncheckedIOException e) {
if (e.getCause() instanceof JMXProviderException) {
throw (JMXProviderException) e.getCause();
} else {
throw e;
}
}
}
static url
was found, but couldn't create the connector
* some reason.
*
* @return an instance of JMXConnector if a provider was found from
* which one could be instantiated, {@code null} otherwise.
*/
private static JMXConnector getConnectorAsService(ClassLoader loader,
JMXServiceURL url,
Map
* a. (JMXConnectorProvider, JMXConnector) or
* b. (JMXConnectorServerProvider, JMXConnectorServer)
*
* a. (JMXConnectorProvider, JMXConnector) or
* b. (JMXConnectorServerProvider, JMXConnectorServer)
*
* @param providerClass The service type for which an implementation
* should be looked up from the {@code ServiceLoader}. This will
* be either {@code JMXConnectorProvider.class} or
* {@code JMXConnectorServerProvider.class}
*
* @param loader The ClassLoader to use when looking up an implementation
* of the service. If null, then only installed services will be
* considered.
*
* @param url The JMXServiceURL of the connector for which a provider is
* requested.
*
* @param filter A filter used to exclude or return provider
* implementations. Typically the filter will either exclude
* system services (system default implementations) or only
* retain those.
* This can allow to first look for custom implementations (e.g.
* deployed on the CLASSPATH with META-INF/services) and
* then only default to system implementations.
*
* @param factory A functional factory that can attempt to create an
* instance of connector {@code C} from a provider {@code P}.
* Typically, this is a simple wrapper over {@code
* JMXConnectorProvider::newJMXConnector} or {@code
* JMXConnectorProviderServer::newJMXConnectorServer}.
*
* @throws IOException if {@code C} could not be instantiated, and
* at least one provider {@code P} threw an exception that wasn't a
* {@code MalformedURLException} or a {@code JMProviderException}.
*
* @throws JMXProviderException if a provider {@code P} for the protocol in
* url
was found, but couldn't create the connector
* {@code C} for some reason.
*
* @return an instance of {@code C} if a provider {@code P} was found from
* which one could be instantiated, {@code null} otherwise.
*/
static