github.com/TIBCOSoftware/flogo-lib@v0.5.9/util/service.go (about)

     1  package util
     2  
     3  import (
     4  	"errors"
     5  	"sync"
     6  
     7  	"github.com/TIBCOSoftware/flogo-lib/util/managed"
     8  )
     9  
    10  // Service is an interface for defining/managing a service
    11  type Service interface {
    12  	managed.Managed
    13  
    14  	Name() string
    15  	Enabled() bool
    16  }
    17  
    18  // ServiceConfig is a simple service configuration object
    19  type ServiceConfig struct {
    20  	Name     string            `json:"name"`
    21  	Enabled  bool              `json:"enabled"`
    22  	Settings map[string]string `json:"settings,omitempty"`
    23  }
    24  
    25  // ServiceManager is a simple service manager
    26  type ServiceManager struct {
    27  	servicesMu sync.Mutex
    28  	services   map[string]Service
    29  	started    []Service
    30  }
    31  
    32  var defaultServiceManager *ServiceManager
    33  
    34  func init() {
    35  	defaultServiceManager = NewServiceManager()
    36  }
    37  
    38  func GetDefaultServiceManager() *ServiceManager {
    39  	return defaultServiceManager
    40  }
    41  
    42  // NewServiceManager creates a new ServiceManager
    43  func NewServiceManager() *ServiceManager {
    44  
    45  	var manager ServiceManager
    46  	manager.services = make(map[string]Service)
    47  
    48  	return &manager
    49  }
    50  
    51  // RegisterService registers the specified service
    52  func (sm *ServiceManager) RegisterService(service Service) error {
    53  	sm.servicesMu.Lock()
    54  	defer sm.servicesMu.Unlock()
    55  
    56  	if service == nil {
    57  		panic("ServiceManager.RegisterService: service is nil")
    58  	}
    59  
    60  	serviceName := service.Name()
    61  
    62  	if _, dup := sm.services[serviceName]; dup {
    63  		return errors.New("service already registered: " + serviceName)
    64  	}
    65  
    66  	sm.services[serviceName] = service
    67  
    68  	return nil
    69  }
    70  
    71  // Services gets all the registered Service Services
    72  func (sm *ServiceManager) Services() []Service {
    73  
    74  	sm.servicesMu.Lock()
    75  	defer sm.servicesMu.Unlock()
    76  
    77  	return sm.allServices()
    78  }
    79  
    80  // Services gets all the registered Service Services
    81  func (sm *ServiceManager) allServices() []Service {
    82  
    83  	var curServices = sm.services
    84  
    85  	list := make([]Service, 0, len(curServices))
    86  
    87  	for _, value := range curServices {
    88  		list = append(list, value)
    89  	}
    90  
    91  	return list
    92  }
    93  
    94  // GetService gets specified Service
    95  func (sm *ServiceManager) GetService(name string) Service {
    96  
    97  	sm.servicesMu.Lock()
    98  	defer sm.servicesMu.Unlock()
    99  
   100  	return sm.services[name]
   101  }
   102  
   103  // Start implements util.Managed.Start()
   104  func (sm *ServiceManager) Start() error {
   105  
   106  	sm.servicesMu.Lock()
   107  	defer sm.servicesMu.Unlock()
   108  
   109  	if len(sm.started) == 0 {
   110  		services := sm.allServices()
   111  
   112  		sm.started = make([]Service, 0, len(services))
   113  
   114  		for _, service := range services {
   115  
   116  			if service.Enabled() {
   117  				err := managed.Start(service.Name(), service)
   118  
   119  				if err == nil {
   120  					sm.started = append(sm.started, service)
   121  				} else {
   122  					return err
   123  				}
   124  			}
   125  		}
   126  	}
   127  
   128  	return nil
   129  }
   130  
   131  // Stop implements util.Managed.Stop()
   132  func (sm *ServiceManager) Stop() error {
   133  
   134  	sm.servicesMu.Lock()
   135  	defer sm.servicesMu.Unlock()
   136  
   137  	var err error
   138  
   139  	if len(sm.started) > 0 {
   140  
   141  		var notStopped []Service
   142  
   143  		for _, service := range sm.started {
   144  
   145  			err = managed.Stop(service.Name(), service)
   146  
   147  			if err != nil {
   148  				notStopped = append(notStopped, service)
   149  			}
   150  		}
   151  
   152  		sm.started = notStopped
   153  	}
   154  
   155  	return err
   156  }