public  void create(ObjectName serviceName) throws Exception 
{
      create(serviceName, null);
}

 public  void create(ObjectName serviceName,
    Collection depends) throws Exception 
{
      if (serviceName == null)
      {
         log.warn("Ignoring request to create null service: ", new Exception("STACKTRACE"));
         return;
      }
      log.debug("Creating service " + serviceName);
      // Register if not already done so
      ServiceControllerContext context = installed.get(serviceName);
      if (context == null)
      {
         register(serviceName, depends);
         context = installed.get(serviceName);
      }
      ServiceContext ctx = context.getServiceContext();
      // If we are already created (can happen in dependencies) or failed just return
      if (ctx.state == ServiceContext.CREATED
            || ctx.state == ServiceContext.RUNNING
            || ctx.state == ServiceContext.FAILED)
      {
         log.debug("Ignoring create request for service: " + ctx.objectName + " at state " + ctx.getStateString());
         return;
      }
      // Request the mbean go to the created state
      KernelController controller = kernel.getController();
      try
      {
         doChange(controller, context, ControllerState.CREATE, "create");
      }
      catch (Throwable t)
      {
         log.warn("Problem creating service " + serviceName, t);
      }
}

 public  void destroy(ObjectName serviceName) throws Exception 
{
      if (serviceName == null)
      {
         log.warn("Ignoring request to destroy null service: ", new Exception("STACKTRACE"));
         return;
      }
      log.debug("destroying service: " + serviceName);
      ServiceControllerContext context = installed.get(serviceName);
      if (context == null)
      {
         log.warn("Ignoring request to destroy nonexistent service: " + serviceName);
         return;
      }
      // If we are already destroyed (can happen in dependencies) just return
      ServiceContext ctx = context.getServiceContext();
      if (ctx.state == ServiceContext.DESTROYED || ctx.state == ServiceContext.NOTYETINSTALLED || ctx.state == ServiceContext.FAILED)
      {
         log.debug("Ignoring destroy request for service: " + ctx.objectName + " at state " + ctx.getStateString());
         return;
      }
      // Request the mbean go the configured state
      KernelController controller = kernel.getController();
      try
      {
         doChange(controller, context, ControllerState.CONFIGURED, null);
      }
      catch (Throwable t)
      {
         log.warn("Problem stopping service " + serviceName, t);
      }
}

 public Kernel getKernel() 
{
      return kernel;
}

Get the kernel.

 public MBeanServer getMBeanServer() 
{
   
      return server;
}

Get the MBeanServer

 public ServiceBinding getServiceBinding() 
{
      return serviceBinding;
}

Get the serviceBinding.

 public ServiceContext getServiceContext(ObjectName serviceName) 
{
      ServiceControllerContext context = installed.get(serviceName);
      if (context != null)
         return context.getServiceContext();
      return null;
}

 public List install(List metaDatas,
    ObjectName loaderName) throws DeploymentException 
{
      KernelController controller = kernel.getController();
      // Track the registered mbeans both for returning the result
      // and uninstalling in the event of an error
      List< ObjectName > result = new ArrayList< ObjectName >(metaDatas.size());
      List< ServiceControllerContext > contexts = new ArrayList< ServiceControllerContext >(metaDatas.size());
      // Go through each mbean in the passed xml
      for (ServiceMetaData metaData : metaDatas)
      {
         metaData.setClassLoaderName(loaderName);
         // Install the context to the configured level
         ServiceControllerContext context = new ServiceControllerContext(this, metaData);
         try
         {
            doInstall(controller, context);
            contexts.add(context);
            doChange(controller, context, ControllerState.CONFIGURED, "configure");
            result.add(context.getObjectName());
         }
         catch (Throwable t)
         {
            // Something went wrong
            for (ServiceControllerContext ctx : contexts)
               safelyRemoveAnyRegisteredContext(ctx);
            DeploymentException.rethrowAsDeploymentException("Error during install", t);
         }
      }
      return result;
}

 public ObjectName install(ServiceMetaData metaData,
    ObjectName loaderName) throws DeploymentException 
{
      KernelController controller = kernel.getController();
      metaData.setClassLoaderName(loaderName);
      ObjectName name = metaData.getObjectName();
      // Install the context to the configured level
      ServiceControllerContext context = new ServiceControllerContext(this, metaData);
      try
      {
         doInstall(controller, context);
         doChange(controller, context, ControllerState.CONFIGURED, "configure");
         return context.getObjectName();
      }
      catch (Throwable t)
      {
         throw DeploymentException.rethrowAsDeploymentException("Error during install " + name, t);
      }
}

 public List install(Element config,
    ObjectName loaderName) throws DeploymentException 
{
      // Parse the xml
      ServiceMetaDataParser parser = new ServiceMetaDataParser(config);
      List< ServiceMetaData > metaDatas = parser.parse();
      return install(metaDatas, loaderName);
}

 public  void install(ObjectName name,
    Object object) throws DeploymentException 
{
      if (name == null)
         throw new IllegalArgumentException("Null name");
      if (object == null)
         throw new IllegalArgumentException("Null object");
      KernelController controller = kernel.getController();
      ServiceControllerContext context = new ServiceControllerContext(this, name, object); 
      try
      {
         doInstall(controller, context);
         doChange(controller, context, ControllerState.CONFIGURED, "configure");
      }
      catch (Throwable t)
      {
         // Something went wrong
         safelyRemoveAnyRegisteredContext(context);
         DeploymentException.rethrowAsDeploymentException("Error during install", t);
      }
}

