micro/runtime/local/service.go

254 lines
4.9 KiB
Go
Raw Normal View History

package local
import (
"fmt"
"io"
"path/filepath"
"strconv"
"strings"
"sync"
"time"
"github.com/micro/go-micro/v3/build"
"github.com/micro/go-micro/v3/logger"
"github.com/micro/go-micro/v3/runtime"
"github.com/micro/go-micro/v3/runtime/local/process"
proc "github.com/micro/go-micro/v3/runtime/local/process/os"
)
type service struct {
sync.RWMutex
running bool
closed chan bool
err error
updated time.Time
retries int
maxRetries int
// output for logs
output io.Writer
// service to manage
*runtime.Service
// process creator
Process *proc.Process
// Exec
Exec *process.Binary
// process pid
PID *process.PID
}
func newService(s *runtime.Service, c runtime.CreateOptions) *service {
var exec string
var args []string
2019-11-29 14:35:00 +03:00
// set command
exec = strings.Join(c.Command, " ")
args = c.Args
dir := s.Source
// For uploaded packages, we upload the whole repo
// so the correct working directory to do a `go run .`
// needs to include the relative path from the repo root
// which is the service name.
//
// Could use a better upload check.
if strings.Contains(s.Source, "uploads") {
// There are two cases to consider here:
// a., if the uploaded code comes from a repo - in this case
// the service name is the relative path.
// b., if the uploaded code comes from a non repo folder -
// in this case the service name is the folder name.
// Because of this, we only append the service name to the source in
// case `a`
if ex, err := exists(filepath.Join(s.Source, s.Name)); err == nil && ex {
dir = filepath.Join(s.Source, s.Name)
}
}
return &service{
Service: s,
Process: new(proc.Process),
Exec: &process.Binary{
2019-11-19 19:09:43 +03:00
Package: &build.Package{
Name: s.Name,
Path: exec,
},
Env: c.Env,
Args: args,
Dir: dir,
},
closed: make(chan bool),
output: c.Output,
updated: time.Now(),
maxRetries: c.Retries,
}
}
func (s *service) streamOutput() {
go io.Copy(s.output, s.PID.Output)
go io.Copy(s.output, s.PID.Error)
}
2020-02-07 16:55:55 +03:00
func (s *service) shouldStart() bool {
if s.running {
return false
}
2020-03-20 01:38:37 +03:00
return s.retries <= s.maxRetries
}
func (s *service) key() string {
return fmt.Sprintf("%v:%v", s.Name, s.Version)
}
2020-02-07 16:55:55 +03:00
func (s *service) ShouldStart() bool {
s.RLock()
defer s.RUnlock()
return s.shouldStart()
}
func (s *service) Running() bool {
s.RLock()
defer s.RUnlock()
return s.running
}
// Start starts the service
func (s *service) Start() error {
s.Lock()
defer s.Unlock()
2020-02-07 16:55:55 +03:00
if !s.shouldStart() {
return nil
}
// reset
s.err = nil
s.closed = make(chan bool)
2020-04-16 18:50:24 +03:00
s.retries = 0
2020-01-11 00:54:28 +03:00
if s.Metadata == nil {
s.Metadata = make(map[string]string)
}
s.Status("starting", nil)
2020-01-11 00:54:28 +03:00
// TODO: pull source & build binary
if logger.V(logger.DebugLevel, logger.DefaultLogger) {
logger.Debugf("Runtime service %s forking new process", s.Service.Name)
}
2020-04-16 18:50:24 +03:00
p, err := s.Process.Fork(s.Exec)
if err != nil {
s.Status("error", err)
return err
}
// set the pid
s.PID = p
// set to running
s.running = true
2020-01-11 00:54:28 +03:00
// set status
s.Status("running", nil)
2020-03-20 15:48:12 +03:00
// set started
s.Metadata["started"] = time.Now().Format(time.RFC3339)
if s.output != nil {
s.streamOutput()
}
// wait and watch
go s.Wait()
return nil
}
// Status updates the status of the service. Assumes it's called under a lock as it mutates state
func (s *service) Status(status string, err error) {
s.Metadata["lastStatusUpdate"] = time.Now().Format(time.RFC3339)
s.Metadata["status"] = status
if err == nil {
delete(s.Metadata, "error")
return
}
s.Metadata["error"] = err.Error()
}
// Stop stops the service
func (s *service) Stop() error {
s.Lock()
defer s.Unlock()
select {
case <-s.closed:
return nil
default:
close(s.closed)
s.running = false
2020-04-16 18:50:24 +03:00
s.retries = 0
if s.PID == nil {
return nil
}
2020-01-11 00:54:28 +03:00
// set status
s.Status("stopping", nil)
2020-01-11 00:54:28 +03:00
// kill the process
err := s.Process.Kill(s.PID)
if err == nil {
// wait for it to exit
s.Process.Wait(s.PID)
2020-04-16 18:50:24 +03:00
}
2020-01-11 00:54:28 +03:00
// set status
s.Status("stopped", err)
2020-01-11 00:54:28 +03:00
// return the kill error
return err
}
}
// Error returns the last error service has returned
func (s *service) Error() error {
s.RLock()
defer s.RUnlock()
return s.err
}
// Wait waits for the service to finish running
func (s *service) Wait() {
// wait for process to exit
s.RLock()
thisPID := s.PID
s.RUnlock()
err := s.Process.Wait(thisPID)
s.Lock()
defer s.Unlock()
if s.PID.ID != thisPID.ID {
// trying to update when it's already been switched out, ignore
logger.Debugf("Trying to update a process status but PID doesn't match. Old %s, New %s. Skipping update.", thisPID.ID, s.PID.ID)
return
}
// save the error
if err != nil {
if logger.V(logger.ErrorLevel, logger.DefaultLogger) {
logger.Errorf("Service %s terminated with error %s", s.Name, err)
}
s.retries++
s.Status("error", err)
s.Metadata["retries"] = strconv.Itoa(s.retries)
s.err = err
2020-02-03 18:56:16 +03:00
} else {
s.Status("done", nil)
}
// no longer running
s.running = false
}