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