Java > Open Source Codes > org > jboss > mx > server > MBeanServerImpl


1 /*
2   * JBoss, Home of Professional Open Source
3   * Copyright 2005, JBoss Inc., and individual contributors as indicated
4   * by the @authors tag. See the copyright.txt in the distribution for a
5   * full listing of individual contributors.
6   *
7   * This is free software; you can redistribute it and/or modify it
8   * under the terms of the GNU Lesser General Public License as
9   * published by the Free Software Foundation; either version 2.1 of
10   * the License, or (at your option) any later version.
11   *
12   * This software is distributed in the hope that it will be useful,
13   * but WITHOUT ANY WARRANTY; without even the implied warranty of
14   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15   * Lesser General Public License for more details.
16   *
17   * You should have received a copy of the GNU Lesser General Public
18   * License along with this software; if not, write to the Free
19   * Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
20   * 02110-1301 USA, or see the FSF site: http://www.fsf.org.
21   */
22 package org.jboss.mx.server;
23
24 import java.io.ByteArrayInputStream ;
25 import java.io.IOException ;
26 import java.io.ObjectInputStream ;
27 import java.lang.reflect.Constructor ;
28 import java.lang.reflect.InvocationTargetException ;
29 import java.util.ArrayList ;
30 import java.util.HashMap ;
31 import java.util.HashSet ;
32 import java.util.Iterator ;
33 import java.util.List ;
34 import java.util.Map ;
35 import java.util.Set ;
36 import java.security.ProtectionDomain ;
37 import java.security.AccessController ;
38 import java.security.PrivilegedAction ;
39 import java.security.PrivilegedExceptionAction ;
40 import java.security.PrivilegedActionException ;
41
42 import javax.management.Attribute ;
43 import javax.management.AttributeList ;
44 import javax.management.AttributeNotFoundException ;
45 import javax.management.InstanceAlreadyExistsException ;
46 import javax.management.InstanceNotFoundException ;
47 import javax.management.IntrospectionException ;
48 import javax.management.InvalidAttributeValueException ;
49 import javax.management.JMException ;
50 import javax.management.ListenerNotFoundException ;
51 import javax.management.MBeanException ;
52 import javax.management.MBeanInfo ;
53 import javax.management.MBeanParameterInfo ;
54 import javax.management.MBeanRegistrationException ;
55 import javax.management.MBeanServer ;
56 import javax.management.MBeanServerDelegate ;
57 import javax.management.NotCompliantMBeanException ;
58 import javax.management.NotificationBroadcaster ;
59 import javax.management.NotificationFilter ;
60 import javax.management.NotificationListener ;
61 import javax.management.ObjectInstance ;
62 import javax.management.ObjectName ;
63 import javax.management.OperationsException ;
64 import javax.management.QueryExp ;
65 import javax.management.ReflectionException ;
66 import javax.management.RuntimeErrorException ;
67 import javax.management.RuntimeMBeanException ;
68 import javax.management.RuntimeOperationsException ;
69 import javax.management.JMRuntimeException ;
70 import javax.management.MBeanPermission ;
71 import javax.management.MalformedObjectNameException ;
72 import javax.management.MBeanTrustPermission ;
73 import javax.management.loading.ClassLoaderRepository ;
74 import javax.management.modelmbean.DescriptorSupport ;
75 import javax.management.modelmbean.ModelMBean ;
76 import javax.management.modelmbean.ModelMBeanAttributeInfo ;
77 import javax.management.modelmbean.ModelMBeanConstructorInfo ;
78 import javax.management.modelmbean.ModelMBeanInfo ;
79 import javax.management.modelmbean.ModelMBeanInfoSupport ;
80 import javax.management.modelmbean.ModelMBeanNotificationInfo ;
81 import javax.management.modelmbean.ModelMBeanOperationInfo ;
82
83 import org.jboss.logging.Logger;
84 import org.jboss.mx.loading.LoaderRepository;
85 import org.jboss.mx.modelmbean.ModelMBeanConstants;
86 import org.jboss.mx.modelmbean.RequiredModelMBeanInstantiator;
87 import org.jboss.mx.notification.MBeanServerListenerRegistry;
88 import org.jboss.mx.server.registry.MBeanEntry;
89 import org.jboss.mx.server.registry.MBeanRegistry;
90 import org.jboss.mx.service.ServiceConstants;
91 import org.jboss.mx.util.JMXExceptionDecoder;
92 import org.jboss.mx.util.PropertyAccess;
93 import org.jboss.util.NestedRuntimeException;
94
95 /**
96  * MBean server implementation.
97  *
98  * The MBean server behaviour can be configured by setting the following
99  * system properties: <ul>
100  * <li><tt>jbossmx.loader.repository.class</tt>
101  ({@link ServerConstants#LOADER_REPOSITORY_CLASS_PROPERTY LOADER_REPOSITORY_CLASS_PROPERTY})</li>
102  * <li><tt>jbossmx.mbean.registry.class</tt>
103  ({@link ServerConstants#MBEAN_REGISTRY_CLASS_PROPERTY MBEAN_REGISTRY_CLASS_PROPERTY})</li>
104  * <li><tt>jbossmx.required.modelmbean.class</tt>
105  ({@link ServerConstants#REQUIRED_MODELMBEAN_CLASS_PROPERTY REQUIRED_MODELMBEAN_CLASS_PROPERTY})</li>
106  * </ul>
107  *
108  * The loader repository is used for managing class loaders in the MBean server.
109  * The default repository uses the <tt>UnifiedLoaderRepository</tt> implementation
110  * ({@link ServerConstants#DEFAULT_LOADER_REPOSITORY_CLASS DEFAULT_LOADER_REPOSITORY_CLASS}).<p>
111  *
112  * The default registry is
113  * ({@link ServerConstants#DEFAULT_MBEAN_REGISTRY_CLASS DEFAULT_MBEAN_REGISTRY_CLASS}).<p>
114  *
115  * The <tt>RequiredModelMBean</tt> uses <tt>XMBean</tt> implementation by default
116  * ({@link ServerConstants#DEFAULT_REQUIRED_MODELMBEAN_CLASS DEFAULT_REQUIRED_MODELMBEAN_CLASS}).
117  *
118  * @see javax.management.MBeanServer
119  * @see javax.management.modelmbean.RequiredModelMBean
120  * @see org.jboss.mx.server.ServerConstants
121  * @see org.jboss.mx.loading.LoaderRepository
122  * @see org.jboss.mx.loading.UnifiedLoaderRepository3
123  * @see org.jboss.mx.modelmbean.XMBean
124  *
125  * @author <a HREF="mailto:juha@jboss.org">Juha Lindfors</a>.
126  * @author <a HREF="mailto:trevor@protocool.com">Trevor Squires</a>.
127  * @author <a HREF="mailto:Adrian.Brock@HappeningTimes.com">Adrian Brock</a>.
128  * @author <a HREF="mailto:thomas.diesler@jboss.com">Thomas Diesler</a>.
129  * @author Scott.Stark@jboss.org
130  * @version $Revision: 57108 $
131  */
132 public class MBeanServerImpl
133    implements MBeanServer , ServerConstants, ServiceConstants, ModelMBeanConstants
134 {
135    // Constants ------------------------------------------------------
136
137    /**
138     * No parameters array
139     */
140    private static final Object [] NOPARAMS = new Object [0];
141
142    /**
143     * No signature array
144     */
145    private static final String [] NOSIG = new String [0];
146
147    // Attributes ----------------------------------------------------
148
149    /**
150     * The wrapping MBeanServer
151     */
152    protected MBeanServer outer = null;
153
154    /**
155     * Registry used by this server to map MBean object names to resource references.
156     */
157    protected MBeanRegistry registry = null;
158
159    /**
160     * The notification registrations
161     */
162    private MBeanServerListenerRegistry listeners = new MBeanServerListenerRegistry();
163
164    /**
165     * This server's class loader repository
166     */
167    private ClassLoaderRepository classLoaderRepository;
168
169    // Static --------------------------------------------------------
170
171    /**
172     * The logger
173     */
174    private static Logger log = Logger.getLogger(MBeanServerImpl.class);
175
176    
177    // Constructors --------------------------------------------------
178
179    /**
180     * Creates an MBean server implementation with a given default domain name and
181     * registers the mandatory server delegate MBean to the server
182     * ({@link ServerConstants#MBEAN_SERVER_DELEGATE MBEAN_SERVER_DELEGATE}).
183     *
184     * @param defaultDomain default domain name
185     * @param outer the wrapping MBeanServer, passed to MBeans
186     * at registration.
187     * @param delegate the delegate to use
188     * for Notifications.
189     */
190    public MBeanServerImpl(String defaultDomain, MBeanServer outer, MBeanServerDelegate delegate)
191    {
192       // Determine the MBeanServer to pass to MBeans
193 if (outer == null)
194          this.outer = this;
195       else
196          this.outer = outer;
197
198       // the very first thing to do is to create a class loader repository
199 this.classLoaderRepository = getClassLoaderRepository();
200
201       // the second first thing to do is to create a registry instance
202 this.registry = createRegistry(defaultDomain);
203       
204       // The first MBean to be registered should be the server delegate
205 // to guarantee correct functionality (other MBeans may be dependent
206 // on the existence of the delegate).
207 try
208       {
209          // the magic token that allows us to register to the
210 // protected JMImplementation domain
211 HashMap valueMap = new HashMap ();
212          valueMap.put(JMI_DOMAIN, JMI_DOMAIN);
213
214          // register the delegate
215 registry.registerMBean(delegate,
216                  new ObjectName (MBEAN_SERVER_DELEGATE),
217                  valueMap);
218          
219          // We expose the registry as an MBean for other components
220 ModelMBean rmm = RequiredModelMBeanInstantiator.instantiate();
221          rmm.setModelMBeanInfo(getRegistryManagementInterface());
222          rmm.setManagedResource(registry, "ObjectReference");
223
224          // register the registry MBean
225 registry.registerMBean(rmm, new ObjectName (MBEAN_REGISTRY), valueMap);
226          
227          // register the loader repository
228 //String loaderClassMBeanName = classLoaderRepository.getClass().getName() + "MBean";
229 //ClassLoader cl = classLoaderRepository.getClass().getClassLoader();
230 //Class mbean = cl.loadClass(loaderClassMBeanName);
231
232          //there must be a class with the MBean extension.
233 ObjectName loaderName = new ObjectName (DEFAULT_LOADER_NAME);
234          registry.registerMBean(classLoaderRepository, loaderName, valueMap);
235
236       }
237       catch (Exception e)
238       {
239          throw new RuntimeException ("Cannot create MBeanServer", e);
240       }
241    }
242
243    // MBeanServer implementation ------------------------------------
244
245    public Object instantiate(String className)
246            throws ReflectionException , MBeanException
247    {
248       return instantiate(className, (ClassLoader ) null, NOPARAMS, NOSIG);
249    }
250
251    public Object instantiate(String className, Object [] params, String [] signature)
252            throws ReflectionException , MBeanException
253    {
254       return instantiate(className, (ClassLoader ) null, params, signature);
255    }
256
257    public Object instantiate(String className, ObjectName loaderName)
258            throws ReflectionException , MBeanException , InstanceNotFoundException
259    {
260       return instantiate(className, loaderName, NOPARAMS, NOSIG);
261    }
262
263    public Object instantiate(String className, ObjectName loaderName, Object [] params, String [] signature)
264            throws ReflectionException , MBeanException , InstanceNotFoundException
265    {
266       ClassLoader cl = null;
267
268       // if instantiate() is called with null loader name, we use the cl that
269 // loaded the MBean server (see javadoc)
270
271       try
272       {
273          if (loaderName != null)
274             cl = (ClassLoader ) registry.get(loaderName).getResourceInstance();
275       }
276       catch (ClassCastException e)
277       {
278          throw new ReflectionException (e, loaderName + " is not a class loader.");
279       }
280
281       if (cl == null)
282          cl = this.getClass().getClassLoader();
283       if (cl == null)
284          cl = ClassLoader.getSystemClassLoader();
285
286       return instantiate(className, cl, params, signature);
287    }
288
289    public ObjectInstance createMBean(String className, ObjectName name)
290            throws ReflectionException , InstanceAlreadyExistsException , MBeanRegistrationException , MBeanException , NotCompliantMBeanException
291    {
292       try
293       {
294          Object mbean = instantiate(className);
295          return registerMBean(mbean, name, (ClassLoader ) null);
296       }
297       catch (SecurityException e)
298       {
299          throw e;
300       }
301       catch (ReflectionException refex)
302       {
303          // Note, the CTS wants a NotCompliantMBeanException for this case
304 if (refex.getCause() instanceof InstantiationException )
305             throw new NotCompliantMBeanException ("Cannot instanciate MBean: " + className);
306          else
307             throw refex;
308       }
309    }
310
311    public ObjectInstance createMBean(String className, ObjectName name, Object [] params, String [] signature)
312            throws ReflectionException , InstanceAlreadyExistsException , MBeanRegistrationException , MBeanException , NotCompliantMBeanException
313    {
314       try
315       {
316          Object mbean = instantiate(className, params, signature);
317          return registerMBean(mbean, name, (ClassLoader ) null);
318       }
319       catch (ReflectionException refex)
320       {
321          return handleExceptionOnCreate(refex, className);
322       }
323    }
324
325    public ObjectInstance createMBean(String className, ObjectName name, ObjectName loaderName)
326            throws ReflectionException , InstanceAlreadyExistsException , MBeanRegistrationException , MBeanException , NotCompliantMBeanException , InstanceNotFoundException
327    {
328       try
329       {
330          Object mbean = instantiate(className, loaderName);
331          return registerMBean(mbean, name, loaderName);
332       }
333       catch (ReflectionException refex)
334       {
335          return handleExceptionOnCreate(refex, className);
336       }
337    }
338
339    public ObjectInstance createMBean(String className, ObjectName name, ObjectName loaderName, Object [] params, String [] signature)
340            throws ReflectionException , InstanceAlreadyExistsException , MBeanRegistrationException , MBeanException , NotCompliantMBeanException , InstanceNotFoundException
341    {
342       try
343       {
344          Object mbean = instantiate(className, loaderName, params, signature);
345          return registerMBean(mbean, name, loaderName);
346       }
347       catch (ReflectionException refex)
348       {
349          return handleExceptionOnCreate(refex, className);
350       }
351    }
352
353    /**
354     * The CTS wants a NotCompliantMBeanException in case the MBean cannot be created.
355     * We need this, because instanciate cannot throw NotCompliantMBeanException.
356     */
357    private ObjectInstance handleExceptionOnCreate(ReflectionException refex, String className)
358            throws NotCompliantMBeanException , ReflectionException
359    {
360       if (refex.getCause() instanceof InstantiationException )
361          throw new NotCompliantMBeanException ("Cannot instanciate MBean: " + className);
362
363       throw refex;
364    }
365
366    /**
367     * Registers a pre-existing object as an MBean with the MBean server. If the object name given is null,
368     * the MBean must provide its own name by implementing the MBeanRegistration interface and returning the name
369     * from the preRegister method.
370     */
371    public ObjectInstance registerMBean(Object object, ObjectName name)
372            throws InstanceAlreadyExistsException ,
373            MBeanRegistrationException ,
374            NotCompliantMBeanException
375    {
376       return registerMBean(object, name, (ClassLoader ) null);
377    }
378
379    public void unregisterMBean(ObjectName name)
380            throws InstanceNotFoundException , MBeanRegistrationException
381    {
382       // Get the mbean to remove
383 MBeanEntry entry = registry.get(name);
384       Object mbean = entry.getResourceInstance();
385       name = entry.getObjectName();
386
387       checkMBeanPermission(entry.getResourceClassName(), null, name, "unregisterMBean");
388
389       try
390       {
391          final Object [] args = {name};
392          final String [] sig = {ObjectName .class.getName()};
393          try
394          {
395             AccessController.doPrivileged(
396                new PrivilegedExceptionAction ()
397                {
398                   public Object run() throws Exception
399                   {
400                      return invoke(new ObjectName (MBEAN_REGISTRY),
401                         "unregisterMBean", args, sig);
402                   }
403                }
404             );
405          }
406          catch(PrivilegedActionException e)
407          {
408             throw e.getException();
409          }
410       }
411       catch (Throwable t)
412       {
413          Throwable result = JMXExceptionDecoder.decodeToJMXException(t);
414          if (result instanceof InstanceNotFoundException )
415             throw (InstanceNotFoundException ) result;
416          if (result instanceof MBeanRegistrationException )
417             throw (MBeanRegistrationException ) result;
418          if ( result instanceof JMRuntimeException )
419             throw (JMRuntimeException ) result;
420          if (result instanceof MBeanException )
421          {
422             MBeanException e = (MBeanException ) result;
423             t = e.getTargetException();
424             if (t instanceof InstanceNotFoundException )
425                throw (InstanceNotFoundException ) t;
426             if (t instanceof MBeanRegistrationException )
427                throw (MBeanRegistrationException ) t;
428          }
429          if (result instanceof RuntimeException )
430             throw new RuntimeMBeanException ((RuntimeException ) result);
431          if (result instanceof Error )
432             throw new RuntimeErrorException ((Error ) result);
433
434          // for some other reason, unregistration failed
435 throw new MBeanRegistrationException (new InvocationTargetException (t), "Cannot unregister MBean");
436       }
437       
438       // Unregistration worked, remove any proxies for a broadcaster
439 if (mbean instanceof NotificationBroadcaster )
440          listeners.remove(name);
441    }
442
443    public ObjectInstance getObjectInstance(ObjectName name)
444            throws InstanceNotFoundException
445    {
446       ObjectInstance oi = registry.getObjectInstance(name);
447       checkMBeanPermission(oi.getClassName(), null, name,
448          "getObjectInstance");
449
450       return oi;
451    }
452
453    public Set queryMBeans(ObjectName name, QueryExp query)
454    {
455       // At least one mbean must be queriable
456 checkMBeanPermission(null, null, null, "queryMBeans");
457
458       // Set up the query
459 Set result = new HashSet ();
460       if (query != null)
461          query.setMBeanServer(outer);
462
463       SecurityManager sm = System.getSecurityManager();
464       // Get the possible MBeans
465 List entries = registry.findEntries(name);
466       Iterator iterator = entries.iterator();
467       while (iterator.hasNext())
468       {
469          // Check each MBean against the query
470 MBeanEntry entry = (MBeanEntry) iterator.next();
471          ObjectName objectName = entry.getObjectName();
472          // The permission check must be done before the query is applied
473 if( sm != null )
474          {
475             try
476             {
477                checkMBeanPermission(entry.getResourceClassName(), null,
478                   objectName, "queryMBeans");
479             }
480             catch(SecurityException e)
481             {
482                if( log.isTraceEnabled() )
483                   log.trace("Excluded mbean due to security: "+objectName);
484                continue;
485             }
486          }
487          // Check the mbean against the query
488 if (queryMBean(objectName, query) == true)
489          {
490             try
491             {
492                ObjectInstance instance = registry.getObjectInstance(objectName);
493                result.add(instance);
494             }
495             catch (InstanceNotFoundException ignored)
496             {
497             }
498          }
499       }
500
501       return result;
502    }
503
504    public Set queryNames(ObjectName name, QueryExp query)
505    {
506       // At least one mbean must be queriable
507 checkMBeanPermission(null, null, null, "queryNames");
508
509       // Set up the query
510 Set result = new HashSet ();
511       if (query != null)
512          query.setMBeanServer(outer);
513
514       SecurityManager sm = System.getSecurityManager();
515       // Get the possible MBeans
516 List entries = registry.findEntries(name);
517       Iterator iterator = entries.iterator();
518       while (iterator.hasNext())
519       {
520          // Check each MBean against the query
521 MBeanEntry entry = (MBeanEntry) iterator.next();
522          ObjectName objectName = entry.getObjectName();
523          // The permission check must be done before the query is applied
524 if( sm != null )
525          {
526             try
527             {
528                checkMBeanPermission(entry.getResourceClassName(), null,
529                   objectName, "queryNames");
530             }
531             catch(SecurityException e)
532             {
533                if( log.isTraceEnabled() )
534                   log.trace("Excluded mbean due to security: "+objectName);
535                continue;
536             }
537          }
538          // Check the mbean against the query
539 if (queryMBean(objectName, query) == true)
540             result.add(objectName);
541       }
542
543       return result;
544    }
545
546    public boolean isRegistered(ObjectName name)
547    {
548       return registry.contains(name);
549    }
550
551    public java.lang.Integer getMBeanCount()
552    {
553       return new Integer (registry.getSize());
554    }
555
556    public Object getAttribute(ObjectName name, String attribute)
557            throws MBeanException , AttributeNotFoundException , InstanceNotFoundException , ReflectionException
558    {
559       MBeanEntry entry = registry.get(name);
560       checkMBeanPermission(entry.getResourceClassName(), attribute, name,
561          "getAttribute");
562
563       MBeanInvoker mbean = entry.getInvoker();
564
565       return mbean.getAttribute(attribute);
566    }
567
568    public AttributeList getAttributes(ObjectName name, String [] attributes)
569            throws InstanceNotFoundException , ReflectionException
570    {
571       MBeanEntry entry = registry.get(name);
572       String className = entry.getResourceClassName();
573       /* Access to an attribute is required and this check will fail only
574       if access to no attributes are allowed and will result in a security
575       exception rather than an empty list.
576       */
577       checkMBeanPermission(className, null, name, "getAttribute");
578       
579       MBeanInvoker mbean = entry.getInvoker();
580       AttributeList list = mbean.getAttributes(attributes);
581       SecurityManager sm = System.getSecurityManager();
582       if( sm != null )
583       {
584          // Remove any attributes that are not allowed
585 Iterator iter = list.iterator();
586          while( iter.hasNext() )
587          {
588             Attribute attr = (Attribute ) iter.next();
589             String aname = attr.getName();
590             try
591             {
592                checkMBeanPermission(className, aname, name, "getAttribute");
593             }
594             catch(SecurityException e)
595             {
596                if( log.isTraceEnabled() )
597                   log.trace("Excluded attribute due to security: "+aname);
598                iter.remove();
599             }
600          }
601       }
602       return list;
603    }
604
605    public void setAttribute(ObjectName name, Attribute attribute)
606            throws InstanceNotFoundException , AttributeNotFoundException , InvalidAttributeValueException , MBeanException , ReflectionException
607    {
608       MBeanEntry entry = registry.get(name);
609       String attributeName = null;
610       if (attribute != null)
611          attributeName = attribute.getName();
612       checkMBeanPermission(entry.getResourceClassName(), attributeName,
613          name, "setAttribute");
614
615       MBeanInvoker mbean = entry.getInvoker();
616
617       mbean.setAttribute(attribute);
618    }
619
620    public AttributeList setAttributes(ObjectName name, AttributeList attributes)
621            throws InstanceNotFoundException , ReflectionException
622    {
623       MBeanEntry entry = registry.get(name);
624
625       String className = entry.getResourceClassName();
626       /* Access to an attribute is required and this check will fail only
627       if access to no attributes are allowed and will result in a security
628       exception rather than an empty list.
629       */
630       checkMBeanPermission(className, null, name, "setAttribute");
631
632       MBeanInvoker mbean = entry.getInvoker();
633       AttributeList list = mbean.setAttributes(attributes);
634       SecurityManager sm = System.getSecurityManager();
635       if( sm != null )
636       {
637          // Remove any attributes that are not allowed
638 Iterator iter = list.iterator();
639          while( iter.hasNext() )
640          {
641             Attribute attr = (Attribute ) iter.next();
642             String aname = attr.getName();
643             try
644             {
645                checkMBeanPermission(className, aname, name, "setAttribute");
646             }
647