wamblee.org Git - utils/blob - system/general/src/main/java/org/wamblee/system/AbstractSubSystem.java

   1 package org.wamblee.system;
   2
   3 import java.util.ArrayList;
   4 import java.util.Arrays;
   5 import java.util.HashMap;
   6 import java.util.List;
   7 import java.util.Map;
   8
   9 import org.apache.commons.logging.Log;
  10 import org.apache.commons.logging.LogFactory;
  11
  12 /**
  13  * Abstract subsystem class making it easy to implement new subsystems.
  14  */
  15 public abstract class AbstractSubSystem implements SubSystem {
  16
  17         private static final Log LOG = LogFactory.getLog(AbstractSubSystem.class);
  18
  19         private String _name;
  20         private List<ServiceDescriptor> _provided;
  21         private List<ServiceDescriptor> _required;
  22         private Map<ServiceDescriptor, Service> _running;
  23
  24         /**
  25          * Constructs the subsystem.
  26          *
  27          * @param aRegistry
  28          *            Registry of services.
  29          * @param aName
  30          *            Name of the system.
  31          * @param aProvided
  32          *            Provided services.
  33          * @param aRequired
  34          *            Required services.
  35          */
  36         protected AbstractSubSystem(String aName, ServiceDescriptor[] aProvided,
  37                         ServiceDescriptor[] aRequired) {
  38                 _name = aName;
  39                 _provided = new ArrayList<ServiceDescriptor>();
  40                 _provided.addAll(Arrays.asList(aProvided));
  41                 _required = new ArrayList<ServiceDescriptor>();
  42                 _required.addAll(Arrays.asList(aRequired));
  43                 _running = new HashMap<ServiceDescriptor, Service>();
  44         }
  45
  46         @Override
  47         public final String getName() {
  48                 return _name;
  49         }
  50
  51         @Override
  52         public final ServiceDescriptor[] getProvidedServices() {
  53                 return _provided.toArray(new ServiceDescriptor[0]);
  54         }
  55
  56         @Override
  57         public final ServiceDescriptor[] getRequiredServices() {
  58                 return _required.toArray(new ServiceDescriptor[0]);
  59         }
  60
  61         @Override
  62         public final Service[] start(String aContext, ServiceRegistry aRegistry,
  63                         Service[] aRequiredServices) {
  64                 LOG.info("Initializing '" + aContext + "." + _name + "' with "
  65                                 + Arrays.asList(aRequiredServices));
  66                 doStart(aContext + "." + getName(), aRegistry, aRequiredServices);
  67                 return _running.values().toArray(new Service[0]);
  68         }
  69
  70         /**
  71          * Must be implemented for initializing the subsystem. The implementation
  72          * must call {@link #addService(Service)} for each service that is started.
  73          *
  74          * @param aRegistry Service registry.
  75          * @param aRequiredServices
  76          *            Services that are already running from other subsystems that
  77          *            may be used.
  78          */
  79         protected abstract void doStart(String aContext,
  80                         ServiceRegistry aRegistry,
  81                         Service[] aRequiredServices);
  82
  83         /**
  84          * Implementations must call this method to indicate that a new service has
  85          * been started.
  86          *
  87          * @param aService
  88          *            Service.
  89          */
  90         protected final void addService(String aContext,
  91                         ServiceRegistry aRegistry,
  92                         ServiceDescriptor aDescriptor, Object aService) {
  93                 LOG.info(aContext + ": service '" + aService + "' started.");
  94                 Service svc = aRegistry.register(aDescriptor, aService);
  95                 _running.put(svc.getDescriptor(), svc);
  96         }
  97
  98         @Override
  99         public Service[] getRunningServices() {
 100                 return _running.values().toArray(new Service[0]);
 101         }
 102
 103         @Override
 104         public void stop(String aContext, ServiceRegistry aRegistry) {
 105                 doStop(aContext);
 106                 for (Service svc: _running.values()) {
 107                         aRegistry.remove(svc);
 108                 }
 109         }
 110
 111         protected abstract void doStop(String aContext);
 112
 113         @Override
 114         public String toString() {
 115                 return _name;
 116         }
 117
 118 }