/*
 * JBoss, Home of Professional Open Source.
 * Copyright 2008, Red Hat Middleware LLC, and individual contributors
 * as indicated by the @author tags. See the copyright.txt file in the
 * distribution for a full listing of individual contributors.
 *
 * This is free software; you can redistribute it and/or modify it
 * under the terms of the GNU Lesser General Public License as
 * published by the Free Software Foundation; either version 2.1 of
 * the License, or (at your option) any later version.
 *
 * This software is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this software; if not, write to the Free
 * Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
 * 02110-1301 USA, or see the FSF site: http://www.fsf.org.
 */
package org.jboss.test.system.controller.legacy;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.ListIterator;
import java.util.Map;

import javax.management.JMException;
import javax.management.MBeanInfo;
import javax.management.MBeanOperationInfo;
import javax.management.MBeanRegistration;
import javax.management.MBeanServer;
import javax.management.Notification;
import javax.management.ObjectName;

import org.jboss.logging.Logger;
import org.jboss.mx.server.ServerConstants;
import org.jboss.mx.util.JBossNotificationBroadcasterSupport;
import org.jboss.mx.util.JMXExceptionDecoder;
import org.jboss.mx.util.ObjectNameFactory;
import org.jboss.system.Service;
import org.jboss.system.ServiceContext;
import org.jboss.system.ServiceFactory;
import org.jboss.system.ServiceMBean;
import org.w3c.dom.Element;

/**
 * This is the main Service Controller. A controller can deploy a service to a
 * jboss.system It installs by delegating, it configures by delegating
 *
 * @see org.jboss.system.Service
 *
 * @author <a href="mailto:marc.fleury@jboss.org">Marc Fleury</a>
 * @author <a href="mailto:d_jencks@users.sourceforge.net">David Jencks</a>
 * @author <a href="mailto:scott.stark@jboss.org">Scott Stark</a>
 * @author <a href="mailto:dimitris@jboss.org">Dimitris Andreadis</a>
 * @version $Revision: 85120 $
 */
