add ability to register RPC endpoint

Signed-off-by: Vasiliy Tolstov <v.tolstov@unistack.org>

go.mod

@@ -3,6 +3,6 @@ module github.com/unistack-org/micro-server-http/v3
 go 1.16
 
 require (
-	github.com/unistack-org/micro/v3 v3.3.17
-	golang.org/x/net v0.0.0-20210423184538-5f58ad60dda6
+	github.com/unistack-org/micro/v3 v3.4.7
+	golang.org/x/net v0.0.0-20210614182718-04defd469f4e
 )

go.sum

@@ -6,10 +6,11 @@ github.com/imdario/mergo v0.3.12/go.mod h1:jmQim1M+e3UYxmgPu/WyfjB3N3VflVyUjjjwH
 github.com/patrickmn/go-cache v2.1.0+incompatible h1:HRMgzkcYKYpi3C8ajMPV8OFXaaRUnok+kx1WdO15EQc=
 github.com/patrickmn/go-cache v2.1.0+incompatible/go.mod h1:3Qf8kWWT7OJRJbdiICTKqZju1ZixQ/KpMGzzAfe6+WQ=
 github.com/silas/dag v0.0.0-20210121180416-41cf55125c34/go.mod h1:7RTUFBdIRC9nZ7/3RyRNH1bdqIShrDejd1YbLwgPS+I=
-github.com/unistack-org/micro/v3 v3.3.17 h1:WcyS7InP0DlS/JpRQGLh5sG6VstkdHJbgpMp+gmHmwg=
-github.com/unistack-org/micro/v3 v3.3.17/go.mod h1:022EOEZZ789hZY3yB5ZSMXU6jLiadBgcNB/cpediV3c=
-golang.org/x/net v0.0.0-20210423184538-5f58ad60dda6 h1:0PC75Fz/kyMGhL0e1QnypqK2kQMqKt9csD1GnMJR+Zk=
-golang.org/x/net v0.0.0-20210423184538-5f58ad60dda6/go.mod h1:OJAsFXCWl8Ukc7SiCT/9KSuxbyM7479/AVlXFRxuMCk=
+github.com/unistack-org/micro/v3 v3.4.7 h1:zmGFx2J6tIbmr4IGLcc+LNtbftQFZI42bfuNV5xNYM0=
+github.com/unistack-org/micro/v3 v3.4.7/go.mod h1:LXmPfbJnJNvL0kQs8HfnkV3Wya2Wb+C7keVq++RCZnk=
+golang.org/x/net v0.0.0-20210510120150-4163338589ed/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y=
+golang.org/x/net v0.0.0-20210614182718-04defd469f4e h1:XpT3nA5TvE525Ne3hInMh6+GETgn27Zfm9dxsThnX2Q=
+golang.org/x/net v0.0.0-20210614182718-04defd469f4e/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y=
 golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20210423082822-04245dca01da/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=

handler.go

@@ -81,7 +81,15 @@ func (h *httpServer) ServeHTTP(w http.ResponseWriter, r *http.Request) {
 		}
 	}
 
-	ctx := metadata.NewIncomingContext(r.Context(), nil)
+	ctx := context.WithValue(r.Context(), rspCodeKey{}, &rspCodeVal{})
+	md, ok := metadata.FromIncomingContext(ctx)
+	if !ok {
+		md = metadata.New(len(r.Header))
+	}
+	for k, v := range r.Header {
+		md.Set(k, strings.Join(v, ", "))
+	}
+	ctx = metadata.NewIncomingContext(ctx, md)
 
 	defer r.Body.Close()
 
