util/reflect: add interface merging

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

.github/generate.sh

@@ -1,15 +0,0 @@
-#!/bin/bash -e
-
-find . -type f -name '*.pb.*.go' -o -name '*.pb.go' -a ! -name 'message.pb.go' -delete
-PROTOS=$(find . -type f -name '*.proto' | grep -v proto/google/api)
-
-mkdir -p proto/google/api
-curl -s -o proto/google/api/annotations.proto -L https://raw.githubusercontent.com/googleapis/googleapis/master/google/api/annotations.proto
-curl -s -o proto/google/api/http.proto -L https://raw.githubusercontent.com/googleapis/googleapis/master/google/api/http.proto
-
-for PROTO in $PROTOS; do
-  echo $PROTO
-  protoc -I./proto -I. -I$(dirname $PROTO) --go-grpc_out=paths=source_relative:. --go_out=paths=source_relative:. --micro_out=paths=source_relative:. $PROTO
-done
-
-rm -r proto

auth/auth.go

@@ -30,7 +30,7 @@ var (
 // Auth provides authentication and authorization
 type Auth interface {
 	// Init the auth
-	Init(opts ...Option)
+	Init(opts ...Option) error
 	// Options set for auth
 	Options() Options
 	// Generate a new account

auth/noop.go

@@ -14,10 +14,11 @@ func (n *noopAuth) String() string {
 }
 
 // Init the auth
-func (n *noopAuth) Init(opts ...Option) {
+func (n *noopAuth) Init(opts ...Option) error {
 	for _, o := range opts {
 		o(&n.opts)
 	}
+	return nil
 }
 
 // Options set for auth

client/options.go

@@ -2,6 +2,7 @@ package client
 
 import (
 	"context"
+	"crypto/tls"
 	"time"
 
 	"github.com/unistack-org/micro/v3/broker"
@@ -52,6 +53,8 @@ type Options struct {
 	PoolSize int
 	// PoolTTL connection pool ttl
 	PoolTTL time.Duration
+	// TLSConfig specifies tls.Config for secure connection
+	TLSConfig *tls.Config
 }
 
 // NewCallOptions creates new call options struct
@@ -77,6 +80,8 @@ type CallOptions struct {
 	Backoff BackoffFunc
 	// Network name
 	Network string
+	// Content-Type
+	ContentType string
 	// CallWrappers call wrappers
 	CallWrappers []CallWrapper
 	// SelectOptions selector options
@@ -167,14 +172,16 @@ func NewOptions(opts ...Option) Options {
 			RequestTimeout: DefaultRequestTimeout,
 			DialTimeout:    transport.DefaultDialTimeout,
 		},
-		Lookup:   LookupRoute,
-		PoolSize: DefaultPoolSize,
-		PoolTTL:  DefaultPoolTTL,
-		Selector: random.NewSelector(),
-		Logger:   logger.DefaultLogger,
-		Broker:   broker.DefaultBroker,
-		Meter:    meter.DefaultMeter,
-		Tracer:   tracer.DefaultTracer,
+		Lookup:    LookupRoute,
+		PoolSize:  DefaultPoolSize,
+		PoolTTL:   DefaultPoolTTL,
+		Selector:  random.NewSelector(),
+		Logger:    logger.DefaultLogger,
+		Broker:    broker.DefaultBroker,
+		Meter:     meter.DefaultMeter,
+		Tracer:    tracer.DefaultTracer,
+		Router:    router.DefaultRouter,
+		Transport: transport.DefaultTransport,
 	}
 
 	for _, o := range opts {
@@ -312,6 +319,22 @@ func Lookup(l LookupFunc) Option {
 	}
 }
 
+// TLSConfig specifies a *tls.Config
+func TLSConfig(t *tls.Config) Option {
+	return func(o *Options) {
+		// set the internal tls
+		o.TLSConfig = t
+
+		// set the default transport if one is not
+		// already set. Required for Init call below.
+
+		// set the transport tls
+		o.Transport.Init(
+			transport.TLSConfig(t),
+		)
+	}
+}
+
 // Retries sets the retry count when making the request.
 func Retries(i int) Option {
 	return func(o *Options) {
@@ -361,6 +384,13 @@ func PublishContext(ctx context.Context) PublishOption {
 	}
 }
 
+// WithContentType specifies call content type
+func WithContentType(ct string) CallOption {
+	return func(o *CallOptions) {
+		o.ContentType = ct
+	}
+}
+
 // WithAddress sets the remote addresses to use rather than using service discovery
 func WithAddress(a ...string) CallOption {
 	return func(o *CallOptions) {
@@ -465,16 +495,16 @@ func WithMessageContentType(ct string) MessageOption {
 	}
 }
 
-// WithContentType specifies request content type
-func WithContentType(ct string) RequestOption {
+// StreamingRequest specifies that request is streaming
+func StreamingRequest(b bool) RequestOption {
+	return func(o *RequestOptions) {
+		o.Stream = b
+	}
+}
+
+// RequestContentType specifies request content type
+func RequestContentType(ct string) RequestOption {
 	return func(o *RequestOptions) {
 		o.ContentType = ct
 	}
 }
-
-// StreamingRequest specifies that request is streaming
-func StreamingRequest() RequestOption {
-	return func(o *RequestOptions) {
-		o.Stream = true
-	}
-}

generate.go

@@ -1,3 +0,0 @@
-package micro
-
-//go:generate ./.github/generate.sh

go.mod

@@ -9,5 +9,5 @@ require (
 	github.com/imdario/mergo v0.3.12
 	github.com/patrickmn/go-cache v2.1.0+incompatible
 	github.com/silas/dag v0.0.0-20210121180416-41cf55125c34
-	golang.org/x/net v0.0.0-20210316092652-d523dce5a7f4
+	golang.org/x/net v0.0.0-20210415231046-e915ea6b2b7d
 )

go.sum

@@ -10,12 +10,12 @@ github.com/patrickmn/go-cache v2.1.0+incompatible h1:HRMgzkcYKYpi3C8ajMPV8OFXaaR
 github.com/patrickmn/go-cache v2.1.0+incompatible/go.mod h1:3Qf8kWWT7OJRJbdiICTKqZju1ZixQ/KpMGzzAfe6+WQ=
 github.com/silas/dag v0.0.0-20210121180416-41cf55125c34 h1:vBfVmA5mZhsQa2jr1FOL9nfA37N/jnbBmi5XUfviVTI=
 github.com/silas/dag v0.0.0-20210121180416-41cf55125c34/go.mod h1:7RTUFBdIRC9nZ7/3RyRNH1bdqIShrDejd1YbLwgPS+I=
-golang.org/x/net v0.0.0-20210316092652-d523dce5a7f4 h1:b0LrWgu8+q7z4J+0Y3Umo5q1dL7NXBkKBWkaVkAq17E=
-golang.org/x/net v0.0.0-20210316092652-d523dce5a7f4/go.mod h1:RBQZq4jEuRlivfhVLdyRGr576XBO4/greRjx4P4O3yc=
+golang.org/x/net v0.0.0-20210415231046-e915ea6b2b7d h1:BgJvlyh+UqCUaPlscHJ+PN8GcpfrFdr7NHjd1JL0+Gs=
+golang.org/x/net v0.0.0-20210415231046-e915ea6b2b7d/go.mod h1:9tjilg8BloeKEkVJvy7fQ90B1CfIiPueXVOjqfkSzI8=
 golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20210315160823-c6e025ad8005/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20210330210617-4fbd30eecc44/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
-golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
+golang.org/x/text v0.3.6/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
 golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/yaml.v2 v2.3.0 h1:clyUAQHOM3G0M3f5vQj7LuJrETvjVot3Z5el9nffUtU=

logger/wrapper/wrapper.go

@@ -3,6 +3,7 @@ package wrapper
 
 import (
 	"context"
+	"fmt"
 
 	"github.com/unistack-org/micro/v3/client"
 	"github.com/unistack-org/micro/v3/logger"
@@ -57,6 +58,8 @@ var (
 		}
 		return labels
 	}
+
+	DefaultSkipEndpoints = []string{"Meter.Metrics"}
 )
 
 type lWrapper struct {
@@ -94,6 +97,8 @@ type Options struct {
 	ServerHandlerObservers []ServerHandlerObserver
 	// ServerSubscriberObservers funcs
 	ServerSubscriberObservers []ServerSubscriberObserver
+	// SkipEndpoints
+	SkipEndpoints []string
 }
 
 // Option func signature
@@ -110,6 +115,7 @@ func NewOptions(opts ...Option) Options {
 		ClientCallFuncObservers:   []ClientCallFuncObserver{DefaultClientCallFuncObserver},
 		ServerHandlerObservers:    []ServerHandlerObserver{DefaultServerHandlerObserver},
 		ServerSubscriberObservers: []ServerSubscriberObserver{DefaultServerSubscriberObserver},
+		SkipEndpoints:             DefaultSkipEndpoints,
 	}
 
 	for _, o := range opts {
@@ -182,9 +188,23 @@ func WithServerSubscriberObservers(ob ...ServerSubscriberObserver) Option {
 	}
 }
 
+// SkipEndpoins
+func SkipEndpoints(eps ...string) Option {
+	return func(o *Options) {
+		o.SkipEndpoints = append(o.SkipEndpoints, eps...)
+	}
+}
+
 func (l *lWrapper) Call(ctx context.Context, req client.Request, rsp interface{}, opts ...client.CallOption) error {
 	err := l.Client.Call(ctx, req, rsp, opts...)
 
+	endpoint := fmt.Sprintf("%s.%s", req.Service(), req.Endpoint())
+	for _, ep := range l.opts.SkipEndpoints {
+		if ep == endpoint {
+			return err
+		}
+	}
+
 	if !l.opts.Enabled {
 		return err
 	}
@@ -205,6 +225,13 @@ func (l *lWrapper) Call(ctx context.Context, req client.Request, rsp interface{}
 func (l *lWrapper) Stream(ctx context.Context, req client.Request, opts ...client.CallOption) (client.Stream, error) {
 	stream, err := l.Client.Stream(ctx, req, opts...)
 
+	endpoint := fmt.Sprintf("%s.%s", req.Service(), req.Endpoint())
+	for _, ep := range l.opts.SkipEndpoints {
+		if ep == endpoint {
+			return stream, err
+		}
+	}
+
 	if !l.opts.Enabled {
 		return stream, err
 	}
@@ -225,6 +252,13 @@ func (l *lWrapper) Stream(ctx context.Context, req client.Request, opts ...clien
 func (l *lWrapper) Publish(ctx context.Context, msg client.Message, opts ...client.PublishOption) error {
 	err := l.Client.Publish(ctx, msg, opts...)
 
+	endpoint := msg.Topic()
+	for _, ep := range l.opts.SkipEndpoints {
+		if ep == endpoint {
+			return err
+		}
+	}
+
 	if !l.opts.Enabled {
 		return err
 	}
@@ -245,6 +279,13 @@ func (l *lWrapper) Publish(ctx context.Context, msg client.Message, opts ...clie
 func (l *lWrapper) ServerHandler(ctx context.Context, req server.Request, rsp interface{}) error {
 	err := l.serverHandler(ctx, req, rsp)
 
+	endpoint := req.Endpoint()
+	for _, ep := range l.opts.SkipEndpoints {
+		if ep == endpoint {
+			return err
+		}
+	}
+
 	if !l.opts.Enabled {
 		return err
 	}
@@ -265,6 +306,13 @@ func (l *lWrapper) ServerHandler(ctx context.Context, req server.Request, rsp in
 func (l *lWrapper) ServerSubscriber(ctx context.Context, msg server.Message) error {
 	err := l.serverSubscriber(ctx, msg)
 
+	endpoint := msg.Topic()
+	for _, ep := range l.opts.SkipEndpoints {
+		if ep == endpoint {
+			return err
+		}
+	}
+
 	if !l.opts.Enabled {
 		return err
 	}
@@ -309,6 +357,13 @@ func NewClientCallWrapper(opts ...Option) client.CallWrapper {
 func (l *lWrapper) ClientCallFunc(ctx context.Context, addr string, req client.Request, rsp interface{}, opts client.CallOptions) error {
 	err := l.clientCallFunc(ctx, addr, req, rsp, opts)
 
+	endpoint := fmt.Sprintf("%s.%s", req.Service(), req.Endpoint())
+	for _, ep := range l.opts.SkipEndpoints {
+		if ep == endpoint {
+			return err
+		}
+	}
+
 	if !l.opts.Enabled {
 		return err
 	}

meter/generate.go

@@ -0,0 +1,3 @@
+package meter
+
+//go:generate protoc -I./handler -I../ -I/home/vtolstov/.cache/go-path/pkg/mod/github.com/unistack-org/micro-proto@v0.0.1 --micro_out=components=micro|http|server,standalone=false,debug=true,paths=source_relative:./handler handler/handler.proto

meter/handler/handler.go

@@ -0,0 +1,69 @@
+package handler
+
+import (
+	"bytes"
+	"context"
+
+	"github.com/unistack-org/micro/v3/codec"
+	"github.com/unistack-org/micro/v3/errors"
+	"github.com/unistack-org/micro/v3/meter"
+)
+
+var (
+	// guard to fail early
+	_ MeterServer = &handler{}
+)
+
+type handler struct {
+	opts Options
+}
+
+type Option func(*Options)
+
+type Options struct {
+	Meter        meter.Meter
+	MeterOptions []meter.Option
+	Name         string
+}
+
+func Meter(m meter.Meter) Option {
+	return func(o *Options) {
+		o.Meter = m
+	}
+}
+
+func Name(name string) Option {
+	return func(o *Options) {
+		o.Name = name
+	}
+}
+
+func MeterOptions(opts ...meter.Option) Option {
+	return func(o *Options) {
+		o.MeterOptions = append(o.MeterOptions, opts...)
+	}
+}
+
+func NewOptions(opts ...Option) Options {
+	options := Options{Meter: meter.DefaultMeter}
+	for _, o := range opts {
+		o(&options)
+	}
+	return options
+}
+
+func NewHandler(opts ...Option) *handler {
+	options := NewOptions(opts...)
+	return &handler{opts: options}
+}
+
+func (h *handler) Metrics(ctx context.Context, req *codec.Frame, rsp *codec.Frame) error {
+	buf := bytes.NewBuffer(nil)
+	if err := h.opts.Meter.Write(buf, h.opts.MeterOptions...); err != nil {
+		return errors.InternalServerError(h.opts.Name, "%v", err)
+	}
+
+	rsp.Data = buf.Bytes()
+
+	return nil
+}

meter/handler/handler.proto

@@ -0,0 +1,28 @@
+syntax = "proto3";
+
+package micro.meter.handler;
+option go_package = "github.com/unistack-org/micro/v3/meter/handler;handler";
+
+import "api/annotations.proto";
+import "openapiv2/annotations.proto";
+import "codec/frame.proto";
+
+service Meter {
+	rpc Metrics(micro.codec.Frame) returns (micro.codec.Frame) {
+		option (micro.openapiv2.openapiv2_operation) = {
+      operation_id: "Metrics";
+        responses: {
+          key: "default";
+          value: {
+            description: "Error response";
+            schema: {
+              json_schema: {
+                ref: "micro.codec.Frame";
+              }
+            }
+          }
+        }
+    };
+		option (micro.api.http) = { get: "/metrics"; };
+  };
+};

meter/handler/handler_micro.pb.go

@@ -0,0 +1,24 @@
+// Code generated by protoc-gen-micro
+// source: handler.proto
+package handler
+
+import (
+	context "context"
+	api "github.com/unistack-org/micro/v3/api"
+	codec "github.com/unistack-org/micro/v3/codec"
+)
+
+func NewMeterEndpoints() []*api.Endpoint {
+	return []*api.Endpoint{
+		&api.Endpoint{
+			Name:    "Meter.Metrics",
+			Path:    []string{"/metrics"},
+			Method:  []string{"GET"},
+			Handler: "rpc",
+		},
+	}
+}
+
+type MeterServer interface {
+	Metrics(ctx context.Context, req *codec.Frame, rsp *codec.Frame) error
+}

meter/handler/handler_micro_http.pb.go

@@ -0,0 +1,33 @@
+// Code generated by protoc-gen-micro
+// source: handler.proto
+package handler
+
+import (
+	context "context"
+	api "github.com/unistack-org/micro/v3/api"
+	codec "github.com/unistack-org/micro/v3/codec"
+	server "github.com/unistack-org/micro/v3/server"
+)
+
+type meterServer struct {
+	MeterServer
+}
+
+func (h *meterServer) Metrics(ctx context.Context, req *codec.Frame, rsp *codec.Frame) error {
+	return h.MeterServer.Metrics(ctx, req, rsp)
+}
+
+func RegisterMeterServer(s server.Server, sh MeterServer, opts ...server.HandlerOption) error {
+	type meter interface {
+		Metrics(ctx context.Context, req *codec.Frame, rsp *codec.Frame) error
+	}
+	type Meter struct {
+		meter
+	}
+	h := &meterServer{sh}
+	var nopts []server.HandlerOption
+	for _, endpoint := range NewMeterEndpoints() {
+		nopts = append(nopts, api.WithEndpoint(endpoint))
+	}
+	return s.Handle(s.NewHandler(&Meter{h}, append(nopts, opts...)...))
+}

meter/wrapper/wrapper.go

@@ -28,19 +28,24 @@ var (
 	labelFailure  = "failure"
 	labelStatus   = "status"
 	labelEndpoint = "endpoint"
+
+	// DefaultSkipEndpoints contains list of endpoints that not evaluted by wrapper
+	DefaultSkipEndpoints = []string{"Meter.Metrics"}
 )
 
 type Options struct {
-	Meter meter.Meter
-	lopts []meter.Option
+	Meter         meter.Meter
+	lopts         []meter.Option
+	SkipEndpoints []string
 }
 
 type Option func(*Options)
 
 func NewOptions(opts ...Option) Options {
 	options := Options{
-		Meter: meter.DefaultMeter,
-		lopts: make([]meter.Option, 0, 5),
+		Meter:         meter.DefaultMeter,
+		lopts:         make([]meter.Option, 0, 5),
+		SkipEndpoints: DefaultSkipEndpoints,
 	}
 	for _, o := range opts {
 		o(&options)
@@ -72,6 +77,12 @@ func Meter(m meter.Meter) Option {
 	}
 }
 
+func SkipEndoints(eps ...string) Option {
+	return func(o *Options) {
+		o.SkipEndpoints = append(o.SkipEndpoints, eps...)
+	}
+}
+
 type wrapper struct {
 	client.Client
 	callFunc client.CallFunc
@@ -100,7 +111,11 @@ func NewCallWrapper(opts ...Option) client.CallWrapper {
 
 func (w *wrapper) CallFunc(ctx context.Context, addr string, req client.Request, rsp interface{}, opts client.CallOptions) error {
 	endpoint := fmt.Sprintf("%s.%s", req.Service(), req.Endpoint())
-
+	for _, ep := range w.opts.SkipEndpoints {
+		if ep == endpoint {
+			return w.callFunc(ctx, addr, req, rsp, opts)
+		}
+	}
 	ts := time.Now()
 	err := w.callFunc(ctx, addr, req, rsp, opts)
 	te := time.Since(ts)
@@ -123,6 +138,11 @@ func (w *wrapper) CallFunc(ctx context.Context, addr string, req client.Request,
 
 func (w *wrapper) Call(ctx context.Context, req client.Request, rsp interface{}, opts ...client.CallOption) error {
 	endpoint := fmt.Sprintf("%s.%s", req.Service(), req.Endpoint())
+	for _, ep := range w.opts.SkipEndpoints {
+		if ep == endpoint {
+			return w.Client.Call(ctx, req, rsp, opts...)
+		}
+	}
 
 	ts := time.Now()
 	err := w.Client.Call(ctx, req, rsp, opts...)
@@ -146,6 +166,11 @@ func (w *wrapper) Call(ctx context.Context, req client.Request, rsp interface{},
 
 func (w *wrapper) Stream(ctx context.Context, req client.Request, opts ...client.CallOption) (client.Stream, error) {
 	endpoint := fmt.Sprintf("%s.%s", req.Service(), req.Endpoint())
+	for _, ep := range w.opts.SkipEndpoints {
+		if ep == endpoint {
+			return w.Client.Stream(ctx, req, opts...)
+		}
+	}
 
 	ts := time.Now()
 	stream, err := w.Client.Stream(ctx, req, opts...)
@@ -200,6 +225,11 @@ func NewHandlerWrapper(opts ...Option) server.HandlerWrapper {
 func (w *wrapper) HandlerFunc(fn server.HandlerFunc) server.HandlerFunc {
 	return func(ctx context.Context, req server.Request, rsp interface{}) error {
 		endpoint := req.Endpoint()
+		for _, ep := range w.opts.SkipEndpoints {
+			if ep == endpoint {
+				return fn(ctx, req, rsp)
+			}
+		}
 
 		ts := time.Now()
 		err := fn(ctx, req, rsp)

router/dns.go

@@ -0,0 +1,91 @@
+package router
+
+import (
+	"fmt"
+	"net"
+	"strconv"
+)
+
+// NewRouter returns an initialized dns router
+func NewRouter(opts ...Option) Router {
+	options := NewOptions(opts...)
+	return &dns{options}
+}
+
+type dns struct {
+	options Options
+}
+
+func (d *dns) Init(opts ...Option) error {
+	for _, o := range opts {
+		o(&d.options)
+	}
+	return nil
+}
+
+func (d *dns) Options() Options {
+	return d.options
+}
+
+func (d *dns) Table() Table {
+	return nil
+}
+
+func (d *dns) Close() error {
+	return nil
+}
+
+func (d *dns) Lookup(opts ...QueryOption) ([]Route, error) {
+	options := NewQuery(opts...)
+	// check to see if we have the port provided in the service, e.g. go-micro-srv-foo:8000
+	host, port, err := net.SplitHostPort(options.Service)
+	if err == nil {
+		// lookup the service using A records
+		ips, err := net.LookupHost(host)
+		if err != nil {
+			return nil, err
+		}
+
+		p, _ := strconv.Atoi(port)
+
+		// convert the ip addresses to routes
+		result := make([]Route, len(ips))
+		for i, ip := range ips {
+			result[i] = Route{
+				Service: options.Service,
+				Address: fmt.Sprintf("%s:%d", ip, uint16(p)),
+			}
+		}
+		return result, nil
+	}
+
+	// we didn't get the port so we'll lookup the service using SRV records. If we can't lookup the
+	// service using the SRV record, we return the error.
+	_, nodes, err := net.LookupSRV(options.Service, "tcp", d.options.Network)
+	if err != nil {
+		return nil, err
+	}
+
+	// convert the nodes (net services) to routes
+	result := make([]Route, len(nodes))
+	for i, n := range nodes {
+		result[i] = Route{
+			Service: options.Service,
+			Address: fmt.Sprintf("%s:%d", n.Target, n.Port),
+			Network: d.options.Network,
+		}
+	}
+	return result, nil
+}
+
+func (d *dns) Watch(opts ...WatchOption) (Watcher, error) {
+	return nil, nil
+}
+
+func (d *dns) Name() string {
+	return d.options.Name
+}
+
+func (d *dns) String() string {
+	return "dns"
+}

router/router.go

@@ -7,7 +7,7 @@ import (
 
 var (
 	// DefaultRouter is the global default router
-	DefaultRouter Router
+	DefaultRouter Router = NewRouter()
 	// DefaultNetwork is default micro network
 	DefaultNetwork = "micro"
 	// ErrRouteNotFound is returned when no route was found in the routing table

server/generate.go

@@ -0,0 +1,3 @@
+package server
+
+//go:generate protoc -I./health -I../ -I/home/vtolstov/.cache/go-path/pkg/mod/github.com/unistack-org/micro-proto@v0.0.1 --micro_out=components=micro|http|server,standalone=false,debug=true,paths=source_relative:./health health/health.proto

server/health/health.go

@@ -0,0 +1,87 @@
+package health
+
+import (
+	"context"
+
+	"github.com/unistack-org/micro/v3/codec"
+	"github.com/unistack-org/micro/v3/errors"
+	"github.com/unistack-org/micro/v3/server"
+)
+
+var (
+	// guard to fail early
+	_ HealthServer = &handler{}
+)
+
+type handler struct {
+	server server.Server
+	opts   Options
+}
+
+type CheckFunc func(context.Context) error
+
+type Option func(*Options)
+
+type Options struct {
+	LiveChecks  []CheckFunc
+	ReadyChecks []CheckFunc
+	Version     string
+	Name        string
+}
+
+func LiveChecks(fns ...CheckFunc) Option {
+	return func(o *Options) {
+		o.LiveChecks = append(o.LiveChecks, fns...)
+	}
+}
+
+func ReadyChecks(fns ...CheckFunc) Option {
+	return func(o *Options) {
+		o.ReadyChecks = append(o.ReadyChecks, fns...)
+	}
+}
+
+func Name(name string) Option {
+	return func(o *Options) {
+		o.Name = name
+	}
+}
+
+func Version(version string) Option {
+	return func(o *Options) {
+		o.Version = version
+	}
+}
+
+func NewHandler(opts ...Option) *handler {
+	options := Options{}
+	for _, o := range opts {
+		o(&options)
+	}
+	return &handler{opts: options}
+}
+
+func (h *handler) Live(ctx context.Context, req *codec.Frame, rsp *codec.Frame) error {
+	var err error
+	for _, fn := range h.opts.LiveChecks {
+		if err = fn(ctx); err != nil {
+			return errors.ServiceUnavailable(h.opts.Name, "%v", err)
+		}
+	}
+	return nil
+}
+
+func (h *handler) Ready(ctx context.Context, req *codec.Frame, rsp *codec.Frame) error {
+	var err error
+	for _, fn := range h.opts.ReadyChecks {
+		if err = fn(ctx); err != nil {
+			return errors.ServiceUnavailable(h.opts.Name, "%v", err)
+		}
+	}
+	return nil
+}
+
+func (h *handler) Version(ctx context.Context, req *codec.Frame, rsp *codec.Frame) error {
+	rsp.Data = []byte(h.opts.Version)
+	return nil
+}

server/health/health.proto

@@ -0,0 +1,62 @@
+syntax = "proto3";
+
+package micro.server.health;
+option go_package = "github.com/unistack-org/micro/v3/server/health;health";
+
+import "api/annotations.proto";
+import "openapiv2/annotations.proto";
+import "codec/frame.proto";
+
+service Health {
+	rpc Live(micro.codec.Frame) returns (micro.codec.Frame) {
+		option (micro.openapiv2.openapiv2_operation) = {
+      operation_id: "Live";
+        responses: {
+          key: "default";
+          value: {
+            description: "Error response";
+            schema: {
+              json_schema: {
+                ref: "micro.codec.Frame";
+              }
+            }
+          }
+        }
+    };
+		option (micro.api.http) = { get: "/live"; };
+  };
+	rpc Ready(micro.codec.Frame) returns (micro.codec.Frame) {
+		option (micro.openapiv2.openapiv2_operation) = {
+      operation_id: "Ready";
+        responses: {
+          key: "default";
+          value: {
+            description: "Error response";
+            schema: {
+              json_schema: {
+                ref: "micro.codec.Frame";
+              }
+            }
+          }
+        }
+    };
+		option (micro.api.http) = { get: "/ready"; };
+  };
+	rpc Version(micro.codec.Frame) returns (micro.codec.Frame) {
+		option (micro.openapiv2.openapiv2_operation) = {
+      operation_id: "Version";
+        responses: {
+          key: "default";
+          value: {
+            description: "Error response";
+            schema: {
+              json_schema: {
+                ref: "micro.codec.Frame";
+              }
+            }
+          }
+        }
+    };
+		option (micro.api.http) = { get: "/version"; };
+  };
+};

server/health/health_micro.pb.go

@@ -0,0 +1,38 @@
+// Code generated by protoc-gen-micro
+// source: health.proto
+package health
+
+import (
+	context "context"
+	api "github.com/unistack-org/micro/v3/api"
+	codec "github.com/unistack-org/micro/v3/codec"
+)
+
+func NewHealthEndpoints() []*api.Endpoint {
+	return []*api.Endpoint{
+		&api.Endpoint{
+			Name:    "Health.Live",
+			Path:    []string{"/live"},
+			Method:  []string{"GET"},
+			Handler: "rpc",
+		},
+		&api.Endpoint{
+			Name:    "Health.Ready",
+			Path:    []string{"/ready"},
+			Method:  []string{"GET"},
+			Handler: "rpc",
+		},
+		&api.Endpoint{
+			Name:    "Health.Version",
+			Path:    []string{"/version"},
+			Method:  []string{"GET"},
+			Handler: "rpc",
+		},
+	}
+}
+
+type HealthServer interface {
+	Live(ctx context.Context, req *codec.Frame, rsp *codec.Frame) error
+	Ready(ctx context.Context, req *codec.Frame, rsp *codec.Frame) error
+	Version(ctx context.Context, req *codec.Frame, rsp *codec.Frame) error
+}

server/health/health_micro_http.pb.go

@@ -0,0 +1,43 @@
+// Code generated by protoc-gen-micro
+// source: health.proto
+package health
+
+import (
+	context "context"
+	api "github.com/unistack-org/micro/v3/api"
+	codec "github.com/unistack-org/micro/v3/codec"
+	server "github.com/unistack-org/micro/v3/server"
+)
+
+type healthServer struct {
+	HealthServer
+}
+
+func (h *healthServer) Live(ctx context.Context, req *codec.Frame, rsp *codec.Frame) error {
+	return h.HealthServer.Live(ctx, req, rsp)
+}
+
+func (h *healthServer) Ready(ctx context.Context, req *codec.Frame, rsp *codec.Frame) error {
+	return h.HealthServer.Ready(ctx, req, rsp)
+}
+
+func (h *healthServer) Version(ctx context.Context, req *codec.Frame, rsp *codec.Frame) error {
+	return h.HealthServer.Version(ctx, req, rsp)
+}
+
+func RegisterHealthServer(s server.Server, sh HealthServer, opts ...server.HandlerOption) error {
+	type health interface {
+		Live(ctx context.Context, req *codec.Frame, rsp *codec.Frame) error
+		Ready(ctx context.Context, req *codec.Frame, rsp *codec.Frame) error
+		Version(ctx context.Context, req *codec.Frame, rsp *codec.Frame) error
+	}
+	type Health struct {
+		health
+	}
+	h := &healthServer{sh}
+	var nopts []server.HandlerOption
+	for _, endpoint := range NewHealthEndpoints() {
+		nopts = append(nopts, api.WithEndpoint(endpoint))
+	}
+	return s.Handle(s.NewHandler(&Health{h}, append(nopts, opts...)...))
+}

server/options.go

@@ -39,8 +39,12 @@ type Options struct {
 	Meter meter.Meter
 	// Transport holds the transport
 	Transport transport.Transport
-	// Router for requests
-	Router Router
+
+	/*
+		// Router for requests
+		Router Router
+	*/
+
 	// Listener may be passed if already created
 	Listener net.Listener
 	// Wait group
@@ -262,12 +266,14 @@ func TLSConfig(t *tls.Config) Option {
 	}
 }
 
+/*
 // WithRouter sets the request router
 func WithRouter(r Router) Option {
 	return func(o *Options) {
 		o.Router = r
 	}
 }
+*/
 
 // Wait tells the server to wait for requests to finish before exiting
 // If `wg` is nil, server only wait for completion of rpc handler.

server/server.go

@@ -65,6 +65,7 @@ type Server interface {
 	String() string
 }
 
+/*
 // Router handle serving messages
 type Router interface {
 	// ProcessMessage processes a message
@@ -72,6 +73,7 @@ type Router interface {
 	// ServeRequest processes a request to completion
 	ServeRequest(ctx context.Context, req Request, rsp Response) error
 }
+*/
 
 // Message is an async message interface
 type Message interface {

service.go

@@ -103,48 +103,48 @@ func (s *service) Init(opts ...Option) error {
 			// skip config as the struct not passed
 			continue
 		}
-		if err = cfg.Init(config.Context(s.opts.Context)); err != nil {
+		if err = cfg.Init(config.Context(cfg.Options().Context)); err != nil {
 			return err
 		}
 
-		if err = cfg.Load(s.opts.Context); err != nil {
+		if err = cfg.Load(cfg.Options().Context); err != nil {
 			return err
 		}
 
 	}
 
 	for _, log := range s.opts.Loggers {
-		if err = log.Init(logger.WithContext(s.opts.Context)); err != nil {
+		if err = log.Init(logger.WithContext(log.Options().Context)); err != nil {
 			return err
 		}
 	}
 
 	for _, reg := range s.opts.Registers {
-		if err = reg.Init(register.Context(s.opts.Context)); err != nil {
+		if err = reg.Init(register.Context(reg.Options().Context)); err != nil {
 			return err
 		}
 	}
 
 	for _, brk := range s.opts.Brokers {
-		if err = brk.Init(broker.Context(s.opts.Context)); err != nil {
+		if err = brk.Init(broker.Context(brk.Options().Context)); err != nil {
 			return err
 		}
 	}
 
 	for _, str := range s.opts.Stores {
-		if err = str.Init(store.Context(s.opts.Context)); err != nil {
+		if err = str.Init(store.Context(str.Options().Context)); err != nil {
 			return err
 		}
 	}
 
 	for _, srv := range s.opts.Servers {
-		if err = srv.Init(server.Context(s.opts.Context)); err != nil {
+		if err = srv.Init(server.Context(srv.Options().Context)); err != nil {
 			return err
 		}
 	}
 
 	for _, cli := range s.opts.Clients {
-		if err = cli.Init(client.Context(s.opts.Context)); err != nil {
+		if err = cli.Init(client.Context(cli.Options().Context)); err != nil {
 			return err
 		}
 	}

tracer/wrapper/wrapper.go

@@ -101,6 +101,8 @@ var (
 		}
 		sp.SetLabels(labels...)
 	}
+
+	DefaultSkipEndpoints = []string{"Meter.Metrics"}
 )
 
 type tWrapper struct {
@@ -134,6 +136,8 @@ type Options struct {
 	ServerHandlerObservers []ServerHandlerObserver
 	// ServerSubscriberObservers funcs
 	ServerSubscriberObservers []ServerSubscriberObserver
+	// SkipEndpoints
+	SkipEndpoints []string
 }
 
 // Option func signature
@@ -149,6 +153,7 @@ func NewOptions(opts ...Option) Options {
 		ClientCallFuncObservers:   []ClientCallFuncObserver{DefaultClientCallFuncObserver},
 		ServerHandlerObservers:    []ServerHandlerObserver{DefaultServerHandlerObserver},
 		ServerSubscriberObservers: []ServerSubscriberObserver{DefaultServerSubscriberObserver},
+		SkipEndpoints:             DefaultSkipEndpoints,
 	}
 
 	for _, o := range opts {
@@ -165,6 +170,13 @@ func WithTracer(t tracer.Tracer) Option {
 	}
 }
 
+// SkipEndponts
+func SkipEndpoins(eps ...string) Option {
+	return func(o *Options) {
+		o.SkipEndpoints = append(o.SkipEndpoints, eps...)
+	}
+}
+
 // WithClientCallObservers funcs
 func WithClientCallObservers(ob ...ClientCallObserver) Option {
 	return func(o *Options) {
@@ -208,6 +220,13 @@ func WithServerSubscriberObservers(ob ...ServerSubscriberObserver) Option {
 }
 
 func (ot *tWrapper) Call(ctx context.Context, req client.Request, rsp interface{}, opts ...client.CallOption) error {
+	endpoint := fmt.Sprintf("%s.%s", req.Service(), req.Endpoint())
+	for _, ep := range ot.opts.SkipEndpoints {
+		if ep == endpoint {
+			return ot.Client.Call(ctx, req, rsp, opts...)
+		}
+	}
+
 	sp := tracer.SpanFromContext(ctx)
 	defer sp.Finish()
 
@@ -221,6 +240,13 @@ func (ot *tWrapper) Call(ctx context.Context, req client.Request, rsp interface{
 }
 
 func (ot *tWrapper) Stream(ctx context.Context, req client.Request, opts ...client.CallOption) (client.Stream, error) {
+	endpoint := fmt.Sprintf("%s.%s", req.Service(), req.Endpoint())
+	for _, ep := range ot.opts.SkipEndpoints {
+		if ep == endpoint {
+			return ot.Client.Stream(ctx, req, opts...)
+		}
+	}
+
 	sp := tracer.SpanFromContext(ctx)
 	defer sp.Finish()
 
@@ -247,6 +273,13 @@ func (ot *tWrapper) Publish(ctx context.Context, msg client.Message, opts ...cli
 }
 
 func (ot *tWrapper) ServerHandler(ctx context.Context, req server.Request, rsp interface{}) error {
+	endpoint := req.Endpoint()
+	for _, ep := range ot.opts.SkipEndpoints {
+		if ep == endpoint {
+			return ot.serverHandler(ctx, req, rsp)
+		}
+	}
+
 	sp := tracer.SpanFromContext(ctx)
 	defer sp.Finish()
 
@@ -297,6 +330,13 @@ func NewClientCallWrapper(opts ...Option) client.CallWrapper {
 }
 
 func (ot *tWrapper) ClientCallFunc(ctx context.Context, addr string, req client.Request, rsp interface{}, opts client.CallOptions) error {
+	endpoint := fmt.Sprintf("%s.%s", req.Service(), req.Endpoint())
+	for _, ep := range ot.opts.SkipEndpoints {
+		if ep == endpoint {
+			return ot.ClientCallFunc(ctx, addr, req, rsp, opts)
+		}
+	}
+
 	sp := tracer.SpanFromContext(ctx)
 	defer sp.Finish()
 

util/reflect/struct.go

@@ -0,0 +1,398 @@
+package reflect
+
+import (
+	"errors"
+	"fmt"
+	"net/url"
+	"reflect"
+	"regexp"
+	"strings"
+)
+
+var (
+	// ErrInvalidParam specifies invalid url query params
+	ErrInvalidParam = errors.New("invalid url query param provided")
+)
+
+var (
+	bracketSplitter = regexp.MustCompile(`\[|\]`)
+)
+
+// StructFields returns slice of struct fields
+func StructFields(src interface{}) ([]reflect.StructField, error) {
+	var fields []reflect.StructField
+
+	sv := reflect.ValueOf(src)
+	if sv.Kind() == reflect.Ptr {
+		sv = sv.Elem()
+	}
+	if sv.Kind() != reflect.Struct {
+		return nil, ErrInvalidStruct
+	}
+
+	typ := sv.Type()
+	for idx := 0; idx < typ.NumField(); idx++ {
+		fld := typ.Field(idx)
+		val := sv.Field(idx)
+		if !val.CanSet() || len(fld.PkgPath) != 0 {
+			continue
+		}
+		if val.Kind() == reflect.Struct {
+			infields, err := StructFields(val.Interface())
+			if err != nil {
+				return nil, err
+			}
+			fields = append(fields, infields...)
+		} else {
+			fields = append(fields, fld)
+		}
+	}
+
+	return fields, nil
+}
+
+// CopyDefaults for a from b
+// a and b should be pointers to the same kind of struct
+func CopyDefaults(a, b interface{}) {
+	pt := reflect.TypeOf(a)
+	t := pt.Elem()
+	va := reflect.ValueOf(a).Elem()
+	vb := reflect.ValueOf(b).Elem()
+	for i := 0; i < t.NumField(); i++ {
+		aField := va.Field(i)
+		if aField.CanSet() {
+			bField := vb.Field(i)
+			aField.Set(bField)
+		}
+	}
+}
+
+// CopyFrom sets the public members of a from b
+// a and b should be pointers to structs
+// a can be a different type from b
+// Only the Fields which have the same name and assignable type on a
+// and b will be set.
+func CopyFrom(a, b interface{}) {
+	ta := reflect.TypeOf(a).Elem()
+	tb := reflect.TypeOf(b).Elem()
+	va := reflect.ValueOf(a).Elem()
+	vb := reflect.ValueOf(b).Elem()
+	for i := 0; i < tb.NumField(); i++ {
+		bField := vb.Field(i)
+		tbField := tb.Field(i)
+		name := tbField.Name
+		aField := va.FieldByName(name)
+		taField, found := ta.FieldByName(name)
+		if found && aField.IsValid() && bField.IsValid() && aField.CanSet() && tbField.Type.AssignableTo(taField.Type) {
+			aField.Set(bField)
+		}
+	}
+}
+
+func StructURLValues(src interface{}, pref string, tags []string) (url.Values, error) {
+	data := url.Values{}
+
+	sv := reflect.ValueOf(src)
+	if sv.Kind() == reflect.Ptr {
+		sv = sv.Elem()
+	}
+	if sv.Kind() != reflect.Struct {
+		return nil, ErrInvalidStruct
+	}
+
+	typ := sv.Type()
+	for idx := 0; idx < typ.NumField(); idx++ {
+		fld := typ.Field(idx)
+		val := sv.Field(idx)
+		if !val.CanSet() || len(fld.PkgPath) != 0 || !val.IsValid() {
+			continue
+		}
+
+		var t *tag
+		for _, tn := range tags {
+			ts, ok := fld.Tag.Lookup(tn)
+			if !ok {
+				continue
+			}
+
+			tp := strings.Split(ts, ",")
+			// special
+			switch tn {
+			case "protobuf": // special
+				t = &tag{key: tn, name: tp[3][5:], opts: append(tp[:3], tp[4:]...)}
+			default:
+				t = &tag{key: tn, name: tp[0], opts: tp[1:]}
+			}
+			if t.name != "" {
+				break
+			}
+		}
+
+		if t.name == "" {
+			// fallback to lowercase
+			t.name = strings.ToLower(fld.Name)
+		}
+		if pref != "" {
+			t.name = pref + "." + t.name
+		}
+
+		if !val.IsValid() || val.IsZero() {
+			continue
+		}
+
+		switch val.Kind() {
+		case reflect.Struct, reflect.Ptr:
+			if val.IsNil() {
+				continue
+			}
+			ndata, err := StructURLValues(val.Interface(), t.name, tags)
+			if err != nil {
+				return ndata, err
+			}
+			for k, v := range ndata {
+				data[k] = v
+			}
+		default:
+			switch val.Kind() {
+			case reflect.Slice:
+				for i := 0; i < val.Len(); i++ {
+					va := val.Index(i)
+					//if va.Type().Elem().Kind() != reflect.Ptr {
+					if va.Kind() != reflect.Ptr {
+						data.Set(t.name, fmt.Sprintf("%v", va.Interface()))
+						continue
+					}
+					switch va.Type().Elem().String() {
+					case "wrapperspb.BoolValue", "wrapperspb.BytesValue", "wrapperspb.StringValue":
+						if eva := reflect.Indirect(va).FieldByName("Value"); eva.IsValid() {
+							data.Add(t.name, fmt.Sprintf("%v", eva.Interface()))
+						}
+					case "wrapperspb.DoubleValue", "wrapperspb.FloatValue":
+						if eva := reflect.Indirect(va).FieldByName("Value"); eva.IsValid() {
+							data.Add(t.name, fmt.Sprintf("%v", eva.Interface()))
+						}
+					case "wrapperspb.Int32Value", "wrapperspb.Int64Value":
+						if eva := reflect.Indirect(va).FieldByName("Value"); eva.IsValid() {
+							data.Add(t.name, fmt.Sprintf("%v", eva.Interface()))
+						}
+					case "wrapperspb.UInt32Value", "wrapperspb.UInt64Value":
+						if eva := reflect.Indirect(va).FieldByName("Value"); eva.IsValid() {
+							data.Add(t.name, fmt.Sprintf("%v", eva.Interface()))
+						}
+					default:
+						data.Add(t.name, fmt.Sprintf("%v", val.Index(i).Interface()))
+					}
+				}
+			default:
+				data.Set(t.name, fmt.Sprintf("%v", val.Interface()))
+			}
+		}
+	}
+	return data, nil
+}
+
+// URLMap returns map of url query params
+func URLMap(query string) (map[string]interface{}, error) {
+	var (
+		mp interface{} = make(map[string]interface{})
+	)
+
+	params := strings.Split(query, "&")
+
+	for _, part := range params {
+		tm, err := queryToMap(part)
+		if err != nil {
+			return nil, err
+		}
+		mp = merge(mp, tm)
+	}
+
+	return mp.(map[string]interface{}), nil
+}
+
+// FlattenMap expand key.subkey to nested map
+func FlattenMap(a map[string]interface{}) map[string]interface{} {
+	// preprocess map
+	nb := make(map[string]interface{}, len(a))
+	for k, v := range a {
+		ps := strings.Split(k, ".")
+		if len(ps) == 1 {
+			nb[k] = v
+			continue
+		}
+		em := make(map[string]interface{})
+		em[ps[len(ps)-1]] = v
+		for i := len(ps) - 2; i > 0; i-- {
+			nm := make(map[string]interface{})
+			nm[ps[i]] = em
+			em = nm
+		}
+		if vm, ok := nb[ps[0]]; ok {
+			// nested map
+			nm := vm.(map[string]interface{})
+			for vk, vv := range em {
+				nm[vk] = vv
+			}
+			nb[ps[0]] = nm
+		} else {
+			nb[ps[0]] = em
+		}
+	}
+	return nb
+}
+
+/*
+	case reflect.String:
+		fn := func(c rune) bool { return c == ',' || c == ';' || c == ' ' }
+		slice := strings.FieldsFunc(vb.String(), fn)
+		if va.IsNil() {
+			va.Set(reflect.MakeSlice(va.Type(), len(slice), len(slice)))
+		}
+*/
+
+func btSplitter(str string) []string {
+	r := bracketSplitter.Split(str, -1)
+	for idx, s := range r {
+		if len(s) == 0 {
+			if len(r) > idx+1 {
+				copy(r[idx:], r[idx+1:])
+				r = r[:len(r)-1]
+			}
+		}
+	}
+	return r
+}
+
+// queryToMap turns something like a[b][c]=4 into
+//   map[string]interface{}{
+//     "a": map[string]interface{}{
+// 		  "b": map[string]interface{}{
+// 			  "c": 4,
+// 		  },
+// 	  },
+//   }
+func queryToMap(param string) (map[string]interface{}, error) {
+	rawKey, rawValue, err := splitKeyAndValue(param)
+	if err != nil {
+		return nil, err
+	}
+	rawValue, err = url.QueryUnescape(rawValue)
+	if err != nil {
+		return nil, err
+	}
+	rawKey, err = url.QueryUnescape(rawKey)
+	if err != nil {
+		return nil, err
+	}
+
+	pieces := btSplitter(rawKey)
+	key := pieces[0]
+
+	// If len==1 then rawKey has no [] chars and we can just
+	// decode this as key=value into {key: value}
+	if len(pieces) == 1 {
+		return map[string]interface{}{
+			key: rawValue,
+		}, nil
+	}
+
+	// If len > 1 then we have something like a[b][c]=2
+	// so we need to turn this into {"a": {"b": {"c": 2}}}
+	// To do this we break our key into two pieces:
+	//   a and b[c]
+	// and then we set {"a": queryToMap("b[c]", value)}
+	ret := make(map[string]interface{})
+	ret[key], err = queryToMap(buildNewKey(rawKey) + "=" + rawValue)
+	if err != nil {
+		return nil, err
+	}
+
+	// When URL params have a set of empty brackets (eg a[]=1)
+	// it is assumed to be an array. This will get us the
+	// correct value for the array item and return it as an
+	// []interface{} so that it can be merged properly.
+	if pieces[1] == "" {
+		temp := ret[key].(map[string]interface{})
+		ret[key] = []interface{}{temp[""]}
+	}
+	return ret, nil
+}
+
+// buildNewKey will take something like:
+// origKey = "bar[one][two]"
+// pieces = [bar one two ]
+// and return "one[two]"
+func buildNewKey(origKey string) string {
+	pieces := btSplitter(origKey)
+
+	ret := origKey[len(pieces[0])+1:]
+	ret = ret[:len(pieces[1])] + ret[len(pieces[1])+1:]
+	return ret
+}
+
+// splitKeyAndValue splits a URL param at the last equal
+// sign and returns the two strings. If no equal sign is
+// found, the ErrInvalidParam error is returned.
+func splitKeyAndValue(param string) (string, string, error) {
+	li := strings.LastIndex(param, "=")
+	if li == -1 {
+		return "", "", ErrInvalidParam
+	}
+	return param[:li], param[li+1:], nil
+}
+
+// merge merges a with b if they are either both slices
+// or map[string]interface{} types. Otherwise it returns b.
+func merge(a interface{}, b interface{}) interface{} {
+	if av, aok := a.(map[string]interface{}); aok {
+		if bv, bok := b.(map[string]interface{}); bok {
+			return mergeMapIface(av, bv)
+		}
+	}
+	if av, aok := a.([]interface{}); aok {
+		if bv, bok := b.([]interface{}); bok {
+			return mergeSliceIface(av, bv)
+		}
+	}
+
+	va := reflect.ValueOf(a)
+	vb := reflect.ValueOf(b)
+	if (va.Type().Kind() == reflect.Slice) && (va.Type().Elem().Kind() == vb.Type().Kind() || vb.Type().ConvertibleTo(va.Type().Elem())) {
+		va = reflect.Append(va, vb.Convert(va.Type().Elem()))
+		return va.Interface()
+	}
+
+	return b
+}
+
+// mergeMap merges a with b, attempting to merge any nested
+// values in nested maps but eventually overwriting anything
+// in a that can't be merged with whatever is in b.
+func mergeMapIface(a map[string]interface{}, b map[string]interface{}) map[string]interface{} {
+	for bK, bV := range b {
+		if aV, ok := a[bK]; ok {
+			if (reflect.ValueOf(aV).Type().Kind() == reflect.ValueOf(bV).Type().Kind()) ||
+				((reflect.ValueOf(aV).Type().Kind() == reflect.Slice) && reflect.ValueOf(aV).Type().Elem().Kind() == reflect.ValueOf(bV).Type().Kind()) {
+				nV := []interface{}{aV, bV}
+				a[bK] = nV
+			} else {
+				a[bK] = merge(a[bK], bV)
+			}
+		} else {
+			a[bK] = bV
+		}
+	}
+	return a
+}
+
+// mergeSlice merges a with b and returns the result.
+func mergeSliceIface(a []interface{}, b []interface{}) []interface{} {
+	a = append(a, b...)
+	return a
+}
+
+type tag struct {
+	key  string
+	name string
+	opts []string
+}

util/reflect/struct_test.go

@@ -5,6 +5,24 @@ import (
 	"testing"
 )
 
+func TestStructURLValues(t *testing.T) {
+	type Str struct {
+		Name string `json:"name"`
+		Args []int  `json:"args"`
+		Str  *Str   `json:"str"`
+	}
+
+	val := &Str{Name: "test_name", Args: []int{1, 2, 3}, Str: &Str{Name: "nested_name"}}
+	data, err := StructURLValues(val, "", []string{"json"})
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	if data.Get("name") != "test_name" {
+		t.Fatalf("invalid data: %v", data)
+	}
+}
+
 func TestURLSliceVars(t *testing.T) {
 	u, err := url.Parse("http://localhost/v1/test/call/my_name?key=arg1&key=arg2&key=arg3")
 	if err != nil {