micro/service.go

170 lines
2.7 KiB
Go
Raw Normal View History

2016-01-02 22:14:56 +03:00
package micro
2015-12-21 02:50:16 +03:00
import (
"os"
"os/signal"
2017-10-09 15:55:03 +03:00
"sync"
2015-12-21 02:50:16 +03:00
"syscall"
2016-01-27 02:32:27 +03:00
"time"
2015-12-21 02:50:16 +03:00
"github.com/micro/go-micro/client"
"github.com/micro/go-micro/cmd"
2016-01-28 20:55:28 +03:00
"github.com/micro/go-micro/metadata"
2015-12-21 02:50:16 +03:00
"github.com/micro/go-micro/server"
)
type service struct {
opts Options
once sync.Once
2015-12-21 02:50:16 +03:00
}
func newService(opts ...Option) Service {
options := newOptions(opts...)
2015-12-23 03:02:42 +03:00
options.Client = &clientWrapper{
2015-12-21 02:50:16 +03:00
options.Client,
2016-01-28 20:55:28 +03:00
metadata.Metadata{
2016-01-01 04:16:21 +03:00
HeaderPrefix + "From-Service": options.Server.Options().Name,
2015-12-21 02:50:16 +03:00
},
}
return &service{
opts: options,
}
}
2016-01-27 02:32:27 +03:00
func (s *service) run(exit chan bool) {
if s.opts.RegisterInterval <= time.Duration(0) {
return
}
t := time.NewTicker(s.opts.RegisterInterval)
for {
select {
case <-t.C:
2016-01-27 15:23:18 +03:00
s.opts.Server.Register()
2016-01-27 02:32:27 +03:00
case <-exit:
t.Stop()
return
}
}
}
// Init initialises options. Additionally it calls cmd.Init
// which parses command line flags. cmd.Init is only called
// on first Init.
2016-01-01 04:16:21 +03:00
func (s *service) Init(opts ...Option) {
// process options
for _, o := range opts {
o(&s.opts)
}
s.once.Do(func() {
// Initialise the command flags, overriding new service
s.opts.Cmd.Init(
cmd.Broker(&s.opts.Broker),
cmd.Registry(&s.opts.Registry),
cmd.Transport(&s.opts.Transport),
cmd.Client(&s.opts.Client),
cmd.Server(&s.opts.Server),
)
})
2016-01-01 04:16:21 +03:00
}
2016-01-02 22:12:17 +03:00
func (s *service) Options() Options {
return s.opts
2016-01-01 04:16:21 +03:00
}
2015-12-21 02:50:16 +03:00
func (s *service) Client() client.Client {
return s.opts.Client
}
func (s *service) Server() server.Server {
return s.opts.Server
}
func (s *service) String() string {
return "go-micro"
}
func (s *service) Start() error {
2016-01-01 04:16:21 +03:00
for _, fn := range s.opts.BeforeStart {
if err := fn(); err != nil {
return err
}
}
2015-12-21 02:50:16 +03:00
if err := s.opts.Server.Start(); err != nil {
return err
}
2016-01-27 15:23:18 +03:00
if err := s.opts.Server.Register(); err != nil {
2015-12-21 02:50:16 +03:00
return err
}
for _, fn := range s.opts.AfterStart {
if err := fn(); err != nil {
return err
}
}
2015-12-21 02:50:16 +03:00
return nil
}
func (s *service) Stop() error {
var gerr error
for _, fn := range s.opts.BeforeStop {
if err := fn(); err != nil {
gerr = err
}
}
2015-12-21 02:50:16 +03:00
if err := s.opts.Server.Deregister(); err != nil {
return err
}
if err := s.opts.Server.Stop(); err != nil {
return err
}
2016-01-01 04:16:21 +03:00
for _, fn := range s.opts.AfterStop {
if err := fn(); err != nil {
gerr = err
}
}
2016-01-01 04:16:21 +03:00
return gerr
2015-12-21 02:50:16 +03:00
}
func (s *service) Run() error {
if err := s.Start(); err != nil {
return err
}
2016-01-27 02:32:27 +03:00
// start reg loop
ex := make(chan bool)
go s.run(ex)
2015-12-21 02:50:16 +03:00
ch := make(chan os.Signal, 1)
signal.Notify(ch, syscall.SIGTERM, syscall.SIGINT, syscall.SIGKILL)
select {
// wait on kill signal
case <-ch:
// wait on context cancel
case <-s.opts.Context.Done():
}
2015-12-21 02:50:16 +03:00
2016-01-27 02:32:27 +03:00
// exit reg loop
close(ex)
2015-12-21 02:50:16 +03:00
if err := s.Stop(); err != nil {
return err
}
return nil
}