Install an MBean without any meta data

 public String listConfiguration(ObjectName[] objectNames) throws Exception 
{
      return ServiceConfigurator.getConfiguration(server, this, objectNames);
}

 public List listDeployed() 
{
      // Retrieve the service context from all our installed contexts
      ArrayList< ServiceContext > result = new ArrayList< ServiceContext >(installedOrder.size());
      for (ServiceControllerContext context : installedOrder)
         result.add(context.getServiceContext());
      return result;
}

 public List listDeployedNames() 
{
      // Get all the object names from our installed contexts
      ArrayList< ObjectName > result = new ArrayList< ObjectName >(installed.size());
      for (ObjectName name : installed.keySet())
         result.add(name);
      return result;
}

 public List listIncompletelyDeployed() 
{
      // Retrieve the service contexts that are not deployed properly
      ArrayList< ServiceContext > result = new ArrayList< ServiceContext >();
      for (ServiceControllerContext context : installedOrder)
      {
         ServiceContext sc = context.getServiceContext();
         if (sc.state != ServiceContext.CREATED &&
             sc.state != ServiceContext.RUNNING &&
             sc.state != ServiceContext.STOPPED &&
             sc.state != ServiceContext.DESTROYED)
         {
            result.add(sc);
         }
      }
      return result;
}

 public  void postDeregister() 
{
      installed.clear();
      installedOrder.clear();
      server = null;
}

 public  void postRegister(Boolean registrationDone) 
{
      if (registrationDone.booleanValue() == false)
         log.fatal("Registration of ServiceController failed");
      else
      {
         // Register the ServiceController as a running service
         KernelController controller = kernel.getController();
         ServiceControllerContext context = new ServiceControllerContext(this, ServiceControllerMBean.OBJECT_NAME);
         context.setMode(ControllerMode.AUTOMATIC);
         try
         {
            controller.install(context);
         }
         catch (Throwable t)
         {
            log.fatal("Error registering service controller", t);
         }
      }
}

 public  void preDeregister() throws Exception 
{

}

 public ObjectName preRegister(MBeanServer server,
    ObjectName name) throws Exception 
{
      this.server = server;
      if( kernel == null )
      {
         // Bootstrap the microcontainer. 
         BasicBootstrap bootstrap = new BasicBootstrap();
         bootstrap.run();
         kernel = bootstrap.getKernel();
      }
      log.debug("Controller MBean online");
      return name == null ? OBJECT_NAME : name;
}

 public  void register(ObjectName serviceName) throws Exception 
{
      register(serviceName, null);
}

 public  void register(ObjectName serviceName,
    Collection depends) throws Exception 
{
      register(serviceName, depends, true);
}

 public  void register(ObjectName serviceName,
    Collection depends,
    boolean includeLifecycle) throws Exception 
{
      if (serviceName == null)
      {
         log.warn("Ignoring request to register null service: ", new Exception("STACKTRACE"));
         return;
      }
      log.debug("Registering service " + serviceName);
      // This is an already registered mbean
      KernelController controller = kernel.getController();
      ServiceControllerContext context = new ServiceControllerContext(this, serviceName, includeLifecycle);
      if (depends != null)
         addDependencies(context, depends);
      // Install the context to the configured level
      try
      {
         doInstall(controller, context);
         doChange(controller, context, ControllerState.CONFIGURED, "configure");
      }
      catch (Throwable t)
      {
         // Something went wrong
         safelyRemoveAnyRegisteredContext(context);
         DeploymentException.rethrowAsDeploymentException("Error during register: " + serviceName, t);
      }
}

 public  void remove(ObjectName objectName) throws Exception 
{
      if (objectName == null)
      {
         log.warn("Ignoring request to remove null service: ", new Exception("STACKTRACE"));
         return;
      }
      // Removal can be attempted twice, this is because ServiceMBeanSupport does a "double check" 
      // to make sure the ServiceController is tidied up
      // However, if the tidyup is done correctly, it invokes this method recursively:
      // ServiceController::remove - > MBeanServer::unregisterMBean
      // ServiceMBeanSupport::postDeregister - > ServiceController::remove
      ServiceControllerContext context = installed.remove(objectName);
      if (context == null)
      {
         log.trace("Ignoring request to remove nonexistent service: " + objectName);
         return;
      }
      installedOrder.remove(context);
      log.debug("removing service: " + objectName);
      // Uninstall the context
      safelyRemoveAnyRegisteredContext(context);
}

 public  void restart(ObjectName serviceName) throws Exception 
{
      if (serviceName == null)
      {
         log.warn("Ignoring request to restart null service: ", new Exception("STACKTRACE"));
         return;
      }
      log.debug("restarting service " + serviceName);
      stop(serviceName);
      start(serviceName);
}

 public  void sendControllerNotification(String type,
    ObjectName serviceName) 
{
      Notification notification = new Notification(type, this, super.nextNotificationSequenceNumber());
      notification.setUserData(serviceName);
      sendNotification(notification);
}