@@ -115,6 +123,7 @@ func (h *httpServer) ServeHTTP(w http.ResponseWriter, r *http.Request) {
 	var match bool
 	var hldr patHandler
 	var handler *httpHandler
+
 	for _, hpat := range h.handlers {
 		handlertmp := hpat.(*httpHandler)
 		for _, hldrtmp := range handlertmp.handlers[r.Method] {
@@ -136,15 +145,6 @@ func (h *httpServer) ServeHTTP(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 
-	md, ok := metadata.FromIncomingContext(ctx)
-	if !ok {
-		md = metadata.New(0)
-	}
-
-	for k, v := range r.Header {
-		md.Set(k, strings.Join(v, ", "))
-	}
-
 	// get fields from url values
 	if len(r.URL.RawQuery) > 0 {
 		umd, cerr := rflutil.URLMap(r.URL.RawQuery)
@@ -203,24 +203,28 @@ func (h *httpServer) ServeHTTP(w http.ResponseWriter, r *http.Request) {
 		method:      fmt.Sprintf("%s.%s", hldr.name, hldr.mtype.method.Name),
 		body:        b,
 		payload:     argv.Interface(),
+		header:      md,
 	}
 
-	var scode int
 	// define the handler func
 	fn := func(fctx context.Context, req server.Request, rsp interface{}) (err error) {
-		fctx = context.WithValue(fctx, rspCodeKey{}, &rspCodeVal{})
-		fctx = metadata.NewIncomingContext(fctx, md)
 		returnValues = function.Call([]reflect.Value{hldr.rcvr, hldr.mtype.prepareContext(fctx), reflect.ValueOf(argv.Interface()), reflect.ValueOf(rsp)})
 
-		scode = GetRspCode(fctx)
 		// The return value for the method is an error.
 		if rerr := returnValues[0].Interface(); rerr != nil {
 			err = rerr.(error)
 		}
 
-		if md, ok := metadata.FromOutgoingContext(fctx); ok {
-			metadata.SetOutgoingContext(ctx, md)
+		md, ok := metadata.FromOutgoingContext(ctx)
+		if !ok {
+			md = metadata.New(0)
 		}
+		if nmd, ok := metadata.FromOutgoingContext(fctx); ok {
+			for k, v := range nmd {
+				md.Set(k, v)
+			}
+		}
+		metadata.SetOutgoingContext(ctx, md)
 
 		return err
 	}
@@ -239,7 +243,23 @@ func (h *httpServer) ServeHTTP(w http.ResponseWriter, r *http.Request) {
 		ct = DefaultContentType
 	}
 
-	if appErr := fn(ctx, hr, replyv.Interface()); appErr != nil {
+	scode := int(200)
+	appErr := fn(ctx, hr, replyv.Interface())
+
+	w.Header().Set("Content-Type", ct)
+	if md, ok := metadata.FromOutgoingContext(ctx); ok {
+		for k, v := range md {
+			w.Header().Set(k, v)
+		}
+	}
+	if nct := w.Header().Get("Content-Type"); nct != ct {
+		if cf, err = h.newCodec(nct); err != nil {
+			h.errorHandler(ctx, nil, w, r, err, http.StatusBadRequest)
+			return
+		}
+	}
+
+	if appErr != nil {
 		switch verr := appErr.(type) {
 		case *errors.Error:
 			scode = int(verr.Code)
@@ -252,24 +272,17 @@ func (h *httpServer) ServeHTTP(w http.ResponseWriter, r *http.Request) {
 	} else {
 		b, err = cf.Marshal(replyv.Interface())
 	}
+
 	if err != nil && handler.sopts.Logger.V(logger.ErrorLevel) {
 		handler.sopts.Logger.Errorf(handler.sopts.Context, "handler err: %v", err)
 		return
 	}
 
-	if md, ok := metadata.FromOutgoingContext(ctx); ok {
-		for k, v := range md {
-			w.Header().Set(k, v)
-		}
+	if nscode := GetRspCode(ctx); nscode != 0 {
+		scode = nscode
 	}
+	w.WriteHeader(scode)
 
-	w.Header().Set("content-Type", ct)
-	if scode != 0 {
-		w.WriteHeader(scode)
-	} else {
-		// handler.sopts.Logger.Warn(handler.sopts.Context, "response code not set in handler via SetRspCode(ctx, http.StatusXXX)")
-		w.WriteHeader(200)
-	}
 	if _, cerr := w.Write(b); cerr != nil {
 		logger.DefaultLogger.Errorf(ctx, "write failed: %v", cerr)
 	}

http.go

@@ -33,20 +33,20 @@ type httpServer struct {
 	pathHandlers        map[*regexp.Regexp]http.HandlerFunc
 	contentTypeHandlers map[string]http.HandlerFunc
 	opts                server.Options
+	registerRPC         bool
 	sync.RWMutex
 	registered bool
 	init       bool
 }
 
 func (h *httpServer) newCodec(ct string) (codec.Codec, error) {
-	h.RLock()
-	defer h.RUnlock()
-
 	if idx := strings.IndexRune(ct, ';'); idx >= 0 {
 		ct = ct[:idx]
 	}
-
-	if cf, ok := h.opts.Codecs[ct]; ok {
+	h.RLock()
+	cf, ok := h.opts.Codecs[ct]
+	h.RUnlock()
+	if ok {
 		return cf, nil
 	}
 	return nil, codec.ErrUnknownContentType
@@ -65,7 +65,6 @@ func (h *httpServer) Init(opts ...server.Option) error {
 	}
 
 	h.Lock()
-	defer h.Unlock()
 
 	for _, o := range opts {
 		o(&h.opts)
@@ -82,10 +81,16 @@ func (h *httpServer) Init(opts ...server.Option) error {
 	if h.contentTypeHandlers == nil {
 		h.contentTypeHandlers = make(map[string]http.HandlerFunc)
 	}
+
+	if v, ok := h.opts.Context.Value(registerRPCHandlerKey{}).(bool); ok {
+		h.registerRPC = v
+	}
+
 	if phs, ok := h.opts.Context.Value(pathHandlerKey{}).(*pathHandlerVal); ok && phs.h != nil {
 		for pp, ph := range phs.h {
 			exp, err := regexp.Compile(pp)
 			if err != nil {
+				h.Unlock()
 				return err
 			}
 			h.pathHandlers[exp] = ph
@@ -96,52 +101,68 @@ func (h *httpServer) Init(opts ...server.Option) error {
 			h.contentTypeHandlers[pp] = ph
 		}
 	}
+	h.Unlock()
 
+	h.RLock()
 	if err := h.opts.Register.Init(); err != nil {
+		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
 	}
 	if err := h.opts.Auth.Init(); err != nil {
+		h.RUnlock()
 		return err
 	}
 	if err := h.opts.Logger.Init(); err != nil {
+		h.RUnlock()
 		return err
 	}
 	if err := h.opts.Meter.Init(); err != nil {
+		h.RUnlock()
 		return err
 	}
 	if err := h.opts.Transport.Init(); err != nil {
+		h.RUnlock()
 		return err
 	}
+	h.RUnlock()
 
+	h.Lock()
 	h.init = true
+	h.Unlock()
 
 	return nil
 }
 
 func (h *httpServer) Handle(handler server.Handler) error {
-	h.Lock()
-	defer h.Unlock()
 	hdlr, ok := handler.(*httpHandler)
 	if !ok {
+		h.Lock()
 		h.hd = handler
+		h.Unlock()
 		return nil
 	}
 
 	if _, ok := hdlr.hd.(http.Handler); ok {
+		h.Lock()
 		h.hd = handler
+		h.Unlock()
 		return nil
 	}
 
+	h.Lock()
 	if h.handlers == nil {
 		h.handlers = make(map[string]server.Handler)
 	}
 	h.handlers[handler.Name()] = handler
+	h.Unlock()
 
 	return nil
 }
@@ -225,6 +246,24 @@ func (h *httpServer) NewHandler(handler interface{}, opts ...server.HandlerOptio
 		pth := patHandler{pat: pat, mtype: mtype, name: name, rcvr: rcvr}
 		hdlr.name = name
 		hdlr.handlers[md["Method"]] = append(hdlr.handlers[md["Method"]], pth)
+
+		if !h.registerRPC {
+			continue
+		}
+
+		cmp, err = rutil.Parse("/" + hn)
+		if err != nil && h.opts.Logger.V(logger.ErrorLevel) {
+			h.opts.Logger.Errorf(h.opts.Context, "parsing path pattern err: %v", err)
+			continue
+		}
+		tpl = cmp.Compile()
+		pat, err = rutil.NewPattern(tpl.Version, tpl.OpCodes, tpl.Pool, tpl.Verb)
+		if err != nil && h.opts.Logger.V(logger.ErrorLevel) {
+			h.opts.Logger.Errorf(h.opts.Context, "creating new pattern err: %v", err)
+			continue
+		}
+		pth = patHandler{pat: pat, mtype: mtype, name: name, rcvr: rcvr}
+		hdlr.handlers[http.MethodPost] = append(hdlr.handlers[http.MethodPost], pth)
 	}
 
 	return hdlr
@@ -247,13 +286,15 @@ func (h *httpServer) Subscribe(sb server.Subscriber) error {
 		return err
 	}
 
-	h.Lock()
-	defer h.Unlock()
+	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
 }
 
@@ -318,8 +359,6 @@ func (h *httpServer) Register() error {
 	}
 
 	h.Lock()
-	defer h.Unlock()
-
 	for sb := range h.subscribers {
 		handler := h.createSubHandler(sb, config)
 		var opts []broker.SubscribeOption
@@ -336,6 +375,7 @@ func (h *httpServer) Register() error {
 
 		sub, err := config.Broker.Subscribe(subCtx, sb.Topic(), handler, opts...)
 		if err != nil {
+			h.Unlock()
 			return err
 		}
 		h.subscribers[sb] = []broker.Subscriber{sub}
@@ -343,6 +383,7 @@ func (h *httpServer) Register() error {
 
 	h.registered = true
 	h.rsvc = service
+	h.Unlock()
 
 	return nil
 }
@@ -384,6 +425,7 @@ func (h *httpServer) Deregister() error {
 		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
 			}
@@ -497,7 +539,7 @@ func (h *httpServer) Start() error {
 		}()
 	} else {
 		go func() {
-			if cerr := http.Serve(ts, fn); cerr != nil {
+			if cerr := http.Serve(ts, fn); cerr != nil && !strings.Contains(cerr.Error(), "use of closed network connection") {
 				h.opts.Logger.Error(h.opts.Context, cerr)
 			}
 		}()
@@ -556,8 +598,6 @@ func (h *httpServer) Start() error {
 			}
 		}
 
-		ch <- ts.Close()
-
 		// deregister
 		if err := h.Deregister(); err != nil {
 			config.Logger.Errorf(config.Context, "Server deregister error: %s", err)
@@ -566,6 +606,8 @@ func (h *httpServer) Start() error {
 		if err := config.Broker.Disconnect(config.Context); err != nil {
 			config.Logger.Errorf(config.Context, "Broker disconnect error: %s", err)
 		}
+
+		ch <- ts.Close()
 	}()
 
 	return nil

options.go

@@ -110,3 +110,10 @@ func ContentTypeHandler(ct string, h http.HandlerFunc) server.Option {
 		o.Context = context.WithValue(o.Context, contentTypeHandlerKey{}, v)
 	}
 }
+
+type registerRPCHandlerKey struct{}
+
+// RegisterRPCHandler registers compatibility endpoints with /ServiceName.ServiceEndpoint method POST
+func RegisterRPCHandler(b bool) server.Option {
+	return server.SetOption(registerRPCHandlerKey{}, b)
+}