micro/server/rpc_server.go

309 lines
6.1 KiB
Go
Raw Normal View History

2015-01-14 02:31:27 +03:00
package server
import (
"fmt"
"strconv"
"strings"
"sync"
2015-11-20 19:17:33 +03:00
"github.com/micro/go-micro/broker"
"github.com/micro/go-micro/codec"
2015-11-20 19:17:33 +03:00
c "github.com/micro/go-micro/context"
"github.com/micro/go-micro/registry"
"github.com/micro/go-micro/transport"
2015-05-23 13:53:40 +03:00
log "github.com/golang/glog"
2015-05-21 00:57:19 +03:00
"golang.org/x/net/context"
2015-01-14 02:31:27 +03:00
)
2015-05-23 19:40:53 +03:00
type rpcServer struct {
rpc *server
2015-05-27 00:39:48 +03:00
exit chan chan error
sync.RWMutex
opts options
handlers map[string]Handler
subscribers map[*subscriber][]broker.Subscriber
2015-01-14 02:31:27 +03:00
}
2015-05-27 00:39:48 +03:00
func newRpcServer(opts ...Option) Server {
options := newOptions(opts...)
2015-05-23 19:40:53 +03:00
return &rpcServer{
opts: options,
rpc: &server{
serviceMap: make(map[string]*service),
wrappers: options.wrappers,
},
handlers: make(map[string]Handler),
subscribers: make(map[*subscriber][]broker.Subscriber),
exit: make(chan chan error),
2015-05-23 19:40:53 +03:00
}
}
2015-01-14 02:31:27 +03:00
2015-05-23 19:40:53 +03:00
func (s *rpcServer) accept(sock transport.Socket) {
2015-05-21 23:08:19 +03:00
var msg transport.Message
if err := sock.Recv(&msg); err != nil {
2015-01-14 02:31:27 +03:00
return
}
cf, err := s.newCodec(msg.Header["Content-Type"])
2015-11-25 22:50:05 +03:00
// TODO: needs better error handling
if err != nil {
sock.Send(&transport.Message{
Header: map[string]string{
"Content-Type": "text/plain",
},
Body: []byte(err.Error()),
})
sock.Close()
return
}
codec := newRpcPlusCodec(&msg, sock, cf)
2015-01-14 02:31:27 +03:00
2015-05-23 13:53:40 +03:00
// strip our headers
hdr := make(map[string]string)
for k, v := range msg.Header {
hdr[k] = v
2015-01-14 02:31:27 +03:00
}
delete(hdr, "Content-Type")
2015-01-14 02:31:27 +03:00
ctx := c.WithMetadata(context.Background(), hdr)
// TODO: needs better error handling
2015-12-02 04:38:56 +03:00
if err := s.rpc.serveRequest(ctx, codec); err != nil {
2015-11-25 22:50:05 +03:00
log.Errorf("Unexpected error serving request, closing socket: %v", err)
sock.Close()
}
2015-05-21 00:57:19 +03:00
}
func (s *rpcServer) newCodec(contentType string) (codec.NewCodec, error) {
2015-11-25 22:50:05 +03:00
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 {
return cf, nil
}
return nil, fmt.Errorf("Unsupported Content-Type: %s", contentType)
}
2015-05-27 00:39:48 +03:00
func (s *rpcServer) Config() options {
s.RLock()
opts := s.opts
s.RUnlock()
return opts
2015-01-14 02:31:27 +03:00
}
2015-05-27 00:39:48 +03:00
func (s *rpcServer) Init(opts ...Option) {
s.Lock()
2015-05-27 00:39:48 +03:00
for _, opt := range opts {
opt(&s.opts)
}
if len(s.opts.id) == 0 {
s.opts.id = s.opts.name + "-" + DefaultId
}
s.Unlock()
2015-01-14 02:31:27 +03:00
}
func (s *rpcServer) NewHandler(h interface{}) Handler {
return newRpcHandler(h)
2015-01-14 02:31:27 +03:00
}
func (s *rpcServer) Handle(h Handler) error {
2015-12-02 04:18:32 +03:00
if err := s.rpc.register(h.Handler()); err != nil {
return err
}
s.Lock()
s.handlers[h.Name()] = h
s.Unlock()
return nil
2015-01-14 02:31:27 +03:00
}
func (s *rpcServer) NewSubscriber(topic string, sb interface{}) Subscriber {
return newSubscriber(topic, sb)
}
func (s *rpcServer) Subscribe(sb Subscriber) error {
sub, ok := sb.(*subscriber)
if !ok {
return fmt.Errorf("invalid subscriber: expected *subscriber")
}
if len(sub.handlers) == 0 {
return fmt.Errorf("invalid subscriber: no handler functions")
}
if err := validateSubscriber(sb); err != nil {
return err
}
s.Lock()
_, ok = s.subscribers[sub]
if ok {
return fmt.Errorf("subscriber %v already exists", s)
}
s.subscribers[sub] = nil
s.Unlock()
return nil
}
func (s *rpcServer) Register() error {
// parse address for host, port
config := s.Config()
2015-11-11 21:22:04 +03:00
var advt, host string
var port int
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()
} else {
advt = config.Address()
}
parts := strings.Split(advt, ":")
if len(parts) > 1 {
host = strings.Join(parts[:len(parts)-1], ":")
port, _ = strconv.Atoi(parts[len(parts)-1])
} else {
host = parts[0]
2015-01-14 02:31:27 +03:00
}
addr, err := extractAddress(host)
if err != nil {
return err
}
// register service
node := &registry.Node{
Id: config.Id(),
Address: addr,
Port: port,
Metadata: config.Metadata(),
}
s.RLock()
var endpoints []*registry.Endpoint
for _, e := range s.handlers {
endpoints = append(endpoints, e.Endpoints()...)
}
for e, _ := range s.subscribers {
endpoints = append(endpoints, e.Endpoints()...)
}
s.RUnlock()
service := &registry.Service{
Name: config.Name(),
Version: config.Version(),
Nodes: []*registry.Node{node},
Endpoints: endpoints,
}
log.Infof("Registering node: %s", node.Id)
if err := config.registry.Register(service); err != nil {
return err
}
s.Lock()
defer s.Unlock()
for sb, _ := range s.subscribers {
handler := s.createSubHandler(sb)
sub, err := config.broker.Subscribe(sb.Topic(), handler)
if err != nil {
return err
}
s.subscribers[sb] = []broker.Subscriber{sub}
}
return nil
}
func (s *rpcServer) Deregister() error {
config := s.Config()
2015-11-11 21:22:04 +03:00
var advt, host string
var port int
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()
} else {
advt = config.Address()
}
parts := strings.Split(advt, ":")
if len(parts) > 1 {
host = strings.Join(parts[:len(parts)-1], ":")
port, _ = strconv.Atoi(parts[len(parts)-1])
} else {
host = parts[0]
}
addr, err := extractAddress(host)
if err != nil {
return err
}
node := &registry.Node{
Id: config.Id(),
Address: addr,
Port: port,
}
service := &registry.Service{
Name: config.Name(),
Version: config.Version(),
Nodes: []*registry.Node{node},
}
log.Infof("Deregistering node: %s", node.Id)
if err := config.registry.Deregister(service); err != nil {
return err
}
s.Lock()
for sb, subs := range s.subscribers {
for _, sub := range subs {
log.Infof("Unsubscribing from topic: %s", 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 {
2015-05-22 01:06:01 +03:00
registerHealthChecker(s)
config := s.Config()
2015-01-14 02:31:27 +03:00
ts, err := config.transport.Listen(s.opts.address)
2015-01-14 02:31:27 +03:00
if err != nil {
return err
}
2015-05-21 00:57:19 +03:00
log.Infof("Listening on %s", ts.Addr())
s.Lock()
2015-05-27 00:39:48 +03:00
s.opts.address = ts.Addr()
s.Unlock()
2015-05-21 23:08:19 +03:00
go ts.Accept(s.accept)
2015-01-14 02:31:27 +03:00
go func() {
ch := <-s.exit
2015-05-21 00:57:19 +03:00
ch <- ts.Close()
config.broker.Disconnect()
2015-01-14 02:31:27 +03:00
}()
// TODO: subscribe to cruft
return config.broker.Connect()
2015-01-14 02:31:27 +03:00
}
2015-05-23 19:40:53 +03:00
func (s *rpcServer) Stop() error {
2015-01-14 02:31:27 +03:00
ch := make(chan error)
s.exit <- ch
return <-ch
}