micro/service.go

158 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 (
2016-01-27 02:32:27 +03:00
"fmt"
2015-12-21 02:50:16 +03:00
"os"
"os/signal"
"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"
2015-12-21 02:50:16 +03:00
"github.com/micro/go-micro/context"
"github.com/micro/go-micro/server"
)
type service struct {
opts Options
}
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,
context.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:
fmt.Println("heartbeat")
if err := s.opts.Server.Register(server.RegisterTTL(s.opts.RegisterTTL)); err != nil {
fmt.Println("FUCK", err)
}
case <-exit:
t.Stop()
return
}
}
}
2016-01-01 04:16:21 +03:00
func (s *service) Init(opts ...Option) {
2016-01-02 22:12:17 +03:00
// We might get more command flags or the action here
// This is pretty ugly, find a better way
options := newOptions()
options.Cmd = s.opts.Cmd
for _, o := range opts {
o(&options)
}
s.opts.Cmd = options.Cmd
2016-01-02 03:38:57 +03:00
// 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 05:45:15 +03:00
2016-01-02 03:38:57 +03:00
// Update any options to override command flags
2016-01-01 05:45:15 +03:00
for _, o := range opts {
o(&s.opts)
}
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 02:32:27 +03:00
if err := s.opts.Server.Register(server.RegisterTTL(s.opts.RegisterTTL)); err != nil {
2015-12-21 02:50:16 +03:00
return err
}
return nil
}
func (s *service) Stop() error {
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
var gerr error
for _, fn := range s.opts.AfterStop {
if err := fn(); err != nil {
// should we bail if it fails?
// other funcs will not be executed
// seems wrong
gerr = err
}
}
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)
2015-12-21 04:41:36 +03:00
<-ch
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
}