Save This Page
Home » apache-tomcat-6.0.26-src » org.apache » catalina » mbeans » [javadoc | source]
    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
Home » apache-tomcat-6.0.26-src » org.apache » catalina » mbeans » [javadoc | source]