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
29 import org.apache.catalina.Contained;
30 import org.apache.catalina.Container;
31 import org.apache.catalina.Context;
32 import org.apache.catalina.Engine;
33 import org.apache.catalina.Group;
34 import org.apache.catalina.Host;
35 import org.apache.catalina.Loader;
36 import org.apache.catalina.Manager;
37 import org.apache.catalina.Realm;
38 import org.apache.catalina.Role;
39 import org.apache.catalina.Server;
40 import org.apache.catalina.Service;
41 import org.apache.catalina.User;
42 import org.apache.catalina.UserDatabase;
43 import org.apache.catalina.Valve;
44 import org.apache.catalina.connector.Connector;
45 import org.apache.catalina.deploy.ContextEnvironment;
46 import org.apache.catalina.deploy.ContextResource;
47 import org.apache.catalina.deploy.ContextResourceLink;
48 import org.apache.catalina.deploy.NamingResources;
49 import org.apache.catalina.valves.ValveBase;
50 import org.apache.juli.logging.Log;
51 import org.apache.juli.logging.LogFactory;
52 import org.apache.tomcat.util.IntrospectionUtils;
53 import org.apache.tomcat.util.modeler.ManagedBean;
54 import org.apache.tomcat.util.modeler.Registry;
55
56
57 /**
58 * Public utility methods in support of the server side MBeans implementation.
59 *
60 * @author Craig R. McClanahan
61 * @author Amy Roh
62 * @version $Revision: 500684 $ $Date: 2007-01-28 00:27:18 +0100 (dim., 28 janv. 2007) $
63 */
64
65 public class MBeanUtils {
66 private static Log log = LogFactory.getLog(MBeanUtils.class);
67
68 // ------------------------------------------------------- Static Variables
69
70
71 /**
72 * The set of exceptions to the normal rules used by
73 * <code>createManagedBean()</code>. The first element of each pair
74 * is a class name, and the second element is the managed bean name.
75 */
76 private static String exceptions[][] = {
77 { "org.apache.ajp.tomcat4.Ajp13Connector",
78 "Ajp13Connector" },
79 { "org.apache.coyote.tomcat4.Ajp13Connector",
80 "CoyoteConnector" },
81 { "org.apache.catalina.users.JDBCGroup",
82 "Group" },
83 { "org.apache.catalina.users.JDBCRole",
84 "Role" },
85 { "org.apache.catalina.users.JDBCUser",
86 "User" },
87 { "org.apache.catalina.users.MemoryGroup",
88 "Group" },
89 { "org.apache.catalina.users.MemoryRole",
90 "Role" },
91 { "org.apache.catalina.users.MemoryUser",
92 "User" },
93 };
94
95
96 /**
97 * The configuration information registry for our managed beans.
98 */
99 private static Registry registry = createRegistry();
100
101
102 /**
103 * The <code>MBeanServer</code> for this application.
104 */
105 private static MBeanServer mserver = createServer();
106
107
108 // --------------------------------------------------------- Static Methods
109
110 /**
111 * Create and return the name of the <code>ManagedBean</code> that
112 * corresponds to this Catalina component.
113 *
114 * @param component The component for which to create a name
115 */
116 static String createManagedName(Object component) {
117
118 // Deal with exceptions to the standard rule
119 String className = component.getClass().getName();
120 for (int i = 0; i < exceptions.length; i++) {
121 if (className.equals(exceptions[i][0])) {
122 return (exceptions[i][1]);
123 }
124 }
125
126 // Perform the standard transformation
127 int period = className.lastIndexOf('.');
128 if (period >= 0)
129 className = className.substring(period + 1);
130 return (className);
131
132 }
133
134
135 /**
136 * Create, register, and return an MBean for this
137 * <code>Connector</code> object.
138 *
139 * @param connector The Connector to be managed
140 *
141 * @exception Exception if an MBean cannot be created or registered
142 */
143 static DynamicMBean createMBean(Connector connector)
144 throws Exception {
145
146 String mname = createManagedName(connector);
147 ManagedBean managed = registry.findManagedBean(mname);
148 if (managed == null) {
149 Exception e = new Exception("ManagedBean is not found with "+mname);
150 throw new MBeanException(e);
151 }
152 String domain = managed.getDomain();
153 if (domain == null)
154 domain = mserver.getDefaultDomain();
155 DynamicMBean mbean = managed.createMBean(connector);
156 ObjectName oname = createObjectName(domain, connector);
157 if( mserver.isRegistered( oname )) {
158 mserver.unregisterMBean(oname);
159 }
160 mserver.registerMBean(mbean, oname);
161 return (mbean);
162
163 }
164
165
166 /**
167 * Create, register, and return an MBean for this
168 * <code>Context</code> object.
169 *
170 * @param context The Context to be managed
171 *
172 * @exception Exception if an MBean cannot be created or registered
173 */
174 static DynamicMBean createMBean(Context context)
175 throws Exception {
176
177 String mname = createManagedName(context);
178 ManagedBean managed = registry.findManagedBean(mname);
179 if (managed == null) {
180 Exception e = new Exception("ManagedBean is not found with "+mname);
181 throw new MBeanException(e);
182 }
183 String domain = managed.getDomain();
184 if (domain == null)
185 domain = mserver.getDefaultDomain();
186 DynamicMBean mbean = managed.createMBean(context);
187 ObjectName oname = createObjectName(domain, context);
188 if( mserver.isRegistered(oname)) {
189 log.debug("Already registered " + oname);
190 mserver.unregisterMBean(oname);
191 }
192 mserver.registerMBean(mbean, oname);
193 return (mbean);
194
195 }
196
197
198 /**
199 * Create, register, and return an MBean for this
200 * <code>ContextEnvironment</code> object.
201 *
202 * @param environment The ContextEnvironment to be managed
203 *
204 * @exception Exception if an MBean cannot be created or registered
205 */
206 static DynamicMBean createMBean(ContextEnvironment environment)
207 throws Exception {
208
209 String mname = createManagedName(environment);
210 ManagedBean managed = registry.findManagedBean(mname);
211 if (managed == null) {
212 Exception e = new Exception("ManagedBean is not found with "+mname);
213 throw new MBeanException(e);
214 }
215 String domain = managed.getDomain();
216 if (domain == null)
217 domain = mserver.getDefaultDomain();
218 DynamicMBean mbean = managed.createMBean(environment);
219 ObjectName oname = createObjectName(domain, environment);
220 if( mserver.isRegistered( oname )) {
221 mserver.unregisterMBean(oname);
222 }
223 mserver.registerMBean(mbean, oname);
224 return (mbean);
225
226 }
227
228
229 /**
230 * Create, register, and return an MBean for this
231 * <code>ContextResource</code> object.
232 *
233 * @param resource The ContextResource to be managed
234 *
235 * @exception Exception if an MBean cannot be created or registered
236 */
237 static DynamicMBean createMBean(ContextResource resource)
238 throws Exception {
239
240 String mname = createManagedName(resource);
241 ManagedBean managed = registry.findManagedBean(mname);
242 if (managed == null) {
243 Exception e = new Exception("ManagedBean is not found with "+mname);
244 throw new MBeanException(e);
245 }
246 String domain = managed.getDomain();
247 if (domain == null)
248 domain = mserver.getDefaultDomain();
249 DynamicMBean mbean = managed.createMBean(resource);
250 ObjectName oname = createObjectName(domain, resource);
251 if( mserver.isRegistered( oname )) {
252 mserver.unregisterMBean(oname);
253 }
254 mserver.registerMBean(mbean, oname);
255 return (mbean);
256
257 }
258
259
260 /**
261 * Create, register, and return an MBean for this
262 * <code>ContextResourceLink</code> object.
263 *
264 * @param resourceLink The ContextResourceLink to be managed
265 *
266 * @exception Exception if an MBean cannot be created or registered
267 */
268 static DynamicMBean createMBean(ContextResourceLink resourceLink)
269 throws Exception {
270
271 String mname = createManagedName(resourceLink);
272 ManagedBean managed = registry.findManagedBean(mname);
273 if (managed == null) {
274 Exception e = new Exception("ManagedBean is not found with "+mname);
275 throw new MBeanException(e);
276 }
277 String domain = managed.getDomain();
278 if (domain == null)
279 domain = mserver.getDefaultDomain();
280 DynamicMBean mbean = managed.createMBean(resourceLink);
281 ObjectName oname = createObjectName(domain, resourceLink);
282 if( mserver.isRegistered( oname )) {
283 mserver.unregisterMBean(oname);
284 }
285 mserver.registerMBean(mbean, oname);
286 return (mbean);
287
288 }
289
290 /**
291 * Create, register, and return an MBean for this
292 * <code>Engine</code> object.
293 *
294 * @param engine The Engine to be managed
295 *
296 * @exception Exception if an MBean cannot be created or registered
297 */
298 static DynamicMBean createMBean(Engine engine)
299 throws Exception {
300
301 String mname = createManagedName(engine);
302 ManagedBean managed = registry.findManagedBean(mname);
303 if (managed == null) {
304 Exception e = new Exception("ManagedBean is not found with "+mname);
305 throw new MBeanException(e);
306 }
307 String domain = managed.getDomain();
308 if (domain == null)
309 domain = mserver.getDefaultDomain();
310 DynamicMBean mbean = managed.createMBean(engine);
311 ObjectName oname = createObjectName(domain, engine);
312 if( mserver.isRegistered( oname )) {
313 mserver.unregisterMBean(oname);
314 }
315 mserver.registerMBean(mbean, oname);
316 return (mbean);
317
318 }
319
320
321 /**
322 * Create, register, and return an MBean for this
323 * <code>Group</code> object.
324 *
325 * @param group The Group to be managed
326 *
327 * @exception Exception if an MBean cannot be created or registered
328 */
329 static DynamicMBean createMBean(Group group)
330 throws Exception {
331
332 String mname = createManagedName(group);
333 ManagedBean managed = registry.findManagedBean(mname);
334 if (managed == null) {
335 Exception e = new Exception("ManagedBean is not found with "+mname);
336 throw new MBeanException(e);
337 }
338 String domain = managed.getDomain();
339 if (domain == null)
340 domain = mserver.getDefaultDomain();
341 DynamicMBean mbean = managed.createMBean(group);
342 ObjectName oname = createObjectName(domain, group);
343 if( mserver.isRegistered( oname )) {
344 mserver.unregisterMBean(oname);
345 }
346 mserver.registerMBean(mbean, oname);
347 return (mbean);
348
349 }
350
351
352 /**
353 * Create, register, and return an MBean for this
354 * <code>Host</code> object.
355 *
356 * @param host The Host to be managed
357 *
358 * @exception Exception if an MBean cannot be created or registered
359 */
360 static DynamicMBean createMBean(Host host)
361 throws Exception {
362
363 String mname = createManagedName(host);
364 ManagedBean managed = registry.findManagedBean(mname);
365 if (managed == null) {
366 Exception e = new Exception("ManagedBean is not found with "+mname);
367 throw new MBeanException(e);
368 }
369 String domain = managed.getDomain();
370 if (domain == null)
371 domain = mserver.getDefaultDomain();
372 DynamicMBean mbean = managed.createMBean(host);
373 ObjectName oname = createObjectName(domain, host);
374 if( mserver.isRegistered( oname )) {
375 mserver.unregisterMBean(oname);
376 }
377 mserver.registerMBean(mbean, oname);
378 return (mbean);
379
380 }
381
382
383 /**
384 * Create, register, and return an MBean for this
385 * <code>Loader</code> object.
386 *
387 * @param loader The Loader to be managed
388 *
389 * @exception Exception if an MBean cannot be created or registered
390 */
391 static DynamicMBean createMBean(Loader loader)
392 throws Exception {
393
394 String mname = createManagedName(loader);
395 ManagedBean managed = registry.findManagedBean(mname);
396 if (managed == null) {
397 Exception e = new Exception("ManagedBean is not found with "+mname);
398 throw new MBeanException(e);
399 }
400 String domain = managed.getDomain();
401 if (domain == null)
402 domain = mserver.getDefaultDomain();
403 DynamicMBean mbean = managed.createMBean(loader);
404 ObjectName oname = createObjectName(domain, loader);
405 if( mserver.isRegistered( oname )) {
406 // side effect: stop it
407 mserver.unregisterMBean( oname );
408 }
409 mserver.registerMBean(mbean, oname);
410 return (mbean);
411
412 }
413
414 /**
415 * Create, register, and return an MBean for this
416 * <code>Manager</code> object.
417 *
418 * @param manager The Manager to be managed
419 *
420 * @exception Exception if an MBean cannot be created or registered
421 */
422 static DynamicMBean createMBean(Manager manager)
423 throws Exception {
424
425 String mname = createManagedName(manager);
426 ManagedBean managed = registry.findManagedBean(mname);
427 if (managed == null) {
428 Exception e = new Exception("ManagedBean is not found with "+mname);
429 throw new MBeanException(e);
430 }
431 String domain = managed.getDomain();
432 if (domain == null)
433 domain = mserver.getDefaultDomain();
434 DynamicMBean mbean = managed.createMBean(manager);
435 ObjectName oname = createObjectName(domain, manager);
436 if( mserver.isRegistered( oname )) {
437 mserver.unregisterMBean(oname);
438 }
439 mserver.registerMBean(mbean, oname);
440 return (mbean);
441
442 }
443
444
445 /**
446 * Create, register, and return an MBean for this
447 * <code>MBeanFactory</code> object.
448 *
449 * @param factory The MBeanFactory to be managed
450 *
451 * @exception Exception if an MBean cannot be created or registered
452 */
453 static DynamicMBean createMBean(MBeanFactory factory)
454 throws Exception {
455
456 String mname = createManagedName(factory);
457 ManagedBean managed = registry.findManagedBean(mname);
458 if (managed == null) {
459 Exception e = new Exception("ManagedBean is not found with "+mname);
460 throw new MBeanException(e);
461 }
462 String domain = managed.getDomain();
463 if (domain == null)
464 domain = mserver.getDefaultDomain();
465 DynamicMBean mbean = managed.createMBean(factory);
466 ObjectName oname = createObjectName(domain, factory);
467 if( mserver.isRegistered(oname )) {
468 mserver.unregisterMBean(oname);
469 }
470 mserver.registerMBean(mbean, oname);
471 return (mbean);
472
473 }
474
475
476 /**
477 * Create, register, and return an MBean for this
478 * <code>NamingResources</code> object.
479 *
480 * @param resource The NamingResources to be managed
481 *
482 * @exception Exception if an MBean cannot be created or registered
483 */
484 static DynamicMBean createMBean(NamingResources resource)
485 throws Exception {
486
487 String mname = createManagedName(resource);
488 ManagedBean managed = registry.findManagedBean(mname);
489 if (managed == null) {
490 Exception e = new Exception("ManagedBean is not found with "+mname);
491 throw new MBeanException(e);
492 }
493 String domain = managed.getDomain();
494 if (domain == null)
495 domain = mserver.getDefaultDomain();
496 DynamicMBean mbean = managed.createMBean(resource);
497 ObjectName oname = createObjectName(domain, resource);
498 if( mserver.isRegistered( oname )) {
499 mserver.unregisterMBean(oname);
500 }
501 mserver.registerMBean(mbean, oname);
502 return (mbean);
503
504 }
505
506
507 /**
508 * Create, register, and return an MBean for this
509 * <code>Realm</code> object.
510 *
511 * @param realm The Realm to be managed
512 *
513 * @exception Exception if an MBean cannot be created or registered
514 */
515 static DynamicMBean createMBean(Realm realm)
516 throws Exception {
517
518 String mname = createManagedName(realm);
519 ManagedBean managed = registry.findManagedBean(mname);
520 if (managed == null) {
521 Exception e = new Exception("ManagedBean is not found with "+mname);
522 throw new MBeanException(e);
523 }
524 String domain = managed.getDomain();
525 if (domain == null)
526 domain = mserver.getDefaultDomain();
527 DynamicMBean mbean = managed.createMBean(realm);
528 ObjectName oname = createObjectName(domain, realm);
529 if( mserver.isRegistered( oname )) {
530 mserver.unregisterMBean(oname);
531 }
532 mserver.registerMBean(mbean, oname);
533 return (mbean);
534
535 }
536
537
538 /**
539 * Create, register, and return an MBean for this
540 * <code>Role</code> object.
541 *
542 * @param role The Role to be managed
543 *
544 * @exception Exception if an MBean cannot be created or registered
545 */
546 static DynamicMBean createMBean(Role role)
547 throws Exception {
548
549 String mname = createManagedName(role);
550 ManagedBean managed = registry.findManagedBean(mname);
551 if (managed == null) {
552 Exception e = new Exception("ManagedBean is not found with "+mname);
553 throw new MBeanException(e);
554 }
555 String domain = managed.getDomain();
556 if (domain == null)
557 domain = mserver.getDefaultDomain();
558 DynamicMBean mbean = managed.createMBean(role);
559 ObjectName oname = createObjectName(domain, role);
560 if( mserver.isRegistered( oname )) {
561 mserver.unregisterMBean(oname);
562 }
563 mserver.registerMBean(mbean, oname);
564 return (mbean);
565
566 }
567
568
569 /**
570 * Create, register, and return an MBean for this
571 * <code>Server</code> object.
572 *
573 * @param server The Server to be managed
574 *
575 * @exception Exception if an MBean cannot be created or registered
576 */
577 static DynamicMBean createMBean(Server server)
578 throws Exception {
579
580 String mname = createManagedName(server);
581 ManagedBean managed = registry.findManagedBean(mname);
582 if (managed == null) {
583 Exception e = new Exception("ManagedBean is not found with "+mname);
584 throw new MBeanException(e);
585 }
586 String domain = managed.getDomain();
587 if (domain == null)
588 domain = mserver.getDefaultDomain();
589 DynamicMBean mbean = managed.createMBean(server);
590 ObjectName oname = createObjectName(domain, server);
591 if( mserver.isRegistered( oname )) {
592 mserver.unregisterMBean(oname);
593 }
594 mserver.registerMBean(mbean, oname);
595 return (mbean);
596
597 }
598
599
600 /**
601 * Create, register, and return an MBean for this
602 * <code>Service</code> object.
603 *
604 * @param service The Service to be managed
605 *
606 * @exception Exception if an MBean cannot be created or registered
607 */
608 static DynamicMBean createMBean(Service service)
609 throws Exception {
610
611 String mname = createManagedName(service);
612 ManagedBean managed = registry.findManagedBean(mname);
613 if (managed == null) {
614 Exception e = new Exception("ManagedBean is not found with "+mname);
615 throw new MBeanException(e);
616 }
617 String domain = managed.getDomain();
618 if (domain == null)
619 domain = mserver.getDefaultDomain();
620 DynamicMBean mbean = managed.createMBean(service);
621 ObjectName oname = createObjectName(domain, service);
622 if( mserver.isRegistered( oname )) {
623 mserver.unregisterMBean(oname);
624 }
625 mserver.registerMBean(mbean, oname);
626 return (mbean);
627
628 }
629
630
631 /**
632 * Create, register, and return an MBean for this
633 * <code>User</code> object.
634 *
635 * @param user The User to be managed
636 *
637 * @exception Exception if an MBean cannot be created or registered
638 */
639 static DynamicMBean createMBean(User user)
640 throws Exception {
641
642 String mname = createManagedName(user);
643 ManagedBean managed = registry.findManagedBean(mname);
644 if (managed == null) {
645 Exception e = new Exception("ManagedBean is not found with "+mname);
646 throw new MBeanException(e);
647 }
648 String domain = managed.getDomain();
649 if (domain == null)
650 domain = mserver.getDefaultDomain();
651 DynamicMBean mbean = managed.createMBean(user);
652 ObjectName oname = createObjectName(domain, user);
653 if( mserver.isRegistered( oname )) {
654 mserver.unregisterMBean(oname);
655 }
656 mserver.registerMBean(mbean, oname);
657 return (mbean);
658
659 }
660
661
662 /**
663 * Create, register, and return an MBean for this
664 * <code>UserDatabase</code> object.
665 *
666 * @param userDatabase The UserDatabase to be managed
667 *
668 * @exception Exception if an MBean cannot be created or registered
669 */
670 static DynamicMBean createMBean(UserDatabase userDatabase)
671 throws Exception {
672
673 String mname = createManagedName(userDatabase);
674 ManagedBean managed = registry.findManagedBean(mname);
675 if (managed == null) {
676 Exception e = new Exception("ManagedBean is not found with "+mname);
677 throw new MBeanException(e);
678 }
679 String domain = managed.getDomain();
680 if (domain == null)
681 domain = mserver.getDefaultDomain();
682 DynamicMBean mbean = managed.createMBean(userDatabase);
683 ObjectName oname = createObjectName(domain, userDatabase);
684 if( mserver.isRegistered( oname )) {
685 mserver.unregisterMBean(oname);
686 }
687 mserver.registerMBean(mbean, oname);
688 return (mbean);
689
690 }
691
692
693 /**
694 * Create, register, and return an MBean for this
695 * <code>Valve</code> object.
696 *
697 * @param valve The Valve to be managed
698 *
699 * @exception Exception if an MBean cannot be created or registered
700 */
701 static DynamicMBean createMBean(Valve valve)
702 throws Exception {
703
704 String mname = createManagedName(valve);
705 ManagedBean managed = registry.findManagedBean(mname);
706 if (managed == null) {
707 Exception e = new Exception("ManagedBean is not found with "+mname);
708 throw new MBeanException(e);
709 }
710 String domain = managed.getDomain();
711 if (domain == null)
712 domain = mserver.getDefaultDomain();
713 DynamicMBean mbean = managed.createMBean(valve);
714 ObjectName oname = createObjectName(domain, valve);
715 if( mserver.isRegistered( oname )) {
716 mserver.unregisterMBean(oname);
717 }
718 mserver.registerMBean(mbean, oname);
719 return (mbean);
720
721 }
722
723 /**
724 * Create an <code>ObjectName</code> for this
725 * <code>Connector</code> object.
726 *
727 * @param domain Domain in which this name is to be created
728 * @param connector The Connector to be named
729 *
730 * @exception MalformedObjectNameException if a name cannot be created
731 */
732 static ObjectName createObjectName(String domain,
733 Connector connector)
734 throws MalformedObjectNameException {
735
736 ObjectName name = null;
737 if (connector.getClass().getName().indexOf("CoyoteConnector") >= 0 ) {
738 try {
739 String address = (String)
740 IntrospectionUtils.getProperty(connector, "address");
741 Integer port = (Integer)
742 IntrospectionUtils.getProperty(connector, "port");
743 Service service = connector.getService();
744 String serviceName = null;
745 if (service != null)
746 serviceName = service.getName();
747 StringBuffer sb = new StringBuffer(domain);
748 sb.append(":type=Connector");
749 sb.append(",port=" + port);
750 if ((address != null) && (address.length()>0)) {
751 sb.append(",address=" + address);
752 }
753 name = new ObjectName(sb.toString());
754 return (name);
755 } catch (Exception e) {
756 throw new MalformedObjectNameException
757 ("Cannot create object name for " + connector+e);
758 }
759 } else {
760 throw new MalformedObjectNameException
761 ("Cannot create object name for " + connector);
762 }
763
764 }
765
766
767 /**
768 * Create an <code>ObjectName</code> for this
769 * <code>Context</code> object.
770 *
771 * @param domain Domain in which this name is to be created
772 * @param context The Context to be named
773 *
774 * @exception MalformedObjectNameException if a name cannot be created
775 */
776 static ObjectName createObjectName(String domain,
777 Context context)
778 throws MalformedObjectNameException {
779
780 ObjectName name = null;
781 Host host = (Host)context.getParent();
782 Service service = ((Engine)host.getParent()).getService();
783 String path = context.getPath();
784 if (path.length() < 1)
785 path = "/";
786 // FIXME
787 name = new ObjectName(domain + ":j2eeType=WebModule,name=//" +
788 host.getName()+ path +
789 ",J2EEApplication=none,J2EEServer=none");
790
791 return (name);
792
793 }
794
795
796 /**
797 * Create an <code>ObjectName</code> for this
798 * <code>Service</code> object.
799 *
800 * @param domain Domain in which this name is to be created
801 * @param environment The ContextEnvironment to be named
802 *
803 * @exception MalformedObjectNameException if a name cannot be created
804 */
805 public static ObjectName createObjectName(String domain,
806 ContextEnvironment environment)
807 throws MalformedObjectNameException {
808
809 ObjectName name = null;
810 Object container =
811 environment.getNamingResources().getContainer();
812 if (container instanceof Server) {
813 name = new ObjectName(domain + ":type=Environment" +
814 ",resourcetype=Global,name=" + environment.getName());
815 } else if (container instanceof Context) {
816 String path = ((Context)container).getPath();
817 if (path.length() < 1)
818 path = "/";
819 Host host = (Host) ((Context)container).getParent();
820 Engine engine = (Engine) host.getParent();
821 Service service = engine.getService();
822 name = new ObjectName(domain + ":type=Environment" +
823 ",resourcetype=Context,path=" + path +
824 ",host=" + host.getName() +
825 ",name=" + environment.getName());
826 }
827 return (name);
828
829 }
830
831
832 /**
833 * Create an <code>ObjectName</code> for this
834 * <code>ContextResource</code> object.
835 *
836 * @param domain Domain in which this name is to be created
837 * @param resource The ContextResource to be named
838 *
839 * @exception MalformedObjectNameException if a name cannot be created
840 */
841 public static ObjectName createObjectName(String domain,
842 ContextResource resource)
843 throws MalformedObjectNameException {
844
845 ObjectName name = null;
846 String quotedResourceName = ObjectName.quote(resource.getName());
847 Object container =
848 resource.getNamingResources().getContainer();
849 if (container instanceof Server) {
850 name = new ObjectName(domain + ":type=Resource" +
851 ",resourcetype=Global,class=" + resource.getType() +
852 ",name=" + quotedResourceName);
853 } else if (container instanceof Context) {
854 String path = ((Context)container).getPath();
855 if (path.length() < 1)
856 path = "/";
857 Host host = (Host) ((Context)container).getParent();
858 Engine engine = (Engine) host.getParent();
859 Service service = engine.getService();
860 name = new ObjectName(domain + ":type=Resource" +
861 ",resourcetype=Context,path=" + path +
862 ",host=" + host.getName() +
863 ",class=" + resource.getType() +
864 ",name=" + quotedResourceName);
865 }
866
867 return (name);
868
869 }
870
871
872 /**
873 * Create an <code>ObjectName</code> for this
874 * <code>ContextResourceLink</code> object.
875 *
876 * @param domain Domain in which this name is to be created
877 * @param resourceLink The ContextResourceLink to be named
878 *
879 * @exception MalformedObjectNameException if a name cannot be created
880 */
881 public static ObjectName createObjectName(String domain,
882 ContextResourceLink resourceLink)
883 throws MalformedObjectNameException {
884
885 ObjectName name = null;
886 String quotedResourceLinkName
887 = ObjectName.quote(resourceLink.getName());
888 Object container =
889 resourceLink.getNamingResources().getContainer();
890 if (container instanceof Server) {
891 name = new ObjectName(domain + ":type=ResourceLink" +
892 ",resourcetype=Global" +
893 ",name=" + quotedResourceLinkName);
894 } else if (container instanceof Context) {
895 String path = ((Context)container).getPath();
896 if (path.length() < 1)
897 path = "/";
898 Host host = (Host) ((Context)container).getParent();
899 Engine engine = (Engine) host.getParent();
900 Service service = engine.getService();
901 name = new ObjectName(domain + ":type=ResourceLink" +
902 ",resourcetype=Context,path=" + path +
903 ",host=" + host.getName() +
904 ",name=" + quotedResourceLinkName);
905 }
906
907 return (name);
908
909 }
910
911
912
913 /**
914 * Create an <code>ObjectName</code> for this
915 * <code>Engine</code> object.
916 *
917 * @param domain Domain in which this name is to be created
918 * @param engine The Engine to be named
919 *
920 * @exception MalformedObjectNameException if a name cannot be created
921 */
922 static ObjectName createObjectName(String domain,
923 Engine engine)
924 throws MalformedObjectNameException {
925
926 ObjectName name = null;
927 name = new ObjectName(domain + ":type=Engine");
928 return (name);
929
930 }
931
932
933 /**
934 * Create an <code>ObjectName</code> for this
935 * <code>Group</code> object.
936 *
937 * @param domain Domain in which this name is to be created
938 * @param group The Group to be named
939 *
940 * @exception MalformedObjectNameException if a name cannot be created
941 */
942 static ObjectName createObjectName(String domain,
943 Group group)
944 throws MalformedObjectNameException {
945
946 ObjectName name = null;
947 name = new ObjectName(domain + ":type=Group,groupname=" +
948 ObjectName.quote(group.getGroupname()) +
949 ",database=" + group.getUserDatabase().getId());
950 return (name);
951
952 }
953
954
955 /**
956 * Create an <code>ObjectName</code> for this
957 * <code>Host</code> object.
958 *
959 * @param domain Domain in which this name is to be created
960 * @param host The Host to be named
961 *
962 * @exception MalformedObjectNameException if a name cannot be created
963 */
964 static ObjectName createObjectName(String domain,
965 Host host)
966 throws MalformedObjectNameException {
967
968 ObjectName name = null;
969 Engine engine = (Engine)host.getParent();
970 Service service = engine.getService();
971 name = new ObjectName(domain + ":type=Host,host=" +
972 host.getName());
973 return (name);
974
975 }
976
977
978 /**
979 * Create an <code>ObjectName</code> for this
980 * <code>Loader</code> object.
981 *
982 * @param domain Domain in which this name is to be created
983 * @param loader The Loader to be named
984 *
985 * @exception MalformedObjectNameException if a name cannot be created
986 */
987 static ObjectName createObjectName(String domain,
988 Loader loader)
989 throws MalformedObjectNameException {
990
991 ObjectName name = null;
992 Container container = loader.getContainer();
993
994 if (container instanceof Engine) {
995 Service service = ((Engine)container).getService();
996 name = new ObjectName(domain + ":type=Loader");
997 } else if (container instanceof Host) {
998 Engine engine = (Engine) container.getParent();
999 Service service = engine.getService();
1000 name = new ObjectName(domain + ":type=Loader,host=" +
1001 container.getName());
1002 } else if (container instanceof Context) {
1003 String path = ((Context)container).getPath();
1004 if (path.length() < 1) {
1005 path = "/";
1006 }
1007 Host host = (Host) container.getParent();
1008 Engine engine = (Engine) host.getParent();
1009 Service service = engine.getService();
1010 name = new ObjectName(domain + ":type=Loader,path=" + path +
1011 ",host=" + host.getName());
1012 }
1013
1014 return (name);
1015
1016 }
1017
1018
1019 /**
1020 * Create an <code>ObjectName</code> for this
1021 * <code>Manager</code> object.
1022 *
1023 * @param domain Domain in which this name is to be created
1024 * @param manager The Manager to be named
1025 *
1026 * @exception MalformedObjectNameException if a name cannot be created
1027 */
1028 static ObjectName createObjectName(String domain,
1029 Manager manager)
1030 throws MalformedObjectNameException {
1031
1032 ObjectName name = null;
1033 Container container = manager.getContainer();
1034
1035 if (container instanceof Engine) {
1036 Service service = ((Engine)container).getService();
1037 name = new ObjectName(domain + ":type=Manager");
1038 } else if (container instanceof Host) {
1039 Engine engine = (Engine) container.getParent();
1040 Service service = engine.getService();
1041 name = new ObjectName(domain + ":type=Manager,host=" +
1042 container.getName());
1043 } else if (container instanceof Context) {
1044 String path = ((Context)container).getPath();
1045 if (path.length() < 1) {
1046 path = "/";
1047 }
1048 Host host = (Host) container.getParent();
1049 Engine engine = (Engine) host.getParent();
1050 Service service = engine.getService();
1051 name = new ObjectName(domain + ":type=Manager,path=" + path +
1052 ",host=" + host.getName());
1053 }
1054
1055 return (name);
1056
1057 }
1058
1059
1060 /**
1061 * Create an <code>ObjectName</code> for this
1062 * <code>Server</code> object.
1063 *
1064 * @param domain Domain in which this name is to be created
1065 * @param resources The NamingResources to be named
1066 *
1067 * @exception MalformedObjectNameException if a name cannot be created
1068 */
1069 static ObjectName createObjectName(String domain,
1070 NamingResources resources)
1071 throws MalformedObjectNameException {
1072
1073 ObjectName name = null;
1074 Object container = resources.getContainer();
1075 if (container instanceof Server) {
1076 name = new ObjectName(domain + ":type=NamingResources" +
1077 ",resourcetype=Global");
1078 } else if (container instanceof Context) {
1079 String path = ((Context)container).getPath();
1080 if (path.length() < 1)
1081 path = "/";
1082 Host host = (Host) ((Context)container).getParent();
1083 Engine engine = (Engine) host.getParent();
1084 Service service = engine.getService();
1085 name = new ObjectName(domain + ":type=NamingResources" +
1086 ",resourcetype=Context,path=" + path +
1087 ",host=" + host.getName());
1088 }
1089
1090 return (name);
1091
1092 }
1093
1094
1095 /**
1096 * Create an <code>ObjectName</code> for this
1097 * <code>MBeanFactory</code> object.
1098 *
1099 * @param domain Domain in which this name is to be created
1100 * @param factory The MBeanFactory to be named
1101 *
1102 * @exception MalformedObjectNameException if a name cannot be created
1103 */
1104 static ObjectName createObjectName(String domain,
1105 MBeanFactory factory)
1106 throws MalformedObjectNameException {
1107
1108 ObjectName name = new ObjectName(domain + ":type=MBeanFactory");
1109
1110 return (name);
1111
1112 }
1113
1114
1115 /**
1116 * Create an <code>ObjectName</code> for this
1117 * <code>Realm</code> object.
1118 *
1119 * @param domain Domain in which this name is to be created
1120 * @param realm The Realm to be named
1121 *
1122 * @exception MalformedObjectNameException if a name cannot be created
1123 */
1124 static ObjectName createObjectName(String domain,
1125 Realm realm)
1126 throws MalformedObjectNameException {
1127
1128 ObjectName name = null;
1129 Container container = realm.getContainer();
1130
1131 if (container instanceof Engine) {
1132 Service service = ((Engine)container).getService();
1133 name = new ObjectName(domain + ":type=Realm");
1134 } else if (container instanceof Host) {
1135 Engine engine = (Engine) container.getParent();
1136 Service service = engine.getService();
1137 name = new ObjectName(domain + ":type=Realm,host=" +
1138 container.getName());
1139 } else if (container instanceof Context) {
1140 String path = ((Context)container).getPath();
1141 if (path.length() < 1) {
1142 path = "/";
1143 }
1144 Host host = (Host) container.getParent();
1145 Engine engine = (Engine) host.getParent();
1146 Service service = engine.getService();
1147 name = new ObjectName(domain + ":type=Realm,path=" + path +
1148 ",host=" + host.getName());
1149 }
1150
1151 return (name);
1152
1153 }
1154
1155
1156 /**
1157 * Create an <code>ObjectName</code> for this
1158 * <code>Role</code> object.
1159 *
1160 * @param domain Domain in which this name is to be created
1161 * @param role The Role to be named
1162 *
1163 * @exception MalformedObjectNameException if a name cannot be created
1164 */
1165 static ObjectName createObjectName(String domain,
1166 Role role)
1167 throws MalformedObjectNameException {
1168
1169 ObjectName name = null;
1170 name = new ObjectName(domain + ":type=Role,rolename=" +
1171 role.getRolename() + ",database=" +
1172 role.getUserDatabase().getId());
1173 return (name);
1174
1175 }
1176
1177
1178 /**
1179 * Create an <code>ObjectName</code> for this
1180 * <code>Server</code> object.
1181 *
1182 * @param domain Domain in which this name is to be created
1183 * @param server The Server to be named
1184 *
1185 * @exception MalformedObjectNameException if a name cannot be created
1186 */
1187 static ObjectName createObjectName(String domain,
1188 Server server)
1189 throws MalformedObjectNameException {
1190
1191 ObjectName name = null;
1192 name = new ObjectName(domain + ":type=Server");
1193 return (name);
1194
1195 }
1196
1197
1198 /**
1199 * Create an <code>ObjectName</code> for this
1200 * <code>Service</code> object.
1201 *
1202 * @param domain Domain in which this name is to be created
1203 * @param service The Service to be named
1204 *
1205 * @exception MalformedObjectNameException if a name cannot be created
1206 */
1207 static ObjectName createObjectName(String domain,
1208 Service service)
1209 throws MalformedObjectNameException {
1210
1211 ObjectName name = null;
1212 name = new ObjectName(domain + ":type=Service,serviceName=" +
1213 service.getName());
1214 return (name);
1215
1216 }
1217
1218
1219 /**
1220 * Create an <code>ObjectName</code> for this
1221 * <code>User</code> object.
1222 *
1223 * @param domain Domain in which this name is to be created
1224 * @param user The User to be named
1225 *
1226 * @exception MalformedObjectNameException if a name cannot be created
1227 */
1228 static ObjectName createObjectName(String domain,
1229 User user)
1230 throws MalformedObjectNameException {
1231
1232 ObjectName name = null;
1233 name = new ObjectName(domain + ":type=User,username=" +
1234 ObjectName.quote(user.getUsername())
1235 + ",database=" + user.getUserDatabase().getId());
1236 return (name);
1237
1238 }
1239
1240
1241 /**
1242 * Create an <code>ObjectName</code> for this
1243 * <code>UserDatabase</code> object.
1244 *
1245 * @param domain Domain in which this name is to be created
1246 * @param userDatabase The UserDatabase to be named
1247 *
1248 * @exception MalformedObjectNameException if a name cannot be created
1249 */
1250 static ObjectName createObjectName(String domain,
1251 UserDatabase userDatabase)
1252 throws MalformedObjectNameException {
1253
1254 ObjectName name = null;
1255 name = new ObjectName(domain + ":type=UserDatabase,database=" +
1256 userDatabase.getId());
1257 return (name);
1258
1259 }
1260
1261
1262 /**
1263 * Create an <code>ObjectName</code> for this
1264 * <code>Valve</code> object.
1265 *
1266 * @param domain Domain in which this name is to be created
1267 * @param valve The Valve to be named
1268 *
1269 * @exception MalformedObjectNameException if a name cannot be created
1270 */
1271 static ObjectName createObjectName(String domain,
1272 Valve valve)
1273 throws MalformedObjectNameException {
1274 if( valve instanceof ValveBase ) {
1275 ObjectName name=((ValveBase)valve).getObjectName();
1276 if( name != null )
1277 return name;
1278 }
1279
1280 ObjectName name = null;
1281 Container container = null;
1282 String className=valve.getClass().getName();
1283 int period = className.lastIndexOf('.');
1284 if (period >= 0)
1285 className = className.substring(period + 1);
1286 if( valve instanceof Contained ) {
1287 container = ((Contained)valve).getContainer();
1288 }
1289 if( container == null ) {
1290 throw new MalformedObjectNameException(
1291 "Cannot create mbean for non-contained valve " +
1292 valve);
1293 }
1294 if (container instanceof Engine) {
1295 Service service = ((Engine)container).getService();
1296 String local="";
1297 int seq = getSeq(local);
1298 String ext="";
1299 if( seq > 0 ) {
1300 ext=",seq=" + seq;
1301 }
1302 name = new ObjectName(domain + ":type=Valve,name=" + className +
1303 ext + local );
1304 } else if (container instanceof Host) {
1305 Service service = ((Engine)container.getParent()).getService();
1306 String local=",host=" +container.getName();
1307 int seq = getSeq(local);
1308 String ext="";
1309 if( seq > 0 ) {
1310 ext=",seq=" + seq;
1311 }
1312 name = new ObjectName(domain + ":type=Valve,name=" + className +
1313 ext + local );
1314 } else if (container instanceof Context) {
1315 String path = ((Context)container).getPath();
1316 if (path.length() < 1) {
1317 path = "/";
1318 }
1319 Host host = (Host) container.getParent();
1320 Service service = ((Engine) host.getParent()).getService();
1321 String local=",path=" + path + ",host=" +
1322 host.getName();
1323 int seq = getSeq(local);
1324 String ext="";
1325 if( seq > 0 ) {
1326 ext=",seq=" + seq;
1327 }
1328 name = new ObjectName(domain + ":type=Valve,name=" + className +
1329 ext + local );
1330 }
1331
1332 return (name);
1333
1334 }
1335
1336 static Hashtable seq=new Hashtable();
1337 static int getSeq( String key ) {
1338 int i[]=(int [])seq.get( key );
1339 if (i == null ) {
1340 i=new int[1];
1341 i[0]=0;
1342 seq.put( key, i);
1343 } else {
1344 i[0]++;
1345 }
1346 return i[0];
1347 }
1348
1349 /**
1350 * Create and configure (if necessary) and return the registry of
1351 * managed object descriptions.
1352 */
1353 public synchronized static Registry createRegistry() {
1354
1355 if (registry == null) {
1356 registry = Registry.getRegistry(null, null);
1357 ClassLoader cl=ServerLifecycleListener.class.getClassLoader();
1358
1359 registry.loadDescriptors("org.apache.catalina.mbeans", cl);
1360 registry.loadDescriptors("org.apache.catalina.authenticator", cl);
1361 registry.loadDescriptors("org.apache.catalina.core", cl);
1362 registry.loadDescriptors("org.apache.catalina", cl);
1363 registry.loadDescriptors("org.apache.catalina.deploy", cl);
1364 registry.loadDescriptors("org.apache.catalina.loader", cl);
1365 registry.loadDescriptors("org.apache.catalina.realm", cl);
1366 registry.loadDescriptors("org.apache.catalina.session", cl);
1367 registry.loadDescriptors("org.apache.catalina.startup", cl);
1368 registry.loadDescriptors("org.apache.catalina.users", cl);
1369 registry.loadDescriptors("org.apache.catalina.ha", cl);
1370 registry.loadDescriptors("org.apache.catalina.connector", cl);
1371 registry.loadDescriptors("org.apache.catalina.valves", cl);
1372 }
1373 return (registry);
1374
1375 }
1376
1377
1378 /**
1379 * Create and configure (if necessary) and return the
1380 * <code>MBeanServer</code> with which we will be
1381 * registering our <code>DynamicMBean</code> implementations.
1382 */
1383 public synchronized static MBeanServer createServer() {
1384
1385 if (mserver == null) {
1386 try {
1387 mserver = Registry.getRegistry(null, null).getMBeanServer();
1388 } catch (Throwable t) {
1389 t.printStackTrace(System.out);
1390 System.exit(1);
1391 }
1392 }
1393 return (mserver);
1394
1395 }
1396
1397
1398 /**
1399 * Deregister the MBean for this
1400 * <code>Connector</code> object.
1401 *
1402 * @param connector The Connector to be managed
1403 *
1404 * @exception Exception if an MBean cannot be deregistered
1405 */
1406 static void destroyMBean(Connector connector, Service service)
1407 throws Exception {
1408
1409 connector.setService(service);
1410 String mname = createManagedName(connector);
1411 ManagedBean managed = registry.findManagedBean(mname);
1412 if (managed == null) {
1413 return;
1414 }
1415 String domain = managed.getDomain();
1416 if (domain == null)
1417 domain = mserver.getDefaultDomain();
1418 ObjectName oname = createObjectName(domain, connector);
1419 connector.setService(null);
1420 if( mserver.isRegistered( oname )) {
1421 mserver.unregisterMBean(oname);
1422 }
1423 }
1424
1425
1426 /**
1427 * Deregister the MBean for this
1428 * <code>Context</code> object.
1429 *
1430 * @param context The Context to be managed
1431 *
1432 * @exception Exception if an MBean cannot be deregistered
1433 */
1434 static void destroyMBean(Context context)
1435 throws Exception {
1436
1437 String mname = createManagedName(context);
1438 ManagedBean managed = registry.findManagedBean(mname);
1439 if (managed == null) {
1440 return;
1441 }
1442 String domain = managed.getDomain();
1443 if (domain == null)
1444 domain = mserver.getDefaultDomain();
1445 ObjectName oname = createObjectName(domain, context);
1446 if( mserver.isRegistered(oname) )
1447 mserver.unregisterMBean(oname);
1448
1449 }
1450
1451
1452 /**
1453 * Deregister the MBean for this
1454 * <code>ContextEnvironment</code> object.
1455 *
1456 * @param environment The ContextEnvironment to be managed
1457 *
1458 * @exception Exception if an MBean cannot be deregistered
1459 */
1460 static void destroyMBean(ContextEnvironment environment)
1461 throws Exception {
1462
1463 String mname = createManagedName(environment);
1464 ManagedBean managed = registry.findManagedBean(mname);
1465 if (managed == null) {
1466 return;
1467 }
1468 String domain = managed.getDomain();
1469 if (domain == null)
1470 domain = mserver.getDefaultDomain();
1471 ObjectName oname = createObjectName(domain, environment);
1472 if( mserver.isRegistered(oname) )
1473 mserver.unregisterMBean(oname);
1474
1475 }
1476
1477
1478 /**
1479 * Deregister the MBean for this
1480 * <code>ContextResource</code> object.
1481 *
1482 * @param resource The ContextResource to be managed
1483 *
1484 * @exception Exception if an MBean cannot be deregistered
1485 */
1486 static void destroyMBean(ContextResource resource)
1487 throws Exception {
1488
1489 String mname = createManagedName(resource);
1490 ManagedBean managed = registry.findManagedBean(mname);
1491 if (managed == null) {
1492 return;
1493 }
1494 String domain = managed.getDomain();
1495 if (domain == null)
1496 domain = mserver.getDefaultDomain();
1497 ObjectName oname = createObjectName(domain, resource);
1498 if( mserver.isRegistered(oname ))
1499 mserver.unregisterMBean(oname);
1500
1501 }
1502
1503
1504 /**
1505 * Deregister the MBean for this
1506 * <code>ContextResourceLink</code> object.
1507 *
1508 * @param resourceLink The ContextResourceLink to be managed
1509 *
1510 * @exception Exception if an MBean cannot be deregistered
1511 */
1512 static void destroyMBean(ContextResourceLink resourceLink)
1513 throws Exception {
1514
1515 String mname = createManagedName(resourceLink);
1516 ManagedBean managed = registry.findManagedBean(mname);
1517 if (managed == null) {
1518 return;
1519 }
1520 String domain = managed.getDomain();
1521 if (domain == null)
1522 domain = mserver.getDefaultDomain();
1523 ObjectName oname = createObjectName(domain, resourceLink);
1524 if( mserver.isRegistered(oname) )
1525 mserver.unregisterMBean(oname);
1526
1527 }
1528
1529 /**
1530 * Deregister the MBean for this
1531 * <code>Engine</code> object.
1532 *
1533 * @param engine The Engine to be managed
1534 *
1535 * @exception Exception if an MBean cannot be deregistered
1536 */
1537 static void destroyMBean(Engine engine)
1538 throws Exception {
1539
1540 String mname = createManagedName(engine);
1541 ManagedBean managed = registry.findManagedBean(mname);
1542 if (managed == null) {
1543 return;
1544 }
1545 String domain = managed.getDomain();
1546 if (domain == null)
1547 domain = mserver.getDefaultDomain();
1548 ObjectName oname = createObjectName(domain, engine);
1549 if( mserver.isRegistered(oname) )
1550 mserver.unregisterMBean(oname);
1551
1552 }
1553
1554
1555 /**
1556 * Deregister the MBean for this
1557 * <code>Group</code> object.
1558 *
1559 * @param group The Group to be managed
1560 *
1561 * @exception Exception if an MBean cannot be deregistered
1562 */
1563 static void destroyMBean(Group group)
1564 throws Exception {
1565
1566 String mname = createManagedName(group);
1567 ManagedBean managed = registry.findManagedBean(mname);
1568 if (managed == null) {
1569 return;
1570 }
1571 String domain = managed.getDomain();
1572 if (domain == null)
1573 domain = mserver.getDefaultDomain();
1574 ObjectName oname = createObjectName(domain, group);
1575 if( mserver.isRegistered(oname) )
1576 mserver.unregisterMBean(oname);
1577
1578 }
1579
1580
1581 /**
1582 * Deregister the MBean for this
1583 * <code>Host</code> object.
1584 *
1585 * @param host The Host to be managed
1586 *
1587 * @exception Exception if an MBean cannot be deregistered
1588 */
1589 static void destroyMBean(Host host)
1590 throws Exception {
1591
1592 String mname = createManagedName(host);
1593 ManagedBean managed = registry.findManagedBean(mname);
1594 if (managed == null) {
1595 return;
1596 }
1597 String domain = managed.getDomain();
1598 if (domain == null)
1599 domain = mserver.getDefaultDomain();
1600 ObjectName oname = createObjectName(domain, host);
1601 if( mserver.isRegistered(oname) )
1602 mserver.unregisterMBean(oname);
1603
1604 }
1605
1606
1607 /**
1608 * Deregister the MBean for this
1609 * <code>Loader</code> object.
1610 *
1611 * @param loader The Loader to be managed
1612 *
1613 * @exception Exception if an MBean cannot be deregistered
1614 */
1615 static void destroyMBean(Loader loader)
1616 throws Exception {
1617
1618 String mname = createManagedName(loader);
1619 ManagedBean managed = registry.findManagedBean(mname);
1620 if (managed == null) {
1621 return;
1622 }
1623 String domain = managed.getDomain();
1624 if (domain == null)
1625 domain = mserver.getDefaultDomain();
1626 ObjectName oname = createObjectName(domain, loader);
1627 if( mserver.isRegistered(oname) )
1628 mserver.unregisterMBean(oname);
1629
1630 }
1631
1632
1633 /**
1634 * Deregister the MBean for this
1635 * <code>Manager</code> object.
1636 *
1637 * @param manager The Manager to be managed
1638 *
1639 * @exception Exception if an MBean cannot be deregistered
1640 */
1641 static void destroyMBean(Manager manager)
1642 throws Exception {
1643
1644 String mname = createManagedName(manager);
1645 ManagedBean managed = registry.findManagedBean(mname);
1646 if (managed == null) {
1647 return;
1648 }
1649 String domain = managed.getDomain();
1650 if (domain == null)
1651 domain = mserver.getDefaultDomain();
1652 ObjectName oname = createObjectName(domain, manager);
1653 if( mserver.isRegistered(oname) )
1654 mserver.unregisterMBean(oname);
1655
1656 }
1657
1658
1659 /**
1660 * Deregister the MBean for this
1661 * <code>NamingResources</code> object.
1662 *
1663 * @param resources The NamingResources to be managed
1664 *
1665 * @exception Exception if an MBean cannot be deregistered
1666 */
1667 static void destroyMBean(NamingResources resources)
1668 throws Exception {
1669
1670 String mname = createManagedName(resources);
1671 ManagedBean managed = registry.findManagedBean(mname);
1672 if (managed == null) {
1673 return;
1674 }
1675 String domain = managed.getDomain();
1676 if (domain == null)
1677 domain = mserver.getDefaultDomain();
1678 ObjectName oname = createObjectName(domain, resources);
1679 if( mserver.isRegistered(oname) )
1680 mserver.unregisterMBean(oname);
1681
1682 }
1683
1684
1685 /**
1686 * Deregister the MBean for this
1687 * <code>Realm</code> object.
1688 *
1689 * @param realm The Realm to be managed
1690 *
1691 * @exception Exception if an MBean cannot be deregistered
1692 */
1693 static void destroyMBean(Realm realm)
1694 throws Exception {
1695
1696 String mname = createManagedName(realm);
1697 ManagedBean managed = registry.findManagedBean(mname);
1698 if (managed == null) {
1699 return;
1700 }
1701 String domain = managed.getDomain();
1702 if (domain == null)
1703 domain = mserver.getDefaultDomain();
1704 ObjectName oname = createObjectName(domain, realm);
1705 if( mserver.isRegistered(oname) )
1706 mserver.unregisterMBean(oname);
1707
1708 }
1709
1710
1711 /**
1712 * Deregister the MBean for this
1713 * <code>Role</code> object.
1714 *
1715 * @param role The Role to be managed
1716 *
1717 * @exception Exception if an MBean cannot be deregistered
1718 */
1719 static void destroyMBean(Role role)
1720 throws Exception {
1721
1722 String mname = createManagedName(role);
1723 ManagedBean managed = registry.findManagedBean(mname);
1724 if (managed == null) {
1725 return;
1726 }
1727 String domain = managed.getDomain();
1728 if (domain == null)
1729 domain = mserver.getDefaultDomain();
1730 ObjectName oname = createObjectName(domain, role);
1731 if( mserver.isRegistered(oname) )
1732 mserver.unregisterMBean(oname);
1733
1734 }
1735
1736
1737 /**
1738 * Deregister the MBean for this
1739 * <code>Server</code> object.
1740 *
1741 * @param server The Server to be managed
1742 *
1743 * @exception Exception if an MBean cannot be deregistered
1744 */
1745 static void destroyMBean(Server server)
1746 throws Exception {
1747
1748 String mname = createManagedName(server);
1749 ManagedBean managed = registry.findManagedBean(mname);
1750 if (managed == null) {
1751 return;
1752 }
1753 String domain = managed.getDomain();
1754 if (domain == null)
1755 domain = mserver.getDefaultDomain();
1756 ObjectName oname = createObjectName(domain, server);
1757 if( mserver.isRegistered(oname) )
1758 mserver.unregisterMBean(oname);
1759
1760 }
1761
1762
1763 /**
1764 * Deregister the MBean for this
1765 * <code>Service</code> object.
1766 *
1767 * @param service The Service to be managed
1768 *
1769 * @exception Exception if an MBean cannot be deregistered
1770 */
1771 static void destroyMBean(Service service)
1772 throws Exception {
1773
1774 String mname = createManagedName(service);
1775 ManagedBean managed = registry.findManagedBean(mname);
1776 if (managed == null) {
1777 return;
1778 }
1779 String domain = managed.getDomain();
1780 if (domain == null)
1781 domain = mserver.getDefaultDomain();
1782 ObjectName oname = createObjectName(domain, service);
1783 if( mserver.isRegistered(oname) )
1784 mserver.unregisterMBean(oname);
1785
1786 }
1787
1788
1789 /**
1790 * Deregister the MBean for this
1791 * <code>User</code> object.
1792 *
1793 * @param user The User to be managed
1794 *
1795 * @exception Exception if an MBean cannot be deregistered
1796 */
1797 static void destroyMBean(User user)
1798 throws Exception {
1799
1800 String mname = createManagedName(user);
1801 ManagedBean managed = registry.findManagedBean(mname);
1802 if (managed == null) {
1803 return;
1804 }
1805 String domain = managed.getDomain();
1806 if (domain == null)
1807 domain = mserver.getDefaultDomain();
1808 ObjectName oname = createObjectName(domain, user);
1809 if( mserver.isRegistered(oname) )
1810 mserver.unregisterMBean(oname);
1811
1812 }
1813
1814
1815 /**
1816 * Deregister the MBean for this
1817 * <code>UserDatabase</code> object.
1818 *
1819 * @param userDatabase The UserDatabase to be managed
1820 *
1821 * @exception Exception if an MBean cannot be deregistered
1822 */
1823 static void destroyMBean(UserDatabase userDatabase)
1824 throws Exception {
1825
1826 String mname = createManagedName(userDatabase);
1827 ManagedBean managed = registry.findManagedBean(mname);
1828 if (managed == null) {
1829 return;
1830 }
1831 String domain = managed.getDomain();
1832 if (domain == null)
1833 domain = mserver.getDefaultDomain();
1834 ObjectName oname = createObjectName(domain, userDatabase);
1835 if( mserver.isRegistered(oname) )
1836 mserver.unregisterMBean(oname);
1837
1838 }
1839
1840
1841 /**
1842 * Deregister the MBean for this
1843 * <code>Valve</code> object.
1844 *
1845 * @param valve The Valve to be managed
1846 *
1847 * @exception Exception if an MBean cannot be deregistered
1848 */
1849 static void destroyMBean(Valve valve, Container container)
1850 throws Exception {
1851
1852 ((Contained)valve).setContainer(container);
1853 String mname = createManagedName(valve);
1854 ManagedBean managed = registry.findManagedBean(mname);
1855 if (managed == null) {
1856 return;
1857 }
1858 String domain = managed.getDomain();
1859 if (domain == null)
1860 domain = mserver.getDefaultDomain();
1861 ObjectName oname = createObjectName(domain, valve);
1862 try {
1863 ((Contained)valve).setContainer(null);
1864 } catch (Throwable t) {
1865 ;
1866 }
1867 if( mserver.isRegistered(oname) ) {
1868 mserver.unregisterMBean(oname);
1869 }
1870
1871 }
1872
1873 }
Save This Page