public class OldServiceController extends JBossNotificationBroadcasterSupport
   implements OldServiceControllerMBean, MBeanRegistration
{
   /** The ObjectName of the default loader repository */
   public static final ObjectName DEFAULT_LOADER_REPOSITORY = ObjectNameFactory.create(ServerConstants.DEFAULT_LOADER_NAME);

   /** The operation name for lifecycle */
   public static final String JBOSS_INTERNAL_LIFECYCLE = "jbossInternalLifecycle";

   /** The signature for lifecycle operations */
   public static final String[] JBOSS_INTERNAL_LIFECYCLE_SIG = new String[] { String.class.getName() };

   /** Class logger. */
   private static final Logger log = Logger.getLogger(OldServiceController.class);

   /** A callback to the JMX MBeanServer */
   protected MBeanServer server;

   /** Creator, helper class to instantiate MBeans **/
   protected OldServiceCreator creator;

   /** Configurator, helper class to configure MBeans **/
   protected OldServiceConfigurator configurator;

   /** ObjectName to ServiceContext map **/
   protected Map<ObjectName, ServiceContext> nameToServiceMap = Collections.synchronizedMap(new HashMap<ObjectName, ServiceContext>());

   /** A linked list of services in the order they were created **/
   protected List<ServiceContext> installedServices = new LinkedList<ServiceContext>();

   public List<ServiceContext> listDeployed()
   {
      return new ArrayList<ServiceContext>(installedServices);
   }

   public List<ServiceContext> listIncompletelyDeployed()
   {
      List<ServiceContext> id = new ArrayList<ServiceContext>();
      for (Iterator<ServiceContext> i = installedServices.iterator(); i.hasNext();)
      {
         ServiceContext sc = i.next();
         if ( sc.state != ServiceContext.CREATED &&
              sc.state != ServiceContext.RUNNING &&
              sc.state != ServiceContext.STOPPED &&
              sc.state != ServiceContext.DESTROYED )
         {
            id.add(sc);
         }
      }
      return id;
   }

   public List<ObjectName> listDeployedNames()
   {
      List<ObjectName> names = new ArrayList<ObjectName>(installedServices.size());
      for (Iterator<ServiceContext> i = installedServices.iterator(); i.hasNext();)
      {
         ServiceContext ctx = i.next();
         names.add(ctx.objectName);
      }

      return names;
   }

   public String listConfiguration(ObjectName[] objectNames) throws Exception
   {
      return configurator.getConfiguration(objectNames);
   }

   public synchronized List<ObjectName> install(Element config, ObjectName loaderName) throws DeploymentException
   {
      List<ObjectName> mbeans = configurator.install(config, loaderName);
      for (Iterator<ObjectName> i = mbeans.iterator(); i.hasNext();)
      {
         ObjectName mbean = i.next();
         installedServices.add(createServiceContext(mbean));
      }
      return mbeans;
   }

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

   public synchronized void register(ObjectName serviceName, Collection<ObjectName> depends)
         throws Exception
   {
      if (serviceName == null)
      {
         log.warn("Ignoring request to register null service: ", new Exception("STACKTRACE"));
         return;
      }
      
      log.debug("Registering service " + serviceName);
      ServiceContext ctx = createServiceContext(serviceName);

      register(ctx, depends);
   }

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

   public synchronized void create(ObjectName serviceName, Collection<ObjectName> depends)
         throws Exception
   {
      if (serviceName == null)
      {
         log.warn("Ignoring request to create null service: ", new Exception("STACKTRACE"));
         return;
      }
      
      log.debug("Creating service " + serviceName);
      ServiceContext ctx = createServiceContext(serviceName);

      // Register the context and its dependencies if necessary
      register(ctx, depends);

      // 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);
         return;
      }

      // JSR 77, and to avoid circular dependencies
      int oldState = ctx.state;
      ctx.state = ServiceContext.CREATED;

      // Are all the mbeans I depend on created?   if not just return
      for (Iterator iterator = ctx.iDependOn.iterator(); iterator.hasNext();)
      {
         ServiceContext sc = (ServiceContext) iterator.next();
         int state = sc.state;

         // A dependent is not created or running
         if (!(state == ServiceContext.CREATED || state == ServiceContext.RUNNING))
         {
            log.debug("waiting in create of " + serviceName +
                  " waiting on " + sc.objectName);
            ctx.state = oldState;
            return;
         }
      }

      // Call create on the service Proxy
      try
      {
         ctx.proxy.create();
         sendControllerNotification(ServiceMBean.CREATE_EVENT, serviceName);            
      }
      catch (Throwable e)
      {
         ctx.state = ServiceContext.FAILED;
         ctx.problem = e;
         log.warn("Problem creating service " + serviceName, e);
         return;
      }

      // Those that depend on me are waiting for my creation, recursively create them
      log.debug("Creating dependent components for: " + serviceName
            + " dependents are: " + ctx.dependsOnMe);
      ArrayList<ServiceContext> tmp = new ArrayList<ServiceContext>(ctx.dependsOnMe);
      for (int n = 0; n < tmp.size(); n++)
      {
         // marcf fixme circular dependencies?
         ServiceContext ctx2 = tmp.get(n);
         create(ctx2.objectName);
      }
      tmp.clear();
   }

   public synchronized 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);

      ServiceContext ctx = createServiceContext(serviceName);

      if (!installedServices.contains(ctx))
         installedServices.add(ctx);

      // 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);
         return;
      }

      // Start() is called before create(), so call create() to compensate
      if (ctx.state != ServiceContext.CREATED && ctx.state != ServiceContext.STOPPED)
      {
         log.debug("Start requested before create, calling create now for service: " + serviceName);
         create(serviceName);
      }
      
      // Get the fancy service proxy (for the lifecycle API)
      if (ctx.proxy == null)
         ctx.proxy = getServiceProxy(ctx.objectName, null);

      // JSR 77, and to avoid circular dependencies
      int oldState = ctx.state;
      ctx.state = ServiceContext.RUNNING;

      // Are all the mbeans I depend on started?   if not just return
      for (Iterator iterator = ctx.iDependOn.iterator(); iterator.hasNext();)
      {
         ServiceContext sctx = (ServiceContext) iterator.next();

         int state = sctx.state;

         // A dependent is not running
         if (!(state == ServiceContext.RUNNING))
         {
            log.debug("waiting in start " + serviceName + " on " + sctx.objectName);
            ctx.state = oldState;
            return;
         }
      }

      // Call start on the service Proxy
      try
      {
         ctx.proxy.start();
         sendControllerNotification(ServiceMBean.START_EVENT, serviceName);            
      }
      catch (Throwable e)
      {
         ctx.state = ServiceContext.FAILED;
         ctx.problem = e;
         log.warn("Problem starting service " + serviceName, e);
         return;
      }
      // Those that depend on me are waiting for my start, recursively start them
      log.debug("Starting dependent components for: " + serviceName
            + " dependent components: " + ctx.dependsOnMe);
      ArrayList<ServiceContext> tmp = new ArrayList<ServiceContext>(ctx.dependsOnMe);
      for (int n = 0; n < tmp.size(); n++)
      {
         // marcf fixme circular dependencies?
         ServiceContext ctx2 = tmp.get(n);
         start(ctx2.objectName);
      }
      tmp.clear();
   }

   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 stop(ObjectName serviceName) throws Exception
   {
      if (serviceName == null)
      {
         log.warn("Ignoring request to stop null service: ", new Exception("STACKTRACE"));
         return;
      }

      ServiceContext ctx = nameToServiceMap.get(serviceName);
      log.debug("stopping service: " + serviceName);

      if (ctx == null)
      {
         log.warn("Ignoring request to stop nonexistent service: " + serviceName);
         return;
      }

      // If we are already stopped (can happen in dependencies) just return
      if (ctx.state != ServiceContext.RUNNING) return;

      // JSR 77 and to avoid circular dependencies
      ctx.state = ServiceContext.STOPPED;

      log.debug("stopping dependent services for: " + serviceName
            + " dependent services are: " + ctx.dependsOnMe);
      
      ArrayList<ServiceContext> tmp = new ArrayList<ServiceContext>(ctx.dependsOnMe);
      for (int n = 0; n < tmp.size(); n++)
      {
         // stop all the mbeans that depend on me
         ServiceContext ctx2 = tmp.get(n);
         ObjectName other = ctx2.objectName;
         stop(other);
      }
      tmp.clear();

      // Call stop on the service Proxy
      if (ctx.proxy != null)
      {
         try
         {
            ctx.proxy.stop();
            sendControllerNotification(ServiceMBean.STOP_EVENT, serviceName);
         }
         catch (Throwable e)
         {
            ctx.state = ServiceContext.FAILED;
            ctx.problem = e;
            log.warn("Problem stopping service " + serviceName, e);
         }
      }
   }

   public void destroy(ObjectName serviceName) throws Exception
   {
      if (serviceName == null)
      {
         log.warn("Ignoring request to destroy null service: ", new Exception("STACKTRACE"));
         return;
      }

      ServiceContext ctx = nameToServiceMap.get(serviceName);
      log.debug("destroying service: " + serviceName);

      if (ctx == null)
      {
         log.warn("Ignoring request to destroy nonexistent service: " + serviceName);
         return;
      }

      // If we are already destroyed (can happen in dependencies) just return
      if (ctx.state == ServiceContext.DESTROYED ||
          ctx.state == ServiceContext.NOTYETINSTALLED)
         return;
      
      // If we are still running, stop service first
      if (ctx.state == ServiceContext.RUNNING)
      {
         log.debug("Destroy requested before stop, calling stop now for service: " + serviceName);
         stop(serviceName);
      }

      // JSR 77, and to avoid circular dependencies
      ctx.state = ServiceContext.DESTROYED;

      log.debug("destroying dependent services for: " + serviceName
            + " dependent services are: " + ctx.dependsOnMe);
      
      ArrayList<ServiceContext> tmp = new ArrayList<ServiceContext>(ctx.dependsOnMe);
      for (int n = 0; n < tmp.size(); n++)
      {
         // destroy all the mbeans that depend on me
         ServiceContext ctx2 = tmp.get(n);
         ObjectName other = ctx2.objectName;
         destroy(other);
      }
      tmp.clear();

      // Call destroy on the service Proxy
      if (ctx.proxy != null)
      {
         try
         {
            ctx.proxy.destroy();
            sendControllerNotification(ServiceMBean.DESTROY_EVENT, serviceName);
         }
         catch (Throwable e)
         {
            ctx.state = ServiceContext.FAILED;
            ctx.problem = e;
            log.warn("Problem destroying service " + serviceName, e);
         }
      }
   }

   public void remove(ObjectName objectName) throws Exception
   {
      if (objectName == null)
      {
         log.warn("Ignoring request to remove null service: ", new Exception("STACKTRACE"));
         return;
      }

      ServiceContext ctx = nameToServiceMap.get(objectName);
      if (ctx == null)
      {
         log.debug("Ignoring request to remove nonexistent service: " + objectName);
         return;
      }
      log.debug("removing service: " + objectName);

      // Notify those that think I depend on them
      Iterator iterator = ctx.iDependOn.iterator();
      while (iterator.hasNext())
      {
         ServiceContext iDependOnContext = (ServiceContext) iterator.next();
         iDependOnContext.dependsOnMe.remove(ctx);

         // Remove any context whose only reason for existence is that
         // we depend on it, i.e. it otherwise unknown to the system
         if (iDependOnContext.state == ServiceContext.NOTYETINSTALLED
               && iDependOnContext.dependsOnMe.size() == 0)
         {
            nameToServiceMap.remove(iDependOnContext.objectName);
            log.debug("Removing context for nonexistent service it is " +
                  "no longer recording dependencies: " + iDependOnContext);
         }
      }
      //We remove all traces of our dependency configuration, since we
      //don't know what will show up the next time we are deployed.
      ctx.iDependOn.clear();

      // Do we have a deployed MBean?
      if (server.isRegistered(objectName))
      {
         log.debug("removing " + objectName + " from server");

         // Remove the context, unless it is still recording dependencies
         if (ctx.dependsOnMe.size() == 0)
            nameToServiceMap.remove(objectName);
         else
         {
            log.debug("Context not removed, it is recording " +
                  "dependencies: " + ctx);
            ctx.proxy = null;
         }

         // remove the mbean from the instaled ones
         installedServices.remove(ctx);
         creator.remove(objectName);
      }
      else
      {
         // Remove the context, unless it is still recording dependencies
         installedServices.remove(ctx);
         if (ctx.dependsOnMe.size() == 0)
         {
            log.debug("removing already unregistered " + objectName + " from server");
            nameToServiceMap.remove(objectName);
         }
         else
         {
            log.debug("no need to remove " + objectName + " from server");
            ctx.proxy = null;
         }
      }
      // This context is no longer installed, but it may still exist
      // to record dependent services
      ctx.state = ServiceContext.NOTYETINSTALLED;
   }

   /**
    * Lookup the ServiceContext for the given serviceName
    *
    * @jmx.managed-operation
    */
   public ServiceContext getServiceContext(ObjectName serviceName)
   {
      ServiceContext ctx = nameToServiceMap.get(serviceName);
      return ctx;
   }
   
   public void shutdown()
   {
      log.debug("Stopping " + nameToServiceMap.size() + " services");

      List<ServiceContext> servicesCopy = new ArrayList<ServiceContext>(installedServices);

      int serviceCounter = 0;
      ObjectName name = null;

      ListIterator i = servicesCopy.listIterator(servicesCopy.size());
      while (i.hasPrevious())
      {
         ServiceContext ctx = (ServiceContext) i.previous();
         name = ctx.objectName;

         // Go through the full stop/destroy cycle
         try
         {
            stop(name);
         }
         catch (Throwable e)
         {
            log.error("Could not stop mbean: " + name, e);
         }
         try
         {
            destroy(name);
         }
         catch (Throwable e)
         {
            log.error("Could not destroy mbean: " + name, e);
         }
         try
         {
            remove(name);
            serviceCounter++;
         }
         catch (Throwable e)
         {
            log.error("Could not remove mbean: " + name, e);
         }
      }
      log.debug("Stopped " + serviceCounter + " services");
   }
   
   // MBeanRegistration implementation ----------------------------------------

   /**
    * #Description of the Method
    *
    * @param server Description of Parameter
    * @param name Description of Parameter
    * @return Description of the Returned Value
    * @exception Exception Description of Exception
    */
   public ObjectName preRegister(MBeanServer server, ObjectName name)
         throws Exception
   {
      this.server = server;

      creator = new OldServiceCreator(server);
      configurator = new OldServiceConfigurator(server, this, creator);

      // Register the ServiceController as a running service
      ServiceContext sc = this.createServiceContext(name);
      sc.state = ServiceContext.RUNNING;

      log.debug("Controller MBean online");
      return name == null ? OBJECT_NAME : name;
   }

   public void postRegister(Boolean registrationDone)
   {
      if (!registrationDone.booleanValue())
      {
         log.info("Registration of ServiceController failed");
      }
   }

   public void preDeregister()
         throws Exception
   {
   }

   public void postDeregister()
   {
      nameToServiceMap.clear();
      installedServices.clear();
      creator.shutdown();
      creator = null;
      configurator = null;
      server = null;
   }

   // Package Protected ---------------------------------------------
   
   // Create a Service Context for the service, or get one if it exists
   synchronized ServiceContext createServiceContext(ObjectName objectName)
   {
      // If it is already there just return it
      if (nameToServiceMap.containsKey(objectName))
         return nameToServiceMap.get(objectName);

      // If not create it, add it and return it
      ServiceContext ctx = new ServiceContext();
      ctx.objectName = objectName;

      // we keep track of these here
      nameToServiceMap.put(objectName, ctx);

      return ctx;
   }

   void registerDependency(ObjectName needs, ObjectName used)
   {
      log.debug("recording that " + needs + " depends on " + used);
      ServiceContext needsCtx = createServiceContext(needs);
      ServiceContext usedCtx = createServiceContext(used);


      if (!needsCtx.iDependOn.contains(usedCtx))
      {
         // needsCtx depends on usedCtx
         needsCtx.iDependOn.add(usedCtx);
         // UsedCtx needs to know I depend on him
         usedCtx.dependsOnMe.add(needsCtx);
      }
   }

   // Private -------------------------------------------------------
   
   /**
    * Register the service context and its dependencies against the microkernel.
    * If the context is already registered it does nothing.
    * 
    * @param ctx the ServiceContext to register
    * @param depends a collection of ObjectNames of services the registered service depends on
    */
   private void register(ServiceContext ctx, Collection depends) throws Exception
   {
      if (!installedServices.contains(ctx))
         installedServices.add(ctx);
      
      if (depends != null)
      {
         log.debug("adding depends in ServiceController.register: " + depends);
         for (Iterator i = depends.iterator(); i.hasNext();)
         {
            registerDependency(ctx.objectName, (ObjectName) i.next());
         }
      }

      // Get the fancy service proxy (for the lifecycle API), if needed
      if (ctx.proxy == null)
         ctx.proxy = getServiceProxy(ctx.objectName, null);
   }
   
   /**
    * Get the Service interface through which the mbean given by objectName
    * will be managed.
    *
    * @param objectName
    * @param serviceFactory
    * @return The Service value
    *
    * @throws ClassNotFoundException
    * @throws InstantiationException
    * @throws IllegalAccessException
    */
   private Service getServiceProxy(ObjectName objectName, String serviceFactory)
         throws ClassNotFoundException, InstantiationException,
         IllegalAccessException, JMException
   {
      Service service = null;
      ClassLoader loader = Thread.currentThread().getContextClassLoader();
      if (serviceFactory != null && serviceFactory.length() > 0)
      {
         Class clazz = loader.loadClass(serviceFactory);
         ServiceFactory factory = (ServiceFactory) clazz.newInstance();
         service = factory.createService(server, objectName);
      }
      else
      {
         MBeanInfo info = server.getMBeanInfo(objectName);
         MBeanOperationInfo[] opInfo = info.getOperations();
         Class[] interfaces = {Service.class};
         InvocationHandler handler = new ServiceProxy(objectName, opInfo);
         service = (Service) Proxy.newProxyInstance(Service.class.getClassLoader(), interfaces, handler);
      }

      return service;
   }

   /**
    * Sends outs controller notifications about service lifecycle events 
    */
   private void sendControllerNotification(String type, ObjectName serviceName)
   {
      Notification notification = new Notification(type, this, super.nextNotificationSequenceNumber());
      notification.setUserData(serviceName);
      sendNotification(notification);
   }
   
   // Inner classes -------------------------------------------------

   /**
    * A mapping from the Service interface method names to the corresponding
    * index into the ServiceProxy.hasOp array.
    */
   private static HashMap<String, Integer> serviceOpMap = new HashMap<String, Integer>();

   /**
    * An implementation of InvocationHandler used to proxy of the Service
    * interface for mbeans. It determines which of the start/stop
    * methods of the Service interface an mbean implements by inspecting its
    * MBeanOperationInfo values. Each Service interface method that has a
    * matching operation is forwarded to the mbean by invoking the method
    * through the MBeanServer object.
    */
   public class ServiceProxy implements InvocationHandler
   {
      private boolean[] hasOp = {false, false, false, false};
      private ObjectName objectName;

      /** Whether we have the lifecycle method */
      private boolean hasJBossInternalLifecycle;

      /**
       * Go through the opInfo array and for each operation that matches on of
       * the Service interface methods set the corresponding hasOp array value
       * to true.
       *
       * @param objectName
       * @param opInfo
       */
      public ServiceProxy(ObjectName objectName, MBeanOperationInfo[] opInfo)
      {
         this.objectName = objectName;

         for (int op = 0; op < opInfo.length; op++)
         {
            MBeanOperationInfo info = opInfo[op];
            String name = info.getName();

            if (name.equals(JBOSS_INTERNAL_LIFECYCLE))
            {
               hasJBossInternalLifecycle = true;
               continue;
            }

            Integer opID = serviceOpMap.get(name);
            if (opID == null)
            {
               continue;
            }

            // Validate that is a no-arg void return type method
            if (info.getReturnType().equals("void") == false)
            {
               continue;
            }
            if (info.getSignature().length != 0)
            {
               continue;
            }

            hasOp[opID.intValue()] = true;
         }
      }

      /**
       * Map the method name to a Service interface method index and if the
       * corresponding hasOp array element is true, dispatch the method to the
       * mbean we are proxying.
       *
       * @param proxy
       * @param method
       * @param args
       * @return             Always null.
       * @throws Throwable
       */
      public Object invoke(Object proxy, Method method, Object[] args)
            throws Throwable
      {
         String name = method.getName();

         if (hasJBossInternalLifecycle)
         {
            try
            {
               server.invoke(objectName, JBOSS_INTERNAL_LIFECYCLE, new Object[] { name }, JBOSS_INTERNAL_LIFECYCLE_SIG);
               return null;
            }
            catch (Exception e)
            {
               throw JMXExceptionDecoder.decode(e);
            }
         }

         Integer opID = serviceOpMap.get(name);

         if (opID != null && hasOp[opID.intValue()] == true)
         {
            // deal with those pesky JMX exceptions
            try
            {
               String[] sig = {};
               server.invoke(objectName, name, args, sig);
            }
            catch (Exception e)
            {
               throw JMXExceptionDecoder.decode(e);
            }
         }

         return null;
      }
   }

   /**
    * Initialize the service operation map.
    */
   static
   {
      serviceOpMap.put("create", new Integer(0));
      serviceOpMap.put("start", new Integer(1));
      serviceOpMap.put("destroy", new Integer(2));
      serviceOpMap.put("stop", new Integer(3));
   }
}
