micro/runtime/default.go

343 lines
6.7 KiB
Go
Raw Normal View History

2019-09-14 07:33:14 +03:00
package runtime
import (
"errors"
"sync"
"time"
"github.com/micro/go-micro/util/log"
)
type runtime struct {
sync.RWMutex
// options configure runtime
options Options
2019-09-14 18:07:36 +03: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
// TODO: track different versions of the same service
2019-09-14 07:33:14 +03:00
services map[string]*service
}
// NewRuntime creates new local runtime and returns it
func NewRuntime(opts ...Option) Runtime {
// get default options
options := Options{}
2019-09-14 07:33:14 +03:00
// apply requested options
for _, o := range opts {
o(&options)
}
2019-09-14 07:33:14 +03:00
return &runtime{
options: options,
2019-09-14 07:33:14 +03:00
closed: make(chan bool),
2019-09-14 18:07:36 +03:00
start: make(chan *service, 128),
2019-09-14 07:33:14 +03:00
services: make(map[string]*service),
}
}
// Init initializes runtime options
func (r *runtime) Init(opts ...Option) error {
r.Lock()
defer r.Unlock()
2019-09-14 07:33:14 +03:00
for _, o := range opts {
o(&r.options)
2019-09-14 07:33:14 +03:00
}
return nil
}
// run runs the runtime management loop
func (r *runtime) run(events <-chan Event) {
2019-09-24 20:05:51 +03:00
t := time.NewTicker(time.Second * 5)
defer t.Stop()
// 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 20:05:51 +03: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
log.Debugf("Runtime starting service %s", service.Name)
2019-09-24 20:05:51 +03:00
if err := service.Start(); err != nil {
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 {
r.RLock()
service, ok := r.services[event.Service]
r.RUnlock()
if !ok {
log.Debugf("Runtime unknown service: %s", event.Service)
continue
}
if err := processEvent(event, service); err != nil {
log.Debugf("Runtime error updating service %s: %v", event.Service, err)
}
continue
}
r.RLock()
services := r.services
r.RUnlock()
// if blank service was received we update all services
for _, service := range services {
if err := processEvent(event, service); err != nil {
log.Debugf("Runtime error updating service %s: %v", service.Name, err)
}
}
2019-09-24 20:05:51 +03:00
}
case <-r.closed:
2019-12-11 17:37:03 +03:00
log.Debugf("Runtime stopped")
2019-09-24 20:05:51 +03:00
return
}
}
}
// Create creates a new service which is then started by runtime
2019-09-24 20:32:35 +03:00
func (r *runtime) Create(s *Service, opts ...CreateOption) error {
2019-09-14 07:33:14 +03:00
r.Lock()
defer r.Unlock()
if _, ok := r.services[s.Name]; ok {
return errors.New("service already registered")
}
2019-09-24 20:32:35 +03:00
var options CreateOptions
for _, o := range opts {
o(&options)
}
2019-11-29 14:35:00 +03:00
if len(options.Command) == 0 {
2019-09-24 20:32:35 +03:00
return errors.New("missing exec command")
}
2019-12-24 20:51:30 +03:00
// create new service
service := newService(s, options)
// start the service
if err := service.Start(); err != nil {
return err
}
2019-09-14 07:33:14 +03:00
2019-12-24 20:51:30 +03:00
// save service
r.services[s.Name] = service
2019-09-14 18:07:36 +03:00
2019-09-14 07:33:14 +03:00
return nil
}
// Read returns all instances of requested service
// If no service name is provided we return all the track services.
2019-11-29 14:35:00 +03:00
func (r *runtime) Read(opts ...ReadOption) ([]*Service, error) {
r.Lock()
defer r.Unlock()
gopts := ReadOptions{}
for _, o := range opts {
o(&gopts)
}
2019-11-29 14:35:00 +03:00
save := func(k, v string) bool {
if len(k) == 0 {
return true
}
return k == v
}
//nolint:prealloc
var services []*Service
2019-11-29 14:35:00 +03:00
for _, service := range r.services {
if !save(gopts.Service, service.Name) {
continue
}
2019-11-29 14:35:00 +03:00
if !save(gopts.Version, service.Version) {
continue
}
// TODO deal with service type
// no version has sbeen requested, just append the service
2019-11-29 14:35:00 +03:00
services = append(services, service.Service)
}
2019-11-29 14:35:00 +03:00
return services, nil
}
// Update attemps to update the service
2019-10-29 15:29:21 +03:00
func (r *runtime) Update(s *Service) error {
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 15:29:21 +03:00
// delete the service
if err := r.Delete(s); err != nil {
return err
}
// create new service
return r.Create(s, opts...)
2019-10-29 15:29:21 +03: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
}
// List returns a slice of all services tracked by the runtime
2019-10-29 15:29:21 +03:00
func (r *runtime) List() ([]*Service, error) {
r.RLock()
defer r.RUnlock()
services := make([]*Service, 0, len(r.services))
2019-10-29 15:29:21 +03:00
for _, service := range r.services {
services = append(services, service.Service)
}
return services, nil
}
// Start starts the runtime
func (r *runtime) Start() error {
2019-09-14 07:33:14 +03:00
r.Lock()
2019-09-24 20:05:51 +03:00
defer r.Unlock()
2019-09-14 07:33:14 +03:00
// already running
if r.running {
return nil
}
// set running
r.running = true
r.closed = make(chan bool)
2019-09-14 18:07:36 +03: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 07:33:14 +03:00
return nil
}
// Stop stops the runtime
2019-09-14 07:33:14 +03: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 20:05:51 +03:00
log.Debugf("Runtime stopping %s", service.Name)
2019-09-14 07:33:14 +03:00
service.Stop()
}
// stop the notifier too
if r.options.Notifier != nil {
return r.options.Notifier.Close()
}
2019-09-14 07:33:14 +03:00
}
return nil
}
// String implements stringer interface
func (r *runtime) String() string {
return "local"
}