コード例 #1
0
  private Object invokeAttribute(PropertyDescriptor pd, MethodInvocation invocation)
      throws JMException, IOException {

    String attributeName = JmxUtils.getAttributeName(pd, this.useStrictCasing);
    MBeanAttributeInfo inf = (MBeanAttributeInfo) this.allowedAttributes.get(attributeName);

    // If no attribute is returned, we know that it is not defined in the
    // management interface.
    if (inf == null) {
      throw new InvalidInvocationException(
          "Attribute '" + pd.getName() + "' is not exposed on the management interface");
    }
    if (invocation.getMethod().equals(pd.getReadMethod())) {
      if (inf.isReadable()) {
        return this.server.getAttribute(this.objectName, attributeName);
      } else {
        throw new InvalidInvocationException("Attribute '" + attributeName + "' is not readable");
      }
    } else if (invocation.getMethod().equals(pd.getWriteMethod())) {
      if (inf.isWritable()) {
        server.setAttribute(
            this.objectName, new Attribute(attributeName, invocation.getArguments()[0]));
        return null;
      } else {
        throw new InvalidInvocationException("Attribute '" + attributeName + "' is not writable");
      }
    } else {
      throw new IllegalStateException(
          "Method [" + invocation.getMethod() + "] is neither a bean property getter nor a setter");
    }
  }
コード例 #2
0
 public void testAnnotatedMXBean() throws Exception {
   if (JdkVersion.getMajorJavaVersion() < JdkVersion.JAVA_16) {
     return;
   }
   FooX foo = new FooX();
   assertTrue("MXBean annotation not detected correctly", JmxUtils.isMBean(foo.getClass()));
 }
コード例 #3
0
  /**
   * Loads the management interface info for the configured MBean into the caches. This information
   * is used by the proxy when determining whether an invocation matches a valid operation or
   * attribute on the management interface of the managed resource.
   */
  private void retrieveMBeanInfo()
      throws MBeanServerNotFoundException, MBeanInfoRetrievalException {
    try {
      MBeanInfo info = this.server.getMBeanInfo(this.objectName);

      // get attributes
      MBeanAttributeInfo[] attributeInfo = info.getAttributes();
      this.allowedAttributes = new HashMap(attributeInfo.length);

      for (int x = 0; x < attributeInfo.length; x++) {
        this.allowedAttributes.put(attributeInfo[x].getName(), attributeInfo[x]);
      }

      // get operations
      MBeanOperationInfo[] operationInfo = info.getOperations();
      this.allowedOperations = new HashMap(operationInfo.length);

      for (int x = 0; x < operationInfo.length; x++) {
        MBeanOperationInfo opInfo = operationInfo[x];
        this.allowedOperations.put(
            new MethodCacheKey(
                opInfo.getName(), JmxUtils.parameterInfoToTypes(opInfo.getSignature())),
            opInfo);
      }
    } catch (ClassNotFoundException ex) {
      throw new MBeanInfoRetrievalException(
          "Unable to locate class specified in method signature", ex);
    } catch (IntrospectionException ex) {
      throw new MBeanInfoRetrievalException(
          "Unable to obtain MBean info for bean [" + this.objectName + "]", ex);
    } catch (InstanceNotFoundException ex) {
      // if we are this far this shouldn't happen, but...
      throw new MBeanInfoRetrievalException(
          "Unable to obtain MBean info for bean ["
              + this.objectName
              + "]: it is likely that this bean was unregistered during the proxy creation process",
          ex);
    } catch (ReflectionException ex) {
      throw new MBeanInfoRetrievalException(
          "Unable to read MBean info for bean [ " + this.objectName + "]", ex);
    } catch (IOException ex) {
      throw new MBeanInfoRetrievalException(
          "An IOException occurred when communicating with the MBeanServer. "
              + "It is likely that you are communicating with a remote MBeanServer. "
              + "Check the inner exception for exact details.",
          ex);
    }
  }
