public LocalJBossServerDomain() 
{

}

 public  void createService() throws Exception 
{
      MBeanServer server = getServer();
      setupJ2EEMBeans(server);
      registerWithController(server);
      populateFactoryMap();
      registerWithCurrentDeployers(server);
}

 protected  void destroyService() throws Exception 
{
      MBeanServer server = getServer();
      unregisterWithCurrentDeployers(server);
      cleanupLeftoverMBeans(server);
      unregisterWithController(server);
}

Called to destroy the service. This unregisters with all deployers and then removes all MBeans in this services domain to remove all JSR77 beans.

 public ObjectName getCARDeployer() 
{
      return carDeployer;
}

 public ObjectName getCMDeployer() 
{
      return jcaCMDeployer;
}

 public ObjectName getEARDeployer() 
{
      return earDeployer;
}

 public ObjectName getEJBDeployer() 
{
      return ejbDeployer;
}

 public ObjectName getJMSService() 
{
      return jmsService;
}

 public ObjectName getJNDIService() 
{
      return jndiService;
}

 public ObjectName getJTAService() 
{
      return jtaService;
}

 public ObjectName getJndiBindingService() 
{
      return jndiBindingService;
}

 public ObjectName getMailService() 
{
      return mailService;
}

 public ObjectName getMainDeployer() 
{
      return mainDeployer;
}

 public Class getManagementObjFactoryMapClass() 
{
      return managedObjFactoryMapClass;
}

 public ObjectName getRARDeployer() 
{
      return rarDeployer;
}

 public ObjectName getRMI_IIOPService() 
{
      return rmiiiopService;
}

 public ObjectName getSARDeployer() 
{
      return sarDeployer;
}

 public ObjectName getUserTransactionService() 
{
      return userTxService;
}

 public ObjectName getWARDeployer() 
{
      return warDeployer;
}

 public  void handleNotification(Notification msg,
    Object handback) 
{
      MBeanServer mbeanServer = getServer();
      if (managedObjFactoryMap == null || mbeanServer == null)
      {
         return;
      }
      log.debug("handleNotification: " + msg);
      String type = msg.getType();
      Object userData = msg.getUserData();
      try
      {
         /* As this section keeps growing I should change this to a command
         dispatch pattern as well. An issue here is that there is a choice
         made about what 'data' to pass the ManagedObjectFactory based on
         the event type that probably should be hidden in the factory map.
         */
         if (type.equals(ServiceMBean.CREATE_EVENT))
         {
            ManagedObjectFactory factory = managedObjFactoryMap.getFactory(msg);
            if (factory != null)
            {
               factory.create(mbeanServer, userData);
            }
         }
         else if (type.equals(ServiceMBean.DESTROY_EVENT))
         {
            ManagedObjectFactory factory = managedObjFactoryMap.getFactory(msg);
            if (factory != null)
            {
               factory.destroy(mbeanServer, userData);
            }
         }
         else if (type.equals(SubDeployer.START_NOTIFICATION))
         {
            ManagedObjectFactory factory = managedObjFactoryMap.getFactory(msg);
            if (factory != null)
            {
               factory.create(mbeanServer, userData);
            }
         }
         else if (type.equals(SubDeployer.DESTROY_NOTIFICATION))
         {
            ManagedObjectFactory factory = managedObjFactoryMap.getFactory(msg);
            if (factory != null)
            {
               DeploymentInfo di = (DeploymentInfo) msg.getUserData();
               factory.destroy(mbeanServer, di);
            }
         }
         else if (type.equals(MainDeployerConstants.ADD_DEPLOYER))
         {
            ObjectName deployerName = (ObjectName) msg.getUserData();
            registerWithDeployer(deployerName);
         }
         else if (type.equals(MainDeployerConstants.REMOVE_DEPLOYER))
         {
            ObjectName deployerName = (ObjectName) msg.getUserData();
            unregisterWithDeployer(deployerName);
         }
      }
      catch (Throwable t)
      {
         log.debug("Failed to handle event", t);
      }
}

The JMX nofication callback. Here we create/destroy JSR77 MBeans based on the create/destory notifications.

 protected  void registerWithDeployer(ObjectName deployerName) 
{
      log.debug("Registering as listener of deployer: " + deployerName);
      try
      {
         getServer().addNotificationListener(deployerName, this, null, null);
      }
      catch (Exception e)
      {
         log.debug("Failed to register with deployer: " + deployerName, e);
      }
}

Register as a listener of the given deployer.

 public  void setCARDeployer(ObjectName name) 
{
      this.carDeployer = name;
}

 public  void setCMDeployer(ObjectName name) 
{
      this.jcaCMDeployer = name;
}

 public  void setEARDeployer(ObjectName name) 
{
      this.earDeployer = name;
}

 public  void setEJBDeployer(ObjectName name) 
{
      this.ejbDeployer = name;
}

 public  void setJMSService(ObjectName name) 
{
      this.jmsService = name;
}

 public  void setJNDIService(ObjectName name) 
{
      this.jndiService = name;
}

 public  void setJTAService(ObjectName name) 
{
      this.jtaService = name;
}

 public  void setJndiBindingService(ObjectName name) 
{
      this.jndiBindingService = name;
}

 public  void setMailService(ObjectName name) 
{
      this.mailService = name;
}

 public  void setMainDeployer(ObjectName name) 
{
      this.mainDeployer = name;
}

 public  void setManagementObjFactoryMapClass(Class cls) 
{
      this.managedObjFactoryMapClass = cls;
}

 public  void setRARDeployer(ObjectName name) 
{
      this.rarDeployer = name;
}

 public  void setRMI_IIOPService(ObjectName name) 
{
      this.rmiiiopService = name;
}

 public  void setSARDeployer(ObjectName name) 
{
      this.sarDeployer = name;
}

 public  void setUserTransactionService(ObjectName name) 
{
      this.userTxService = name;
}

 public  void setWARDeployer(ObjectName name) 
{
      this.warDeployer = name;
}

 public String toString() 
{
      return "LocalJBossServerDomain { " + super.toString() + " } []";
}

 protected  void unregisterWithDeployer(ObjectName deployerName) 
{
      log.debug("Unregistering as listener of deployer: " + deployerName);
      try
      {
         getServer().removeNotificationListener(deployerName, this);
      }
      catch (Exception e)
      {
         log.debug("Failed to unregister with deployer: " + deployerName, e);
      }
}

Unregister as a listener of the given deployer.