Change receiver to handler, breaking change, grrr

README.md

@@ -107,8 +107,8 @@ func main() {
 	)
 
 	// Register Handlers
-	server.Register(
+	server.Handle(
-		server.NewReceiver(
+		server.NewHandler(
 			new(handler.Example),
 		),
 	)

examples/server/main.go

@@ -17,8 +17,8 @@ func main() {
 	)
 
 	// Register Handlers
-	server.Register(
+	server.Handle(
-		server.NewReceiver(
+		server.NewHandler(
 			new(handler.Example),
 		),
 	)

registry/registry.go

@@ -12,19 +12,6 @@ type Watcher interface {
 	Stop()
 }
 
-type Service struct {
-	Name     string
-	Metadata map[string]string
-	Nodes    []*Node
-}
-
-type Node struct {
-	Id       string
-	Address  string
-	Port     int
-	Metadata map[string]string
-}
-
 type options struct{}
 
 type Option func(*options)

registry/service.go

@@ -0,0 +1,28 @@
+package registry
+
+type Service struct {
+	Name      string
+	Version   string
+	Metadata  map[string]string
+	Endpoints []*Endpoint
+	Nodes     []*Node
+}
+
+type Node struct {
+	Id       string
+	Address  string
+	Port     int
+	Metadata map[string]string
+}
+
+type Endpoint struct {
+	Name     string
+	Request  *Value
+	Response *Value
+}
+
+type Value struct {
+	Name   string
+	Type   string
+	Values []*Value
+}

server/extractor.go

@@ -0,0 +1,66 @@
+package server
+
+import (
+	"reflect"
+
+	"github.com/myodc/go-micro/registry"
+)
+
+func extractValue(v reflect.Type) *registry.Value {
+	if v == nil {
+		return nil
+	}
+
+	if v.Kind() == reflect.Ptr {
+		v = v.Elem()
+	}
+
+	arg := &registry.Value{
+		Name: v.Name(),
+		Type: v.Name(),
+	}
+
+	if v.Kind() == reflect.Struct {
+		for i := 0; i < v.NumField(); i++ {
+			val := extractValue(v.Field(i).Type)
+			val.Name = v.Field(i).Name
+			arg.Values = append(arg.Values, val)
+		}
+	}
+
+	return arg
+}
+
+func extractEndpoint(method reflect.Method) *registry.Endpoint {
+	if method.PkgPath != "" {
+		return nil
+	}
+
+	var rspType, reqType reflect.Type
+	//	var stream bool
+	mt := method.Type
+
+	switch mt.NumIn() {
+	case 3:
+		reqType = mt.In(1)
+		rspType = mt.In(2)
+	case 4:
+		reqType = mt.In(2)
+		rspType = mt.In(3)
+	default:
+		return nil
+	}
+
+	//	if rspType.Kind() == reflect.Func {
+	//		stream = true
+	//	}
+
+	request := extractValue(reqType)
+	response := extractValue(rspType)
+
+	return &registry.Endpoint{
+		Name:     method.Name,
+		Request:  request,
+		Response: response,
+	}
+}

server/handler.go

@@ -0,0 +1,11 @@
+package server
+
+import (
+	"github.com/myodc/go-micro/registry"
+)
+
+type Handler interface {
+	Name() string
+	Handler() interface{}
+	Endpoints() []*registry.Endpoint
+}

server/health_checker.go

@@ -12,6 +12,6 @@ func (d *Debug) Health(ctx context.Context, req *health.Request, rsp *health.Res
 	return nil
 }
 
-func registerHealthChecker(r Server) {
+func registerHealthChecker(s Server) {
-	r.Register(r.NewReceiver(&Debug{}))
+	s.Handle(s.NewHandler(&Debug{}))
 }

server/options.go

@@ -12,6 +12,7 @@ type options struct {
 	name      string
 	address   string
 	id        string
+	version   string
 }
 
 func newOptions(opt ...Option) options {
@@ -41,6 +42,10 @@ func newOptions(opt ...Option) options {
 		opts.id = DefaultId
 	}
 
+	if len(opts.version) == 0 {
+		opts.version = DefaultVersion
+	}
+
 	return opts
 }
 
@@ -52,6 +57,10 @@ func (o options) Id() string {
 	return o.name + "-" + o.id
 }
 
+func (o options) Version() string {
+	return o.version
+}
+
 func (o options) Address() string {
 	return o.address
 }
@@ -59,3 +68,45 @@ func (o options) Address() string {
 func (o options) Metadata() map[string]string {
 	return o.metadata
 }
+
+func Name(n string) Option {
+	return func(o *options) {
+		o.name = n
+	}
+}
+
+func Id(id string) Option {
+	return func(o *options) {
+		o.id = id
+	}
+}
+
+func Version(v string) Option {
+	return func(o *options) {
+		o.version = v
+	}
+}
+
+func Address(a string) Option {
+	return func(o *options) {
+		o.address = a
+	}
+}
+
+func Registry(r registry.Registry) Option {
+	return func(o *options) {
+		o.registry = r
+	}
+}
+
+func Transport(t transport.Transport) Option {
+	return func(o *options) {
+		o.transport = t
+	}
+}
+
+func Metadata(md map[string]string) Option {
+	return func(o *options) {
+		o.metadata = md
+	}
+}

server/receiver.go

@@ -1,6 +0,0 @@
-package server
-
-type Receiver interface {
-	Name() string
-	Handler() interface{}
-}

server/rpc_handler.go

@@ -0,0 +1,45 @@
+package server
+
+import (
+	"reflect"
+
+	"github.com/myodc/go-micro/registry"
+)
+
+type rpcHandler struct {
+	name      string
+	handler   interface{}
+	endpoints []*registry.Endpoint
+}
+
+func newRpcHandler(handler interface{}) Handler {
+	typ := reflect.TypeOf(handler)
+	hdlr := reflect.ValueOf(handler)
+	name := reflect.Indirect(hdlr).Type().Name()
+
+	var endpoints []*registry.Endpoint
+
+	for m := 0; m < typ.NumMethod(); m++ {
+		if e := extractEndpoint(typ.Method(m)); e != nil {
+			endpoints = append(endpoints, e)
+		}
+	}
+
+	return &rpcHandler{
+		name:      name,
+		handler:   handler,
+		endpoints: endpoints,
+	}
+}
+
+func (r *rpcHandler) Name() string {
+	return r.name
+}
+
+func (r *rpcHandler) Handler() interface{} {
+	return r.handler
+}
+
+func (r *rpcHandler) Endpoints() []*registry.Endpoint {
+	return r.endpoints
+}

server/rpc_receiver.go

@@ -1,21 +0,0 @@
-package server
-
-type rpcReceiver struct {
-	name    string
-	handler interface{}
-}
-
-func newRpcReceiver(name string, handler interface{}) Receiver {
-	return &rpcReceiver{
-		name:    name,
-		handler: handler,
-	}
-}
-
-func (r *rpcReceiver) Name() string {
-	return r.name
-}
-
-func (r *rpcReceiver) Handler() interface{} {
-	return r.handler
-}

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...),
+		opts:     newOptions(opts...),
-		rpc:  rpc.NewServer(),
+		rpc:      rpc.NewServer(),
-		exit: make(chan chan error),
+		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 {
+func (s *rpcServer) NewHandler(h interface{}) Handler {
-	return newRpcReceiver("", handler)
+	return newRpcHandler(h)
 }
 
-func (s *rpcServer) NewNamedReceiver(name string, handler interface{}) Receiver {
+func (s *rpcServer) Handle(h Handler) error {
-	return newRpcReceiver(name, handler)
+	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 {
+func (s *rpcServer) Register() error {
-	if len(r.Name()) > 0 {
+	// parse address for host, port
-		s.rpc.RegisterName(r.Name(), r.Handler())
+	config := s.Config()
-		return nil
+	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())
+	// register service
-	return nil
+	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)
 

server/server.go

@@ -3,22 +3,19 @@ package server
 import (
 	"os"
 	"os/signal"
-	"strconv"
-	"strings"
 	"syscall"
 
 	"code.google.com/p/go-uuid/uuid"
 	log "github.com/golang/glog"
-	"github.com/myodc/go-micro/registry"
-	"github.com/myodc/go-micro/transport"
 )
 
 type Server interface {
 	Config() options
 	Init(...Option)
-	NewReceiver(interface{}) Receiver
+	Handle(Handler) error
-	NewNamedReceiver(string, interface{}) Receiver
+	NewHandler(interface{}) Handler
-	Register(Receiver) error
+	Register() error
+	Deregister() error
 	Start() error
 	Stop() error
 }
@@ -28,46 +25,11 @@ type Option func(*options)
 var (
 	DefaultAddress        = ":0"
 	DefaultName           = "go-server"
+	DefaultVersion        = "1.0.0"
 	DefaultId             = uuid.NewUUID().String()
 	DefaultServer  Server = newRpcServer()
 )
 
-func Name(n string) Option {
-	return func(o *options) {
-		o.name = n
-	}
-}
-
-func Id(id string) Option {
-	return func(o *options) {
-		o.id = id
-	}
-}
-
-func Address(a string) Option {
-	return func(o *options) {
-		o.address = a
-	}
-}
-
-func Registry(r registry.Registry) Option {
-	return func(o *options) {
-		o.registry = r
-	}
-}
-
-func Transport(t transport.Transport) Option {
-	return func(o *options) {
-		o.transport = t
-	}
-}
-
-func Metadata(md map[string]string) Option {
-	return func(o *options) {
-		o.metadata = md
-	}
-}
-
 func Config() options {
 	return DefaultServer.Config()
 }
@@ -83,16 +45,20 @@ func NewServer(opt ...Option) Server {
 	return newRpcServer(opt...)
 }
 
-func NewReceiver(handler interface{}) Receiver {
+func NewHandler(h interface{}) Handler {
-	return DefaultServer.NewReceiver(handler)
+	return DefaultServer.NewHandler(h)
 }
 
-func NewNamedReceiver(path string, handler interface{}) Receiver {
+func Handle(h Handler) error {
-	return DefaultServer.NewNamedReceiver(path, handler)
+	return DefaultServer.Handle(h)
 }
 
-func Register(r Receiver) error {
+func Register() error {
-	return DefaultServer.Register(r)
+	return DefaultServer.Register()
+}
+
+func Deregister() error {
+	return DefaultServer.Deregister()
 }
 
 func Run() error {
@@ -100,44 +66,20 @@ func Run() error {
 		return err
 	}
 
-	// parse address for host, port
+	if err := DefaultServer.Register(); err != nil {
-	config := DefaultServer.Config()
+		return err
-	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]
-	}
-
-	// register service
-	node := &registry.Node{
-		Id:       config.Id(),
-		Address:  host,
-		Port:     port,
-		Metadata: config.Metadata(),
-	}
-
-	service := &registry.Service{
-		Name:  config.Name(),
-		Nodes: []*registry.Node{node},
-	}
-
-	log.Infof("Registering node: %s", node.Id)
-
-	err := config.registry.Register(service)
-	if err != nil {
-		log.Fatalf("Failed to register: %v", err)
 	}
 
 	ch := make(chan os.Signal, 1)
 	signal.Notify(ch, syscall.SIGTERM, syscall.SIGINT, syscall.SIGKILL)
 	log.Infof("Received signal %s", <-ch)
 
-	log.Infof("Deregistering %s", node.Id)
+	if err := DefaultServer.Deregister(); err != nil {
-	config.registry.Deregister(service)
+		return err
+	}
+
+	log.Infof("Deregistering %s", DefaultServer.Config().Id())
+	DefaultServer.Deregister()
 
 	return Stop()
 }