Sends outs controller notifications about service lifecycle events

 public  void setKernel(Kernel kernel) 
{
      this.kernel = kernel;
}

Set the kernel.

 public  void setMBeanServer(MBeanServer server) 
{
      this.server = server;
}

Set the server.

 public  void setServiceBinding(ServiceBinding serviceBinding) 
{
      this.serviceBinding = serviceBinding;
}

Plugin a ServiceBinding policy

 public  void shutdown() 
{
      log.debug("Stopping " + installedOrder.size() + " services");
      KernelController controller = kernel.getController();
      int serviceCounter = 0;
      // Uninstall all the contexts we know about
      ListIterator< ServiceControllerContext > iterator = installedOrder.listIterator(installedOrder.size());
      while (iterator.hasPrevious())
      {
         ServiceControllerContext context = iterator.previous();
         controller.uninstall(context.getName());
         ++serviceCounter;
      }
      log.debug("Stopped " + serviceCounter + " services");
      // Shutdown ourselves
      controller.uninstall(ServiceControllerMBean.OBJECT_NAME.getCanonicalName());
}

 public  void start(ObjectName serviceName) throws Exception 
{
      if (serviceName == null)
      {
         log.warn("Ignoring request to start null service: ", new Exception("STACKTRACE"));
         return;
      }
      log.debug("starting service " + serviceName);
      // Register if not already done so
      ServiceControllerContext context = installed.get(serviceName);
      if (context == null)
      {
         register(serviceName, null);
         context = installed.get(serviceName);
      }
      ServiceContext ctx = context.getServiceContext();
      // If we are already started (can happen in dependencies) just return
      if (ctx.state == ServiceContext.RUNNING || ctx.state == ServiceContext.FAILED)
      {
         log.debug("Ignoring start request for service: " + ctx.objectName + " at state " + ctx.getStateString());
         return;
      }
      // Request the mbean go to the fully installed state
      KernelController controller = kernel.getController();
      try
      {
         doChange(controller, context, ControllerState.INSTALLED, "start");
      }
      catch (Throwable t)
      {
         log.warn("Problem starting service " + serviceName, t);
      }
}

 public  void stop(ObjectName serviceName) throws Exception 
{
      if (serviceName == null)
      {
         log.warn("Ignoring request to stop null service: ", new Exception("STACKTRACE"));
         return;
      }
      log.debug("stopping service: " + serviceName);
      ServiceControllerContext context = installed.get(serviceName);
      if (context == null)
      {
         log.warn("Ignoring request to stop nonexistent service: " + serviceName);
         return;
      }
      // If we are already stopped (can happen in dependencies) just return
      ServiceContext ctx = context.getServiceContext();
      if (ctx.state != ServiceContext.RUNNING)
      {
         log.debug("Ignoring stop request for service: " + ctx.objectName + " at state " + ctx.getStateString());
         return;
      }
      // Request the mbean go back to the created state
      KernelController controller = kernel.getController();
      try
      {
         doChange(controller, context, ControllerState.CREATE, null);
      }
      catch (Throwable t)
      {
         log.warn("Problem stopping service " + serviceName, t);
      }
}

 public  void validateDeploymentState(DeploymentInfo di,
    DeploymentState state) 
{
      ArrayList< ObjectName > mbeans = new ArrayList< ObjectName >(di.mbeans);
      if (di.deployedObject != null)
         mbeans.add(di.deployedObject);
      boolean mbeansStateIsValid = true;
      for (int m = 0; m <  mbeans.size(); ++m)
      {
         ObjectName serviceName = mbeans.get(m);
         ServiceContext ctx = getServiceContext(serviceName);
         if (ctx != null && state == DeploymentState.STARTED)
            mbeansStateIsValid &= ctx.state == ServiceContext.RUNNING;
      }
      if (mbeansStateIsValid == true)
         di.state = state;
}