micro/server/rpc_server.go

998 lines
22 KiB
Go
Raw Normal View History

2015-01-14 02:31:27 +03:00
package server
import (
2018-03-03 14:53:52 +03:00
"context"
"fmt"
2019-09-27 17:01:16 +03:00
"io"
"net"
2015-12-21 20:18:04 +03:00
"runtime/debug"
"sort"
"strconv"
"strings"
"sync"
2016-05-13 01:32:58 +03:00
"time"
"github.com/micro/go-micro/v2/broker"
"github.com/micro/go-micro/v2/codec"
raw "github.com/micro/go-micro/v2/codec/bytes"
"github.com/micro/go-micro/v2/logger"
"github.com/micro/go-micro/v2/metadata"
"github.com/micro/go-micro/v2/registry"
"github.com/micro/go-micro/v2/transport"
"github.com/micro/go-micro/v2/util/addr"
"github.com/micro/go-micro/v2/util/backoff"
mnet "github.com/micro/go-micro/v2/util/net"
"github.com/micro/go-micro/v2/util/socket"
2015-01-14 02:31:27 +03:00
)
2015-05-23 19:40:53 +03:00
type rpcServer struct {
2019-01-07 17:44:40 +03:00
router *router
exit chan chan error
sync.RWMutex
opts Options
handlers map[string]Handler
subscribers map[Subscriber][]broker.Subscriber
// marks the serve as started
started bool
// used for first registration
registered bool
// subscribe to service name
subscriber broker.Subscriber
// graceful exit
wg *sync.WaitGroup
rsvc *registry.Service
2015-01-14 02:31:27 +03:00
}
2015-05-27 00:39:48 +03:00
func newRpcServer(opts ...Option) Server {
options := newOptions(opts...)
router := newRpcRouter()
router.hdlrWrappers = options.HdlrWrappers
router.subWrappers = options.SubWrappers
2015-05-23 19:40:53 +03:00
return &rpcServer{
2019-01-07 17:44:40 +03:00
opts: options,
2019-06-12 14:05:34 +03:00
router: router,
handlers: make(map[string]Handler),
subscribers: make(map[Subscriber][]broker.Subscriber),
exit: make(chan chan error),
wg: wait(options.Context),
2015-05-23 19:40:53 +03:00
}
}
2015-01-14 02:31:27 +03:00
// HandleEvent handles inbound messages to the service directly
// TODO: handle requests from an event. We won't send a response.
func (s *rpcServer) HandleEvent(e broker.Event) error {
// formatting horrible cruft
msg := e.Message()
if msg.Header == nil {
// create empty map in case of headers empty to avoid panic later
msg.Header = make(map[string]string)
}
// get codec
ct := msg.Header["Content-Type"]
// default content type
if len(ct) == 0 {
msg.Header["Content-Type"] = DefaultContentType
ct = DefaultContentType
}
// get codec
cf, err := s.newCodec(ct)
if err != nil {
return err
}
// copy headers
hdr := make(map[string]string, len(msg.Header))
for k, v := range msg.Header {
hdr[k] = v
}
// create context
ctx := metadata.NewContext(context.Background(), hdr)
// TODO: inspect message header
// Micro-Service means a request
// Micro-Topic means a message
rpcMsg := &rpcMessage{
topic: msg.Header["Micro-Topic"],
contentType: ct,
2019-12-05 19:10:49 +03:00
payload: &raw.Frame{Data: msg.Body},
codec: cf,
header: msg.Header,
body: msg.Body,
}
// existing router
r := Router(s.router)
// if the router is present then execute it
if s.opts.Router != nil {
// create a wrapped function
handler := s.opts.Router.ProcessMessage
// execute the wrapper for it
for i := len(s.opts.SubWrappers); i > 0; i-- {
handler = s.opts.SubWrappers[i-1](handler)
}
// set the router
r = rpcRouter{m: handler}
}
return r.ProcessMessage(ctx, rpcMsg)
}
2019-01-08 23:32:47 +03:00
// ServeConn serves a single connection
func (s *rpcServer) ServeConn(sock transport.Socket) {
// streams are multiplexed on Micro-Stream or Micro-Id header
2019-11-27 20:12:07 +03:00
pool := socket.NewPool()
// get global waitgroup
s.Lock()
gg := s.wg
s.Unlock()
// waitgroup to wait for processing to finish
wg := &waitGroup{
gg: gg,
}
2015-12-21 20:18:04 +03:00
defer func() {
// wait till done
wg.Wait()
2019-11-27 20:12:07 +03:00
// close all the sockets for this connection
pool.Close()
// close underlying socket
2016-05-10 12:55:18 +03:00
sock.Close()
// recover any panics
2015-12-21 20:18:04 +03:00
if r := recover(); r != nil {
if logger.V(logger.ErrorLevel, log) {
log.Error("panic recovered: ", r)
log.Error(string(debug.Stack()))
}
2015-12-21 20:18:04 +03:00
}
}()
2016-05-13 17:58:53 +03:00
for {
var msg transport.Message
2019-11-27 20:12:07 +03:00
// process inbound messages one at a time
2016-05-13 17:58:53 +03:00
if err := sock.Recv(&msg); err != nil {
return
}
2015-01-14 02:31:27 +03:00
// check the message header for
// Micro-Service is a request
// Micro-Topic is a message
if t := msg.Header["Micro-Topic"]; len(t) > 0 {
// process the event
ev := newEvent(msg)
// TODO: handle the error event
if err := s.HandleEvent(ev); err != nil {
msg.Header["Micro-Error"] = err.Error()
}
// write back some 200
2019-11-27 20:12:07 +03:00
if err := sock.Send(&transport.Message{
Header: msg.Header,
2019-11-27 20:12:07 +03:00
}); err != nil {
break
}
// we're done
continue
}
// business as usual
2019-08-16 16:42:45 +03:00
// use Micro-Stream as the stream identifier
2019-08-15 22:08:49 +03:00
// in the event its blank we'll always process
// on the same socket
id := msg.Header["Micro-Stream"]
// if there's no stream id then its a standard request
2019-08-16 16:42:45 +03:00
// use the Micro-Id
2019-08-15 22:08:49 +03:00
if len(id) == 0 {
id = msg.Header["Micro-Id"]
}
2019-11-27 20:12:07 +03:00
// check stream id
var stream bool
2019-11-27 20:12:07 +03:00
if v := getHeader("Micro-Stream", msg.Header); len(v) > 0 {
stream = true
}
2018-05-26 11:41:41 +03:00
2019-11-27 20:12:07 +03:00
// check if we have an existing socket
psock, ok := pool.Get(id)
2019-08-15 22:08:49 +03:00
2019-11-27 20:12:07 +03:00
// if we don't have a socket and its a stream
if !ok && stream {
// check if its a last stream EOS error
err := msg.Header["Micro-Error"]
if err == lastStreamResponseError.Error() {
pool.Release(psock)
continue
2019-08-15 22:08:49 +03:00
}
2019-11-27 20:12:07 +03:00
}
// got an existing socket already
if ok {
// we're starting processing
wg.Add(1)
2019-08-15 22:08:49 +03:00
2019-11-27 20:12:07 +03:00
// pass the message to that existing socket
if err := psock.Accept(&msg); err != nil {
// release the socket if there's an error
pool.Release(psock)
2019-08-15 22:08:49 +03:00
}
2019-11-27 20:12:07 +03:00
// done waiting
wg.Done()
2019-08-15 22:08:49 +03:00
// continue to the next message
continue
}
2019-11-27 20:12:07 +03:00
// no socket was found so its new
// set the local and remote values
2019-08-15 22:08:49 +03:00
psock.SetLocal(sock.Local())
psock.SetRemote(sock.Remote())
2019-11-27 20:12:07 +03:00
// load the socket with the current message
2019-08-15 22:08:49 +03:00
psock.Accept(&msg)
// now walk the usual path
2016-05-13 17:58:53 +03:00
// we use this Timeout header to set a server deadline
to := msg.Header["Timeout"]
// we use this Content-Type header to identify the codec needed
ct := msg.Header["Content-Type"]
2019-08-15 22:08:49 +03:00
// copy the message headers
hdr := make(map[string]string, len(msg.Header))
2019-01-07 21:20:47 +03:00
for k, v := range msg.Header {
hdr[k] = v
}
// set local/remote ips
hdr["Local"] = sock.Local()
hdr["Remote"] = sock.Remote()
2019-08-15 22:08:49 +03:00
// create new context with the metadata
2019-01-07 21:20:47 +03:00
ctx := metadata.NewContext(context.Background(), hdr)
2019-08-15 22:08:49 +03:00
// set the timeout from the header if we have it
2019-01-07 21:20:47 +03:00
if len(to) > 0 {
if n, err := strconv.ParseUint(to, 10, 64); err == nil {
2019-12-03 10:25:58 +03:00
var cancel context.CancelFunc
ctx, cancel = context.WithTimeout(ctx, time.Duration(n))
defer cancel()
2019-01-07 21:20:47 +03:00
}
}
2019-08-15 22:08:49 +03:00
// if there's no content type default it
if len(ct) == 0 {
2019-01-08 23:32:47 +03:00
msg.Header["Content-Type"] = DefaultContentType
ct = DefaultContentType
}
2019-01-18 13:12:57 +03:00
// setup old protocol
cf := setupProtocol(&msg)
2019-11-27 20:12:07 +03:00
// no legacy codec needed
2019-01-18 13:12:57 +03:00
if cf == nil {
var err error
2019-11-27 20:12:07 +03:00
// try get a new codec
2019-01-18 13:12:57 +03:00
if cf, err = s.newCodec(ct); err != nil {
2019-11-27 20:12:07 +03:00
// no codec found so send back an error
sock.Send(&transport.Message{
2019-01-18 13:12:57 +03:00
Header: map[string]string{
"Content-Type": "text/plain",
},
Body: []byte(err.Error()),
})
2019-11-27 20:12:07 +03:00
// release the socket we just created
pool.Release(psock)
// now continue
continue
2019-01-18 13:12:57 +03:00
}
2016-05-13 17:58:53 +03:00
}
2015-11-25 22:50:05 +03:00
2019-11-27 20:12:07 +03:00
// create a new rpc codec based on the pseudo socket and codec
2019-08-15 22:08:49 +03:00
rcodec := newRpcCodec(&msg, psock, cf)
2019-11-27 20:12:07 +03:00
// check the protocol as well
2019-08-26 14:33:59 +03:00
protocol := rcodec.String()
2019-08-15 22:08:49 +03:00
2019-01-09 19:20:57 +03:00
// internal request
request := &rpcRequest{
2019-01-24 13:11:02 +03:00
service: getHeader("Micro-Service", msg.Header),
method: getHeader("Micro-Method", msg.Header),
endpoint: getHeader("Micro-Endpoint", msg.Header),
2019-01-09 19:20:57 +03:00
contentType: ct,
2019-01-13 15:15:35 +03:00
codec: rcodec,
2019-01-09 22:11:47 +03:00
header: msg.Header,
2019-01-09 19:20:57 +03:00
body: msg.Body,
2019-08-15 22:08:49 +03:00
socket: psock,
stream: stream,
2019-01-09 19:20:57 +03:00
}
2015-01-14 02:31:27 +03:00
2019-01-09 22:11:47 +03:00
// internal response
response := &rpcResponse{
header: make(map[string]string),
2019-08-15 22:08:49 +03:00
socket: psock,
2019-01-13 15:15:35 +03:00
codec: rcodec,
2019-01-09 22:11:47 +03:00
}
2019-01-08 23:32:47 +03:00
2019-01-09 22:11:47 +03:00
// set router
r := Router(s.router)
2019-01-11 18:49:54 +03:00
// if not nil use the router specified
if s.opts.Router != nil {
// create a wrapped function
handler := func(ctx context.Context, req Request, rsp interface{}) error {
return s.opts.Router.ServeRequest(ctx, req, rsp.(Response))
}
2019-01-08 23:32:47 +03:00
// execute the wrapper for it
for i := len(s.opts.HdlrWrappers); i > 0; i-- {
handler = s.opts.HdlrWrappers[i-1](handler)
}
2019-01-11 18:49:54 +03:00
// set the router
r = rpcRouter{h: handler}
2019-01-11 18:49:54 +03:00
}
// wait for two coroutines to exit
// serve the request and process the outbound messages
wg.Add(2)
2019-08-25 21:30:22 +03:00
// process the outbound messages from the socket
go func(id string, psock *socket.Socket) {
defer func() {
2019-08-26 14:33:59 +03:00
// TODO: don't hack this but if its grpc just break out of the stream
// We do this because the underlying connection is h2 and its a stream
switch protocol {
case "grpc":
sock.Close()
}
2019-11-27 20:12:07 +03:00
// release the socket
pool.Release(psock)
// signal we're done
2019-08-25 21:30:22 +03:00
wg.Done()
// recover any panics for outbound process
if r := recover(); r != nil {
if logger.V(logger.ErrorLevel, log) {
log.Error("panic recovered: ", r)
log.Error(string(debug.Stack()))
}
}
2019-08-25 21:30:22 +03:00
}()
for {
// get the message from our internal handler/stream
m := new(transport.Message)
if err := psock.Process(m); err != nil {
return
}
// send the message back over the socket
if err := sock.Send(m); err != nil {
return
}
}
}(id, psock)
2019-08-15 22:08:49 +03:00
// serve the request in a go routine as this may be a stream
go func(id string, psock *socket.Socket) {
2019-11-27 20:12:07 +03:00
defer func() {
// release the socket
pool.Release(psock)
// signal we're done
wg.Done()
// recover any panics for call handler
if r := recover(); r != nil {
log.Error("panic recovered: ", r)
log.Error(string(debug.Stack()))
}
2019-11-27 20:12:07 +03:00
}()
2019-08-15 22:08:49 +03:00
// serve the actual request using the request router
if serveRequestError := r.ServeRequest(ctx, request, response); serveRequestError != nil {
2019-08-15 22:08:49 +03:00
// write an error response
writeError := rcodec.Write(&codec.Message{
2019-08-15 22:08:49 +03:00
Header: msg.Header,
Error: serveRequestError.Error(),
2019-08-15 22:08:49 +03:00
Type: codec.Error,
}, nil)
// if the server request is an EOS error we let the socket know
// sometimes the socket is already closed on the other side, so we can ignore that error
alreadyClosed := serveRequestError == lastStreamResponseError && writeError == io.EOF
// could not write error response
if writeError != nil && !alreadyClosed {
2019-11-27 20:12:07 +03:00
log.Debugf("rpc: unable to write error response: %v", writeError)
2019-08-15 22:08:49 +03:00
}
2019-01-22 16:55:04 +03:00
}
2019-08-15 22:08:49 +03:00
}(id, psock)
}
2015-05-21 00:57:19 +03:00
}
func (s *rpcServer) newCodec(contentType string) (codec.NewCodec, error) {
if cf, ok := s.opts.Codecs[contentType]; ok {
return cf, nil
2015-11-25 22:50:05 +03:00
}
if cf, ok := DefaultCodecs[contentType]; ok {
2015-11-25 22:50:05 +03:00
return cf, nil
}
return nil, fmt.Errorf("Unsupported Content-Type: %s", contentType)
}
func (s *rpcServer) Options() Options {
s.RLock()
opts := s.opts
s.RUnlock()
return opts
2015-01-14 02:31:27 +03:00
}
2016-01-02 22:12:17 +03:00
func (s *rpcServer) Init(opts ...Option) error {
s.Lock()
defer s.Unlock()
2015-05-27 00:39:48 +03:00
for _, opt := range opts {
opt(&s.opts)
}
// update router if its the default
if s.opts.Router == nil {
r := newRpcRouter()
r.hdlrWrappers = s.opts.HdlrWrappers
r.serviceMap = s.router.serviceMap
r.subWrappers = s.opts.SubWrappers
s.router = r
}
s.rsvc = nil
2016-01-02 22:12:17 +03:00
return nil
2015-01-14 02:31:27 +03:00
}
func (s *rpcServer) NewHandler(h interface{}, opts ...HandlerOption) Handler {
2019-01-07 20:17:06 +03:00
return s.router.NewHandler(h, opts...)
2015-01-14 02:31:27 +03:00
}
func (s *rpcServer) Handle(h Handler) error {
s.Lock()
defer s.Unlock()
2019-01-07 20:17:06 +03:00
if err := s.router.Handle(h); err != nil {
return err
}
s.handlers[h.Name()] = h
return nil
2015-01-14 02:31:27 +03:00
}
func (s *rpcServer) NewSubscriber(topic string, sb interface{}, opts ...SubscriberOption) Subscriber {
return s.router.NewSubscriber(topic, sb, opts...)
}
func (s *rpcServer) Subscribe(sb Subscriber) error {
s.Lock()
defer s.Unlock()
if err := s.router.Subscribe(sb); err != nil {
return err
}
s.subscribers[sb] = nil
return nil
}
2016-01-27 15:23:18 +03:00
func (s *rpcServer) Register() error {
s.RLock()
rsvc := s.rsvc
config := s.Options()
s.RUnlock()
regFunc := func(service *registry.Service) error {
// create registry options
rOpts := []registry.RegisterOption{
registry.RegisterTTL(config.RegisterTTL),
registry.RegisterDomain(s.opts.Namespace),
}
var regErr error
for i := 0; i < 3; i++ {
// attempt to register
if err := config.Registry.Register(service, rOpts...); err != nil {
// set the error
regErr = err
// backoff then retry
time.Sleep(backoff.Do(i + 1))
continue
}
// success so nil error
regErr = nil
break
}
return regErr
}
// have we registered before?
if rsvc != nil {
if err := regFunc(rsvc); err != nil {
return err
}
return nil
}
var err error
var advt, host, port string
var cacheService bool
2015-11-11 21:22:04 +03:00
// check the advertise address first
// if it exists then use it, otherwise
// use the address
if len(config.Advertise) > 0 {
advt = config.Advertise
2015-11-11 21:22:04 +03:00
} else {
advt = config.Address
2015-11-11 21:22:04 +03:00
}
if cnt := strings.Count(advt, ":"); cnt >= 1 {
// ipv6 address in format [host]:port or ipv4 host:port
host, port, err = net.SplitHostPort(advt)
if err != nil {
return err
}
} else {
host = advt
2015-01-14 02:31:27 +03:00
}
if ip := net.ParseIP(host); ip != nil {
cacheService = true
}
2017-01-12 16:20:34 +03:00
addr, err := addr.Extract(host)
if err != nil {
return err
}
2019-02-04 13:29:10 +03:00
// make copy of metadata
md := metadata.Copy(config.Metadata)
2019-02-04 13:29:10 +03:00
2019-08-14 16:32:28 +03:00
// mq-rpc(eg. nats) doesn't need the port. its addr is queue name.
if port != "" {
addr = mnet.HostPort(addr, port)
}
// register service
node := &registry.Node{
2016-01-02 03:38:57 +03:00
Id: config.Name + "-" + config.Id,
2019-08-14 16:32:28 +03:00
Address: addr,
2019-02-04 13:29:10 +03:00
Metadata: md,
}
node.Metadata["transport"] = config.Transport.String()
2016-01-04 04:27:05 +03:00
node.Metadata["broker"] = config.Broker.String()
node.Metadata["server"] = s.String()
2016-01-05 02:27:44 +03:00
node.Metadata["registry"] = config.Registry.String()
2019-01-18 15:30:39 +03:00
node.Metadata["protocol"] = "mucp"
2015-12-20 00:56:14 +03:00
s.RLock()
// Maps are ordered randomly, sort the keys for consistency
var handlerList []string
for n, e := range s.handlers {
// Only advertise non internal handlers
if !e.Options().Internal {
handlerList = append(handlerList, n)
}
}
sort.Strings(handlerList)
var subscriberList []Subscriber
for e := range s.subscribers {
// Only advertise non internal subscribers
if !e.Options().Internal {
subscriberList = append(subscriberList, e)
}
}
sort.Slice(subscriberList, func(i, j int) bool {
return subscriberList[i].Topic() > subscriberList[j].Topic()
})
2019-11-05 20:43:12 +03:00
endpoints := make([]*registry.Endpoint, 0, len(handlerList)+len(subscriberList))
for _, n := range handlerList {
endpoints = append(endpoints, s.handlers[n].Endpoints()...)
}
for _, e := range subscriberList {
endpoints = append(endpoints, e.Endpoints()...)
}
service := &registry.Service{
Name: config.Name,
Version: config.Version,
Nodes: []*registry.Node{node},
Endpoints: endpoints,
}
// get registered value
2016-02-28 01:14:25 +03:00
registered := s.registered
s.RUnlock()
2016-02-28 01:14:25 +03:00
if !registered {
2020-04-23 13:24:39 +03:00
if logger.V(logger.InfoLevel, logger.DefaultLogger) {
log.Infof("Registry [%s] Registering node: %s", config.Registry.String(), node.Id)
}
2016-02-28 01:14:25 +03:00
}
// register the service
if err := regFunc(service); err != nil {
return err
}
2016-02-28 01:14:25 +03:00
// already registered? don't need to register subscribers
if registered {
return nil
}
2016-02-28 01:14:25 +03:00
s.Lock()
defer s.Unlock()
// set what we're advertising
s.opts.Advertise = addr
// router can exchange messages
if s.opts.Router != nil {
// subscribe to the topic with own name
sub, err := s.opts.Broker.Subscribe(config.Name, s.HandleEvent)
if err != nil {
return err
}
// save the subscriber
s.subscriber = sub
}
// subscribe for all of the subscribers
for sb := range s.subscribers {
2016-01-23 00:48:43 +03:00
var opts []broker.SubscribeOption
if queue := sb.Options().Queue; len(queue) > 0 {
2016-05-10 12:55:18 +03:00
opts = append(opts, broker.Queue(queue))
2016-01-23 00:48:43 +03:00
}
2019-05-24 15:06:27 +03:00
if cx := sb.Options().Context; cx != nil {
opts = append(opts, broker.SubscribeContext(cx))
}
2019-05-24 15:06:27 +03:00
if !sb.Options().AutoAck {
opts = append(opts, broker.DisableAutoAck())
}
sub, err := config.Broker.Subscribe(sb.Topic(), s.HandleEvent, opts...)
if err != nil {
return err
}
2020-04-23 13:24:39 +03:00
if logger.V(logger.InfoLevel, logger.DefaultLogger) {
log.Infof("Subscribing to topic: %s", sub.Topic())
}
s.subscribers[sb] = []broker.Subscriber{sub}
}
if cacheService {
s.rsvc = service
}
s.registered = true
return nil
}
func (s *rpcServer) Deregister() error {
var err error
var advt, host, port string
s.RLock()
config := s.Options()
s.RUnlock()
2015-11-11 21:22:04 +03:00
// check the advertise address first
// if it exists then use it, otherwise
// use the address
if len(config.Advertise) > 0 {
advt = config.Advertise
2015-11-11 21:22:04 +03:00
} else {
advt = config.Address
2015-11-11 21:22:04 +03:00
}
if cnt := strings.Count(advt, ":"); cnt >= 1 {
// ipv6 address in format [host]:port or ipv4 host:port
host, port, err = net.SplitHostPort(advt)
if err != nil {
return err
}
} else {
host = advt
}
2017-01-12 16:20:34 +03:00
addr, err := addr.Extract(host)
if err != nil {
return err
}
2019-08-15 10:59:50 +03:00
// mq-rpc(eg. nats) doesn't need the port. its addr is queue name.
if port != "" {
addr = mnet.HostPort(addr, port)
}
node := &registry.Node{
2016-01-02 03:38:57 +03:00
Id: config.Name + "-" + config.Id,
2019-08-15 10:59:50 +03:00
Address: addr,
}
service := &registry.Service{
Name: config.Name,
Version: config.Version,
Nodes: []*registry.Node{node},
}
2020-04-23 13:24:39 +03:00
if logger.V(logger.InfoLevel, logger.DefaultLogger) {
log.Infof("Registry [%s] Deregistering node: %s", config.Registry.String(), node.Id)
}
if err := config.Registry.Deregister(service, registry.DeregisterDomain(s.opts.Namespace)); err != nil {
return err
}
s.Lock()
s.rsvc = nil
if !s.registered {
s.Unlock()
return nil
}
s.registered = false
// close the subscriber
if s.subscriber != nil {
s.subscriber.Unsubscribe()
s.subscriber = nil
}
for sb, subs := range s.subscribers {
for _, sub := range subs {
2020-04-23 13:24:39 +03:00
if logger.V(logger.InfoLevel, logger.DefaultLogger) {
log.Infof("Unsubscribing %s from topic: %s", node.Id, sub.Topic())
}
sub.Unsubscribe()
}
s.subscribers[sb] = nil
}
s.Unlock()
return nil
2015-01-14 02:31:27 +03:00
}
2015-05-23 19:40:53 +03:00
func (s *rpcServer) Start() error {
s.RLock()
if s.started {
s.RUnlock()
return nil
}
s.RUnlock()
config := s.Options()
2015-01-14 02:31:27 +03:00
2019-01-24 16:22:17 +03:00
// start listening on the transport
ts, err := config.Transport.Listen(config.Address)
2015-01-14 02:31:27 +03:00
if err != nil {
return err
}
2020-04-23 13:24:39 +03:00
if logger.V(logger.InfoLevel, logger.DefaultLogger) {
log.Infof("Transport [%s] Listening on %s", config.Transport.String(), ts.Addr())
}
2019-01-22 15:18:33 +03:00
// swap address
2019-01-24 16:22:17 +03:00
s.Lock()
addr := s.opts.Address
s.opts.Address = ts.Addr()
s.Unlock()
bname := config.Broker.String()
2019-01-24 16:22:17 +03:00
// connect to the broker
if err := config.Broker.Connect(); err != nil {
if logger.V(logger.ErrorLevel, logger.DefaultLogger) {
log.Errorf("Broker [%s] connect error: %v", bname, err)
}
2019-01-24 16:22:17 +03:00
return err
}
2020-04-23 13:24:39 +03:00
if logger.V(logger.InfoLevel, logger.DefaultLogger) {
log.Infof("Broker [%s] Connected to %s", bname, config.Broker.Address())
}
2019-01-24 16:22:17 +03:00
// use RegisterCheck func before register
if err = s.opts.RegisterCheck(s.opts.Context); err != nil {
if logger.V(logger.ErrorLevel, logger.DefaultLogger) {
log.Errorf("Server %s-%s register check error: %s", config.Name, config.Id, err)
}
} else {
// announce self to the world
if err = s.Register(); err != nil {
if logger.V(logger.ErrorLevel, logger.DefaultLogger) {
log.Errorf("Server %s-%s register error: %s", config.Name, config.Id, err)
}
}
2019-01-24 16:22:17 +03:00
}
exit := make(chan bool)
2018-11-15 22:55:13 +03:00
go func() {
for {
2019-01-24 16:22:17 +03:00
// listen for connections
2019-01-08 23:32:47 +03:00
err := ts.Accept(s.ServeConn)
2018-11-15 22:55:13 +03:00
2019-01-24 16:22:17 +03:00
// TODO: listen for messages
// msg := broker.Exchange(service).Consume()
2018-11-15 22:55:13 +03:00
select {
2019-01-24 16:22:17 +03:00
// check if we're supposed to exit
2018-11-15 22:55:13 +03:00
case <-exit:
return
// check the error and backoff
2019-01-24 16:22:17 +03:00
default:
if err != nil {
if logger.V(logger.ErrorLevel, logger.DefaultLogger) {
log.Errorf("Accept error: %v", err)
}
2019-01-24 16:22:17 +03:00
time.Sleep(time.Second)
continue
}
2018-11-15 22:55:13 +03:00
}
// no error just exit
return
}
}()
2015-01-14 02:31:27 +03:00
go func() {
2019-01-24 19:08:04 +03:00
t := new(time.Ticker)
2019-01-24 16:22:17 +03:00
// only process if it exists
2019-01-24 19:08:04 +03:00
if s.opts.RegisterInterval > time.Duration(0) {
// new ticker
t = time.NewTicker(s.opts.RegisterInterval)
2019-01-24 16:22:17 +03:00
}
// return error chan
var ch chan error
Loop:
for {
select {
// register self on interval
case <-t.C:
s.RLock()
registered := s.registered
s.RUnlock()
rerr := s.opts.RegisterCheck(s.opts.Context)
if rerr != nil && registered {
if logger.V(logger.ErrorLevel, logger.DefaultLogger) {
log.Errorf("Server %s-%s register check error: %s, deregister it", config.Name, config.Id, err)
}
// deregister self in case of error
if err := s.Deregister(); err != nil {
if logger.V(logger.ErrorLevel, logger.DefaultLogger) {
log.Errorf("Server %s-%s deregister error: %s", config.Name, config.Id, err)
}
}
} else if rerr != nil && !registered {
if logger.V(logger.ErrorLevel, logger.DefaultLogger) {
log.Errorf("Server %s-%s register check error: %s", config.Name, config.Id, err)
}
continue
}
if err := s.Register(); err != nil {
if logger.V(logger.ErrorLevel, logger.DefaultLogger) {
log.Errorf("Server %s-%s register error: %s", config.Name, config.Id, err)
}
2019-01-24 16:22:17 +03:00
}
// wait for exit
case ch = <-s.exit:
t.Stop()
close(exit)
break Loop
}
}
s.RLock()
registered := s.registered
s.RUnlock()
if registered {
// deregister self
if err := s.Deregister(); err != nil {
if logger.V(logger.ErrorLevel, logger.DefaultLogger) {
log.Errorf("Server %s-%s deregister error: %s", config.Name, config.Id, err)
}
}
2019-01-24 16:22:17 +03:00
}
s.Lock()
swg := s.wg
s.Unlock()
// wait for requests to finish
if swg != nil {
swg.Wait()
}
// close transport listener
2015-05-21 00:57:19 +03:00
ch <- ts.Close()
2020-04-23 13:24:39 +03:00
if logger.V(logger.InfoLevel, logger.DefaultLogger) {
log.Infof("Broker [%s] Disconnected from %s", bname, config.Broker.Address())
}
// disconnect the broker
if err := config.Broker.Disconnect(); err != nil {
if logger.V(logger.ErrorLevel, logger.DefaultLogger) {
log.Errorf("Broker [%s] Disconnect error: %v", bname, err)
}
}
// swap back address
2019-01-24 16:22:17 +03:00
s.Lock()
s.opts.Address = addr
s.Unlock()
2015-01-14 02:31:27 +03:00
}()
// mark the server as started
s.Lock()
s.started = true
s.Unlock()
2019-01-22 15:18:33 +03:00
return nil
2015-01-14 02:31:27 +03:00
}
2015-05-23 19:40:53 +03:00
func (s *rpcServer) Stop() error {
s.RLock()
if !s.started {
s.RUnlock()
return nil
}
s.RUnlock()
2015-01-14 02:31:27 +03:00
ch := make(chan error)
s.exit <- ch
err := <-ch
s.Lock()
s.started = false
s.Unlock()
return err
2015-01-14 02:31:27 +03:00
}
2015-12-20 00:56:14 +03:00
func (s *rpcServer) String() string {
2019-06-08 21:40:44 +03:00
return "mucp"
2015-12-20 00:56:14 +03:00
}