2019-09-14 06:33:14 +02:00
|
|
|
package runtime
|
|
|
|
|
|
|
|
import (
|
|
|
|
"errors"
|
|
|
|
"sync"
|
|
|
|
"time"
|
|
|
|
|
|
|
|
"github.com/micro/go-micro/util/log"
|
|
|
|
)
|
|
|
|
|
|
|
|
type runtime struct {
|
|
|
|
sync.RWMutex
|
2019-11-02 15:25:10 +02:00
|
|
|
// options configure runtime
|
|
|
|
options Options
|
2019-09-14 17:07:36 +02:00
|
|
|
// used to stop the runtime
|
|
|
|
closed chan bool
|
|
|
|
// used to start new services
|
|
|
|
start chan *service
|
|
|
|
// indicates if we're running
|
|
|
|
running bool
|
|
|
|
// the service map
|
2019-11-15 15:41:40 +02:00
|
|
|
// TODO: track different versions of the same service
|
2019-09-14 06:33:14 +02:00
|
|
|
services map[string]*service
|
|
|
|
}
|
|
|
|
|
2019-11-02 15:25:10 +02:00
|
|
|
// NewRuntime creates new local runtime and returns it
|
|
|
|
func NewRuntime(opts ...Option) Runtime {
|
|
|
|
// get default options
|
|
|
|
options := Options{}
|
2019-09-14 06:33:14 +02:00
|
|
|
|
2019-11-02 15:25:10 +02:00
|
|
|
// apply requested options
|
|
|
|
for _, o := range opts {
|
|
|
|
o(&options)
|
|
|
|
}
|
2019-09-14 06:33:14 +02:00
|
|
|
|
|
|
|
return &runtime{
|
2019-11-02 15:25:10 +02:00
|
|
|
options: options,
|
2019-09-14 06:33:14 +02:00
|
|
|
closed: make(chan bool),
|
2019-09-14 17:07:36 +02:00
|
|
|
start: make(chan *service, 128),
|
2019-09-14 06:33:14 +02:00
|
|
|
services: make(map[string]*service),
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-11-02 15:25:10 +02:00
|
|
|
// Init initializes runtime options
|
|
|
|
func (r *runtime) Init(opts ...Option) error {
|
|
|
|
r.Lock()
|
|
|
|
defer r.Unlock()
|
2019-09-14 06:33:14 +02:00
|
|
|
|
2019-11-02 15:25:10 +02:00
|
|
|
for _, o := range opts {
|
|
|
|
o(&r.options)
|
2019-09-14 06:33:14 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2019-11-02 15:25:10 +02:00
|
|
|
// run runs the runtime management loop
|
|
|
|
func (r *runtime) run(events <-chan Event) {
|
2019-09-24 19:05:51 +02:00
|
|
|
t := time.NewTicker(time.Second * 5)
|
|
|
|
defer t.Stop()
|
|
|
|
|
2019-11-26 19:33:41 +02:00
|
|
|
// process event processes an incoming event
|
|
|
|
processEvent := func(event Event, service *service) error {
|
|
|
|
// get current vals
|
|
|
|
r.RLock()
|
|
|
|
name := service.Name
|
|
|
|
updated := service.updated
|
|
|
|
r.RUnlock()
|
|
|
|
|
|
|
|
// only process if the timestamp is newer
|
|
|
|
if !event.Timestamp.After(updated) {
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
|
|
|
log.Debugf("Runtime updating service %s", name)
|
|
|
|
|
|
|
|
// this will cause a delete followed by created
|
|
|
|
if err := r.Update(service.Service); err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
|
|
|
// update the local timestamp
|
|
|
|
r.Lock()
|
|
|
|
service.updated = updated
|
|
|
|
r.Unlock()
|
|
|
|
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2019-09-24 19:05:51 +02:00
|
|
|
for {
|
|
|
|
select {
|
|
|
|
case <-t.C:
|
|
|
|
// check running services
|
|
|
|
r.RLock()
|
|
|
|
for _, service := range r.services {
|
|
|
|
if service.Running() {
|
|
|
|
continue
|
|
|
|
}
|
|
|
|
|
|
|
|
// TODO: check service error
|
|
|
|
log.Debugf("Runtime starting %s", service.Name)
|
|
|
|
if err := service.Start(); err != nil {
|
|
|
|
log.Debugf("Runtime error starting %s: %v", service.Name, err)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
r.RUnlock()
|
|
|
|
case service := <-r.start:
|
|
|
|
if service.Running() {
|
|
|
|
continue
|
|
|
|
}
|
|
|
|
// TODO: check service error
|
2019-11-02 15:25:10 +02:00
|
|
|
log.Debugf("Runtime starting service %s", service.Name)
|
2019-09-24 19:05:51 +02:00
|
|
|
if err := service.Start(); err != nil {
|
2019-11-02 15:25:10 +02:00
|
|
|
log.Debugf("Runtime error starting service %s: %v", service.Name, err)
|
|
|
|
}
|
|
|
|
case event := <-events:
|
|
|
|
log.Debugf("Runtime received notification event: %v", event)
|
|
|
|
// NOTE: we only handle Update events for now
|
|
|
|
switch event.Type {
|
|
|
|
case Update:
|
|
|
|
if len(event.Service) > 0 {
|
2019-11-14 16:26:21 +02:00
|
|
|
r.RLock()
|
2019-11-02 15:25:10 +02:00
|
|
|
service, ok := r.services[event.Service]
|
2019-11-14 16:26:21 +02:00
|
|
|
r.RUnlock()
|
2019-11-02 15:25:10 +02:00
|
|
|
if !ok {
|
|
|
|
log.Debugf("Runtime unknown service: %s", event.Service)
|
|
|
|
continue
|
|
|
|
}
|
2019-11-26 19:33:41 +02:00
|
|
|
if err := processEvent(event, service); err != nil {
|
2019-11-02 15:25:10 +02:00
|
|
|
log.Debugf("Runtime error updating service %s: %v", event.Service, err)
|
|
|
|
}
|
|
|
|
continue
|
|
|
|
}
|
2019-11-26 19:33:41 +02:00
|
|
|
|
|
|
|
r.RLock()
|
|
|
|
services := r.services
|
|
|
|
r.RUnlock()
|
|
|
|
|
2019-11-02 15:25:10 +02:00
|
|
|
// if blank service was received we update all services
|
2019-11-26 19:33:41 +02:00
|
|
|
for _, service := range services {
|
|
|
|
if err := processEvent(event, service); err != nil {
|
2019-11-02 15:25:10 +02:00
|
|
|
log.Debugf("Runtime error updating service %s: %v", service.Name, err)
|
|
|
|
}
|
|
|
|
}
|
2019-09-24 19:05:51 +02:00
|
|
|
}
|
2019-11-02 15:25:10 +02:00
|
|
|
case <-r.closed:
|
2019-12-11 16:37:03 +02:00
|
|
|
log.Debugf("Runtime stopped")
|
2019-09-24 19:05:51 +02:00
|
|
|
return
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-11-02 15:25:10 +02:00
|
|
|
// Create creates a new service which is then started by runtime
|
2019-09-24 19:32:35 +02:00
|
|
|
func (r *runtime) Create(s *Service, opts ...CreateOption) error {
|
2019-09-14 06:33:14 +02:00
|
|
|
r.Lock()
|
|
|
|
defer r.Unlock()
|
|
|
|
|
|
|
|
if _, ok := r.services[s.Name]; ok {
|
|
|
|
return errors.New("service already registered")
|
|
|
|
}
|
|
|
|
|
2019-09-24 19:32:35 +02:00
|
|
|
var options CreateOptions
|
|
|
|
for _, o := range opts {
|
|
|
|
o(&options)
|
|
|
|
}
|
|
|
|
|
2019-11-29 13:35:00 +02:00
|
|
|
if len(options.Command) == 0 {
|
2019-09-24 19:32:35 +02:00
|
|
|
return errors.New("missing exec command")
|
|
|
|
}
|
|
|
|
|
2019-12-24 19:51:30 +02:00
|
|
|
// create new service
|
|
|
|
service := newService(s, options)
|
|
|
|
|
|
|
|
// start the service
|
|
|
|
if err := service.Start(); err != nil {
|
|
|
|
return err
|
|
|
|
}
|
2019-09-14 06:33:14 +02:00
|
|
|
|
2019-12-24 19:51:30 +02:00
|
|
|
// save service
|
|
|
|
r.services[s.Name] = service
|
2019-09-14 17:07:36 +02:00
|
|
|
|
2019-09-14 06:33:14 +02:00
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2019-11-25 18:31:14 +02:00
|
|
|
// Read returns all instances of requested service
|
2019-11-15 15:41:40 +02:00
|
|
|
// If no service name is provided we return all the track services.
|
2019-11-29 13:35:00 +02:00
|
|
|
func (r *runtime) Read(opts ...ReadOption) ([]*Service, error) {
|
2019-09-14 06:58:03 +02:00
|
|
|
r.Lock()
|
|
|
|
defer r.Unlock()
|
|
|
|
|
2019-11-25 18:31:14 +02:00
|
|
|
gopts := ReadOptions{}
|
2019-11-15 15:41:40 +02:00
|
|
|
for _, o := range opts {
|
|
|
|
o(&gopts)
|
|
|
|
}
|
|
|
|
|
2019-11-29 13:35:00 +02:00
|
|
|
save := func(k, v string) bool {
|
|
|
|
if len(k) == 0 {
|
|
|
|
return true
|
|
|
|
}
|
|
|
|
return k == v
|
|
|
|
}
|
|
|
|
|
2019-12-03 21:59:44 +02:00
|
|
|
//nolint:prealloc
|
2019-11-15 15:41:40 +02:00
|
|
|
var services []*Service
|
2019-11-29 13:35:00 +02:00
|
|
|
|
|
|
|
for _, service := range r.services {
|
|
|
|
if !save(gopts.Service, service.Name) {
|
|
|
|
continue
|
2019-11-15 15:41:40 +02:00
|
|
|
}
|
2019-11-29 13:35:00 +02:00
|
|
|
if !save(gopts.Version, service.Version) {
|
|
|
|
continue
|
|
|
|
}
|
|
|
|
// TODO deal with service type
|
2019-11-15 15:41:40 +02:00
|
|
|
// no version has sbeen requested, just append the service
|
2019-11-29 13:35:00 +02:00
|
|
|
services = append(services, service.Service)
|
2019-11-15 15:41:40 +02:00
|
|
|
}
|
2019-11-29 13:35:00 +02:00
|
|
|
|
2019-11-15 15:41:40 +02:00
|
|
|
return services, nil
|
2019-09-14 06:58:03 +02:00
|
|
|
}
|
|
|
|
|
2019-11-02 15:25:10 +02:00
|
|
|
// Update attemps to update the service
|
2019-10-29 14:29:21 +02:00
|
|
|
func (r *runtime) Update(s *Service) error {
|
2019-11-14 16:26:21 +02:00
|
|
|
var opts []CreateOption
|
|
|
|
|
|
|
|
// check if the service already exists
|
|
|
|
r.RLock()
|
|
|
|
if service, ok := r.services[s.Name]; ok {
|
|
|
|
opts = append(opts, WithOutput(service.output))
|
|
|
|
}
|
|
|
|
r.RUnlock()
|
|
|
|
|
2019-10-29 14:29:21 +02:00
|
|
|
// delete the service
|
|
|
|
if err := r.Delete(s); err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
|
|
|
// create new service
|
2019-11-14 16:26:21 +02:00
|
|
|
return r.Create(s, opts...)
|
2019-10-29 14:29:21 +02:00
|
|
|
}
|
|
|
|
|
2019-11-15 15:41:40 +02:00
|
|
|
// Delete removes the service from the runtime and stops it
|
|
|
|
func (r *runtime) Delete(s *Service) error {
|
|
|
|
r.Lock()
|
|
|
|
defer r.Unlock()
|
|
|
|
|
|
|
|
log.Debugf("Runtime deleting service %s", s.Name)
|
|
|
|
if s, ok := r.services[s.Name]; ok {
|
|
|
|
// check if running
|
|
|
|
if !s.Running() {
|
|
|
|
delete(r.services, s.Name)
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
// otherwise stop it
|
|
|
|
if err := s.Stop(); err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
// delete it
|
|
|
|
delete(r.services, s.Name)
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2019-11-02 15:25:10 +02:00
|
|
|
// List returns a slice of all services tracked by the runtime
|
2019-10-29 14:29:21 +02:00
|
|
|
func (r *runtime) List() ([]*Service, error) {
|
|
|
|
r.RLock()
|
|
|
|
defer r.RUnlock()
|
|
|
|
|
2019-12-03 21:59:44 +02:00
|
|
|
services := make([]*Service, 0, len(r.services))
|
|
|
|
|
2019-10-29 14:29:21 +02:00
|
|
|
for _, service := range r.services {
|
|
|
|
services = append(services, service.Service)
|
|
|
|
}
|
|
|
|
|
|
|
|
return services, nil
|
|
|
|
}
|
|
|
|
|
2019-11-02 15:25:10 +02:00
|
|
|
// Start starts the runtime
|
2019-09-14 06:58:03 +02:00
|
|
|
func (r *runtime) Start() error {
|
2019-09-14 06:33:14 +02:00
|
|
|
r.Lock()
|
2019-09-24 19:05:51 +02:00
|
|
|
defer r.Unlock()
|
2019-09-14 06:33:14 +02:00
|
|
|
|
|
|
|
// already running
|
|
|
|
if r.running {
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
|
|
|
// set running
|
|
|
|
r.running = true
|
|
|
|
r.closed = make(chan bool)
|
2019-09-14 17:07:36 +02:00
|
|
|
|
2019-11-02 15:25:10 +02:00
|
|
|
var events <-chan Event
|
|
|
|
if r.options.Notifier != nil {
|
|
|
|
var err error
|
|
|
|
events, err = r.options.Notifier.Notify()
|
|
|
|
if err != nil {
|
|
|
|
// TODO: should we bail here?
|
|
|
|
log.Debugf("Runtime failed to start update notifier")
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
go r.run(events)
|
2019-09-14 06:33:14 +02:00
|
|
|
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2019-11-02 15:25:10 +02:00
|
|
|
// Stop stops the runtime
|
2019-09-14 06:33:14 +02:00
|
|
|
func (r *runtime) Stop() error {
|
|
|
|
r.Lock()
|
|
|
|
defer r.Unlock()
|
|
|
|
|
|
|
|
if !r.running {
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
|
|
|
select {
|
|
|
|
case <-r.closed:
|
|
|
|
return nil
|
|
|
|
default:
|
|
|
|
close(r.closed)
|
|
|
|
|
|
|
|
// set not running
|
|
|
|
r.running = false
|
|
|
|
|
|
|
|
// stop all the services
|
|
|
|
for _, service := range r.services {
|
2019-09-24 19:05:51 +02:00
|
|
|
log.Debugf("Runtime stopping %s", service.Name)
|
2019-09-14 06:33:14 +02:00
|
|
|
service.Stop()
|
|
|
|
}
|
2019-11-02 15:25:10 +02:00
|
|
|
// stop the notifier too
|
|
|
|
if r.options.Notifier != nil {
|
|
|
|
return r.options.Notifier.Close()
|
|
|
|
}
|
2019-09-14 06:33:14 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
return nil
|
|
|
|
}
|
2019-11-02 15:25:10 +02:00
|
|
|
|
|
|
|
// String implements stringer interface
|
|
|
|
func (r *runtime) String() string {
|
|
|
|
return "local"
|
|
|
|
}
|