コード例 #4
0
 /**
  * Connects to the remote <code>MBeanServer</code> using the configured <code>JMXServiceURL</code>
  * .
  *
  * @see #setServiceUrl(String)
  * @see #setConnectOnStartup(boolean)
  */
 private void connect() throws MBeanServerNotFoundException {
   if (this.serviceUrl != null) {
     if (logger.isDebugEnabled()) {
       logger.debug("Connecting to remote MBeanServer at URL [" + this.serviceUrl + "]");
     }
     try {
       this.connector = JMXConnectorFactory.connect(this.serviceUrl);
       this.server = this.connector.getMBeanServerConnection();
     } catch (IOException ex) {
       throw new MBeanServerNotFoundException(
           "Could not connect to remote MBeanServer at URL [" + this.serviceUrl + "]", ex);
     }
   } else {
     logger.debug("Attempting to locate local MBeanServer");
     this.server = JmxUtils.locateMBeanServer();
   }
 }
コード例 #5
0
  /**
   * Routes a method invocation (not a property get/set) to the corresponding operation on the
   * managed resource.
   *
   * @param method the method corresponding to operation on the managed resource.
   * @param args the invocation arguments
   * @return the value returned by the method invocation.
   */
  private Object invokeOperation(Method method, Object[] args) throws JMException, IOException {
    MethodCacheKey key = new MethodCacheKey(method.getName(), method.getParameterTypes());
    MBeanOperationInfo info = (MBeanOperationInfo) this.allowedOperations.get(key);
    if (info == null) {
      throw new InvalidInvocationException(
          "Operation '" + method.getName() + "' is not exposed on the management interface");
    }

    String[] signature = null;
    synchronized (this.signatureCache) {
      signature = (String[]) this.signatureCache.get(method);
      if (signature == null) {
        signature = JmxUtils.getMethodSignature(method);
        this.signatureCache.put(method, signature);
      }
    }
    return this.server.invoke(this.objectName, method.getName(), args, signature);
  }
コード例 #6
0
  /**
   * Registers the component specifying the info that describes it.
   *
   * <p>Certain interfaces are automatically detected. If the component implements {@code
   * Lifecycle}, it will be registered as though using {@link #registerLifecycle(Lifecycle)}. If it
   * implements {@code ServletContextAware}, then it will be registered as though using {@link
   * #registerServletContextAware(ServletContextAware)}. If it implements {@code InitializingBean},
   * then it will be initialized as though using {@link #initialize(InitializingBean)}.
   *
   * <p>If the component implements {@code FactoryBean}, it will be checked for the automatically
   * detected interfaces before the factory is evaluated. The evaluated factory will then be
   * registered, and the resulting object will again be checked for automatically detected
   * interfaces.
   *
   * @param info the component info to register, not null
   * @param instance the component instance to register, not null
   * @throws IllegalArgumentException if unable to register
   */
  public void registerComponent(final ComponentInfo info, Object instance) {
    ArgumentChecker.notNull(info, "info");
    ArgumentChecker.notNull(instance, "instance");
    checkStatus(Status.CREATING);

    final ComponentKey key = info.toComponentKey();
    try {
      // initialize
      initialize0(instance);
      registerInstanceInterfaces0(instance);

      // handle factories
      if (instance instanceof FactoryBean<?>) {
        try {
          instance = ((FactoryBean<?>) instance).getObject();
        } catch (final Exception ex) {
          throw new OpenGammaRuntimeException("FactoryBean threw exception", ex);
        }
        initialize0(instance);
        registerInstanceInterfaces0(instance);
      }

      // register into data structures
      final Object current = _instanceMap.putIfAbsent(key, instance);
      if (current != null) {
        throw new IllegalArgumentException(
            "Component already registered for specified information: " + key);
      }
      _infoMap.putIfAbsent(info.getType(), new ComponentTypeInfo(info.getType()));
      final ComponentTypeInfo typeInfo = getTypeInfo(info.getType());
      typeInfo.getInfoMap().put(info.getClassifier(), info);
      registeredComponent(info, instance);

      // If the component being registered is also an MBean, then register it as such
      if (JmxUtils.isMBean(instance.getClass())) {
        registerMBean(instance);
      }
    } catch (final RuntimeException ex) {
      _status.set(Status.FAILED);
      throw new RuntimeException("Failed during registration: " + key, ex);
    }
  }