Change receiver to handler, breaking change, grrr

server/rpc_server.go

@@ -1,7 +1,12 @@
 package server
 
 import (
+	"strconv"
+	"strings"
+	"sync"
+
 	c "github.com/myodc/go-micro/context"
+	"github.com/myodc/go-micro/registry"
 	"github.com/myodc/go-micro/transport"
 
 	log "github.com/golang/glog"
@@ -11,16 +16,20 @@ import (
 )
 
 type rpcServer struct {
-	opts options
 	rpc  *rpc.Server
 	exit chan chan error
+
+	sync.RWMutex
+	opts     options
+	handlers map[string]Handler
 }
 
 func newRpcServer(opts ...Option) Server {
 	return &rpcServer{
-		opts: newOptions(opts...),
-		rpc:  rpc.NewServer(),
-		exit: make(chan chan error),
+		opts:     newOptions(opts...),
+		rpc:      rpc.NewServer(),
+		handlers: make(map[string]Handler),
+		exit:     make(chan chan error),
 	}
 }
 
@@ -44,47 +53,116 @@ func (s *rpcServer) accept(sock transport.Socket) {
 }
 
 func (s *rpcServer) Config() options {
-	return s.opts
+	s.RLock()
+	opts := s.opts
+	s.RUnlock()
+	return opts
 }
 
 func (s *rpcServer) Init(opts ...Option) {
+	s.Lock()
 	for _, opt := range opts {
 		opt(&s.opts)
 	}
 	if len(s.opts.id) == 0 {
 		s.opts.id = s.opts.name + "-" + DefaultId
 	}
+	s.Unlock()
 }
 
-func (s *rpcServer) NewReceiver(handler interface{}) Receiver {
-	return newRpcReceiver("", handler)
+func (s *rpcServer) NewHandler(h interface{}) Handler {
+	return newRpcHandler(h)
 }
 
-func (s *rpcServer) NewNamedReceiver(name string, handler interface{}) Receiver {
-	return newRpcReceiver(name, handler)
+func (s *rpcServer) Handle(h Handler) error {
+	if err := s.rpc.Register(h.Handler()); err != nil {
+		return err
+	}
+	s.Lock()
+	s.handlers[h.Name()] = h
+	s.Unlock()
+	return nil
 }
 
-func (s *rpcServer) Register(r Receiver) error {
-	if len(r.Name()) > 0 {
-		s.rpc.RegisterName(r.Name(), r.Handler())
-		return nil
+func (s *rpcServer) Register() error {
+	// parse address for host, port
+	config := s.Config()
+	var host string
+	var port int
+	parts := strings.Split(config.Address(), ":")
+	if len(parts) > 1 {
+		host = strings.Join(parts[:len(parts)-1], ":")
+		port, _ = strconv.Atoi(parts[len(parts)-1])
+	} else {
+		host = parts[0]
 	}
 
-	s.rpc.Register(r.Handler())
-	return nil
+	// register service
+	node := &registry.Node{
+		Id:       config.Id(),
+		Address:  host,
+		Port:     port,
+		Metadata: config.Metadata(),
+	}
+
+	s.RLock()
+	var endpoints []*registry.Endpoint
+	for _, e := range s.handlers {
+		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)
+	return config.registry.Register(service)
+}
+
+func (s *rpcServer) Deregister() error {
+	config := s.Config()
+	var host string
+	var port int
+	parts := strings.Split(config.Address(), ":")
+	if len(parts) > 1 {
+		host = strings.Join(parts[:len(parts)-1], ":")
+		port, _ = strconv.Atoi(parts[len(parts)-1])
+	} else {
+		host = parts[0]
+	}
+
+	node := &registry.Node{
+		Id:      config.Id(),
+		Address: host,
+		Port:    port,
+	}
+
+	service := &registry.Service{
+		Name:    config.Name(),
+		Version: config.Version(),
+		Nodes:   []*registry.Node{node},
+	}
+
+	return config.registry.Deregister(service)
 }
 
 func (s *rpcServer) Start() error {
 	registerHealthChecker(s)
+	config := s.Config()
 
-	ts, err := s.opts.transport.Listen(s.opts.address)
+	ts, err := config.transport.Listen(s.opts.address)
 	if err != nil {
 		return err
 	}
 
 	log.Infof("Listening on %s", ts.Addr())
-
+	s.Lock()
 	s.opts.address = ts.Addr()
+	s.Unlock()
 
 	go ts.Accept(s.accept)