Java > Open Source Codes > org > apache > catalina > mbeans > MBeanUtils


1 /*
2  * Licensed to the Apache Software Foundation (ASF) under one or more
3  * contributor license agreements. See the NOTICE file distributed with
4  * this work for additional information regarding copyright ownership.
5  * The ASF licenses this file to You under the Apache License, Version 2.0
6  * (the "License"); you may not use this file except in compliance with
7  * the License. You may obtain a copy of the License at
8  *
9  * http://www.apache.org/licenses/LICENSE-2.0
10  *
11  * Unless required by applicable law or agreed to in writing, software
12  * distributed under the License is distributed on an "AS IS" BASIS,
13  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14  * See the License for the specific language governing permissions and
15  * limitations under the License.
16  */
17
18 package org.apache.catalina.mbeans;
19
20
21 import java.util.Hashtable ;
22
23 import javax.management.DynamicMBean ;
24 import javax.management.MBeanException ;
25 import javax.management.MBeanServer ;
26 import javax.management.MalformedObjectNameException ;
27 import javax.management.ObjectName ;
28 import javax.management.modelmbean.ModelMBean ;
29
30 import org.apache.catalina.Contained;
31 import org.apache.catalina.Container;
32 import org.apache.catalina.Context;
33 import org.apache.catalina.Engine;
34 import org.apache.catalina.Group;
35 import org.apache.catalina.Host;
36 import org.apache.catalina.Loader;
37 import org.apache.catalina.Manager;
38 import org.apache.catalina.Realm;
39 import org.apache.catalina.Role;
40 import org.apache.catalina.Server;
41 import org.apache.catalina.Service;
42 import org.apache.catalina.User;
43 import org.apache.catalina.UserDatabase;
44 import org.apache.catalina.Valve;
45 import org.apache.catalina.connector.Connector;
46 import org.apache.catalina.deploy.ContextEnvironment;
47 import org.apache.catalina.deploy.ContextResource;
48 import org.apache.catalina.deploy.ContextResourceLink;
49 import org.apache.catalina.deploy.NamingResources;
50 import org.apache.catalina.valves.ValveBase;
51 import org.apache.commons.logging.Log;
52 import org.apache.commons.logging.LogFactory;
53 import org.apache.tomcat.util.IntrospectionUtils;
54 import org.apache.tomcat.util.modeler.ManagedBean;
55 import org.apache.tomcat.util.modeler.Registry;
56
57
58 /**
59  * Public utility methods in support of the server side MBeans implementation.
60  *
61  * @author Craig R. McClanahan
62  * @author Amy Roh
63  * @version $Revision: 467222 $ $Date: 2006-10-24 05:17:11 +0200 (mar., 24 oct. 2006) $
64  */
65
66 public class MBeanUtils {
67     private static Log log = LogFactory.getLog(MBeanUtils.class);
68
69     // ------------------------------------------------------- Static Variables
70
71
72     /**
73      * The set of exceptions to the normal rules used by
74      * <code>createManagedBean()</code>. The first element of each pair
75      * is a class name, and the second element is the managed bean name.
76      */
77     private static String exceptions[][] = {
78         { "org.apache.ajp.tomcat4.Ajp13Connector",
79           "Ajp13Connector" },
80         { "org.apache.coyote.tomcat4.Ajp13Connector",
81           "CoyoteConnector" },
82         { "org.apache.catalina.users.JDBCGroup",
83           "Group" },
84         { "org.apache.catalina.users.JDBCRole",
85           "Role" },
86         { "org.apache.catalina.users.JDBCUser",
87           "User" },
88         { "org.apache.catalina.users.MemoryGroup",
89           "Group" },
90         { "org.apache.catalina.users.MemoryRole",
91           "Role" },
92         { "org.apache.catalina.users.MemoryUser",
93           "User" },
94     };
95
96
97     /**
98      * The configuration information registry for our managed beans.
99      */
100     private static Registry registry = createRegistry();
101
102
103     /**
104      * The <code>MBeanServer</code> for this application.
105      */
106     private static MBeanServer mserver = createServer();
107
108
109     // --------------------------------------------------------- Static Methods
110
111     /**
112      * Create and return the name of the <code>ManagedBean</code> that
113      * corresponds to this Catalina component.
114      *
115      * @param component The component for which to create a name
116      */
117     static String createManagedName(Object component) {
118
119         // Deal with exceptions to the standard rule
120 String className = component.getClass().getName();
121         for (int i = 0; i < exceptions.length; i++) {
122             if (className.equals(exceptions[i][0])) {
123                 return (exceptions[i][1]);
124             }
125         }
126
127         // Perform the standard transformation
128 int period = className.lastIndexOf('.');
129         if (period >= 0)
130             className = className.substring(period + 1);
131         return (className);
132
133     }
134
135
136     /**
137      * Create, register, and return an MBean for this
138      * <code>Connector</code> object.
139      *
140      * @param connector The Connector to be managed
141      *
142      * @exception Exception if an MBean cannot be created or registered
143      */
144     static DynamicMBean createMBean(Connector connector)
145         throws Exception {
146
147         String mname = createManagedName(connector);
148         ManagedBean managed = registry.findManagedBean(mname);
149         if (managed == null) {
150             Exception e = new Exception ("ManagedBean is not found with "+mname);
151             throw new MBeanException (e);
152         }
153         String domain = managed.getDomain();
154         if (domain == null)
155             domain = mserver.getDefaultDomain();
156         DynamicMBean mbean = managed.createMBean(connector);
157         ObjectName oname = createObjectName(domain, connector);
158         if( mserver.isRegistered( oname )) {
159             mserver.unregisterMBean(oname);
160         }
161         mserver.registerMBean(mbean, oname);
162         return (mbean);
163
164     }
165
166
167     /**
168      * Create, register, and return an MBean for this
169      * <code>Context</code> object.
170      *
171      * @param context The Context to be managed
172      *
173      * @exception Exception if an MBean cannot be created or registered
174      */
175     static DynamicMBean createMBean(Context context)
176         throws Exception {
177
178         String mname = createManagedName(context);
179         ManagedBean managed = registry.findManagedBean(mname);
180         if (managed == null) {
181             Exception e = new Exception ("ManagedBean is not found with "+mname);
182             throw new MBeanException (e);
183         }
184         String domain = managed.getDomain();
185         if (domain == null)
186             domain = mserver.getDefaultDomain();
187         DynamicMBean mbean = managed.createMBean(context);
188         ObjectName oname = createObjectName(domain, context);
189         if( mserver.isRegistered(oname)) {
190             log.debug("Already registered " + oname);
191             mserver.unregisterMBean(oname);
192         }
193         mserver.registerMBean(mbean, oname);
194         return (mbean);
195
196     }
197
198     
199     /**
200      * Create, register, and return an MBean for this
201      * <code>ContextEnvironment</code> object.
202      *
203      * @param environment The ContextEnvironment to be managed
204      *
205      * @exception Exception if an MBean cannot be created or registered
206      */
207     static DynamicMBean createMBean(ContextEnvironment environment)
208         throws Exception {
209
210         String mname = createManagedName(environment);
211         ManagedBean managed = registry.findManagedBean(mname);
212         if (managed == null) {
213             Exception e = new Exception ("ManagedBean is not found with "+mname);
214             throw new MBeanException (e);
215         }
216         String domain = managed.getDomain();
217         if (domain == null)
218             domain = mserver.getDefaultDomain();
219         DynamicMBean mbean = managed.createMBean(environment);
220         ObjectName oname = createObjectName(domain, environment);
221         if( mserver.isRegistered( oname )) {
222             mserver.unregisterMBean(oname);
223         }
224         mserver.registerMBean(mbean, oname);
225         return (mbean);
226
227     }
228
229
230     /**
231      * Create, register, and return an MBean for this
232      * <code>ContextResource</code> object.
233      *
234      * @param resource The ContextResource to be managed
235      *
236      * @exception Exception if an MBean cannot be created or registered
237      */
238     static DynamicMBean createMBean(ContextResource resource)
239         throws Exception {
240
241         String mname = createManagedName(resource);
242         ManagedBean managed = registry.findManagedBean(mname);
243         if (managed == null) {
244             Exception e = new Exception ("ManagedBean is not found with "+mname);
245             throw new MBeanException (e);
246         }
247         String domain = managed.getDomain();
248         if (domain == null)
249             domain = mserver.getDefaultDomain();
250         DynamicMBean mbean = managed.createMBean(resource);
251         ObjectName oname = createObjectName(domain, resource);
252         if( mserver.isRegistered( oname )) {
253             mserver.unregisterMBean(oname);
254         }
255         mserver.registerMBean(mbean, oname);
256         return (mbean);
257
258     }
259
260
261     /**
262      * Create, register, and return an MBean for this
263      * <code>ContextResourceLink</code> object.
264      *
265      * @param resourceLink The ContextResourceLink to be managed
266      *
267      * @exception Exception if an MBean cannot be created or registered
268      */
269     static DynamicMBean createMBean(ContextResourceLink resourceLink)
270         throws Exception {
271
272         String mname = createManagedName(resourceLink);
273         ManagedBean managed = registry.findManagedBean(mname);
274         if (managed == null) {
275             Exception e = new Exception ("ManagedBean is not found with "+mname);
276             throw new MBeanException (e);
277         }
278         String domain = managed.getDomain();
279         if (domain == null)
280             domain = mserver.getDefaultDomain();
281         DynamicMBean mbean = managed.createMBean(resourceLink);
282         ObjectName oname = createObjectName(domain, resourceLink);
283         if( mserver.isRegistered( oname )) {
284             mserver.unregisterMBean(oname);
285         }
286         mserver.registerMBean(mbean, oname);
287         return (mbean);
288
289     }
290  
291     /**
292      * Create, register, and return an MBean for this
293      * <code>Engine</code> object.
294      *
295      * @param engine The Engine to be managed
296      *
297      * @exception Exception if an MBean cannot be created or registered
298      */
299     static DynamicMBean createMBean(Engine engine)
300         throws Exception {
301
302         String mname = createManagedName(engine);
303         ManagedBean managed = registry.findManagedBean(mname);
304         if (managed == null) {
305             Exception e = new Exception ("ManagedBean is not found with "+mname);
306             throw new MBeanException (e);
307         }
308         String domain = managed.getDomain();
309         if (domain == null)
310             domain = mserver.getDefaultDomain();
311         DynamicMBean mbean = managed.createMBean(engine);
312         ObjectName oname = createObjectName(domain, engine);
313         if( mserver.isRegistered( oname )) {
314             mserver.unregisterMBean(oname);
315         }
316         mserver.registerMBean(mbean, oname);
317         return (mbean);
318
319     }
320
321
322     /**
323      * Create, register, and return an MBean for this
324      * <code>Group</code> object.
325      *
326      * @param group The Group to be managed
327      *
328      * @exception Exception if an MBean cannot be created or registered
329      */
330     static DynamicMBean createMBean(Group group)
331         throws Exception {
332
333         String mname = createManagedName(group);
334         ManagedBean managed = registry.findManagedBean(mname);
335         if (managed == null) {
336             Exception e = new Exception ("ManagedBean is not found with "+mname);
337             throw new MBeanException (e);
338         }
339         String domain = managed.getDomain();
340         if (domain == null)
341             domain = mserver.getDefaultDomain();
342         DynamicMBean mbean = managed.createMBean(group);
343         ObjectName oname = createObjectName(domain, group);
344         if( mserver.isRegistered( oname )) {
345             mserver.unregisterMBean(oname);
346         }
347         mserver.registerMBean(mbean, oname);
348         return (mbean);
349
350     }
351
352
353     /**
354      * Create, register, and return an MBean for this
355      * <code>Host</code> object.
356      *
357      * @param host The Host to be managed
358      *
359      * @exception Exception if an MBean cannot be created or registered
360      */
361     static DynamicMBean createMBean(Host host)
362         throws Exception {
363
364         String mname = createManagedName(host);
365         ManagedBean managed = registry.findManagedBean(mname);
366         if (managed == null) {
367             Exception e = new Exception ("ManagedBean is not found with "+mname);
368             throw new MBeanException (e);
369         }
370         String domain = managed.getDomain();
371         if (domain == null)
372             domain = mserver.getDefaultDomain();
373         DynamicMBean mbean = managed.createMBean(host);
374         ObjectName oname = createObjectName(domain, host);
375         if( mserver.isRegistered( oname )) {
376             mserver.unregisterMBean(oname);
377         }
378         mserver.registerMBean(mbean, oname);
379         return (mbean);
380
381     }
382
383
384     /**
385      * Create, register, and return an MBean for this
386      * <code>Loader</code> object.
387      *
388      * @param loader The Loader to be managed
389      *
390      * @exception Exception if an MBean cannot be created or registered
391      */
392     static DynamicMBean createMBean(Loader loader)
393         throws Exception {
394
395         String mname = createManagedName(loader);
396         ManagedBean managed = registry.findManagedBean(mname);
397         if (managed == null) {
398             Exception e = new Exception ("ManagedBean is not found with "+mname);
399             throw new MBeanException (e);
400         }
401         String domain = managed.getDomain();
402         if (domain == null)
403             domain = mserver.getDefaultDomain();
404         DynamicMBean mbean = managed.createMBean(loader);
405         ObjectName oname = createObjectName(domain, loader);
406         if( mserver.isRegistered( oname )) {
407             // side effect: stop it
408 mserver.unregisterMBean( oname );
409         }
410         mserver.registerMBean(mbean, oname);
411         return (mbean);
412
413     }
414
415     /**
416      * Create, register, and return an MBean for this
417      * <code>Manager</code> object.
418      *
419      * @param manager The Manager to be managed
420      *
421      * @exception Exception if an MBean cannot be created or registered
422      */
423     static DynamicMBean createMBean(Manager manager)
424         throws Exception {
425
426         String mname = createManagedName(manager);
427         ManagedBean managed = registry.findManagedBean(mname);
428         if (managed == null) {
429             Exception e = new Exception ("ManagedBean is not found with "+mname);
430             throw new MBeanException (e);
431         }
432         String domain = managed.getDomain();
433         if (domain == null)
434             domain = mserver.getDefaultDomain();
435         DynamicMBean mbean = managed.createMBean(manager);
436         ObjectName oname = createObjectName(domain, manager);
437         if( mserver.isRegistered( oname )) {
438             mserver.unregisterMBean(oname);
439         }
440         mserver.registerMBean(mbean, oname);
441         return (mbean);
442
443     }
444
445
446     /**
447      * Create, register, and return an MBean for this
448      * <code>MBeanFactory</code> object.
449      *
450      * @param factory The MBeanFactory to be managed
451      *
452      * @exception Exception if an MBean cannot be created or registered
453      */
454     static DynamicMBean createMBean(MBeanFactory factory)
455         throws Exception {
456
457         String mname = createManagedName(factory);
458         ManagedBean managed = registry.findManagedBean(mname);
459         if (managed == null) {
460             Exception e = new Exception ("ManagedBean is not found with "+mname);
461             throw new MBeanException (e);
462         }
463         String domain = managed.getDomain();
464         if (domain == null)
465             domain = mserver.getDefaultDomain();
466         DynamicMBean mbean = managed.createMBean(factory);
467         ObjectName oname = createObjectName(domain, factory);
468         if( mserver.isRegistered(oname )) {
469             mserver.unregisterMBean(oname);
470         }
471         mserver.registerMBean(mbean, oname);
472         return (mbean);
473
474     }
475
476
477     /**
478      * Create, register, and return an MBean for this
479      * <code>NamingResources</code> object.
480      *
481      * @param resource The NamingResources to be managed
482      *
483      * @exception Exception if an MBean cannot be created or registered
484      */
485     static DynamicMBean createMBean(NamingResources resource)
486         throws Exception {
487
488         String mname = createManagedName(resource);
489         ManagedBean managed = registry.findManagedBean(mname);
490         if (managed == null) {
491             Exception e = new Exception ("ManagedBean is not found with "+mname);
492             throw new MBeanException (e);
493         }
494         String domain = managed.getDomain();
495         if (domain == null)
496             domain = mserver.getDefaultDomain();
497         DynamicMBean mbean = managed.createMBean(resource);
498         ObjectName oname = createObjectName(domain, resource);
499         if( mserver.isRegistered( oname )) {
500             mserver.unregisterMBean(oname);
501         }
502         mserver.registerMBean(mbean, oname);
503         return (mbean);
504
505     }
506
507     
508     /**
509      * Create, register, and return an MBean for this
510      * <code>Realm</code> object.
511      *
512      * @param realm The Realm to be managed
513      *
514      * @exception Exception if an MBean cannot be created or registered
515      */
516     static DynamicMBean createMBean(Realm realm)
517         throws Exception {
518
519         String mname = createManagedName(realm);
520         ManagedBean managed = registry.findManagedBean(mname);
521         if (managed == null) {
522             Exception e = new Exception ("ManagedBean is not found with "+mname);
523             throw new MBeanException (e);
524         }
525         String domain = managed.getDomain();
526         if (domain == null)
527             domain = mserver.getDefaultDomain();
528         DynamicMBean mbean = managed.createMBean(realm);
529         ObjectName oname = createObjectName(domain, realm);
530         if( mserver.isRegistered( oname )) {
531             mserver.unregisterMBean(oname);
532         }
533         mserver.registerMBean(mbean, oname);
534         return (mbean);
535
536     }
537
538
539     /**
540      * Create, register, and return an MBean for this
541      * <code>Role</code> object.
542      *
543      * @param role The Role to be managed
544      *
545      * @exception Exception if an MBean cannot be created or registered
546      */
547     static DynamicMBean createMBean(Role role)
548         throws Exception {
549
550         String mname = createManagedName(role);
551         ManagedBean managed = registry.findManagedBean(mname);
552         if (managed == null) {
553             Exception e = new Exception ("ManagedBean is not found with "+mname);
554             throw new MBeanException (e);
555         }
556         String domain = managed.getDomain();
557         if (domain == null)
558             domain = mserver.getDefaultDomain();
559         DynamicMBean mbean = managed.createMBean(role);
560         ObjectName oname = createObjectName(domain, role);
561         if( mserver.isRegistered( oname )) {
562             mserver.unregisterMBean(oname);
563         }
564         mserver.registerMBean(mbean, oname);
565         return (mbean);
566
567     }
568
569
570     /**
571      * Create, register, and return an MBean for this
572      * <code>Server</code> object.
573      *
574      * @param server The Server to be managed
575      *
576      * @exception Exception if an MBean cannot be created or registered
577      */
578     static DynamicMBean createMBean(Server server)
579         throws Exception {
580
581         String mname = createManagedName(server);
582         ManagedBean managed = registry.findManagedBean(mname);
583         if (managed == null) {
584             Exception e = new Exception ("ManagedBean is not found with "+mname);
585             throw new MBeanException (e);
586         }
587         String domain = managed.getDomain();
588         if (domain == null)
589             domain = mserver.getDefaultDomain();
590         DynamicMBean mbean = managed.createMBean(server);
591         ObjectName oname = createObjectName(domain, server);
592         if( mserver.isRegistered( oname )) {
593             mserver.unregisterMBean(oname);
594         }
595         mserver.registerMBean(mbean, oname);
596         return (mbean);
597
598     }
599
600
601     /**
602      * Create, register, and return an MBean for this
603      * <code>Service</code> object.
604      *
605      * @param service The Service to be managed
606      *
607      * @exception Exception if an MBean cannot be created or registered
608      */
609     static DynamicMBean createMBean(Service service)
610         throws Exception {
611
612         String mname = createManagedName(service);
613         ManagedBean managed = registry.findManagedBean(mname);
614         if (managed == null) {
615             Exception e = new Exception ("ManagedBean is not found with "+mname);
616             throw new MBeanException (e);
617         }
618         String domain = managed.getDomain();
619         if (domain == null)
620             domain = mserver.getDefaultDomain();
621         DynamicMBean mbean = managed.createMBean(service);
622         ObjectName oname = createObjectName(domain, service);
623         if( mserver.isRegistered( oname )) {
624             mserver.unregisterMBean(oname);
625         }
626         mserver.registerMBean(mbean, oname);
627         return (mbean);
628
629     }
630
631
632     /**
633      * Create, register, and return an MBean for this
634      * <code>User</code> object.
635      *
636      * @param user The User to be managed
637      *
638      * @exception Exception if an MBean cannot be created or registered
639      */
640     static DynamicMBean createMBean(User user)
641         throws Exception {
642
643         String mname = createManagedName(user);
644         ManagedBean managed = registry.findManagedBean(mname);
645         if (managed == null) {
646             Exception e = new Exception ("ManagedBean is not found with "+mname);
647             throw new MBeanException (e);
648         }
649         String domain = managed.getDomain();
650         if (domain == null)
651             domain = mserver.getDefaultDomain();
652         DynamicMBean mbean = managed.createMBean(user);
653         ObjectName oname = createObjectName(domain, user);
654         if( mserver.isRegistered( oname )) {
655             mserver.unregisterMBean(oname);
656         }
657         mserver.registerMBean(mbean, oname);
658         return (mbean);
659
660     }
661
662
663     /**
664      * Create, register, and return an MBean for this
665      * <code>UserDatabase</code> object.
666      *
667      * @param userDatabase The UserDatabase to be managed
668      *
669      * @exception Exception if an MBean cannot be created or registered
670      */
671     static DynamicMBean createMBean(UserDatabase userDatabase)
672         throws Exception {
673
674         String mname = createManagedName(userDatabase);
675         ManagedBean managed = registry.findManagedBean(mname);
676         if (managed == null) {
677             Exception e = new Exception ("ManagedBean is not found with "+mname);
678             throw new MBeanException (e);
679         }
680         String domain = managed.getDomain();
681         if (domain == null)
682             domain = mserver.getDefaultDomain();
683         DynamicMBean mbean = managed.createMBean(userDatabase);
684         ObjectName oname = createObjectName(domain, userDatabase);
685         if( mserver.isRegistered( oname )) {
686             mserver.unregisterMBean(oname);
687         }
688         mserver.registerMBean(mbean, oname);
689         return (mbean);
690
691     }
692
693
694     /**
695      * Create, register, and return an MBean for this
696      * <code>Valve</code> object.
697      *
698      * @param valve The Valve to be managed
699      *
700      * @exception Exception if an MBean cannot be created or registered
701      */
702     static DynamicMBean createMBean(Valve valve)
703         throws Exception {
704
705         String mname = createManagedName(valve);
706         ManagedBean managed = registry.findManagedBean(mname);
707         if (managed == null) {
708             Exception e = new Exception ("ManagedBean is not found with "+mname);
709             throw new MBeanException (e);
710         }
711         String domain = managed.getDomain();
712         if (domain == null)
713             domain = mserver.getDefaultDomain();
714         DynamicMBean mbean = managed.createMBean(valve);
715         ObjectName oname = createObjectName(domain, valve);
716         if( mserver.isRegistered( oname )) {
717             mserver.unregisterMBean(oname);
718         }
719         mserver.registerMBean(mbean, oname);
720         return (mbean);
721
722     }
723
724     /**
725      * Create an <code>ObjectName</code> for this
726      * <code>Connector</code> object.
727      *
728      * @param domain Domain in which this name is to be created
729      * @param connector The Connector to be named
730      *
731      * @exception MalformedObjectNameException if a name cannot be created
732      */
733     static ObjectName createObjectName(String domain,
734                                         Connector connector)
735         throws MalformedObjectNameException {
736
737         ObjectName name = null;
738         if (connector.getClass().getName().indexOf("CoyoteConnector") >= 0 ) {
739             try {
740                 String address = (String )
741                     IntrospectionUtils.getProperty(connector, "address");
742                 Integer port = (Integer )
743                     IntrospectionUtils.getProperty(connector, "port");
744                 Service service = connector.getService();
745                 String serviceName = null;
746                 if (service != null)
747                     serviceName = service.getName();
748                 StringBuffer sb = new StringBuffer (domain);
749                 sb.append(":type=Connector");
750                 sb.append(",port=" + port);
751                 if ((address != null) && (address.length()>0)) {
752