| /* |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| */ |
| package org.apache.brooklyn.feed.jmx; |
| |
| import static com.google.common.base.Preconditions.checkNotNull; |
| import static org.apache.brooklyn.util.JavaGroovyEquivalents.groovyTruth; |
| import groovy.time.TimeDuration; |
| |
| import java.io.IOException; |
| import java.security.KeyStore; |
| import java.security.PrivateKey; |
| import java.security.cert.Certificate; |
| import java.util.Arrays; |
| import java.util.Collections; |
| import java.util.LinkedHashMap; |
| import java.util.Map; |
| import java.util.Set; |
| import java.util.WeakHashMap; |
| import java.util.concurrent.Callable; |
| import java.util.concurrent.TimeUnit; |
| import java.util.concurrent.atomic.AtomicBoolean; |
| import java.util.concurrent.atomic.AtomicReference; |
| |
| import javax.management.AttributeNotFoundException; |
| import javax.management.InstanceAlreadyExistsException; |
| import javax.management.InstanceNotFoundException; |
| import javax.management.InvalidAttributeValueException; |
| import javax.management.JMX; |
| import javax.management.ListenerNotFoundException; |
| import javax.management.MBeanServerConnection; |
| import javax.management.MalformedObjectNameException; |
| import javax.management.NotCompliantMBeanException; |
| import javax.management.NotificationFilter; |
| import javax.management.NotificationListener; |
| import javax.management.ObjectInstance; |
| import javax.management.ObjectName; |
| import javax.management.openmbean.CompositeData; |
| import javax.management.openmbean.TabularData; |
| import javax.management.remote.JMXConnector; |
| import javax.management.remote.JMXConnectorFactory; |
| import javax.management.remote.JMXServiceURL; |
| import javax.net.ssl.KeyManagerFactory; |
| import javax.net.ssl.SSLContext; |
| import javax.net.ssl.SSLSocketFactory; |
| import javax.net.ssl.TrustManager; |
| |
| import org.apache.brooklyn.api.entity.EntityLocal; |
| import org.apache.brooklyn.entity.java.JmxSupport; |
| import org.apache.brooklyn.entity.java.UsesJmx; |
| import org.apache.brooklyn.util.core.crypto.SecureKeys; |
| import org.apache.brooklyn.util.crypto.SslTrustUtils; |
| import org.apache.brooklyn.util.exceptions.Exceptions; |
| import org.apache.brooklyn.util.exceptions.RuntimeInterruptedException; |
| import org.apache.brooklyn.util.jmx.jmxmp.JmxmpAgent; |
| import org.apache.brooklyn.util.repeat.Repeater; |
| import org.apache.brooklyn.util.time.Duration; |
| import org.apache.brooklyn.util.time.Time; |
| import org.slf4j.Logger; |
| import org.slf4j.LoggerFactory; |
| |
| import com.google.common.base.Preconditions; |
| import com.google.common.base.Throwables; |
| import com.google.common.collect.ImmutableMap; |
| import com.google.common.collect.ImmutableSet; |
| import com.google.common.collect.Iterables; |
| |
| public class JmxHelper { |
| |
| private static final Logger LOG = LoggerFactory.getLogger(JmxHelper.class); |
| |
| public static final String JMX_URL_FORMAT = "service:jmx:rmi:///jndi/rmi://%s:%d/%s"; |
| // first host:port may be ignored, so above is sufficient, but not sure |
| public static final String RMI_JMX_URL_FORMAT = "service:jmx:rmi://%s:%d/jndi/rmi://%s:%d/%s"; |
| // jmxmp |
| public static final String JMXMP_URL_FORMAT = "service:jmx:jmxmp://%s:%d"; |
| |
| // Tracks the MBeans we have failed to find, with a set keyed off the url |
| private static final Map<String, Set<ObjectName>> notFoundMBeansByUrl = Collections.synchronizedMap(new WeakHashMap<String, Set<ObjectName>>()); |
| |
| public static final Map<String, String> CLASSES = ImmutableMap.<String,String>builder() |
| .put("Integer", Integer.TYPE.getName()) |
| .put("Long", Long.TYPE.getName()) |
| .put("Boolean", Boolean.TYPE.getName()) |
| .put("Byte", Byte.TYPE.getName()) |
| .put("Character", Character.TYPE.getName()) |
| .put("Double", Double.TYPE.getName()) |
| .put("Float", Float.TYPE.getName()) |
| .put("GStringImpl", String.class.getName()) |
| .put("LinkedHashMap", Map.class.getName()) |
| .put("TreeMap", Map.class.getName()) |
| .put("HashMap", Map.class.getName()) |
| .put("ConcurrentHashMap", Map.class.getName()) |
| .put("TabularDataSupport", TabularData.class.getName()) |
| .put("CompositeDataSupport", CompositeData.class.getName()) |
| .build(); |
| |
| /** constructs a JMX URL suitable for connecting to the given entity, being smart about JMX/RMI vs JMXMP */ |
| public static String toJmxUrl(EntityLocal entity) { |
| String url = entity.getAttribute(UsesJmx.JMX_URL); |
| if (url != null) { |
| return url; |
| } else { |
| new JmxSupport(entity, null).setJmxUrl(); |
| url = entity.getAttribute(UsesJmx.JMX_URL); |
| return Preconditions.checkNotNull(url, "Could not find URL for "+entity); |
| } |
| } |
| |
| /** constructs an RMI/JMX URL with the given inputs |
| * (where the RMI Registry Port should be non-null, and at least one must be non-null) */ |
| public static String toRmiJmxUrl(String host, Integer jmxRmiServerPort, Integer rmiRegistryPort, String context) { |
| if (rmiRegistryPort != null && rmiRegistryPort > 0) { |
| if (jmxRmiServerPort!=null && jmxRmiServerPort > 0 && jmxRmiServerPort!=rmiRegistryPort) { |
| // we have an explicit known JMX RMI server port (e.g. because we are using the agent), |
| // distinct from the RMI registry port |
| // (if the ports are the same, it is a short-hand, and don't use this syntax!) |
| return String.format(RMI_JMX_URL_FORMAT, host, jmxRmiServerPort, host, rmiRegistryPort, context); |
| } |
| return String.format(JMX_URL_FORMAT, host, rmiRegistryPort, context); |
| } else if (jmxRmiServerPort!=null && jmxRmiServerPort > 0) { |
| LOG.warn("No RMI registry port set for "+host+"; attempting to use JMX port for RMI lookup"); |
| return String.format(JMX_URL_FORMAT, host, jmxRmiServerPort, context); |
| } else { |
| LOG.warn("No RMI/JMX details set for "+host+"; returning null"); |
| return null; |
| } |
| } |
| |
| /** constructs a JMXMP URL for connecting to the given host and port */ |
| public static String toJmxmpUrl(String host, Integer jmxmpPort) { |
| return "service:jmx:jmxmp://"+host+(jmxmpPort!=null ? ":"+jmxmpPort : ""); |
| } |
| |
| final EntityLocal entity; |
| final String url; |
| final String user; |
| final String password; |
| |
| private volatile transient JMXConnector connector; |
| private volatile transient MBeanServerConnection connection; |
| private transient boolean triedConnecting; |
| private transient boolean failedReconnecting; |
| private transient long failedReconnectingTime; |
| private int minTimeBetweenReconnectAttempts = 1000; |
| private final AtomicBoolean terminated = new AtomicBoolean(); |
| |
| // Tracks the MBeans we have failed to find for this JmsHelper's connection URL (so can log just once for each) |
| private final Set<ObjectName> notFoundMBeans; |
| |
| public JmxHelper(EntityLocal entity) { |
| this(toJmxUrl(entity), entity, entity.getAttribute(UsesJmx.JMX_USER), entity.getAttribute(UsesJmx.JMX_PASSWORD)); |
| |
| if (entity.getAttribute(UsesJmx.JMX_URL) == null) { |
| entity.setAttribute(UsesJmx.JMX_URL, url); |
| } |
| } |
| |
| // TODO split this in to two classes, one for entities, and one entity-neutral |
| // (simplifying set of constructors below) |
| |
| public JmxHelper(String url) { |
| this(url, null, null); |
| } |
| |
| public JmxHelper(String url, String user, String password) { |
| this(url, null, user, password); |
| } |
| |
| public JmxHelper(String url, EntityLocal entity, String user, String password) { |
| this.url = url; |
| this.entity = entity; |
| this.user = user; |
| this.password = password; |
| |
| synchronized (notFoundMBeansByUrl) { |
| Set<ObjectName> set = notFoundMBeansByUrl.get(url); |
| if (set == null) { |
| set = Collections.synchronizedSet(Collections.newSetFromMap(new WeakHashMap<ObjectName, Boolean>())); |
| notFoundMBeansByUrl.put(url, set); |
| } |
| notFoundMBeans = set; |
| } |
| } |
| |
| public void setMinTimeBetweenReconnectAttempts(int val) { |
| minTimeBetweenReconnectAttempts = val; |
| } |
| |
| public String getUrl(){ |
| return url; |
| } |
| |
| // ============== connection related calls ======================= |
| |
| //for tesing purposes |
| protected MBeanServerConnection getConnection() { |
| return connection; |
| } |
| |
| /** |
| * Checks if the JmxHelper is connected. Returned value could be stale as soon |
| * as it is received. |
| * |
| * This method is thread safe. |
| * |
| * @return true if connected, false otherwise. |
| */ |
| public boolean isConnected() { |
| return connection!=null; |
| } |
| |
| /** |
| * Reconnects. If it already is connected, it disconnects first. |
| * |
| * @throws IOException |
| */ |
| public synchronized void reconnectWithRetryDampened() throws IOException { |
| // If we've already tried reconnecting very recently, don't try again immediately |
| if (failedReconnecting) { |
| long timeSince = (System.currentTimeMillis() - failedReconnectingTime); |
| if (timeSince < minTimeBetweenReconnectAttempts) { |
| String msg = "Not reconnecting to JMX at "+url+" because attempt failed "+Time.makeTimeStringRounded(timeSince)+" ago"; |
| throw new IllegalStateException(msg); |
| } |
| } |
| |
| reconnect(); |
| } |
| |
| public synchronized void reconnect() throws IOException { |
| disconnect(); |
| |
| try { |
| connect(); |
| failedReconnecting = false; |
| } catch (Exception e) { |
| if (failedReconnecting) { |
| if (LOG.isDebugEnabled()) LOG.debug("unable to re-connect to JMX url (repeated failure): {}: {}", url, e); |
| } else { |
| LOG.debug("unable to re-connect to JMX url {} (rethrowing): {}", url, e); |
| failedReconnecting = true; |
| } |
| failedReconnectingTime = System.currentTimeMillis(); |
| throw Throwables.propagate(e); |
| } |
| } |
| |
| /** attempts to connect immediately */ |
| @SuppressWarnings({ "rawtypes", "unchecked" }) |
| public synchronized void connect() throws IOException { |
| if (terminated.get()) throw new IllegalStateException("JMX Helper "+this+" already terminated"); |
| if (connection != null) return; |
| |
| triedConnecting = true; |
| if (connector != null) connector.close(); |
| JMXServiceURL serviceUrl = new JMXServiceURL(url); |
| Map env = getConnectionEnvVars(); |
| try { |
| connector = JMXConnectorFactory.connect(serviceUrl, env); |
| } catch (NullPointerException npe) { |
| //some software -- eg WSO2 -- will throw an NPE exception if the JMX connection can't be created, instead of an IOException. |
| //this is a break of contract with the JMXConnectorFactory.connect method, so this code verifies if the NPE is |
| //thrown by a known offender (wso2) and if so replaces the bad exception by a new IOException. |
| //ideally WSO2 will fix this bug and we can remove this code. |
| boolean thrownByWso2 = npe.getStackTrace()[0].toString().contains("org.wso2.carbon.core.security.CarbonJMXAuthenticator.authenticate"); |
| if (thrownByWso2) { |
| throw new IOException("Failed to connect to url "+url+". NullPointerException is thrown, but replaced by an IOException to fix a WSO2 JMX problem", npe); |
| } else { |
| throw npe; |
| } |
| } catch (IOException e) { |
| Exceptions.propagateIfFatal(e); |
| if (terminated.get()) { |
| throw new IllegalStateException("JMX Helper "+this+" already terminated", e); |
| } else { |
| throw e; |
| } |
| } |
| connection = connector.getMBeanServerConnection(); |
| |
| if (terminated.get()) { |
| disconnectNow(); |
| throw new IllegalStateException("JMX Helper "+this+" already terminated"); |
| } |
| } |
| |
| @SuppressWarnings({ "rawtypes", "unchecked" }) |
| public Map getConnectionEnvVars() { |
| Map env = new LinkedHashMap(); |
| |
| if (groovyTruth(user) && groovyTruth(password)) { |
| String[] creds = new String[] {user, password}; |
| env.put(JMXConnector.CREDENTIALS, creds); |
| } |
| |
| if (entity!=null && groovyTruth(entity.getConfig(UsesJmx.JMX_SSL_ENABLED))) { |
| env.put("jmx.remote.profiles", JmxmpAgent.TLS_JMX_REMOTE_PROFILES); |
| |
| PrivateKey key = entity.getConfig(UsesJmx.JMX_SSL_ACCESS_KEY); |
| Certificate cert = entity.getConfig(UsesJmx.JMX_SSL_ACCESS_CERT); |
| KeyStore ks = SecureKeys.newKeyStore(); |
| try { |
| KeyManagerFactory kmf = KeyManagerFactory.getInstance(KeyManagerFactory.getDefaultAlgorithm()); |
| if (key!=null) { |
| ks.setKeyEntry("brooklyn-jmx-access", key, "".toCharArray(), new Certificate[] { cert }); |
| } |
| kmf.init(ks, "".toCharArray()); |
| |
| TrustManager tms = |
| // TODO use root cert for trusting server |
| //trustStore!=null ? SecureKeys.getTrustManager(trustStore) : |
| SslTrustUtils.TRUST_ALL; |
| |
| SSLContext ctx = SSLContext.getInstance("TLSv1"); |
| ctx.init(kmf.getKeyManagers(), new TrustManager[] { tms }, null); |
| SSLSocketFactory ssf = ctx.getSocketFactory(); |
| env.put(JmxmpAgent.TLS_SOCKET_FACTORY_PROPERTY, ssf); |
| |
| } catch (Exception e) { |
| LOG.warn("Error setting key "+key+" for "+entity+": "+e, e); |
| } |
| } |
| |
| return env; |
| } |
| |
| /** |
| * Continuously attempts to connect for at least the indicated amount of time; or indefinitely if -1. This method |
| * is useful when you are not sure if the system you are trying to connect to already is up and running. |
| * |
| * This method doesn't throw an Exception, but returns true on success, false otherwise. |
| * |
| * TODO: What happens if already connected? |
| * |
| * @param timeoutMs |
| * @return |
| */ |
| public boolean connect(long timeoutMs) { |
| if (LOG.isDebugEnabled()) LOG.debug("Connecting to JMX URL: {} ({})", url, ((timeoutMs == -1) ? "indefinitely" : timeoutMs+"ms timeout")); |
| long startMs = System.currentTimeMillis(); |
| long endMs = (timeoutMs == -1) ? Long.MAX_VALUE : (startMs + timeoutMs); |
| long currentTime = startMs; |
| Throwable lastError = null; |
| int attempt = 0; |
| while (currentTime <= endMs) { |
| currentTime = System.currentTimeMillis(); |
| if (attempt != 0) sleep(100); //sleep 100 to prevent thrashing and facilitate interruption |
| if (LOG.isTraceEnabled()) LOG.trace("trying connection to {} at time {}", url, currentTime); |
| |
| try { |
| connect(); |
| return true; |
| } catch (Exception e) { |
| Exceptions.propagateIfFatal(e); |
| if (!terminated.get() && shouldRetryOn(e)) { |
| if (LOG.isDebugEnabled()) LOG.debug("Attempt {} failed connecting to {} ({})", new Object[] {attempt + 1, url, e.getMessage()}); |
| lastError = e; |
| } else { |
| throw Exceptions.propagate(e); |
| } |
| } |
| attempt++; |
| } |
| LOG.warn("unable to connect to JMX url: "+url, lastError); |
| return false; |
| } |
| |
| private boolean shouldRetryOn(Exception e) { |
| // Expect SecurityException, IOException, etc. |
| // But can also see things like javax.naming.ServiceUnavailableException with WSO2 app-servers. |
| // So let's not try to second guess strange behaviours that future entities will exhibit. |
| // |
| // However, if it was our request that was invalid then not worth retrying. |
| |
| if (e instanceof AttributeNotFoundException) return false; |
| if (e instanceof InstanceAlreadyExistsException) return false; |
| if (e instanceof InstanceNotFoundException) return false; |
| if (e instanceof InvalidAttributeValueException) return false; |
| if (e instanceof ListenerNotFoundException) return false; |
| if (e instanceof MalformedObjectNameException) return false; |
| if (e instanceof NotCompliantMBeanException) return false; |
| if (e instanceof InterruptedException) return false; |
| if (e instanceof RuntimeInterruptedException) return false; |
| |
| return true; |
| } |
| |
| /** |
| * A thread-safe version of {@link #disconnectNow()}. |
| * |
| * This method is threadsafe. |
| */ |
| public synchronized void disconnect() { |
| disconnectNow(); |
| } |
| |
| /** |
| * Disconnects, preventing subsequent connections to be made. Method doesn't throw an exception. |
| * |
| * Can safely be called if already disconnected. |
| * |
| * This method is not threadsafe, but will thus not block if |
| * another thread is taking a long time for connections to timeout. |
| * |
| * Any concurrent requests will likely get an IOException - see |
| * {@linkplain http://docs.oracle.com/javase/7/docs/api/javax/management/remote/JMXConnector.html#close()}. |
| * |
| */ |
| public void terminate() { |
| terminated.set(true); |
| disconnectNow(); |
| } |
| |
| protected void disconnectNow() { |
| triedConnecting = false; |
| if (connector != null) { |
| if (LOG.isDebugEnabled()) LOG.debug("Disconnecting from JMX URL {}", url); |
| try { |
| connector.close(); |
| } catch (Exception e) { |
| // close attempts to connect to close cleanly; and if it can't, it throws; |
| // often we disconnect as part of shutdown, even if the other side has already stopped -- |
| // so swallow exceptions (no situations known where we need a clean closure on the remote side) |
| if (LOG.isDebugEnabled()) LOG.debug("Caught exception disconnecting from JMX at {} ({})", url, e.getMessage()); |
| if (LOG.isTraceEnabled()) LOG.trace("Details for exception disconnecting JMX", e); |
| } finally { |
| connector = null; |
| connection = null; |
| } |
| } |
| } |
| |
| /** |
| * Gets a usable MBeanServerConnection. |
| * |
| * Method is threadsafe. |
| * |
| * @returns the MBeanServerConnection |
| * @throws IllegalStateException if not connected. |
| */ |
| private synchronized MBeanServerConnection getConnectionOrFail() { |
| if (isConnected()) |
| return getConnection(); |
| |
| if (triedConnecting) { |
| throw new IllegalStateException("Failed to connect to JMX at "+url); |
| } else { |
| String msg = "Not connected (and not attempted to connect) to JMX at "+url+ |
| (failedReconnecting ? (" (last reconnect failure at "+ Time.makeDateString(failedReconnectingTime) + ")") : ""); |
| throw new IllegalStateException(msg); |
| } |
| } |
| |
| private <T> T invokeWithReconnect(Callable<T> task) { |
| try { |
| return task.call(); |
| } catch (Exception e) { |
| if (shouldRetryOn(e)) { |
| try { |
| reconnectWithRetryDampened(); |
| return task.call(); |
| } catch (Exception e2) { |
| throw Throwables.propagate(e2); |
| } |
| } else { |
| throw Throwables.propagate(e); |
| } |
| } |
| } |
| |
| // ====================== query related calls ======================================= |
| |
| /** |
| * Converts from an object name pattern to a real object name, by querying with findMBean; |
| * if no matching MBean can be found (or if more than one match found) then returns null. |
| * If the supplied object name is not a pattern then just returns that. If the |
| */ |
| public ObjectName toLiteralObjectName(ObjectName objectName) { |
| if (checkNotNull(objectName, "objectName").isPattern()) { |
| ObjectInstance bean = findMBean(objectName); |
| return (bean != null) ? bean.getObjectName() : null; |
| } else { |
| return objectName; |
| } |
| } |
| |
| public Set<ObjectInstance> findMBeans(final ObjectName objectName) { |
| return invokeWithReconnect(new Callable<Set<ObjectInstance>>() { |
| public Set<ObjectInstance> call() throws Exception { |
| return getConnectionOrFail().queryMBeans(objectName, null); |
| }}); |
| } |
| |
| public ObjectInstance findMBean(ObjectName objectName) { |
| Set<ObjectInstance> beans = findMBeans(objectName); |
| if (beans.size() == 1) { |
| notFoundMBeans.remove(objectName); |
| return Iterables.getOnlyElement(beans); |
| } else { |
| boolean changed = notFoundMBeans.add(objectName); |
| |
| if (beans.size() > 1) { |
| if (changed) { |
| LOG.warn("JMX object name query returned {} values for {} at {}; ignoring all", |
| new Object[] {beans.size(), objectName.getCanonicalName(), url}); |
| } else { |
| if (LOG.isDebugEnabled()) LOG.debug("JMX object name query returned {} values for {} at {} (repeating); ignoring all", |
| new Object[] {beans.size(), objectName.getCanonicalName(), url}); |
| } |
| } else { |
| if (changed) { |
| LOG.warn("JMX object {} not found at {}", objectName.getCanonicalName(), url); |
| } else { |
| if (LOG.isDebugEnabled()) LOG.debug("JMX object {} not found at {} (repeating)", objectName.getCanonicalName(), url); |
| } |
| } |
| return null; |
| } |
| } |
| |
| public Set<ObjectInstance> doesMBeanExistsEventually(final ObjectName objectName, Duration timeout) { |
| return doesMBeanExistsEventually(objectName, timeout.toMilliseconds(), TimeUnit.MILLISECONDS); |
| } |
| public Set<ObjectInstance> doesMBeanExistsEventually(final ObjectName objectName, TimeDuration timeout) { |
| return doesMBeanExistsEventually(objectName, timeout.toMilliseconds(), TimeUnit.MILLISECONDS); |
| } |
| |
| public Set<ObjectInstance> doesMBeanExistsEventually(final ObjectName objectName, long timeoutMillis) { |
| return doesMBeanExistsEventually(objectName, timeoutMillis, TimeUnit.MILLISECONDS); |
| } |
| |
| public Set<ObjectInstance> doesMBeanExistsEventually(String objectName, Duration timeout) { |
| return doesMBeanExistsEventually(createObjectName(objectName), timeout); |
| } |
| public Set<ObjectInstance> doesMBeanExistsEventually(String objectName, TimeDuration timeout) { |
| return doesMBeanExistsEventually(createObjectName(objectName), timeout); |
| } |
| |
| public Set<ObjectInstance> doesMBeanExistsEventually(String objectName, long timeout, TimeUnit timeUnit) { |
| return doesMBeanExistsEventually(createObjectName(objectName), timeout, timeUnit); |
| } |
| |
| /** returns set of beans found, with retry, empty set if none after timeout */ |
| public Set<ObjectInstance> doesMBeanExistsEventually(final ObjectName objectName, long timeout, TimeUnit timeUnit) { |
| final long timeoutMillis = timeUnit.toMillis(timeout); |
| final AtomicReference<Set<ObjectInstance>> beans = new AtomicReference<Set<ObjectInstance>>(ImmutableSet.<ObjectInstance>of()); |
| try { |
| Repeater.create("Wait for "+objectName) |
| .limitTimeTo(timeout, timeUnit) |
| .every(500, TimeUnit.MILLISECONDS) |
| .until(new Callable<Boolean>() { |
| public Boolean call() { |
| connect(timeoutMillis); |
| beans.set(findMBeans(objectName)); |
| return !beans.get().isEmpty(); |
| }}) |
| .rethrowException() |
| .run(); |
| return beans.get(); |
| } catch (Exception e) { |
| throw Exceptions.propagate(e); |
| } |
| } |
| |
| public void assertMBeanExistsEventually(ObjectName objectName, Duration timeout) { |
| assertMBeanExistsEventually(objectName, timeout.toMilliseconds(), TimeUnit.MILLISECONDS); |
| } |
| public void assertMBeanExistsEventually(ObjectName objectName, TimeDuration timeout) { |
| assertMBeanExistsEventually(objectName, timeout.toMilliseconds(), TimeUnit.MILLISECONDS); |
| } |
| |
| public void assertMBeanExistsEventually(ObjectName objectName, long timeoutMillis) { |
| assertMBeanExistsEventually(objectName, timeoutMillis, TimeUnit.MILLISECONDS); |
| } |
| |
| public void assertMBeanExistsEventually(ObjectName objectName, long timeout, TimeUnit timeUnit) { |
| Set<ObjectInstance> beans = doesMBeanExistsEventually(objectName, timeout, timeUnit); |
| if (beans.size() != 1) { |
| throw new IllegalStateException("MBean "+objectName+" not found within "+timeout+ |
| (beans.size() > 1 ? "; found multiple matches: "+beans : "")); |
| } |
| } |
| |
| /** |
| * Returns a specific attribute for a JMX {@link ObjectName}. |
| */ |
| public Object getAttribute(ObjectName objectName, final String attribute) { |
| final ObjectName realObjectName = toLiteralObjectName(objectName); |
| |
| if (realObjectName != null) { |
| Object result = invokeWithReconnect(new Callable<Object>() { |
| public Object call() throws Exception { |
| return getConnectionOrFail().getAttribute(realObjectName, attribute); |
| }}); |
| |
| if (LOG.isTraceEnabled()) LOG.trace("From {}, for jmx attribute {}.{}, got value {}", new Object[] {url, objectName.getCanonicalName(), attribute, result}); |
| return result; |
| } else { |
| return null; |
| } |
| } |
| |
| public void setAttribute(String objectName, String attribute, Object val) { |
| setAttribute(createObjectName(objectName), attribute, val); |
| } |
| |
| public void setAttribute(ObjectName objectName, final String attribute, final Object val) { |
| final ObjectName realObjectName = toLiteralObjectName(objectName); |
| |
| if (realObjectName != null) { |
| invokeWithReconnect(new Callable<Void>() { |
| public Void call() throws Exception { |
| getConnectionOrFail().setAttribute(realObjectName, new javax.management.Attribute(attribute, val)); |
| return null; |
| }}); |
| if (LOG.isTraceEnabled()) LOG.trace("From {}, for jmx attribute {}.{}, set value {}", new Object[] {url, objectName.getCanonicalName(), attribute, val}); |
| } else { |
| if (LOG.isDebugEnabled()) LOG.debug("From {}, cannot set attribute {}.{}, because mbean not found", new Object[] {url, objectName.getCanonicalName(), attribute}); |
| } |
| } |
| |
| /** @see #operation(ObjectName, String, Object ...) */ |
| public Object operation(String objectName, String method, Object... arguments) { |
| return operation(createObjectName(objectName), method, arguments); |
| } |
| |
| /** |
| * Executes an operation on a JMX {@link ObjectName}. |
| */ |
| public Object operation(ObjectName objectName, final String method, final Object... arguments) { |
| final ObjectName realObjectName = toLiteralObjectName(objectName); |
| final String[] signature = new String[arguments.length]; |
| for (int i = 0; i < arguments.length; i++) { |
| Class<?> clazz = arguments[i].getClass(); |
| signature[i] = (CLASSES.containsKey(clazz.getSimpleName()) ? CLASSES.get(clazz.getSimpleName()) : clazz.getName()); |
| } |
| |
| Object result = invokeWithReconnect(new Callable<Object>() { |
| public Object call() throws Exception { |
| return getConnectionOrFail().invoke(realObjectName, method, arguments, signature); |
| }}); |
| |
| if (LOG.isTraceEnabled()) LOG.trace("From {}, for jmx operation {}.{}({}), got value {}", new Object[] {url, realObjectName.getCanonicalName(), method, Arrays.asList(arguments), |
| result}); |
| return result; |
| } |
| |
| public void addNotificationListener(String objectName, NotificationListener listener) { |
| addNotificationListener(createObjectName(objectName), listener, null); |
| } |
| |
| public void addNotificationListener(String objectName, NotificationListener listener, NotificationFilter filter) { |
| addNotificationListener(createObjectName(objectName), listener, filter); |
| } |
| |
| public void addNotificationListener(ObjectName objectName, NotificationListener listener) { |
| addNotificationListener(objectName, listener, null); |
| } |
| |
| public void addNotificationListener(final ObjectName objectName, final NotificationListener listener, final NotificationFilter filter) { |
| invokeWithReconnect(new Callable<Void>() { |
| public Void call() throws Exception { |
| getConnectionOrFail().addNotificationListener(objectName, listener, filter, null); |
| return null; |
| }}); |
| } |
| |
| public void removeNotificationListener(String objectName, NotificationListener listener) { |
| removeNotificationListener(createObjectName(objectName), listener); |
| } |
| |
| public void removeNotificationListener(final ObjectName objectName, final NotificationListener listener) { |
| removeNotificationListener(objectName, listener, null); |
| } |
| |
| public void removeNotificationListener(final ObjectName objectName, final NotificationListener listener, final NotificationFilter filter) { |
| if (isConnected()) invokeWithReconnect(new Callable<Void>() { |
| public Void call() throws Exception { |
| getConnectionOrFail().removeNotificationListener(objectName, listener, filter, null); |
| return null; |
| }}); |
| } |
| |
| public <M> M getProxyObject(String objectName, Class<M> mbeanInterface) { |
| return getProxyObject(createObjectName(objectName), mbeanInterface); |
| } |
| |
| public <M> M getProxyObject(ObjectName objectName, Class<M> mbeanInterface) { |
| MBeanServerConnection connection = getConnectionOrFail(); |
| return JMX.newMBeanProxy(connection, objectName, mbeanInterface, false); |
| } |
| |
| public static ObjectName createObjectName(String name) { |
| try { |
| return new ObjectName(name); |
| } catch (MalformedObjectNameException e) { |
| throw Throwables.propagate(e); |
| } |
| } |
| |
| private static void sleep(long sleepTimeMillis) { |
| try { |
| Thread.sleep(sleepTimeMillis); |
| } catch (InterruptedException e) { |
| throw new RuntimeInterruptedException(e); |
| } |
| } |
| } |
