Merge pull request 'fix build' (#161) from fixup into master

Reviewed-on: #161

handler.go

@@ -60,7 +60,7 @@ func (h *httpHandler) Options() server.HandlerOptions {
 	return h.opts
 }
 
-func (h *httpServer) HTTPHandlerFunc(handler interface{}) (http.HandlerFunc, error) {
+func (h *Server) HTTPHandlerFunc(handler interface{}) (http.HandlerFunc, error) {
 	if handler == nil {
 		return nil, fmt.Errorf("invalid handler specified: %v", handler)
 	}
@@ -333,7 +333,7 @@ func (h *httpServer) HTTPHandlerFunc(handler interface{}) (http.HandlerFunc, err
 	}, nil
 }
 
-func (h *httpServer) ServeHTTP(w http.ResponseWriter, r *http.Request) {
+func (h *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) {
 	// check for http.HandlerFunc handlers
 	if ph, _, err := h.pathHandlers.Search(r.Method, r.URL.Path); err == nil {
 		ph.(http.HandlerFunc)(w, r)

http.go

@@ -9,12 +9,10 @@ import (
 	"net"
 	"net/http"
 	"reflect"
-	"sort"
 	"strings"
 	"sync"
 	"time"
 
-	"go.unistack.org/micro/v4/broker"
 	"go.unistack.org/micro/v4/codec"
 	"go.unistack.org/micro/v4/logger"
 	"go.unistack.org/micro/v4/register"
@@ -30,7 +28,6 @@ type Server struct {
 	rsvc         *register.Service
 	handlers     map[string]server.Handler
 	exit         chan chan error
-	subscribers  map[*httpSubscriber][]broker.Subscriber
 	errorHandler func(context.Context, server.Handler, http.ResponseWriter, *http.Request, error, int)
 	pathHandlers *rhttp.Trie
 	opts         server.Options
@@ -101,10 +98,6 @@ func (h *Server) Init(opts ...server.Option) error {
 		h.RUnlock()
 		return err
 	}
-	if err := h.opts.Broker.Init(); err != nil {
-		h.RUnlock()
-		return err
-	}
 	if err := h.opts.Tracer.Init(); err != nil {
 		h.RUnlock()
 		return err
@@ -288,35 +281,6 @@ func (h *Server) NewHandler(handler interface{}, opts ...server.HandlerOption) s
 	return hdlr
 }
 
-func (h *Server) NewSubscriber(topic string, handler interface{}, opts ...server.SubscriberOption) server.Subscriber {
-	return newSubscriber(topic, handler, opts...)
-}
-
-func (h *Server) Subscribe(sb server.Subscriber) error {
-	sub, ok := sb.(*httpSubscriber)
-	if !ok {
-		return fmt.Errorf("invalid subscriber: expected *httpSubscriber")
-	}
-	if len(sub.handlers) == 0 {
-		return fmt.Errorf("invalid subscriber: no handler functions")
-	}
-
-	if err := server.ValidateSubscriber(sb); err != nil {
-		return err
-	}
-
-	h.RLock()
-	_, ok = h.subscribers[sub]
-	h.RUnlock()
-	if ok {
-		return fmt.Errorf("subscriber %v already exists", h)
-	}
-	h.Lock()
-	h.subscribers[sub] = nil
-	h.Unlock()
-	return nil
-}
-
 func (h *Server) Register() error {
 	var eps []*register.Endpoint
 	h.RLock()
@@ -342,21 +306,6 @@ func (h *Server) Register() error {
 	service.Nodes[0].Metadata["protocol"] = "http"
 	service.Endpoints = eps
 
-	h.Lock()
-	subscriberList := make([]*httpSubscriber, 0, len(h.subscribers))
-	for e := range h.subscribers {
-		// Only advertise non internal subscribers
-		subscriberList = append(subscriberList, e)
-	}
-	sort.Slice(subscriberList, func(i, j int) bool {
-		return subscriberList[i].topic > subscriberList[j].topic
-	})
-
-	for _, e := range subscriberList {
-		service.Endpoints = append(service.Endpoints, e.Endpoints()...)
-	}
-	h.Unlock()
-
 	h.RLock()
 	registered := h.registered
 	h.RUnlock()
@@ -378,29 +327,6 @@ func (h *Server) Register() error {
 	}
 
 	h.Lock()
-	for sb := range h.subscribers {
-		handler := h.createSubHandler(sb, config)
-		var opts []broker.SubscribeOption
-		if queue := sb.Options().Queue; len(queue) > 0 {
-			opts = append(opts, broker.SubscribeGroup(queue))
-		}
-
-		subCtx := config.Context
-		if cx := sb.Options().Context; cx != nil {
-			subCtx = cx
-		}
-		opts = append(opts, broker.SubscribeContext(subCtx))
-		opts = append(opts, broker.SubscribeAutoAck(sb.Options().AutoAck))
-		opts = append(opts, broker.SubscribeBodyOnly(sb.Options().BodyOnly))
-
-		sub, err := config.Broker.Subscribe(subCtx, sb.Topic(), handler, opts...)
-		if err != nil {
-			h.Unlock()
-			return err
-		}
-		h.subscribers[sb] = []broker.Subscriber{sub}
-	}
-
 	h.registered = true
 	h.rsvc = service
 	h.Unlock()
@@ -435,23 +361,6 @@ func (h *Server) Deregister() error {
 	}
 
 	h.registered = false
-
-	subCtx := h.opts.Context
-	for sb, subs := range h.subscribers {
-		if cx := sb.Options().Context; cx != nil {
-			subCtx = cx
-		}
-
-		for _, sub := range subs {
-			config.Logger.Infof(config.Context, "Unsubscribing from topic: %s", sub.Topic())
-			if err := sub.Unsubscribe(subCtx); err != nil {
-				h.Unlock()
-				config.Logger.Errorf(config.Context, "failed to unsubscribe topic: %s, error: %v", sb.Topic(), err)
-				return err
-			}
-		}
-		h.subscribers[sb] = nil
-	}
 	h.Unlock()
 	return nil
 }
@@ -525,10 +434,6 @@ func (h *Server) Start() error {
 		return fmt.Errorf("cant process with nil handler")
 	}
 
-	if err := config.Broker.Connect(h.opts.Context); err != nil {
-		return err
-	}
-
 	if err := config.RegisterCheck(h.opts.Context); err != nil {
 		if config.Logger.V(logger.ErrorLevel) {
 			config.Logger.Errorf(config.Context, "Server %s-%s register check error: %s", config.Name, config.ID, err)
@@ -626,10 +531,6 @@ func (h *Server) Start() error {
 			config.Logger.Errorf(config.Context, "Server deregister error: %s", err)
 		}
 
-		if err := config.Broker.Disconnect(config.Context); err != nil {
-			config.Logger.Errorf(config.Context, "Broker disconnect error: %s", err)
-		}
-
 		ch <- ts.Close()
 	}()
 
@@ -659,7 +560,6 @@ func NewServer(opts ...server.Option) *Server {
 	return &Server{
 		opts:         options,
 		exit:         make(chan chan error),
-		subscribers:  make(map[*httpSubscriber][]broker.Subscriber),
 		errorHandler: eh,
 		pathHandlers: rhttp.NewTrie(),
 	}

options.go

@@ -85,8 +85,8 @@ func Middleware(mw ...func(http.Handler) http.Handler) server.Option {
 
 type serverKey struct{}
 
-// Server provide ability to pass *http.Server
-func Server(hs *http.Server) server.Option {
+// HTTPServer provide ability to pass *http.Server
+func HTTPServer(hs *http.Server) server.Option {
 	return server.SetOption(serverKey{}, hs)
 }
 

request.go

@@ -8,10 +8,7 @@ import (
 	"go.unistack.org/micro/v4/server"
 )
 
-var (
-	_ server.Request = &rpcRequest{}
-	_ server.Message = &rpcMessage{}
-)
+var _ server.Request = &rpcRequest{}
 
 type rpcRequest struct {
 	rw          io.ReadWriter
@@ -25,14 +22,6 @@ type rpcRequest struct {
 	stream      bool
 }
 
-type rpcMessage struct {
-	payload     interface{}
-	codec       codec.Codec
-	header      metadata.Metadata
-	topic       string
-	contentType string
-}
-
 func (r *rpcRequest) ContentType() string {
 	return r.contentType
 }
@@ -72,23 +61,3 @@ func (r *rpcRequest) Stream() bool {
 func (r *rpcRequest) Body() interface{} {
 	return r.payload
 }
-
-func (r *rpcMessage) ContentType() string {
-	return r.contentType
-}
-
-func (r *rpcMessage) Topic() string {
-	return r.topic
-}
-
-func (r *rpcMessage) Body() interface{} {
-	return r.payload
-}
-
-func (r *rpcMessage) Header() metadata.Metadata {
-	return r.header
-}
-
-func (r *rpcMessage) Codec() codec.Codec {
-	return r.codec
-}

server.go

@@ -10,6 +10,8 @@ import (
 	"go.unistack.org/micro/v4/server"
 )
 
+var typeOfError = reflect.TypeOf((*error)(nil)).Elem()
+
 type methodType struct {
 	ArgType     reflect.Type
 	ReplyType   reflect.Type

subscriber.go

@@ -1,208 +0,0 @@
-package http
-
-import (
-	"bytes"
-	"context"
-	"fmt"
-	"reflect"
-	"strings"
-
-	"go.unistack.org/micro/v4/broker"
-	"go.unistack.org/micro/v4/codec"
-	"go.unistack.org/micro/v4/metadata"
-	"go.unistack.org/micro/v4/register"
-	"go.unistack.org/micro/v4/server"
-)
-
-var typeOfError = reflect.TypeOf((*error)(nil)).Elem()
-
-type handler struct {
-	reqType reflect.Type
-	ctxType reflect.Type
-	method  reflect.Value
-}
-
-type httpSubscriber struct {
-	topic      string
-	rcvr       reflect.Value
-	typ        reflect.Type
-	subscriber interface{}
-	handlers   []*handler
-	endpoints  []*register.Endpoint
-	opts       server.SubscriberOptions
-}
-
-func newSubscriber(topic string, sub interface{}, opts ...server.SubscriberOption) server.Subscriber {
-	options := server.NewSubscriberOptions(opts...)
-
-	var endpoints []*register.Endpoint
-	var handlers []*handler
-
-	if typ := reflect.TypeOf(sub); typ.Kind() == reflect.Func {
-		h := &handler{
-			method: reflect.ValueOf(sub),
-		}
-
-		switch typ.NumIn() {
-		case 1:
-			h.reqType = typ.In(0)
-		case 2:
-			h.ctxType = typ.In(0)
-			h.reqType = typ.In(1)
-		}
-
-		handlers = append(handlers, h)
-		ep := &register.Endpoint{
-			Name:     "Func",
-			Request:  register.ExtractSubValue(typ),
-			Metadata: metadata.New(2),
-		}
-		ep.Metadata.Set("topic", topic)
-		ep.Metadata.Set("subscriber", "true")
-		endpoints = append(endpoints, ep)
-	} else {
-		hdlr := reflect.ValueOf(sub)
-		name := reflect.Indirect(hdlr).Type().Name()
-
-		for m := 0; m < typ.NumMethod(); m++ {
-			method := typ.Method(m)
-			h := &handler{
-				method: method.Func,
-			}
-
-			switch method.Type.NumIn() {
-			case 2:
-				h.reqType = method.Type.In(1)
-			case 3:
-				h.ctxType = method.Type.In(1)
-				h.reqType = method.Type.In(2)
-			}
-
-			handlers = append(handlers, h)
-			ep := &register.Endpoint{
-				Name:     name + "." + method.Name,
-				Request:  register.ExtractSubValue(method.Type),
-				Metadata: metadata.New(2),
-			}
-			ep.Metadata.Set("topic", topic)
-			ep.Metadata.Set("subscriber", "true")
-			endpoints = append(endpoints, ep)
-		}
-	}
-
-	return &httpSubscriber{
-		rcvr:       reflect.ValueOf(sub),
-		typ:        reflect.TypeOf(sub),
-		topic:      topic,
-		subscriber: sub,
-		handlers:   handlers,
-		endpoints:  endpoints,
-		opts:       options,
-	}
-}
-
-func (s *httpServer) createSubHandler(sb *httpSubscriber, opts server.Options) broker.Handler {
-	return func(p broker.Event) error {
-		msg := p.Message()
-		ct := msg.Header["Content-Type"]
-		cf, err := s.newCodec(ct)
-		if err != nil {
-			return err
-		}
-
-		hdr := metadata.Copy(msg.Header)
-		delete(hdr, "Content-Type")
-		ctx := metadata.NewIncomingContext(context.Background(), hdr)
-
-		results := make(chan error, len(sb.handlers))
-
-		for i := 0; i < len(sb.handlers); i++ {
-			handler := sb.handlers[i]
-
-			var isVal bool
-			var req reflect.Value
-
-			if handler.reqType.Kind() == reflect.Ptr {
-				req = reflect.New(handler.reqType.Elem())
-			} else {
-				req = reflect.New(handler.reqType)
-				isVal = true
-			}
-			if isVal {
-				req = req.Elem()
-			}
-
-			buf := bytes.NewBuffer(msg.Body)
-
-			if err := cf.ReadHeader(buf, &codec.Message{}, codec.Event); err != nil {
-				return err
-			}
-
-			if err := cf.ReadBody(buf, req.Interface()); err != nil {
-				return err
-			}
-
-			fn := func(ctx context.Context, msg server.Message) error {
-				var vals []reflect.Value
-				if sb.typ.Kind() != reflect.Func {
-					vals = append(vals, sb.rcvr)
-				}
-				if handler.ctxType != nil {
-					vals = append(vals, reflect.ValueOf(ctx))
-				}
-
-				vals = append(vals, reflect.ValueOf(msg.Body()))
-
-				returnValues := handler.method.Call(vals)
-				if err := returnValues[0].Interface(); err != nil {
-					return err.(error)
-				}
-				return nil
-			}
-
-			for i := len(opts.SubWrappers); i > 0; i-- {
-				fn = opts.SubWrappers[i-1](fn)
-			}
-
-			go func() {
-				results <- fn(ctx, &httpMessage{
-					topic:       sb.topic,
-					contentType: ct,
-					payload:     req.Interface(),
-					header:      msg.Header,
-					codec:       cf,
-				})
-			}()
-		}
-
-		var errors []string
-
-		for i := 0; i < len(sb.handlers); i++ {
-			if err := <-results; err != nil {
-				errors = append(errors, err.Error())
-			}
-		}
-
-		if len(errors) > 0 {
-			return fmt.Errorf("subscriber error: %s", strings.Join(errors, "\n"))
-		}
-
-		return nil
-	}
-}
-
-func (s *httpSubscriber) Topic() string {
-	return s.topic
-}
-
-func (s *httpSubscriber) Subscriber() interface{} {
-	return s.subscriber
-}
-
-func (s *httpSubscriber) Endpoints() []*register.Endpoint {
-	return s.endpoints
-}
-
-func (s *httpSubscriber) Options() server.SubscriberOptions {
-	return s.opts
-}