/** * Instantiates and registers an MBean in the MBean server. The class loader to be used is * identified by its object name. An object name is associated to the MBean. If the object name of * the loader is not specified, the ClassLoader that loaded the MBean server will be used. If the * MBean object name given is null, the MBean can automatically provide its own name by * implementing the {@link javax.management.MBeanRegistration MBeanRegistration} interface. The * call returns an <CODE>ObjectInstance</CODE> object representing the newly created MBean. * * @param className The class name of the MBean to be instantiated. * @param name The object name of the MBean. May be null. * @param params An array containing the parameters of the constructor to be invoked. * @param signature An array containing the signature of the constructor to be invoked. * @param loaderName The object name of the class loader to be used. * @return An <CODE>ObjectInstance</CODE>, containing the <CODE>ObjectName</CODE> and the Java * class name of the newly instantiated MBean. * @exception ReflectionException Wraps a <CODE>{@link java.lang.ClassNotFoundException}</CODE> or * an <CODE>{@link java.lang.Exception}</CODE> that occurred when trying to invoke the MBean's * constructor. * @exception InstanceAlreadyExistsException The MBean is already under the control of the MBean * server. * @exception MBeanRegistrationException The <CODE>preRegister()</CODE> (<CODE>MBeanRegistration * </CODE> interface) method of the MBean has thrown an exception. The MBean will not be * registered. * @exception MBeanException The constructor of the MBean has thrown an exception * @exception InstanceNotFoundException The specified class loader is not registered in the MBean * server. * @exception RuntimeOperationsException Wraps an <CODE>{@link java.lang.IllegalArgumentException} * </CODE>: The className passed in parameter is null, the <CODE>ObjectName</CODE> passed in * parameter contains a pattern or no <CODE>ObjectName</CODE> is specified for the MBean. */ public ObjectInstance createMBean( String className, ObjectName name, ObjectName loaderName, Object params[], String signature[]) throws ReflectionException, InstanceAlreadyExistsException, MBeanRegistrationException, MBeanException, NotCompliantMBeanException, InstanceNotFoundException { return interceptor.createMBean(className, name, loaderName, params, signature); }
private void initialize(MBeanInstantiator instantiator, MetaData meta, String domain) { this.instantiator = instantiator; if (instantiator == null) throw new IllegalArgumentException("instantiator must not be null."); this.meta = (meta == null ? new MetaDataImpl(instantiator) : meta); this.secureClr = new SecureClassLoaderRepository(instantiator.getClassLoaderRepository()); if (domain != null) { interceptor = new DefaultMBeanInterceptor(this, domain); } else { interceptor = new DefaultMBeanInterceptor(this); } // Create the MBeanServer identification MBean try { MBeanServerDelegateObject = new MBeanServerDelegateImpl(new MBeanServerDelegate()); MBeanServerDelegateObjectName = new ObjectName(ServiceName.DELEGATE); interceptor.registerMBean(MBeanServerDelegateObject, MBeanServerDelegateObjectName); } catch (JMException e) { // This should never happen! final RuntimeException r = new RuntimeException("Unexpected JMException: " + e); Utils.initCause(r, e); throw r; } ClassLoader myLoader = this.getClass().getClassLoader(); final ModifiableClassLoaderRepository loaders = instantiator.getClassLoaderRepository(); if (loaders != null && myLoader != null) { loaders.addClassLoader(myLoader); } }
/** * De-registers an MBean from the MBean server. The MBean is identified by * its object name. Once the method has been invoked, the MBean may * no longer be accessed by its object name. * * @param name The object name of the MBean to be de-registered. * * @exception InstanceNotFoundException The MBean specified is not * registered in the MBean server. * @exception MBeanRegistrationException The <code>preDeregister()<code> * (<CODE>MBeanRegistration</CODE> interface) method of the MBean * has thrown an exception. * @exception RuntimeOperationsException Wraps an * <CODE>{@link java.lang.IllegalArgumentException}</CODE>: The * object name in parameter is null or the MBean you are when * trying to de-register is the * {@link javax.management.MBeanServerDelegate MBeanServerDelegate} * MBean. **/ public void unregisterMBean(ObjectName name) throws InstanceNotFoundException, MBeanRegistrationException { // Now handled by the delegate itself.. // if (name.equals(MBeanServerDelegateObjectName)) { // throw new RuntimeOperationsException( // new IllegalArgumentException( // "The MBeanDelegate MBean cannot be unregistered")); // } interceptor.unregisterMBean(name); }
/** @since Java DMK 1.5 */ public String[] getDomains() { if (interceptor instanceof MBeanServerInterceptor) { return ((MBeanServerInterceptor) interceptor).getDomains(); } final Set names = interceptor.queryNames(null, null); final Set tmpSet = new HashSet(1); for (final Iterator i = names.iterator(); i.hasNext(); ) { final ObjectName x = (ObjectName) i.next(); final String domain = x.getDomain(); if (tmpSet.contains(domain)) continue; tmpSet.add(domain); } final String[] result = new String[tmpSet.size()]; return (String[]) tmpSet.toArray(result); }
/** * Sets the value of a specific attribute of a named MBean. The MBean is identified by its object * name. * * @param name The name of the MBean within which the attribute is to be set. * @param attribute The identification of the attribute to be set and the value it is to be set * to. * @exception InstanceNotFoundException The MBean specified is not registered in the MBean server. * @exception AttributeNotFoundException The attribute specified is not accessible in the MBean. * @exception InvalidAttributeValueException The value specified for the attribute is not valid. * @exception MBeanException Wraps an exception thrown by the MBean's setter. * @exception ReflectionException Wraps an <CODE>{@link java.lang.Exception}</CODE> thrown when * trying to invoke the setter. * @exception RuntimeOperationsException Wraps an <CODE>{@link java.lang.IllegalArgumentException} * </CODE>: The object name in parameter is null or the attribute in parameter is null. */ public void setAttribute(ObjectName name, Attribute attribute) throws InstanceNotFoundException, AttributeNotFoundException, InvalidAttributeValueException, MBeanException, ReflectionException { interceptor.setAttribute(name, attribute); }
/** * This method discovers the attributes and operations that an MBean exposes for management. * * @param name The name of the MBean to analyze * @return An instance of <CODE>MBeanInfo</CODE> allowing the retrieval of all attributes and * operations of this MBean. * @exception IntrospectionException An exception occurs during introspection. * @exception InstanceNotFoundException The MBean specified is not found. * @exception ReflectionException An exception occurred when trying to invoke the getMBeanInfo of * a Dynamic MBean. */ public MBeanInfo getMBeanInfo(ObjectName name) throws InstanceNotFoundException, IntrospectionException, ReflectionException { return interceptor.getMBeanInfo(name); }
/** * Returns true if the MBean specified is an instance of the specified class, false otherwise. * * @param name The <CODE>ObjectName</CODE> of the MBean. * @param className The name of the class. * @return true if the MBean specified is an instance of the specified class, false otherwise. * @exception InstanceNotFoundException The MBean specified is not registered in the MBean server. */ public boolean isInstanceOf(ObjectName name, String className) throws InstanceNotFoundException { return interceptor.isInstanceOf(name, className); }
/** * Adds a listener to a registered MBean. * * @param name The name of the MBean on which the listener should be added. * @param listener The object name of the listener which will handle the notifications emitted by * the registered MBean. * @param filter The filter object. If filter is null, no filtering will be performed before * handling notifications. * @param handback The context to be sent to the listener when a notification is emitted. * @exception InstanceNotFoundException The MBean name of the notification listener or of the * notification broadcaster does not match any of the registered MBeans. */ public void addNotificationListener( ObjectName name, ObjectName listener, NotificationFilter filter, Object handback) throws InstanceNotFoundException { interceptor.addNotificationListener(name, listener, filter, handback); }
/** * Removes a listener from a registered MBean. * * @param name The name of the MBean on which the listener should be removed. * @param listener The object name of the listener which will handle the notifications emitted by * the registered MBean. This method will remove all the information related to this listener. * @exception InstanceNotFoundException The MBean name provided does not match any of the * registered MBeans. * @exception ListenerNotFoundException The listener is not registered in the MBean. */ public void removeNotificationListener(ObjectName name, ObjectName listener) throws InstanceNotFoundException, ListenerNotFoundException { interceptor.removeNotificationListener(name, listener); }
/** * Invokes an operation on an MBean. * * @param name The object name of the MBean on which the method is to be invoked. * @param operationName The name of the operation to be invoked. * @param params An array containing the parameters to be set when the operation is invoked * @param signature An array containing the signature of the operation. The class objects will be * loaded using the same class loader as the one used for loading the MBean on which the * operation was invoked. * @return The object returned by the operation, which represents the result of invoking the * operation on the MBean specified. * @exception InstanceNotFoundException The MBean specified is not registered in the MBean server. * @exception MBeanException Wraps an exception thrown by the MBean's invoked method. * @exception ReflectionException Wraps an <CODE>{@link java.lang.Exception}</CODE> thrown while * trying to invoke the method. */ public Object invoke(ObjectName name, String operationName, Object params[], String signature[]) throws InstanceNotFoundException, MBeanException, ReflectionException { return interceptor.invoke(name, operationName, params, signature); }
/** * Returns the default domain used for naming the MBean. The default domain name is used as the * domain part in the ObjectName of MBeans if no domain is specified by the user. */ public String getDefaultDomain() { return interceptor.getDefaultDomain(); }
/** @since Java DMK 5.1 (JMX 1.2) */ public ClassLoader getClassLoaderFor(ObjectName mbeanName) throws InstanceNotFoundException { return interceptor.getMBeanClassLoader(mbeanName); }
/** * Registers a pre-existing object as an MBean with the MBean server. If the object name given is * null, the MBean may automatically provide its own name by implementing the {@link * javax.management.MBeanRegistration MBeanRegistration} interface. The call returns an <CODE> * ObjectInstance</CODE> object representing the registered MBean. * * @param object The MBean to be registered as an MBean. * @param name The object name of the MBean. May be null. * @return The <CODE>ObjectInstance</CODE> for the MBean that has been registered. * @exception InstanceAlreadyExistsException The MBean is already under the control of the MBean * server. * @exception MBeanRegistrationException The <CODE>preRegister()</CODE> (<CODE>MBeanRegistration * </CODE> interface) method of the MBean has thrown an exception. The MBean will not be * registered. * @exception NotCompliantMBeanException This object is not a JMX compliant MBean * @exception RuntimeOperationsException Wraps an <CODE>{@link java.lang.IllegalArgumentException} * </CODE>: The object passed in parameter is null or no object name is specified. */ public ObjectInstance registerMBean(Object object, ObjectName name) throws InstanceAlreadyExistsException, MBeanRegistrationException, NotCompliantMBeanException { return interceptor.registerMBean(object, name); }
/** * Gets the value of a specific attribute of a named MBean. The MBean is identified by its object * name. * * @param name The object name of the MBean from which the attribute is to be retrieved. * @param attribute A String specifying the name of the attribute to be retrieved. * @return The value of the retrieved attribute. * @exception AttributeNotFoundException The attribute specified is not accessible in the MBean. * @exception MBeanException Wraps an exception thrown by the MBean's getter. * @exception InstanceNotFoundException The MBean specified is not registered in the MBean server. * @exception ReflectionException Wraps an <CODE>{@link java.lang.Exception}</CODE> thrown when * trying to invoke the setter. * @exception RuntimeOperationsException Wraps an <CODE>{@link java.lang.IllegalArgumentException} * </CODE>: The object name in parameter is null or the attribute in parameter is null. */ public Object getAttribute(ObjectName name, String attribute) throws MBeanException, AttributeNotFoundException, InstanceNotFoundException, ReflectionException { return interceptor.getAttribute(name, attribute); }
/** Returns the number of MBeans registered in the MBean server. */ public Integer getMBeanCount() { return interceptor.getMBeanCount(); }
/** * Checks whether an MBean, identified by its object name, is already registered with the MBean * server. * * @param name The object name of the MBean to be checked. * @return True if the MBean is already registered in the MBean server, false otherwise. * @exception RuntimeOperationsException Wraps an <CODE>{@link java.lang.IllegalArgumentException} * </CODE>: The object name in parameter is null. */ public boolean isRegistered(ObjectName name) { return interceptor.isRegistered(name); }
/** * Gets the names of MBeans controlled by the MBean server. This method enables any of the * following to be obtained: The names of all MBeans, the names of a set of MBeans specified by * pattern matching on the <CODE>ObjectName</CODE> and/or a Query expression, a specific MBean * name (equivalent to testing whether an MBean is registered). When the object name is null or or * no domain and key properties are specified, all objects are selected (and filtered if a query * is specified). It returns the set of ObjectNames for the MBeans selected. * * @param name The object name pattern identifying the MBeans to be retrieved. If null or no * domain and key properties are specified, all the MBeans registered will be retrieved. * @param query The query expression to be applied for selecting MBeans. If null no query * expression will be applied for selecting MBeans. * @return A set containing the ObjectNames for the MBeans selected. If no MBean satisfies the * query, an empty list is returned. */ public Set queryNames(ObjectName name, QueryExp query) { return interceptor.queryNames(name, query); }
/** * Gets the <CODE>ObjectInstance</CODE> for a given MBean registered with the MBean server. * * @param name The object name of the MBean. * @return The <CODE>ObjectInstance</CODE> associated to the MBean specified by <VAR>name</VAR>. * @exception InstanceNotFoundException The MBean specified is not registered in the MBean server. */ public ObjectInstance getObjectInstance(ObjectName name) throws InstanceNotFoundException { return interceptor.getObjectInstance(name); }
/** * Sets the values of several attributes of a named MBean. The MBean is identified by its object * name. * * @param name The object name of the MBean within which the attributes are to be set. * @param attributes A list of attributes: The identification of the attributes to be set and the * values they are to be set to. * @return The list of attributes that were set, with their new values. * @exception InstanceNotFoundException The MBean specified is not registered in the MBean server. * @exception ReflectionException An exception occurred when trying to invoke the getAttributes * method of a Dynamic MBean. * @exception RuntimeOperationsException Wraps an <CODE>{@link java.lang.IllegalArgumentException} * </CODE>: The object name in parameter is null or attributes in parameter is null. */ public AttributeList setAttributes(ObjectName name, AttributeList attributes) throws InstanceNotFoundException, ReflectionException { return interceptor.setAttributes(name, attributes); }
/** * Instantiates and registers an MBean in the MBean server. The class loader to be used is * identified by its object name. An object name is associated to the MBean. If the object name of * the loader is null, the ClassLoader that loaded the MBean server will be used. If the MBean's * object name given is null, the MBean can automatically provide its own name by implementing the * {@link javax.management.MBeanRegistration MBeanRegistration} interface. The call returns an * <CODE>ObjectInstance</CODE> object representing the newly created MBean. * * @param className The class name of the MBean to be instantiated. * @param name The object name of the MBean. May be null. * @param loaderName The object name of the class loader to be used. * @return An <CODE>ObjectInstance</CODE>, containing the <CODE>ObjectName</CODE> and the Java * class name of the newly instantiated MBean. * @exception ReflectionException Wraps an <CODE>{@link java.lang.ClassNotFoundException}</CODE> * or an <CODE>{@link java.lang.Exception}</CODE> that occurred when trying to invoke the * MBean's constructor. * @exception InstanceAlreadyExistsException The MBean is already under the control of the MBean * server. * @exception MBeanRegistrationException The <CODE>preRegister()</CODE> (<CODE>MBeanRegistration * </CODE> interface) method of the MBean has thrown an exception. The MBean will not be * registered. * @exception MBeanException The constructor of the MBean has thrown an exception * @exception NotCompliantMBeanException This class is not a JMX compliant MBean. * @exception InstanceNotFoundException The specified class loader is not registered in the MBean * server. * @exception RuntimeOperationsException Wraps an <CODE>{@link java.lang.IllegalArgumentException} * </CODE>: The className passed in parameter is null, the <CODE>ObjectName</CODE> passed in * parameter contains a pattern or no <CODE>ObjectName</CODE> is specified for the MBean. */ public ObjectInstance createMBean(String className, ObjectName name, ObjectName loaderName) throws ReflectionException, InstanceAlreadyExistsException, MBeanRegistrationException, MBeanException, NotCompliantMBeanException, InstanceNotFoundException { return interceptor.createMBean(className, name, loaderName, (Object[]) null, (String[]) null); }