meter/handler: provide default metrics handler

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

.github/renovate.json

@@ -0,0 +1,20 @@
+{
+  "extends": [
+    "config:base"
+  ],
+  "postUpdateOptions": ["gomodTidy"],
+  "packageRules": [
+    {
+      "matchUpdateTypes": ["minor", "patch", "pin", "digest"],
+      "automerge": true
+    },
+    {
+      "groupName": "all deps",
+      "separateMajorMinor": true,
+      "groupSlug": "all",
+      "packagePatterns": [
+        "*"
+      ]
+    }
+  ]
+}

.github/workflows/build.yml

@@ -9,9 +9,9 @@ jobs:
     runs-on: ubuntu-latest
     steps:
     - name: setup
-      uses: actions/setup-go@v1
+      uses: actions/setup-go@v2
       with:
-        go-version: 1.15
+        go-version: 1.16
     - name: cache
       uses: actions/cache@v2
       with:
@@ -49,7 +49,7 @@ jobs:
       - name: checkout
         uses: actions/checkout@v2
       - name: lint
-        uses: golangci/golangci-lint-action@v1
+        uses: golangci/golangci-lint-action@v2
         continue-on-error: true
         with:
           # Required: the version of golangci-lint is required and must be specified without patch version: we always use the latest patch version.

.github/workflows/pr.yml

@@ -9,13 +9,13 @@ jobs:
     runs-on: ubuntu-latest
     steps:
     - name: setup
-      uses: actions/setup-go@v1
+      uses: actions/setup-go@v2
       with:
-        go-version: 1.15
+        go-version: 1.16
     - name: cache
       uses: actions/cache@v2
       with:
-        path: ~/go/pkg/mod
+        path: ~/go/pkg
         key: ${{ runner.os }}-go-${{ hashFiles('**/go.sum') }}
         restore-keys: ${{ runner.os }}-go-
     - name: sdk checkout
@@ -49,7 +49,7 @@ jobs:
       - name: checkout
         uses: actions/checkout@v2
       - name: lint
-        uses: golangci/golangci-lint-action@v1
+        uses: golangci/golangci-lint-action@v2
         continue-on-error: true
         with:
           # Required: the version of golangci-lint is required and must be specified without patch version: we always use the latest patch version.

.golangci.yml

@@ -1,8 +1,6 @@
 run:
   deadline: 5m
   modules-download-mode: readonly
-  skip-dirs:
-    - util/mdns.new
   skip-files:
     - ".*\\.pb\\.go$"
     - ".*\\.pb\\.micro\\.go$"
@@ -30,11 +28,3 @@ linters:
     - interfacer
     - typecheck
     - dupl
-output:
-  format: colored-line-number
-  # print lines of code with issue, default is true
-  print-issued-lines: true
-  # print linter name in the end of issue text, default is true
-  print-linter-name: true
-  # make issues output unique by line, default is true
-  uniq-by-line: true

api/api.go

@@ -5,10 +5,12 @@ import (
 	"regexp"
 	"strings"
 
-	"github.com/unistack-org/micro/v3/registry"
+	"github.com/unistack-org/micro/v3/metadata"
+	"github.com/unistack-org/micro/v3/register"
 	"github.com/unistack-org/micro/v3/server"
 )
 
+// Api interface
 type Api interface {
 	// Initialise options
 	Init(...Option) error
@@ -22,28 +24,30 @@ type Api interface {
 	String() string
 }
 
+// Options holds the options
 type Options struct{}
 
+// Option func signature
 type Option func(*Options) error
 
 // Endpoint is a mapping between an RPC method and HTTP endpoint
 type Endpoint struct {
-	// RPC Method e.g. Greeter.Hello
+	// Name Greeter.Hello
 	Name string
-	// Description e.g what's this endpoint for
+	// Desciption for endpoint
 	Description string
-	// API Handler e.g rpc, proxy
+	// Handler e.g rpc, proxy
 	Handler string
-	// HTTP Host e.g example.com
-	Host []string
-	// HTTP Methods e.g GET, POST
-	Method []string
-	// HTTP Path e.g /greeter. Expect POSIX regex
-	Path []string
 	// Body destination
 	// "*" or "" - top level message value
 	// "string" - inner message value
 	Body string
+	// Host e.g example.com
+	Host []string
+	// Method e.g GET, POST
+	Method []string
+	// Path e.g /greeter. Expect POSIX regex
+	Path []string
 	// Stream flag
 	Stream bool
 }
@@ -52,26 +56,10 @@ type Endpoint struct {
 type Service struct {
 	// Name of service
 	Name string
-	// The endpoint for this service
+	// Endpoint for this service
 	Endpoint *Endpoint
-	// Versions of this service
+	// Services that provides service
-	Services []*registry.Service
+	Services []*register.Service
-}
-
-func strip(s string) string {
-	return strings.TrimSpace(s)
-}
-
-func slice(s string) []string {
-	var sl []string
-
-	for _, p := range strings.Split(s, ",") {
-		if str := strip(p); len(str) > 0 {
-			sl = append(sl, strip(p))
-		}
-	}
-
-	return sl
 }
 
 // Encode encodes an endpoint to endpoint metadata
@@ -97,24 +85,30 @@ func Encode(e *Endpoint) map[string]string {
 	set("method", strings.Join(e.Method, ","))
 	set("path", strings.Join(e.Path, ","))
 	set("host", strings.Join(e.Host, ","))
+	set("body", e.Body)
 
 	return ep
 }
 
 // Decode decodes endpoint metadata into an endpoint
-func Decode(e map[string]string) *Endpoint {
+func Decode(e metadata.Metadata) *Endpoint {
 	if e == nil {
 		return nil
 	}
 
-	return &Endpoint{
+	ep := &Endpoint{}
-		Name:        e["endpoint"],
+	ep.Name, _ = e.Get("endpoint")
-		Description: e["description"],
+	ep.Description, _ = e.Get("description")
-		Method:      slice(e["method"]),
+	epmethod, _ := e.Get("method")
-		Path:        slice(e["path"]),
+	ep.Method = []string{epmethod}
-		Host:        slice(e["host"]),
+	eppath, _ := e.Get("path")
-		Handler:     e["handler"],
+	ep.Path = []string{eppath}
-	}
+	ephost, _ := e.Get("host")
+	ep.Host = []string{ephost}
+	ep.Handler, _ = e.Get("handler")
+	ep.Body, _ = e.Get("body")
+
+	return ep
 }
 
 // Validate validates an endpoint to guarantee it won't blow up when being served

api/api_test.go

@@ -5,6 +5,7 @@ import (
 	"testing"
 )
 
+//nolint:gocyclo
 func TestEncoding(t *testing.T) {
 	testData := []*Endpoint{
 		nil,

api/handler/api/api.go

@@ -1,121 +0,0 @@
-// Package api provides an http-rpc handler which provides the entire http request over rpc
-package api
-
-import (
-	"net/http"
-
-	goapi "github.com/unistack-org/micro/v3/api"
-	"github.com/unistack-org/micro/v3/api/handler"
-	api "github.com/unistack-org/micro/v3/api/proto"
-	"github.com/unistack-org/micro/v3/client"
-	"github.com/unistack-org/micro/v3/errors"
-	"github.com/unistack-org/micro/v3/util/ctx"
-	"github.com/unistack-org/micro/v3/util/router"
-)
-
-type apiHandler struct {
-	opts handler.Options
-	s    *goapi.Service
-}
-
-const (
-	Handler = "api"
-)
-
-// API handler is the default handler which takes api.Request and returns api.Response
-func (a *apiHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
-	bsize := handler.DefaultMaxRecvSize
-	if a.opts.MaxRecvSize > 0 {
-		bsize = a.opts.MaxRecvSize
-	}
-
-	r.Body = http.MaxBytesReader(w, r.Body, bsize)
-	request, err := requestToProto(r)
-	if err != nil {
-		er := errors.InternalServerError("go.micro.api", err.Error())
-		w.Header().Set("Content-Type", "application/json")
-		w.WriteHeader(500)
-		w.Write([]byte(er.Error()))
-		return
-	}
-
-	var service *goapi.Service
-
-	if a.s != nil {
-		// we were given the service
-		service = a.s
-	} else if a.opts.Router != nil {
-		// try get service from router
-		s, err := a.opts.Router.Route(r)
-		if err != nil {
-			er := errors.InternalServerError("go.micro.api", err.Error())
-			w.Header().Set("Content-Type", "application/json")
-			w.WriteHeader(500)
-			w.Write([]byte(er.Error()))
-			return
-		}
-		service = s
-	} else {
-		// we have no way of routing the request
-		er := errors.InternalServerError("go.micro.api", "no route found")
-		w.Header().Set("Content-Type", "application/json")
-		w.WriteHeader(500)
-		w.Write([]byte(er.Error()))
-		return
-	}
-
-	// create request and response
-	c := a.opts.Client
-	req := c.NewRequest(service.Name, service.Endpoint.Name, request)
-	rsp := &api.Response{}
-
-	// create the context from headers
-	cx := ctx.FromRequest(r)
-
-	if err := c.Call(cx, req, rsp, client.WithRouter(router.New(service.Services))); err != nil {
-		w.Header().Set("Content-Type", "application/json")
-		ce := errors.Parse(err.Error())
-		switch ce.Code {
-		case 0:
-			w.WriteHeader(500)
-		default:
-			w.WriteHeader(int(ce.Code))
-		}
-		w.Write([]byte(ce.Error()))
-		return
-	} else if rsp.StatusCode == 0 {
-		rsp.StatusCode = http.StatusOK
-	}
-
-	for _, header := range rsp.GetHeader() {
-		for _, val := range header.Values {
-			w.Header().Add(header.Key, val)
-		}
-	}
-
-	if len(w.Header().Get("Content-Type")) == 0 {
-		w.Header().Set("Content-Type", "application/json")
-	}
-
-	w.WriteHeader(int(rsp.StatusCode))
-	w.Write([]byte(rsp.Body))
-}
-
-func (a *apiHandler) String() string {
-	return "api"
-}
-
-func NewHandler(opts ...handler.Option) handler.Handler {
-	options := handler.NewOptions(opts...)
-	return &apiHandler{
-		opts: options,
-	}
-}
-
-func WithService(s *goapi.Service, opts ...handler.Option) handler.Handler {
-	options := handler.NewOptions(opts...)
-	return &apiHandler{
-		opts: options,
-		s:    s,
-	}
-}

api/handler/api/util.go

@@ -1,109 +0,0 @@
-package api
-
-import (
-	"fmt"
-	"mime"
-	"net"
-	"net/http"
-	"strings"
-
-	"github.com/oxtoacart/bpool"
-	api "github.com/unistack-org/micro/v3/api/proto"
-)
-
-var (
-	// need to calculate later to specify useful defaults
-	bufferPool = bpool.NewSizedBufferPool(1024, 8)
-)
-
-func requestToProto(r *http.Request) (*api.Request, error) {
-	if err := r.ParseForm(); err != nil {
-		return nil, fmt.Errorf("Error parsing form: %v", err)
-	}
-
-	req := &api.Request{
-		Path:   r.URL.Path,
-		Method: r.Method,
-		Header: make(map[string]*api.Pair),
-		Get:    make(map[string]*api.Pair),
-		Post:   make(map[string]*api.Pair),
-		Url:    r.URL.String(),
-	}
-
-	ct, _, err := mime.ParseMediaType(r.Header.Get("Content-Type"))
-	if err != nil {
-		ct = "text/plain; charset=UTF-8" //default CT is text/plain
-		r.Header.Set("Content-Type", ct)
-	}
-
-	//set the body:
-	if r.Body != nil {
-		switch ct {
-		case "application/x-www-form-urlencoded":
-			// expect form vals in Post data
-		default:
-			buf := bufferPool.Get()
-			defer bufferPool.Put(buf)
-			if _, err = buf.ReadFrom(r.Body); err != nil {
-				return nil, err
-			}
-			req.Body = buf.String()
-		}
-	}
-
-	// Set X-Forwarded-For if it does not exist
-	if ip, _, err := net.SplitHostPort(r.RemoteAddr); err == nil {
-		if prior, ok := r.Header["X-Forwarded-For"]; ok {
-			ip = strings.Join(prior, ", ") + ", " + ip
-		}
-
-		// Set the header
-		req.Header["X-Forwarded-For"] = &api.Pair{
-			Key:    "X-Forwarded-For",
-			Values: []string{ip},
-		}
-	}
-
-	// Host is stripped from net/http Headers so let's add it
-	req.Header["Host"] = &api.Pair{
-		Key:    "Host",
-		Values: []string{r.Host},
-	}
-
-	// Get data
-	for key, vals := range r.URL.Query() {
-		header, ok := req.Get[key]
-		if !ok {
-			header = &api.Pair{
-				Key: key,
-			}
-			req.Get[key] = header
-		}
-		header.Values = vals
-	}
-
-	// Post data
-	for key, vals := range r.PostForm {
-		header, ok := req.Post[key]
-		if !ok {
-			header = &api.Pair{
-				Key: key,
-			}
-			req.Post[key] = header
-		}
-		header.Values = vals
-	}
-
-	for key, vals := range r.Header {
-		header, ok := req.Header[key]
-		if !ok {
-			header = &api.Pair{
-				Key: key,
-			}
-			req.Header[key] = header
-		}
-		header.Values = vals
-	}
-
-	return req, nil
-}

api/handler/api/util_test.go

@@ -1,46 +0,0 @@
-package api
-
-import (
-	"net/http"
-	"net/url"
-	"testing"
-)
-
-func TestRequestToProto(t *testing.T) {
-	testData := []*http.Request{
-		{
-			Method: "GET",
-			Header: http.Header{
-				"Header": []string{"test"},
-			},
-			URL: &url.URL{
-				Scheme:   "http",
-				Host:     "localhost",
-				Path:     "/foo/bar",
-				RawQuery: "param1=value1",
-			},
-		},
-	}
-
-	for _, d := range testData {
-		p, err := requestToProto(d)
-		if err != nil {
-			t.Fatal(err)
-		}
-		if p.Path != d.URL.Path {
-			t.Fatalf("Expected path %s got %s", d.URL.Path, p.Path)
-		}
-		if p.Method != d.Method {
-			t.Fatalf("Expected method %s got %s", d.Method, p.Method)
-		}
-		for k, v := range d.Header {
-			if val, ok := p.Header[k]; !ok {
-				t.Fatalf("Expected header %s", k)
-			} else {
-				if val.Values[0] != v[0] {
-					t.Fatalf("Expected val %s, got %s", val.Values[0], v[0])
-				}
-			}
-		}
-	}
-}

api/handler/event/event.go

@@ -1,141 +0,0 @@
-// Package event provides a handler which publishes an event
-package event
-
-import (
-	"encoding/json"
-	"fmt"
-	"net/http"
-	"path"
-	"regexp"
-	"strings"
-	"time"
-
-	"github.com/google/uuid"
-	"github.com/oxtoacart/bpool"
-	"github.com/unistack-org/micro/v3/api/handler"
-	proto "github.com/unistack-org/micro/v3/api/proto"
-	"github.com/unistack-org/micro/v3/util/ctx"
-)
-
-var (
-	bufferPool = bpool.NewSizedBufferPool(1024, 8)
-)
-
-type event struct {
-	opts handler.Options
-}
-
-var (
-	Handler   = "event"
-	versionRe = regexp.MustCompilePOSIX("^v[0-9]+$")
-)
-
-func eventName(parts []string) string {
-	return strings.Join(parts, ".")
-}
-
-func evRoute(ns, p string) (string, string) {
-	p = path.Clean(p)
-	p = strings.TrimPrefix(p, "/")
-
-	if len(p) == 0 {
-		return ns, "event"
-	}
-
-	parts := strings.Split(p, "/")
-
-	// no path
-	if len(parts) == 0 {
-		// topic: namespace
-		// action: event
-		return strings.Trim(ns, "."), "event"
-	}
-
-	// Treat /v[0-9]+ as versioning
-	// /v1/foo/bar => topic: v1.foo action: bar
-	if len(parts) >= 2 && versionRe.Match([]byte(parts[0])) {
-		topic := ns + "." + strings.Join(parts[:2], ".")
-		action := eventName(parts[1:])
-		return topic, action
-	}
-
-	// /foo => topic: ns.foo action: foo
-	// /foo/bar => topic: ns.foo action: bar
-	topic := ns + "." + strings.Join(parts[:1], ".")
-	action := eventName(parts[1:])
-
-	return topic, action
-}
-
-func (e *event) ServeHTTP(w http.ResponseWriter, r *http.Request) {
-	bsize := handler.DefaultMaxRecvSize
-	if e.opts.MaxRecvSize > 0 {
-		bsize = e.opts.MaxRecvSize
-	}
-
-	r.Body = http.MaxBytesReader(w, r.Body, bsize)
-
-	// request to topic:event
-	// create event
-	// publish to topic
-
-	topic, action := evRoute(e.opts.Namespace, r.URL.Path)
-
-	// create event
-	ev := &proto.Event{
-		Name: action,
-		// TODO: dedupe event
-		Id:        fmt.Sprintf("%s-%s-%s", topic, action, uuid.New().String()),
-		Header:    make(map[string]*proto.Pair),
-		Timestamp: time.Now().Unix(),
-	}
-
-	// set headers
-	for key, vals := range r.Header {
-		header, ok := ev.Header[key]
-		if !ok {
-			header = &proto.Pair{
-				Key: key,
-			}
-			ev.Header[key] = header
-		}
-		header.Values = vals
-	}
-
-	// set body
-	if r.Method == "GET" {
-		bytes, _ := json.Marshal(r.URL.Query())
-		ev.Data = string(bytes)
-	} else {
-		// Read body
-		buf := bufferPool.Get()
-		defer bufferPool.Put(buf)
-		if _, err := buf.ReadFrom(r.Body); err != nil {
-			http.Error(w, err.Error(), 500)
-			return
-		}
-		ev.Data = buf.String()
-	}
-
-	// get client
-	c := e.opts.Client
-
-	// create publication
-	p := c.NewMessage(topic, ev)
-
-	// publish event
-	if err := c.Publish(ctx.FromRequest(r), p); err != nil {
-		http.Error(w, err.Error(), 500)
-		return
-	}
-}
-
-func (e *event) String() string {
-	return "event"
-}
-
-func NewHandler(opts ...handler.Option) handler.Handler {
-	return &event{
-		opts: handler.NewOptions(opts...),
-	}
-}

api/handler/http/http.go

@@ -1,105 +0,0 @@
-// Package http is a http reverse proxy handler
-package http
-
-import (
-	"errors"
-	"fmt"
-	"math/rand"
-	"net/http"
-	"net/http/httputil"
-	"net/url"
-
-	"github.com/unistack-org/micro/v3/api"
-	"github.com/unistack-org/micro/v3/api/handler"
-	"github.com/unistack-org/micro/v3/registry"
-)
-
-const (
-	Handler = "http"
-)
-
-type httpHandler struct {
-	options handler.Options
-
-	// set with different initializer
-	s *api.Service
-}
-
-func (h *httpHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
-	service, err := h.getService(r)
-	if err != nil {
-		w.WriteHeader(500)
-		return
-	}
-
-	if len(service) == 0 {
-		w.WriteHeader(404)
-		return
-	}
-
-	rp, err := url.Parse(service)
-	if err != nil {
-		w.WriteHeader(500)
-		return
-	}
-
-	httputil.NewSingleHostReverseProxy(rp).ServeHTTP(w, r)
-}
-
-// getService returns the service for this request from the selector
-func (h *httpHandler) getService(r *http.Request) (string, error) {
-	var service *api.Service
-
-	if h.s != nil {
-		// we were given the service
-		service = h.s
-	} else if h.options.Router != nil {
-		// try get service from router
-		s, err := h.options.Router.Route(r)
-		if err != nil {
-			return "", err
-		}
-		service = s
-	} else {
-		// we have no way of routing the request
-		return "", errors.New("no route found")
-	}
-
-	if len(service.Services) == 0 {
-		return "", errors.New("no route found")
-	}
-
-	// get the nodes for this service
-	nodes := make([]*registry.Node, 0, len(service.Services))
-	for _, srv := range service.Services {
-		nodes = append(nodes, srv.Nodes...)
-	}
-
-	// select a random node
-	node := nodes[rand.Int()%len(nodes)]
-
-	return fmt.Sprintf("http://%s", node.Address), nil
-}
-
-func (h *httpHandler) String() string {
-	return "http"
-}
-
-// NewHandler returns a http proxy handler
-func NewHandler(opts ...handler.Option) handler.Handler {
-	options := handler.NewOptions(opts...)
-
-	return &httpHandler{
-		options: options,
-	}
-}
-
-// WithService creates a handler with a service
-func WithService(s *api.Service, opts ...handler.Option) handler.Handler {
-	options := handler.NewOptions(opts...)
-
-	return &httpHandler{
-		options: options,
-		s:       s,
-	}
-}

api/handler/http/http_test.go

@@ -1,129 +0,0 @@
-// +build ignore
-
-package http
-
-import (
-	"net"
-	"net/http"
-	"net/http/httptest"
-	"testing"
-
-	"github.com/unistack-org/micro/v3/api/handler"
-	"github.com/unistack-org/micro/v3/api/resolver"
-	"github.com/unistack-org/micro/v3/api/resolver/vpath"
-	"github.com/unistack-org/micro/v3/api/router"
-	regRouter "github.com/unistack-org/micro/v3/api/router/registry"
-	"github.com/unistack-org/micro/v3/registry"
-	"github.com/unistack-org/micro/v3/registry/memory"
-)
-
-func testHttp(t *testing.T, path, service, ns string) {
-	r := memory.NewRegistry()
-
-	l, err := net.Listen("tcp", "127.0.0.1:0")
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer l.Close()
-
-	s := &registry.Service{
-		Name: service,
-		Nodes: []*registry.Node{
-			{
-				Id:      service + "-1",
-				Address: l.Addr().String(),
-			},
-		},
-	}
-
-	r.Register(s)
-	defer r.Deregister(s)
-
-	// setup the test handler
-	m := http.NewServeMux()
-	m.HandleFunc(path, func(w http.ResponseWriter, r *http.Request) {
-		w.Write([]byte(`you got served`))
-	})
-
-	// start http test serve
-	go http.Serve(l, m)
-
-	// create new request and writer
-	w := httptest.NewRecorder()
-	req, err := http.NewRequest("POST", path, nil)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	// initialise the handler
-	rt := regRouter.NewRouter(
-		router.WithHandler("http"),
-		router.WithRegistry(r),
-		router.WithResolver(vpath.NewResolver(
-			resolver.WithServicePrefix(ns),
-		)),
-	)
-
-	p := NewHandler(handler.WithRouter(rt))
-
-	// execute the handler
-	p.ServeHTTP(w, req)
-
-	if w.Code != 200 {
-		t.Fatalf("Expected 200 response got %d %s", w.Code, w.Body.String())
-	}
-
-	if w.Body.String() != "you got served" {
-		t.Fatalf("Expected body: you got served. Got: %s", w.Body.String())
-	}
-}
-
-func TestHttpHandler(t *testing.T) {
-	testData := []struct {
-		path      string
-		service   string
-		namespace string
-	}{
-		{
-			"/test/foo",
-			"go.micro.api.test",
-			"go.micro.api",
-		},
-		{
-			"/test/foo/baz",
-			"go.micro.api.test",
-			"go.micro.api",
-		},
-		{
-			"/v1/foo",
-			"go.micro.api.v1.foo",
-			"go.micro.api",
-		},
-		{
-			"/v1/foo/bar",
-			"go.micro.api.v1.foo",
-			"go.micro.api",
-		},
-		{
-			"/v2/baz",
-			"go.micro.api.v2.baz",
-			"go.micro.api",
-		},
-		{
-			"/v2/baz/bar",
-			"go.micro.api.v2.baz",
-			"go.micro.api",
-		},
-		{
-			"/v2/baz/bar",
-			"v2.baz",
-			"",
-		},
-	}
-
-	for _, d := range testData {
-		t.Run(d.service, func(t *testing.T) {
-			testHttp(t, d.path, d.service, d.namespace)
-		})
-	}
-}

api/handler/options.go

@@ -3,24 +3,34 @@ package handler
 import (
 	"github.com/unistack-org/micro/v3/api/router"
 	"github.com/unistack-org/micro/v3/client"
+	"github.com/unistack-org/micro/v3/logger"
 )
 
 var (
+	// DefaultMaxRecvSize specifies max recv size for handler
 	DefaultMaxRecvSize int64 = 1024 * 1024 * 100 // 10Mb
 )
 
+// Options struct holds handler options
 type Options struct {
-	MaxRecvSize int64
-	Namespace   string
 	Router      router.Router
 	Client      client.Client
+	Logger      logger.Logger
+	Namespace   string
+	MaxRecvSize int64
 }
 
+// Option func signature
 type Option func(o *Options)
 
-// NewOptions fills in the blanks
+// NewOptions creates new options struct and fills it
 func NewOptions(opts ...Option) Options {
-	var options Options
+	options := Options{
+		Client:      client.DefaultClient,
+		Router:      router.DefaultRouter,
+		Logger:      logger.DefaultLogger,
+		MaxRecvSize: DefaultMaxRecvSize,
+	}
 	for _, o := range opts {
 		o(&options)
 	}
@@ -30,10 +40,6 @@ func NewOptions(opts ...Option) Options {
 		WithNamespace("go.micro.api")(&options)
 	}
 
-	if options.MaxRecvSize == 0 {
-		options.MaxRecvSize = DefaultMaxRecvSize
-	}
-
 	return options
 }
 
@@ -51,6 +57,7 @@ func WithRouter(r router.Router) Option {
 	}
 }
 
+// WithClient specifies client to be used by the handler
 func WithClient(c client.Client) Option {
 	return func(o *Options) {
 		o.Client = c

api/handler/rpc/rpc.go

@@ -1,495 +0,0 @@
-// Package rpc is a go-micro rpc handler.
-package rpc
-
-import (
-	"encoding/json"
-	"io"
-	"net/http"
-	"strconv"
-	"strings"
-
-	jsonpatch "github.com/evanphx/json-patch/v5"
-	"github.com/oxtoacart/bpool"
-	jsonrpc "github.com/unistack-org/micro-codec-jsonrpc"
-	protorpc "github.com/unistack-org/micro-codec-protorpc"
-	"github.com/unistack-org/micro/v3/api"
-	"github.com/unistack-org/micro/v3/api/handler"
-	"github.com/unistack-org/micro/v3/api/internal/proto"
-	"github.com/unistack-org/micro/v3/client"
-	"github.com/unistack-org/micro/v3/codec"
-	"github.com/unistack-org/micro/v3/errors"
-	"github.com/unistack-org/micro/v3/logger"
-	"github.com/unistack-org/micro/v3/metadata"
-	"github.com/unistack-org/micro/v3/util/ctx"
-	"github.com/unistack-org/micro/v3/util/qson"
-	"github.com/unistack-org/micro/v3/util/router"
-)
-
-const (
-	Handler = "rpc"
-)
-
-var (
-	// supported json codecs
-	jsonCodecs = []string{
-		"application/grpc+json",
-		"application/json",
-		"application/json-rpc",
-	}
-
-	// support proto codecs
-	protoCodecs = []string{
-		"application/grpc",
-		"application/grpc+proto",
-		"application/proto",
-		"application/protobuf",
-		"application/proto-rpc",
-		"application/octet-stream",
-	}
-
-	bufferPool = bpool.NewSizedBufferPool(1024, 8)
-)
-
-type rpcHandler struct {
-	opts handler.Options
-	s    *api.Service
-}
-
-type buffer struct {
-	io.ReadCloser
-}
-
-func (b *buffer) Write(_ []byte) (int, error) {
-	return 0, nil
-}
-
-func (h *rpcHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
-	bsize := handler.DefaultMaxRecvSize
-	if h.opts.MaxRecvSize > 0 {
-		bsize = h.opts.MaxRecvSize
-	}
-
-	r.Body = http.MaxBytesReader(w, r.Body, bsize)
-
-	defer r.Body.Close()
-	var service *api.Service
-
-	if h.s != nil {
-		// we were given the service
-		service = h.s
-	} else if h.opts.Router != nil {
-		// try get service from router
-		s, err := h.opts.Router.Route(r)
-		if err != nil {
-			writeError(w, r, errors.InternalServerError("go.micro.api", err.Error()))
-			return
-		}
-		service = s
-	} else {
-		// we have no way of routing the request
-		writeError(w, r, errors.InternalServerError("go.micro.api", "no route found"))
-		return
-	}
-
-	ct := r.Header.Get("Content-Type")
-
-	// Strip charset from Content-Type (like `application/json; charset=UTF-8`)
-	if idx := strings.IndexRune(ct, ';'); idx >= 0 {
-		ct = ct[:idx]
-	}
-
-	// micro client
-	c := h.opts.Client
-
-	// create context
-	cx := ctx.FromRequest(r)
-
-	// set merged context to request
-	*r = *r.Clone(cx)
-	// if stream we currently only support json
-	if isStream(r, service) {
-		serveWebsocket(cx, w, r, service, c)
-		return
-	}
-
-	// create custom router
-	callOpt := client.WithRouter(router.New(service.Services))
-
-	// walk the standard call path
-	// get payload
-	br, err := requestPayload(r)
-	if err != nil {
-		writeError(w, r, err)
-		return
-	}
-
-	var rsp []byte
-
-	switch {
-	// proto codecs
-	case hasCodec(ct, protoCodecs):
-		request := &proto.Message{}
-		// if the extracted payload isn't empty lets use it
-		if len(br) > 0 {
-			request = proto.NewMessage(br)
-		}
-
-		// create request/response
-		response := &proto.Message{}
-
-		req := c.NewRequest(
-			service.Name,
-			service.Endpoint.Name,
-			request,
-			client.WithContentType(ct),
-		)
-
-		// make the call
-		if err := c.Call(cx, req, response, callOpt); err != nil {
-			writeError(w, r, err)
-			return
-		}
-
-		// marshall response
-		rsp, err = response.Marshal()
-		if err != nil {
-			writeError(w, r, err)
-			return
-		}
-
-	default:
-		// if json codec is not present set to json
-		if !hasCodec(ct, jsonCodecs) {
-			ct = "application/json"
-		}
-
-		// default to trying json
-		var request json.RawMessage
-		// if the extracted payload isn't empty lets use it
-		if len(br) > 0 {
-			request = json.RawMessage(br)
-		}
-
-		// create request/response
-		var response json.RawMessage
-
-		req := c.NewRequest(
-			service.Name,
-			service.Endpoint.Name,
-			&request,
-			client.WithContentType(ct),
-		)
-		// make the call
-		if err := c.Call(cx, req, &response, callOpt); err != nil {
-			writeError(w, r, err)
-			return
-		}
-
-		// marshall response
-		rsp, err = response.MarshalJSON()
-		if err != nil {
-			writeError(w, r, err)
-			return
-		}
-	}
-
-	// write the response
-	writeResponse(w, r, rsp)
-}
-
-func (rh *rpcHandler) String() string {
-	return "rpc"
-}
-
-func hasCodec(ct string, codecs []string) bool {
-	for _, codec := range codecs {
-		if ct == codec {
-			return true
-		}
-	}
-	return false
-}
-
-// requestPayload takes a *http.Request.
-// If the request is a GET the query string parameters are extracted and marshaled to JSON and the raw bytes are returned.
-// If the request method is a POST the request body is read and returned
-func requestPayload(r *http.Request) ([]byte, error) {
-	var err error
-
-	// we have to decode json-rpc and proto-rpc because we suck
-	// well actually because there's no proxy codec right now
-
-	ct := r.Header.Get("Content-Type")
-	switch {
-	case strings.Contains(ct, "application/json-rpc"):
-		msg := codec.Message{
-			Type:   codec.Request,
-			Header: metadata.New(0),
-		}
-		c := jsonrpc.NewCodec(&buffer{r.Body})
-		if err = c.ReadHeader(&msg, codec.Request); err != nil {
-			return nil, err
-		}
-		var raw json.RawMessage
-		if err = c.ReadBody(&raw); err != nil {
-			return nil, err
-		}
-		return ([]byte)(raw), nil
-	case strings.Contains(ct, "application/proto-rpc"), strings.Contains(ct, "application/octet-stream"):
-		msg := codec.Message{
-			Type:   codec.Request,
-			Header: metadata.New(0),
-		}
-		c := protorpc.NewCodec(&buffer{r.Body})
-		if err = c.ReadHeader(&msg, codec.Request); err != nil {
-			return nil, err
-		}
-		var raw proto.Message
-		if err = c.ReadBody(&raw); err != nil {
-			return nil, err
-		}
-		return raw.Marshal()
-	case strings.Contains(ct, "application/www-x-form-urlencoded"):
-		if err = r.ParseForm(); err != nil {
-			return nil, err
-		}
-
-		// generate a new set of values from the form
-		vals := make(map[string]string, len(r.Form))
-		for k, v := range r.Form {
-			vals[k] = strings.Join(v, ",")
-		}
-
-		// marshal
-		return json.Marshal(vals)
-		// TODO: application/grpc
-	}
-
-	// otherwise as per usual
-	ctx := r.Context()
-	// dont user metadata.FromContext as it mangles names
-	md, ok := metadata.FromContext(ctx)
-	if !ok {
-		md = metadata.New(0)
-	}
-
-	// allocate maximum
-	matches := make(map[string]interface{}, len(md))
-	bodydst := ""
-
-	// get fields from url path
-	for k, v := range md {
-		k = strings.ToLower(k)
-		// filter own keys
-		if strings.HasPrefix(k, "x-api-field-") {
-			matches[strings.TrimPrefix(k, "x-api-field-")] = v
-			delete(md, k)
-		} else if k == "x-api-body" {
-			bodydst = v
-			delete(md, k)
-		}
-	}
-
-	// map of all fields
-	req := make(map[string]interface{}, len(md))
-
-	// get fields from url values
-	if len(r.URL.RawQuery) > 0 {
-		umd := make(map[string]interface{})
-		err = qson.Unmarshal(&umd, r.URL.RawQuery)
-		if err != nil {
-			return nil, err
-		}
-		for k, v := range umd {
-			matches[k] = v
-		}
-	}
-
-	// restore context without fields
-	*r = *r.Clone(metadata.NewContext(ctx, md))
-
-	for k, v := range matches {
-		ps := strings.Split(k, ".")
-		if len(ps) == 1 {
-			req[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 := req[ps[0]]; ok {
-			// nested map
-			nm := vm.(map[string]interface{})
-			for vk, vv := range em {
-				nm[vk] = vv
-			}
-			req[ps[0]] = nm
-		} else {
-			req[ps[0]] = em
-		}
-	}
-	pathbuf := []byte("{}")
-	if len(req) > 0 {
-		pathbuf, err = json.Marshal(req)
-		if err != nil {
-			return nil, err
-		}
-	}
-
-	urlbuf := []byte("{}")
-	out, err := jsonpatch.MergeMergePatches(urlbuf, pathbuf)
-	if err != nil {
-		return nil, err
-	}
-
-	switch r.Method {
-	case "GET":
-		// empty response
-		if strings.Contains(ct, "application/json") && string(out) == "{}" {
-			return out, nil
-		} else if string(out) == "{}" && !strings.Contains(ct, "application/json") {
-			return []byte{}, nil
-		}
-		return out, nil
-	case "PATCH", "POST", "PUT", "DELETE":
-		bodybuf := []byte("{}")
-		buf := bufferPool.Get()
-		defer bufferPool.Put(buf)
-		if _, err := buf.ReadFrom(r.Body); err != nil {
-			return nil, err
-		}
-		if b := buf.Bytes(); len(b) > 0 {
-			bodybuf = b
-		}
-		if bodydst == "" || bodydst == "*" {
-			if out, err = jsonpatch.MergeMergePatches(out, bodybuf); err == nil {
-				return out, nil
-			}
-		}
-		var jsonbody map[string]interface{}
-		if json.Valid(bodybuf) {
-			if err = json.Unmarshal(bodybuf, &jsonbody); err != nil {
-				return nil, err
-			}
-		}
-		dstmap := make(map[string]interface{})
-		ps := strings.Split(bodydst, ".")
-		if len(ps) == 1 {
-			if jsonbody != nil {
-				dstmap[ps[0]] = jsonbody
-			} else {
-				// old unexpected behaviour
-				dstmap[ps[0]] = bodybuf
-			}
-		} else {
-			em := make(map[string]interface{})
-			if jsonbody != nil {
-				em[ps[len(ps)-1]] = jsonbody
-			} else {
-				// old unexpected behaviour
-				em[ps[len(ps)-1]] = bodybuf
-			}
-			for i := len(ps) - 2; i > 0; i-- {
-				nm := make(map[string]interface{})
-				nm[ps[i]] = em
-				em = nm
-			}
-			dstmap[ps[0]] = em
-		}
-
-		bodyout, err := json.Marshal(dstmap)
-		if err != nil {
-			return nil, err
-		}
-
-		if out, err = jsonpatch.MergeMergePatches(out, bodyout); err == nil {
-			return out, nil
-		}
-
-		//fallback to previous unknown behaviour
-		return bodybuf, nil
-
-	}
-
-	return []byte{}, nil
-}
-
-func writeError(w http.ResponseWriter, r *http.Request, err error) {
-	ce := errors.Parse(err.Error())
-
-	switch ce.Code {
-	case 0:
-		// assuming it's totally screwed
-		ce.Code = 500
-		ce.Id = "go.micro.api"
-		ce.Status = http.StatusText(500)
-		ce.Detail = "error during request: " + ce.Detail
-		w.WriteHeader(500)
-	default:
-		w.WriteHeader(int(ce.Code))
-	}
-
-	// response content type
-	w.Header().Set("Content-Type", "application/json")
-
-	// Set trailers
-	if strings.Contains(r.Header.Get("Content-Type"), "application/grpc") {
-		w.Header().Set("Trailer", "grpc-status")
-		w.Header().Set("Trailer", "grpc-message")
-		w.Header().Set("grpc-status", "13")
-		w.Header().Set("grpc-message", ce.Detail)
-	}
-
-	_, werr := w.Write([]byte(ce.Error()))
-	if werr != nil {
-		if logger.V(logger.ErrorLevel) {
-			logger.Error(werr.Error())
-		}
-	}
-}
-
-func writeResponse(w http.ResponseWriter, r *http.Request, rsp []byte) {
-	w.Header().Set("Content-Type", r.Header.Get("Content-Type"))
-	w.Header().Set("Content-Length", strconv.Itoa(len(rsp)))
-
-	// Set trailers
-	if strings.Contains(r.Header.Get("Content-Type"), "application/grpc") {
-		w.Header().Set("Trailer", "grpc-status")
-		w.Header().Set("Trailer", "grpc-message")
-		w.Header().Set("grpc-status", "0")
-		w.Header().Set("grpc-message", "")
-	}
-
-	// write 204 status if rsp is nil
-	if len(rsp) == 0 {
-		w.WriteHeader(http.StatusNoContent)
-	}
-
-	// write response
-	_, err := w.Write(rsp)
-	if err != nil {
-		if logger.V(logger.ErrorLevel) {
-			logger.Error(err.Error())
-		}
-	}
-
-}
-
-func NewHandler(opts ...handler.Option) handler.Handler {
-	options := handler.NewOptions(opts...)
-	return &rpcHandler{
-		opts: options,
-	}
-}
-
-func WithService(s *api.Service, opts ...handler.Option) handler.Handler {
-	options := handler.NewOptions(opts...)
-	return &rpcHandler{
-		opts: options,
-		s:    s,
-	}
-}

api/handler/rpc/rpc_test.go

@@ -1,112 +0,0 @@
-package rpc
-
-import (
-	"bytes"
-	"net/http"
-	"testing"
-
-	go_api "github.com/unistack-org/micro/v3/api/proto"
-	jsonpb "google.golang.org/protobuf/encoding/protojson"
-	"google.golang.org/protobuf/proto"
-)
-
-func TestRequestPayloadFromRequest(t *testing.T) {
-
-	// our test event so that we can validate serialising / deserializing of true protos works
-	protoEvent := go_api.Event{
-		Name: "Test",
-	}
-
-	protoBytes, err := proto.Marshal(&protoEvent)
-	if err != nil {
-		t.Fatal("Failed to marshal proto", err)
-	}
-
-	jsonBytes, err := jsonpb.Marshal(&protoEvent)
-	if err != nil {
-		t.Fatal("Failed to marshal proto to JSON ", err)
-	}
-
-	jsonUrlBytes := []byte(`{"key1":"val1","key2":"val2","name":"Test"}`)
-
-	t.Run("extracting a json from a POST request with url params", func(t *testing.T) {
-		r, err := http.NewRequest("POST", "http://localhost/my/path?key1=val1&key2=val2", bytes.NewReader(jsonBytes))
-		if err != nil {
-			t.Fatalf("Failed to created http.Request: %v", err)
-		}
-
-		extByte, err := requestPayload(r)
-		if err != nil {
-			t.Fatalf("Failed to extract payload from request: %v", err)
-		}
-		if string(extByte) != string(jsonUrlBytes) {
-			t.Fatalf("Expected %v and %v to match", string(extByte), jsonUrlBytes)
-		}
-	})
-
-	t.Run("extracting a proto from a POST request", func(t *testing.T) {
-		r, err := http.NewRequest("POST", "http://localhost/my/path", bytes.NewReader(protoBytes))
-		if err != nil {
-			t.Fatalf("Failed to created http.Request: %v", err)
-		}
-
-		extByte, err := requestPayload(r)
-		if err != nil {
-			t.Fatalf("Failed to extract payload from request: %v", err)
-		}
-		if string(extByte) != string(protoBytes) {
-			t.Fatalf("Expected %v and %v to match", string(extByte), string(protoBytes))
-		}
-	})
-
-	t.Run("extracting JSON from a POST request", func(t *testing.T) {
-		r, err := http.NewRequest("POST", "http://localhost/my/path", bytes.NewReader(jsonBytes))
-		if err != nil {
-			t.Fatalf("Failed to created http.Request: %v", err)
-		}
-
-		extByte, err := requestPayload(r)
-		if err != nil {
-			t.Fatalf("Failed to extract payload from request: %v", err)
-		}
-		if string(extByte) != string(jsonBytes) {
-			t.Fatalf("Expected %v and %v to match", string(extByte), string(jsonBytes))
-		}
-	})
-
-	t.Run("extracting params from a GET request", func(t *testing.T) {
-
-		r, err := http.NewRequest("GET", "http://localhost/my/path", nil)
-		if err != nil {
-			t.Fatalf("Failed to created http.Request: %v", err)
-		}
-
-		q := r.URL.Query()
-		q.Add("name", "Test")
-		r.URL.RawQuery = q.Encode()
-
-		extByte, err := requestPayload(r)
-		if err != nil {
-			t.Fatalf("Failed to extract payload from request: %v", err)
-		}
-		if string(extByte) != string(jsonBytes) {
-			t.Fatalf("Expected %v and %v to match", string(extByte), string(jsonBytes))
-		}
-	})
-
-	t.Run("GET request with no params", func(t *testing.T) {
-
-		r, err := http.NewRequest("GET", "http://localhost/my/path", nil)
-		if err != nil {
-			t.Fatalf("Failed to created http.Request: %v", err)
-		}
-
-		extByte, err := requestPayload(r)
-		if err != nil {
-			t.Fatalf("Failed to extract payload from request: %v", err)
-		}
-		if string(extByte) != "" {
-			t.Fatalf("Expected %v and %v to match", string(extByte), "")
-		}
-	})
-}

api/handler/rpc/stream.go

@@ -1,263 +0,0 @@
-package rpc
-
-import (
-	"bytes"
-	"context"
-	"encoding/json"
-	"io"
-	"net/http"
-	"strings"
-	"time"
-
-	"github.com/gobwas/httphead"
-	"github.com/gobwas/ws"
-	"github.com/gobwas/ws/wsutil"
-	raw "github.com/unistack-org/micro-codec-bytes"
-	"github.com/unistack-org/micro/v3/api"
-	"github.com/unistack-org/micro/v3/client"
-	"github.com/unistack-org/micro/v3/logger"
-	"github.com/unistack-org/micro/v3/util/router"
-)
-
-// serveWebsocket will stream rpc back over websockets assuming json
-func serveWebsocket(ctx context.Context, w http.ResponseWriter, r *http.Request, service *api.Service, c client.Client) {
-	var op ws.OpCode
-
-	ct := r.Header.Get("Content-Type")
-	// Strip charset from Content-Type (like `application/json; charset=UTF-8`)
-	if idx := strings.IndexRune(ct, ';'); idx >= 0 {
-		ct = ct[:idx]
-	}
-
-	// check proto from request
-	switch ct {
-	case "application/json":
-		op = ws.OpText
-	default:
-		op = ws.OpBinary
-	}
-
-	hdr := make(http.Header)
-	if proto, ok := r.Header["Sec-WebSocket-Protocol"]; ok {
-		for _, p := range proto {
-			switch p {
-			case "binary":
-				hdr["Sec-WebSocket-Protocol"] = []string{"binary"}
-				op = ws.OpBinary
-			default:
-				op = ws.OpBinary
-			}
-		}
-	}
-	payload, err := requestPayload(r)
-	if err != nil {
-		if logger.V(logger.ErrorLevel) {
-			logger.Error(err.Error())
-		}
-		return
-	}
-
-	upgrader := ws.HTTPUpgrader{Timeout: 5 * time.Second,
-		Protocol: func(proto string) bool {
-			if strings.Contains(proto, "binary") {
-				return true
-			}
-			// fallback to support all protocols now
-			return true
-		},
-		Extension: func(httphead.Option) bool {
-			// disable extensions for compatibility
-			return false
-		},
-		Header: hdr,
-	}
-
-	conn, rw, _, err := upgrader.Upgrade(r, w)
-	if err != nil {
-		if logger.V(logger.ErrorLevel) {
-			logger.Error(err.Error())
-		}
-		return
-	}
-
-	defer func() {
-		if err := conn.Close(); err != nil {
-			if logger.V(logger.ErrorLevel) {
-				logger.Error(err.Error())
-			}
-			return
-		}
-	}()
-
-	var request interface{}
-	if !bytes.Equal(payload, []byte(`{}`)) {
-		switch ct {
-		case "application/json", "":
-			m := json.RawMessage(payload)
-			request = &m
-		default:
-			request = &raw.Frame{Data: payload}
-		}
-	}
-
-	// we always need to set content type for message
-	if ct == "" {
-		ct = "application/json"
-	}
-	req := c.NewRequest(
-		service.Name,
-		service.Endpoint.Name,
-		request,
-		client.WithContentType(ct),
-		client.StreamingRequest(),
-	)
-
-	// create custom router
-	callOpt := client.WithRouter(router.New(service.Services))
-
-	// create a new stream
-	stream, err := c.Stream(ctx, req, callOpt)
-	if err != nil {
-		if logger.V(logger.ErrorLevel) {
-			logger.Error(err.Error())
-		}
-		return
-	}
-
-	if request != nil {
-		if err = stream.Send(request); err != nil {
-			if logger.V(logger.ErrorLevel) {
-				logger.Error(err.Error())
-			}
-			return
-		}
-	}
-
-	go writeLoop(rw, stream)
-
-	rsp := stream.Response()
-
-	// receive from stream and send to client
-	for {
-		select {
-		case <-ctx.Done():
-			return
-		case <-stream.Context().Done():
-			return
-		default:
-			// read backend response body
-			buf, err := rsp.Read()
-			if err != nil {
-				// wants to avoid import  grpc/status.Status
-				if strings.Contains(err.Error(), "context canceled") {
-					return
-				}
-				if logger.V(logger.ErrorLevel) {
-					logger.Error(err.Error())
-				}
-				return
-			}
-
-			// write the response
-			if err := wsutil.WriteServerMessage(rw, op, buf); err != nil {
-				if logger.V(logger.ErrorLevel) {
-					logger.Error(err.Error())
-				}
-				return
-			}
-			if err = rw.Flush(); err != nil {
-				if logger.V(logger.ErrorLevel) {
-					logger.Error(err.Error())
-				}
-				return
-			}
-		}
-	}
-}
-
-// writeLoop
-func writeLoop(rw io.ReadWriter, stream client.Stream) {
-	// close stream when done
-	defer stream.Close()
-
-	for {
-		select {
-		case <-stream.Context().Done():
-			return
-		default:
-			buf, op, err := wsutil.ReadClientData(rw)
-			if err != nil {
-				if wserr, ok := err.(wsutil.ClosedError); ok {
-					switch wserr.Code {
-					case ws.StatusGoingAway:
-						// this happens when user leave the page
-						return
-					case ws.StatusNormalClosure, ws.StatusNoStatusRcvd:
-						// this happens when user close ws connection, or we don't get any status
-						return
-					}
-				}
-				if logger.V(logger.ErrorLevel) {
-					logger.Error(err.Error())
-				}
-				return
-			}
-			switch op {
-			default:
-				// not relevant
-				continue
-			case ws.OpText, ws.OpBinary:
-				break
-			}
-			// send to backend
-			// default to trying json
-			// if the extracted payload isn't empty lets use it
-			request := &raw.Frame{Data: buf}
-			if err := stream.Send(request); err != nil {
-				if logger.V(logger.ErrorLevel) {
-					logger.Error(err.Error())
-				}
-				return
-			}
-		}
-	}
-}
-
-func isStream(r *http.Request, srv *api.Service) bool {
-	// check if it's a web socket
-	if !isWebSocket(r) {
-		return false
-	}
-	// check if the endpoint supports streaming
-	for _, service := range srv.Services {
-		for _, ep := range service.Endpoints {
-			// skip if it doesn't match the name
-			if ep.Name != srv.Endpoint.Name {
-				continue
-			}
-			// matched if the name
-			if v := ep.Metadata["stream"]; v == "true" {
-				return true
-			}
-		}
-	}
-	return false
-}
-
-func isWebSocket(r *http.Request) bool {
-	contains := func(key, val string) bool {
-		vv := strings.Split(r.Header.Get(key), ",")
-		for _, v := range vv {
-			if val == strings.ToLower(strings.TrimSpace(v)) {
-				return true
-			}
-		}
-		return false
-	}
-
-	if contains("Connection", "upgrade") && contains("Upgrade", "websocket") {
-		return true
-	}
-
-	return false
-}

api/handler/web/web.go

@@ -1,182 +0,0 @@
-// Package web contains the web handler including websocket support
-package web
-
-import (
-	"errors"
-	"fmt"
-	"io"
-	"math/rand"
-	"net"
-	"net/http"
-	"net/http/httputil"
-	"net/url"
-	"strings"
-
-	"github.com/unistack-org/micro/v3/api"
-	"github.com/unistack-org/micro/v3/api/handler"
-	"github.com/unistack-org/micro/v3/registry"
-)
-
-const (
-	Handler = "web"
-)
-
-type webHandler struct {
-	opts handler.Options
-	s    *api.Service
-}
-
-func (wh *webHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
-	service, err := wh.getService(r)
-	if err != nil {
-		w.WriteHeader(500)
-		return
-	}
-
-	if len(service) == 0 {
-		w.WriteHeader(404)
-		return
-	}
-
-	rp, err := url.Parse(service)
-	if err != nil {
-		w.WriteHeader(500)
-		return
-	}
-
-	if isWebSocket(r) {
-		wh.serveWebSocket(rp.Host, w, r)
-		return
-	}
-
-	httputil.NewSingleHostReverseProxy(rp).ServeHTTP(w, r)
-}
-
-// getService returns the service for this request from the selector
-func (wh *webHandler) getService(r *http.Request) (string, error) {
-	var service *api.Service
-
-	if wh.s != nil {
-		// we were given the service
-		service = wh.s
-	} else if wh.opts.Router != nil {
-		// try get service from router
-		s, err := wh.opts.Router.Route(r)
-		if err != nil {
-			return "", err
-		}
-		service = s
-	} else {
-		// we have no way of routing the request
-		return "", errors.New("no route found")
-	}
-
-	// get the nodes
-	nodes := make([]*registry.Node, 0, len(service.Services))
-	for _, srv := range service.Services {
-		nodes = append(nodes, srv.Nodes...)
-	}
-
-	if len(nodes) == 0 {
-		return "", errors.New("no route found")
-	}
-
-	// select a random node
-	node := nodes[rand.Int()%len(nodes)]
-
-	return fmt.Sprintf("http://%s", node.Address), nil
-}
-
-// serveWebSocket used to serve a web socket proxied connection
-func (wh *webHandler) serveWebSocket(host string, w http.ResponseWriter, r *http.Request) {
-	req := new(http.Request)
-	*req = *r
-
-	if len(host) == 0 {
-		http.Error(w, "invalid host", 500)
-		return
-	}
-
-	// set x-forward-for
-	if clientIP, _, err := net.SplitHostPort(r.RemoteAddr); err == nil {
-		if ips, ok := req.Header["X-Forwarded-For"]; ok {
-			clientIP = strings.Join(ips, ", ") + ", " + clientIP
-		}
-		req.Header.Set("X-Forwarded-For", clientIP)
-	}
-
-	// connect to the backend host
-	conn, err := net.Dial("tcp", host)
-	if err != nil {
-		http.Error(w, err.Error(), 500)
-		return
-	}
-
-	// hijack the connection
-	hj, ok := w.(http.Hijacker)
-	if !ok {
-		http.Error(w, "failed to connect", 500)
-		return
-	}
-
-	nc, _, err := hj.Hijack()
-	if err != nil {
-		return
-	}
-
-	defer nc.Close()
-	defer conn.Close()
-
-	if err = req.Write(conn); err != nil {
-		return
-	}
-
-	errCh := make(chan error, 2)
-
-	cp := func(dst io.Writer, src io.Reader) {
-		_, err := io.Copy(dst, src)
-		errCh <- err
-	}
-
-	go cp(conn, nc)
-	go cp(nc, conn)
-
-	<-errCh
-}
-
-func isWebSocket(r *http.Request) bool {
-	contains := func(key, val string) bool {
-		vv := strings.Split(r.Header.Get(key), ",")
-		for _, v := range vv {
-			if val == strings.ToLower(strings.TrimSpace(v)) {
-				return true
-			}
-		}
-		return false
-	}
-
-	if contains("Connection", "upgrade") && contains("Upgrade", "websocket") {
-		return true
-	}
-
-	return false
-}
-
-func (wh *webHandler) String() string {
-	return "web"
-}
-
-func NewHandler(opts ...handler.Option) handler.Handler {
-	return &webHandler{
-		opts: handler.NewOptions(opts...),
-	}
-}
-
-func WithService(s *api.Service, opts ...handler.Option) handler.Handler {
-	options := handler.NewOptions(opts...)
-
-	return &webHandler{
-		opts: options,
-		s:    s,
-	}
-}

api/internal/proto/message.pb.go

@@ -1,28 +0,0 @@
-package proto
-
-type Message struct {
-	data []byte
-}
-
-func (m *Message) ProtoMessage() {}
-
-func (m *Message) Reset() {
-	*m = Message{}
-}
-
-func (m *Message) String() string {
-	return string(m.data)
-}
-
-func (m *Message) Marshal() ([]byte, error) {
-	return m.data, nil
-}
-
-func (m *Message) Unmarshal(data []byte) error {
-	m.data = data
-	return nil
-}
-
-func NewMessage(data []byte) *Message {
-	return &Message{data}
-}

api/proto/api.pb.go

@@ -1,511 +0,0 @@
-// Code generated by protoc-gen-go. DO NOT EDIT.
-// versions:
-// 	protoc-gen-go v1.25.0
-// 	protoc        v3.6.1
-// source: api/proto/api.proto
-
-package go_api
-
-import (
-	proto "github.com/golang/protobuf/proto"
-	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
-	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
-	reflect "reflect"
-	sync "sync"
-)
-
-const (
-	// Verify that this generated code is sufficiently up-to-date.
-	_ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion)
-	// Verify that runtime/protoimpl is sufficiently up-to-date.
-	_ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20)
-)
-
-// This is a compile-time assertion that a sufficiently up-to-date version
-// of the legacy proto package is being used.
-const _ = proto.ProtoPackageIsVersion4
-
-type Pair struct {
-	state         protoimpl.MessageState
-	sizeCache     protoimpl.SizeCache
-	unknownFields protoimpl.UnknownFields
-
-	Key    string   `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"`
-	Values []string `protobuf:"bytes,2,rep,name=values,proto3" json:"values,omitempty"`
-}
-
-func (x *Pair) Reset() {
-	*x = Pair{}
-	if protoimpl.UnsafeEnabled {
-		mi := &file_api_proto_api_proto_msgTypes[0]
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		ms.StoreMessageInfo(mi)
-	}
-}
-
-func (x *Pair) String() string {
-	return protoimpl.X.MessageStringOf(x)
-}
-
-func (*Pair) ProtoMessage() {}
-
-func (x *Pair) ProtoReflect() protoreflect.Message {
-	mi := &file_api_proto_api_proto_msgTypes[0]
-	if protoimpl.UnsafeEnabled && x != nil {
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		if ms.LoadMessageInfo() == nil {
-			ms.StoreMessageInfo(mi)
-		}
-		return ms
-	}
-	return mi.MessageOf(x)
-}
-
-// Deprecated: Use Pair.ProtoReflect.Descriptor instead.
-func (*Pair) Descriptor() ([]byte, []int) {
-	return file_api_proto_api_proto_rawDescGZIP(), []int{0}
-}
-
-func (x *Pair) GetKey() string {
-	if x != nil {
-		return x.Key
-	}
-	return ""
-}
-
-func (x *Pair) GetValues() []string {
-	if x != nil {
-		return x.Values
-	}
-	return nil
-}
-
-// A HTTP request as RPC
-// Forward by the api handler
-type Request struct {
-	state         protoimpl.MessageState
-	sizeCache     protoimpl.SizeCache
-	unknownFields protoimpl.UnknownFields
-
-	Method string           `protobuf:"bytes,1,opt,name=method,proto3" json:"method,omitempty"`
-	Path   string           `protobuf:"bytes,2,opt,name=path,proto3" json:"path,omitempty"`
-	Header map[string]*Pair `protobuf:"bytes,3,rep,name=header,proto3" json:"header,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
-	Get    map[string]*Pair `protobuf:"bytes,4,rep,name=get,proto3" json:"get,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
-	Post   map[string]*Pair `protobuf:"bytes,5,rep,name=post,proto3" json:"post,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
-	Body   string           `protobuf:"bytes,6,opt,name=body,proto3" json:"body,omitempty"` // raw request body; if not application/x-www-form-urlencoded
-	Url    string           `protobuf:"bytes,7,opt,name=url,proto3" json:"url,omitempty"`
-}
-
-func (x *Request) Reset() {
-	*x = Request{}
-	if protoimpl.UnsafeEnabled {
-		mi := &file_api_proto_api_proto_msgTypes[1]
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		ms.StoreMessageInfo(mi)
-	}
-}
-
-func (x *Request) String() string {
-	return protoimpl.X.MessageStringOf(x)
-}
-
-func (*Request) ProtoMessage() {}
-
-func (x *Request) ProtoReflect() protoreflect.Message {
-	mi := &file_api_proto_api_proto_msgTypes[1]
-	if protoimpl.UnsafeEnabled && x != nil {
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		if ms.LoadMessageInfo() == nil {
-			ms.StoreMessageInfo(mi)
-		}
-		return ms
-	}
-	return mi.MessageOf(x)
-}
-
-// Deprecated: Use Request.ProtoReflect.Descriptor instead.
-func (*Request) Descriptor() ([]byte, []int) {
-	return file_api_proto_api_proto_rawDescGZIP(), []int{1}
-}
-
-func (x *Request) GetMethod() string {
-	if x != nil {
-		return x.Method
-	}
-	return ""
-}
-
-func (x *Request) GetPath() string {
-	if x != nil {
-		return x.Path
-	}
-	return ""
-}
-
-func (x *Request) GetHeader() map[string]*Pair {
-	if x != nil {
-		return x.Header
-	}
-	return nil
-}
-
-func (x *Request) GetGet() map[string]*Pair {
-	if x != nil {
-		return x.Get
-	}
-	return nil
-}
-
-func (x *Request) GetPost() map[string]*Pair {
-	if x != nil {
-		return x.Post
-	}
-	return nil
-}
-
-func (x *Request) GetBody() string {
-	if x != nil {
-		return x.Body
-	}
-	return ""
-}
-
-func (x *Request) GetUrl() string {
-	if x != nil {
-		return x.Url
-	}
-	return ""
-}
-
-// A HTTP response as RPC
-// Expected response for the api handler
-type Response struct {
-	state         protoimpl.MessageState
-	sizeCache     protoimpl.SizeCache
-	unknownFields protoimpl.UnknownFields
-
-	StatusCode int32            `protobuf:"varint,1,opt,name=statusCode,proto3" json:"statusCode,omitempty"`
-	Header     map[string]*Pair `protobuf:"bytes,2,rep,name=header,proto3" json:"header,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
-	Body       string           `protobuf:"bytes,3,opt,name=body,proto3" json:"body,omitempty"`
-}
-
-func (x *Response) Reset() {
-	*x = Response{}
-	if protoimpl.UnsafeEnabled {
-		mi := &file_api_proto_api_proto_msgTypes[2]
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		ms.StoreMessageInfo(mi)
-	}
-}
-
-func (x *Response) String() string {
-	return protoimpl.X.MessageStringOf(x)
-}
-
-func (*Response) ProtoMessage() {}
-
-func (x *Response) ProtoReflect() protoreflect.Message {
-	mi := &file_api_proto_api_proto_msgTypes[2]
-	if protoimpl.UnsafeEnabled && x != nil {
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		if ms.LoadMessageInfo() == nil {
-			ms.StoreMessageInfo(mi)
-		}
-		return ms
-	}
-	return mi.MessageOf(x)
-}
-
-// Deprecated: Use Response.ProtoReflect.Descriptor instead.
-func (*Response) Descriptor() ([]byte, []int) {
-	return file_api_proto_api_proto_rawDescGZIP(), []int{2}
-}
-
-func (x *Response) GetStatusCode() int32 {
-	if x != nil {
-		return x.StatusCode
-	}
-	return 0
-}
-
-func (x *Response) GetHeader() map[string]*Pair {
-	if x != nil {
-		return x.Header
-	}
-	return nil
-}
-
-func (x *Response) GetBody() string {
-	if x != nil {
-		return x.Body
-	}
-	return ""
-}
-
-// A HTTP event as RPC
-// Forwarded by the event handler
-type Event struct {
-	state         protoimpl.MessageState
-	sizeCache     protoimpl.SizeCache
-	unknownFields protoimpl.UnknownFields
-
-	// e.g login
-	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
-	// uuid
-	Id string `protobuf:"bytes,2,opt,name=id,proto3" json:"id,omitempty"`
-	// unix timestamp of event
-	Timestamp int64 `protobuf:"varint,3,opt,name=timestamp,proto3" json:"timestamp,omitempty"`
-	// event headers
-	Header map[string]*Pair `protobuf:"bytes,4,rep,name=header,proto3" json:"header,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
-	// the event data
-	Data string `protobuf:"bytes,5,opt,name=data,proto3" json:"data,omitempty"`
-}
-
-func (x *Event) Reset() {
-	*x = Event{}
-	if protoimpl.UnsafeEnabled {
-		mi := &file_api_proto_api_proto_msgTypes[3]
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		ms.StoreMessageInfo(mi)
-	}
-}
-
-func (x *Event) String() string {
-	return protoimpl.X.MessageStringOf(x)
-}
-
-func (*Event) ProtoMessage() {}
-
-func (x *Event) ProtoReflect() protoreflect.Message {
-	mi := &file_api_proto_api_proto_msgTypes[3]
-	if protoimpl.UnsafeEnabled && x != nil {
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		if ms.LoadMessageInfo() == nil {
-			ms.StoreMessageInfo(mi)
-		}
-		return ms
-	}
-	return mi.MessageOf(x)
-}
-
-// Deprecated: Use Event.ProtoReflect.Descriptor instead.
-func (*Event) Descriptor() ([]byte, []int) {
-	return file_api_proto_api_proto_rawDescGZIP(), []int{3}
-}
-
-func (x *Event) GetName() string {
-	if x != nil {
-		return x.Name
-	}
-	return ""
-}
-
-func (x *Event) GetId() string {
-	if x != nil {
-		return x.Id
-	}
-	return ""
-}
-
-func (x *Event) GetTimestamp() int64 {
-	if x != nil {
-		return x.Timestamp
-	}
-	return 0
-}
-
-func (x *Event) GetHeader() map[string]*Pair {
-	if x != nil {
-		return x.Header
-	}
-	return nil
-}
-
-func (x *Event) GetData() string {
-	if x != nil {
-		return x.Data
-	}
-	return ""
-}
-
-var File_api_proto_api_proto protoreflect.FileDescriptor
-
-var file_api_proto_api_proto_rawDesc = []byte{
-	0x0a, 0x13, 0x61, 0x70, 0x69, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2f, 0x61, 0x70, 0x69, 0x2e,
-	0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x06, 0x67, 0x6f, 0x2e, 0x61, 0x70, 0x69, 0x22, 0x30, 0x0a,
-	0x04, 0x50, 0x61, 0x69, 0x72, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01,
-	0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x16, 0x0a, 0x06, 0x76, 0x61, 0x6c, 0x75, 0x65,
-	0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x09, 0x52, 0x06, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x73, 0x22,
-	0xc1, 0x03, 0x0a, 0x07, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x16, 0x0a, 0x06, 0x6d,
-	0x65, 0x74, 0x68, 0x6f, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x6d, 0x65, 0x74,
-	0x68, 0x6f, 0x64, 0x12, 0x12, 0x0a, 0x04, 0x70, 0x61, 0x74, 0x68, 0x18, 0x02, 0x20, 0x01, 0x28,
-	0x09, 0x52, 0x04, 0x70, 0x61, 0x74, 0x68, 0x12, 0x33, 0x0a, 0x06, 0x68, 0x65, 0x61, 0x64, 0x65,
-	0x72, 0x18, 0x03, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1b, 0x2e, 0x67, 0x6f, 0x2e, 0x61, 0x70, 0x69,
-	0x2e, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x2e, 0x48, 0x65, 0x61, 0x64, 0x65, 0x72, 0x45,
-	0x6e, 0x74, 0x72, 0x79, 0x52, 0x06, 0x68, 0x65, 0x61, 0x64, 0x65, 0x72, 0x12, 0x2a, 0x0a, 0x03,
-	0x67, 0x65, 0x74, 0x18, 0x04, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x18, 0x2e, 0x67, 0x6f, 0x2e, 0x61,
-	0x70, 0x69, 0x2e, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x2e, 0x47, 0x65, 0x74, 0x45, 0x6e,
-	0x74, 0x72, 0x79, 0x52, 0x03, 0x67, 0x65, 0x74, 0x12, 0x2d, 0x0a, 0x04, 0x70, 0x6f, 0x73, 0x74,
-	0x18, 0x05, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x67, 0x6f, 0x2e, 0x61, 0x70, 0x69, 0x2e,
-	0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x2e, 0x50, 0x6f, 0x73, 0x74, 0x45, 0x6e, 0x74, 0x72,
-	0x79, 0x52, 0x04, 0x70, 0x6f, 0x73, 0x74, 0x12, 0x12, 0x0a, 0x04, 0x62, 0x6f, 0x64, 0x79, 0x18,
-	0x06, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x62, 0x6f, 0x64, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x75,
-	0x72, 0x6c, 0x18, 0x07, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x75, 0x72, 0x6c, 0x1a, 0x47, 0x0a,
-	0x0b, 0x48, 0x65, 0x61, 0x64, 0x65, 0x72, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03,
-	0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x22,
-	0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x0c, 0x2e,
-	0x67, 0x6f, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x50, 0x61, 0x69, 0x72, 0x52, 0x05, 0x76, 0x61, 0x6c,
-	0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x1a, 0x44, 0x0a, 0x08, 0x47, 0x65, 0x74, 0x45, 0x6e, 0x74,
-	0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52,
-	0x03, 0x6b, 0x65, 0x79, 0x12, 0x22, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20,
-	0x01, 0x28, 0x0b, 0x32, 0x0c, 0x2e, 0x67, 0x6f, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x50, 0x61, 0x69,
-	0x72, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x1a, 0x45, 0x0a, 0x09,
-	0x50, 0x6f, 0x73, 0x74, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79,
-	0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x22, 0x0a, 0x05, 0x76,
-	0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x0c, 0x2e, 0x67, 0x6f, 0x2e,
-	0x61, 0x70, 0x69, 0x2e, 0x50, 0x61, 0x69, 0x72, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a,
-	0x02, 0x38, 0x01, 0x22, 0xbd, 0x01, 0x0a, 0x08, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65,
-	0x12, 0x1e, 0x0a, 0x0a, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x43, 0x6f, 0x64, 0x65, 0x18, 0x01,
-	0x20, 0x01, 0x28, 0x05, 0x52, 0x0a, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x43, 0x6f, 0x64, 0x65,
-	0x12, 0x34, 0x0a, 0x06, 0x68, 0x65, 0x61, 0x64, 0x65, 0x72, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b,
-	0x32, 0x1c, 0x2e, 0x67, 0x6f, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e,
-	0x73, 0x65, 0x2e, 0x48, 0x65, 0x61, 0x64, 0x65, 0x72, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x06,
-	0x68, 0x65, 0x61, 0x64, 0x65, 0x72, 0x12, 0x12, 0x0a, 0x04, 0x62, 0x6f, 0x64, 0x79, 0x18, 0x03,
-	0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x62, 0x6f, 0x64, 0x79, 0x1a, 0x47, 0x0a, 0x0b, 0x48, 0x65,
-	0x61, 0x64, 0x65, 0x72, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79,
-	0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x22, 0x0a, 0x05, 0x76,
-	0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x0c, 0x2e, 0x67, 0x6f, 0x2e,
-	0x61, 0x70, 0x69, 0x2e, 0x50, 0x61, 0x69, 0x72, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a,
-	0x02, 0x38, 0x01, 0x22, 0xd9, 0x01, 0x0a, 0x05, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x12, 0x12, 0x0a,
-	0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d,
-	0x65, 0x12, 0x0e, 0x0a, 0x02, 0x69, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x02, 0x69,
-	0x64, 0x12, 0x1c, 0x0a, 0x09, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x18, 0x03,
-	0x20, 0x01, 0x28, 0x03, 0x52, 0x09, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x12,
-	0x31, 0x0a, 0x06, 0x68, 0x65, 0x61, 0x64, 0x65, 0x72, 0x18, 0x04, 0x20, 0x03, 0x28, 0x0b, 0x32,
-	0x19, 0x2e, 0x67, 0x6f, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x2e, 0x48,
-	0x65, 0x61, 0x64, 0x65, 0x72, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x06, 0x68, 0x65, 0x61, 0x64,
-	0x65, 0x72, 0x12, 0x12, 0x0a, 0x04, 0x64, 0x61, 0x74, 0x61, 0x18, 0x05, 0x20, 0x01, 0x28, 0x09,
-	0x52, 0x04, 0x64, 0x61, 0x74, 0x61, 0x1a, 0x47, 0x0a, 0x0b, 0x48, 0x65, 0x61, 0x64, 0x65, 0x72,
-	0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01,
-	0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x22, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65,
-	0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x0c, 0x2e, 0x67, 0x6f, 0x2e, 0x61, 0x70, 0x69, 0x2e,
-	0x50, 0x61, 0x69, 0x72, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x62,
-	0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33,
-}
-
-var (
-	file_api_proto_api_proto_rawDescOnce sync.Once
-	file_api_proto_api_proto_rawDescData = file_api_proto_api_proto_rawDesc
-)
-
-func file_api_proto_api_proto_rawDescGZIP() []byte {
-	file_api_proto_api_proto_rawDescOnce.Do(func() {
-		file_api_proto_api_proto_rawDescData = protoimpl.X.CompressGZIP(file_api_proto_api_proto_rawDescData)
-	})
-	return file_api_proto_api_proto_rawDescData
-}
-
-var file_api_proto_api_proto_msgTypes = make([]protoimpl.MessageInfo, 9)
-var file_api_proto_api_proto_goTypes = []interface{}{
-	(*Pair)(nil),     // 0: go.api.Pair
-	(*Request)(nil),  // 1: go.api.Request
-	(*Response)(nil), // 2: go.api.Response
-	(*Event)(nil),    // 3: go.api.Event
-	nil,              // 4: go.api.Request.HeaderEntry
-	nil,              // 5: go.api.Request.GetEntry
-	nil,              // 6: go.api.Request.PostEntry
-	nil,              // 7: go.api.Response.HeaderEntry
-	nil,              // 8: go.api.Event.HeaderEntry
-}
-var file_api_proto_api_proto_depIdxs = []int32{
-	4,  // 0: go.api.Request.header:type_name -> go.api.Request.HeaderEntry
-	5,  // 1: go.api.Request.get:type_name -> go.api.Request.GetEntry
-	6,  // 2: go.api.Request.post:type_name -> go.api.Request.PostEntry
-	7,  // 3: go.api.Response.header:type_name -> go.api.Response.HeaderEntry
-	8,  // 4: go.api.Event.header:type_name -> go.api.Event.HeaderEntry
-	0,  // 5: go.api.Request.HeaderEntry.value:type_name -> go.api.Pair
-	0,  // 6: go.api.Request.GetEntry.value:type_name -> go.api.Pair
-	0,  // 7: go.api.Request.PostEntry.value:type_name -> go.api.Pair
-	0,  // 8: go.api.Response.HeaderEntry.value:type_name -> go.api.Pair
-	0,  // 9: go.api.Event.HeaderEntry.value:type_name -> go.api.Pair
-	10, // [10:10] is the sub-list for method output_type
-	10, // [10:10] is the sub-list for method input_type
-	10, // [10:10] is the sub-list for extension type_name
-	10, // [10:10] is the sub-list for extension extendee
-	0,  // [0:10] is the sub-list for field type_name
-}
-
-func init() { file_api_proto_api_proto_init() }
-func file_api_proto_api_proto_init() {
-	if File_api_proto_api_proto != nil {
-		return
-	}
-	if !protoimpl.UnsafeEnabled {
-		file_api_proto_api_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*Pair); i {
-			case 0:
-				return &v.state
-			case 1:
-				return &v.sizeCache
-			case 2:
-				return &v.unknownFields
-			default:
-				return nil
-			}
-		}
-		file_api_proto_api_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*Request); i {
-			case 0:
-				return &v.state
-			case 1:
-				return &v.sizeCache
-			case 2:
-				return &v.unknownFields
-			default:
-				return nil
-			}
-		}
-		file_api_proto_api_proto_msgTypes[2].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*Response); i {
-			case 0:
-				return &v.state
-			case 1:
-				return &v.sizeCache
-			case 2:
-				return &v.unknownFields
-			default:
-				return nil
-			}
-		}
-		file_api_proto_api_proto_msgTypes[3].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*Event); i {
-			case 0:
-				return &v.state
-			case 1:
-				return &v.sizeCache
-			case 2:
-				return &v.unknownFields
-			default:
-				return nil
-			}
-		}
-	}
-	type x struct{}
-	out := protoimpl.TypeBuilder{
-		File: protoimpl.DescBuilder{
-			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
-			RawDescriptor: file_api_proto_api_proto_rawDesc,
-			NumEnums:      0,
-			NumMessages:   9,
-			NumExtensions: 0,
-			NumServices:   0,
-		},
-		GoTypes:           file_api_proto_api_proto_goTypes,
-		DependencyIndexes: file_api_proto_api_proto_depIdxs,
-		MessageInfos:      file_api_proto_api_proto_msgTypes,
-	}.Build()
-	File_api_proto_api_proto = out.File
-	file_api_proto_api_proto_rawDesc = nil
-	file_api_proto_api_proto_goTypes = nil
-	file_api_proto_api_proto_depIdxs = nil
-}

api/proto/api.pb.micro.go

@@ -1,21 +0,0 @@
-// Code generated by protoc-gen-micro. DO NOT EDIT.
-// source: api/proto/api.proto
-
-package go_api
-
-import (
-	fmt "fmt"
-	proto "github.com/golang/protobuf/proto"
-	math "math"
-)
-
-// Reference imports to suppress errors if they are not otherwise used.
-var _ = proto.Marshal
-var _ = fmt.Errorf
-var _ = math.Inf
-
-// This is a compile-time assertion to ensure that this generated file
-// is compatible with the proto package it is being compiled against.
-// A compilation error at this line likely means your copy of the
-// proto package needs to be updated.
-const _ = proto.ProtoPackageIsVersion3 // please upgrade the proto package

api/proto/api.proto

@@ -1,43 +0,0 @@
-syntax = "proto3";
-
-package go.api;
-
-message Pair {
-	string key = 1;
-	repeated string values = 2;
-}
-
-// A HTTP request as RPC
-// Forward by the api handler
-message Request {
-        string method = 1;
-        string path = 2;
-        map<string, Pair> header = 3;
-        map<string, Pair> get = 4;
-        map<string, Pair> post = 5;
-        string body = 6;  // raw request body; if not application/x-www-form-urlencoded
-	string url = 7;
-}
-
-// A HTTP response as RPC
-// Expected response for the api handler
-message Response {
-        int32 statusCode = 1;
-        map<string, Pair> header = 2;
-        string body = 3;
-}
-
-// A HTTP event as RPC
-// Forwarded by the event handler
-message Event {
-	// e.g login
-	string name = 1;
-	// uuid
-	string id = 2;
-	// unix timestamp of event
-	int64 timestamp = 3;
-	// event headers
-        map<string, Pair> header = 4;
-	// the event data
-	string data = 5;
-}

api/resolver/host/host.go

@@ -7,11 +7,12 @@ import (
 	"github.com/unistack-org/micro/v3/api/resolver"
 )
 
-type Resolver struct {
+type hostResolver struct {
 	opts resolver.Options
 }
 
-func (r *Resolver) Resolve(req *http.Request, opts ...resolver.ResolveOption) (*resolver.Endpoint, error) {
+// Resolve endpoint
+func (r *hostResolver) Resolve(req *http.Request, opts ...resolver.ResolveOption) (*resolver.Endpoint, error) {
 	// parse options
 	options := resolver.NewResolveOptions(opts...)
 
@@ -24,10 +25,11 @@ func (r *Resolver) Resolve(req *http.Request, opts ...resolver.ResolveOption) (*
 	}, nil
 }
 
-func (r *Resolver) String() string {
+func (r *hostResolver) String() string {
 	return "host"
 }
 
+// NewResolver creates new host api resolver
 func NewResolver(opts ...resolver.Option) resolver.Resolver {
-	return &Resolver{opts: resolver.NewOptions(opts...)}
+	return &hostResolver{opts: resolver.NewOptions(opts...)}
 }

api/resolver/options.go

@@ -1,12 +1,18 @@
 package resolver
 
 import (
-	"github.com/unistack-org/micro/v3/registry"
+	"context"
+
+	"github.com/unistack-org/micro/v3/register"
 )
 
 // Options struct
 type Options struct {
-	Handler       string
+	// Context is for external defined options
+	Context context.Context
+	// Handler name
+	Handler string
+	// ServicePrefix is the prefix
 	ServicePrefix string
 }
 
@@ -29,7 +35,9 @@ func WithServicePrefix(p string) Option {
 
 // NewOptions returns new initialised options
 func NewOptions(opts ...Option) Options {
-	options := Options{}
+	options := Options{
+		Context: context.Background(),
+	}
 	for _, o := range opts {
 		o(&options)
 	}
@@ -53,7 +61,7 @@ func Domain(n string) ResolveOption {
 
 // NewResolveOptions returns new initialised resolve options
 func NewResolveOptions(opts ...ResolveOption) ResolveOptions {
-	options := ResolveOptions{Domain: registry.DefaultDomain}
+	options := ResolveOptions{Domain: register.DefaultDomain}
 	for _, o := range opts {
 		o(&options)
 	}

api/resolver/path/path.go

@@ -8,10 +8,12 @@ import (
 	"github.com/unistack-org/micro/v3/api/resolver"
 )
 
+// Resolver the path resolver
 type Resolver struct {
 	opts resolver.Options
 }
 
+// Resolve resolves endpoint
 func (r *Resolver) Resolve(req *http.Request, opts ...resolver.ResolveOption) (*resolver.Endpoint, error) {
 	// parse options
 	options := resolver.NewResolveOptions(opts...)
@@ -31,10 +33,12 @@ func (r *Resolver) Resolve(req *http.Request, opts ...resolver.ResolveOption) (*
 	}, nil
 }
 
+// String retruns the string representation
 func (r *Resolver) String() string {
 	return "path"
 }
 
+// NewResolver returns new path resolver
 func NewResolver(opts ...resolver.Option) resolver.Resolver {
 	return &Resolver{opts: resolver.NewOptions(opts...)}
 }

api/resolver/subdomain/subdomain.go

@@ -12,17 +12,19 @@ import (
 	"golang.org/x/net/publicsuffix"
 )
 
+// NewResolver creates new subdomain api resolver
 func NewResolver(parent resolver.Resolver, opts ...resolver.Option) resolver.Resolver {
 	options := resolver.NewOptions(opts...)
-	return &Resolver{options, parent}
+	return &subdomainResolver{options, parent}
 }
 
-type Resolver struct {
+type subdomainResolver struct {
 	opts resolver.Options
 	resolver.Resolver
 }
 
-func (r *Resolver) Resolve(req *http.Request, opts ...resolver.ResolveOption) (*resolver.Endpoint, error) {
+// Resolve resolve endpoint based on subdomain
+func (r *subdomainResolver) Resolve(req *http.Request, opts ...resolver.ResolveOption) (*resolver.Endpoint, error) {
 	if dom := r.Domain(req); len(dom) > 0 {
 		opts = append(opts, resolver.Domain(dom))
 	}
@@ -30,7 +32,8 @@ func (r *Resolver) Resolve(req *http.Request, opts ...resolver.ResolveOption) (*
 	return r.Resolver.Resolve(req, opts...)
 }
 
-func (r *Resolver) Domain(req *http.Request) string {
+// Domain returns domain
+func (r *subdomainResolver) Domain(req *http.Request) string {
 	// determine the host, e.g. foobar.m3o.app
 	host := req.URL.Hostname()
 	if len(host) == 0 {
@@ -55,7 +58,7 @@ func (r *Resolver) Domain(req *http.Request) string {
 	domain, err := publicsuffix.EffectiveTLDPlusOne(host)
 	if err != nil {
 		if logger.V(logger.DebugLevel) {
-			logger.Debug("Unable to extract domain from %v", host)
+			logger.Debug(r.opts.Context, "Unable to extract domain from %v", host)
 		}
 		return ""
 	}
@@ -82,6 +85,6 @@ func (r *Resolver) Domain(req *http.Request) string {
 	return strings.Join(comps, "-")
 }
 
-func (r *Resolver) String() string {
+func (r *subdomainResolver) String() string {
 	return "subdomain"
 }

api/resolver/subdomain/subdomain_test.go

@@ -6,8 +6,6 @@ import (
 	"testing"
 
 	"github.com/unistack-org/micro/v3/api/resolver/vpath"
-
-	"github.com/stretchr/testify/assert"
 )
 
 func TestResolve(t *testing.T) {
@@ -62,9 +60,13 @@ func TestResolve(t *testing.T) {
 		t.Run(tc.Name, func(t *testing.T) {
 			r := NewResolver(vpath.NewResolver())
 			result, err := r.Resolve(&http.Request{URL: &url.URL{Host: tc.Host, Path: "foo/bar"}})
-			assert.Nil(t, err, "Expecter err to be nil")
+			if err != nil {
+				t.Fatal(err)
+			}
 			if result != nil {
-				assert.Equal(t, tc.Result, result.Domain, "Expected %v but got %v", tc.Result, result.Domain)
+				if tc.Result != result.Domain {
+					t.Fatalf("Expected %v but got %v", tc.Result, result.Domain)
+				}
 			}
 		})
 	}

api/resolver/vpath/vpath.go

@@ -10,11 +10,12 @@ import (
 	"github.com/unistack-org/micro/v3/api/resolver"
 )
 
+// NewResolver creates new vpath api resolver
 func NewResolver(opts ...resolver.Option) resolver.Resolver {
-	return &Resolver{opts: resolver.NewOptions(opts...)}
+	return &vpathResolver{opts: resolver.NewOptions(opts...)}
 }
 
-type Resolver struct {
+type vpathResolver struct {
 	opts resolver.Options
 }
 
@@ -22,7 +23,8 @@ var (
 	re = regexp.MustCompile("^v[0-9]+$")
 )
 
-func (r *Resolver) Resolve(req *http.Request, opts ...resolver.ResolveOption) (*resolver.Endpoint, error) {
+// Resolve endpoint
+func (r *vpathResolver) Resolve(req *http.Request, opts ...resolver.ResolveOption) (*resolver.Endpoint, error) {
 	if req.URL.Path == "/" {
 		return nil, errors.New("unknown name")
 	}
@@ -60,12 +62,12 @@ func (r *Resolver) Resolve(req *http.Request, opts ...resolver.ResolveOption) (*
 	}, nil
 }
 
-func (r *Resolver) String() string {
+func (r *vpathResolver) String() string {
-	return "path"
+	return "vpath"
 }
 
 // withPrefix transforms "foo" into "go.micro.api.foo"
-func (r *Resolver) withPrefix(parts ...string) string {
+func (r *vpathResolver) withPrefix(parts ...string) string {
 	p := r.opts.ServicePrefix
 	if len(p) > 0 {
 		parts = append([]string{p}, parts...)

api/router/options.go

@@ -5,18 +5,28 @@ import (
 
 	"github.com/unistack-org/micro/v3/api/resolver"
 	"github.com/unistack-org/micro/v3/api/resolver/vpath"
-	"github.com/unistack-org/micro/v3/registry"
+	"github.com/unistack-org/micro/v3/logger"
+	"github.com/unistack-org/micro/v3/register"
 )
 
+// Options holds the options for api router
 type Options struct {
-	Handler  string
+	// Register for service lookup
-	Registry registry.Registry
+	Register register.Register
+	// Resolver to use
 	Resolver resolver.Resolver
-	Context  context.Context
+	// Logger micro logger
+	Logger logger.Logger
+	// Context is for external options
+	Context context.Context
+	// Handler name
+	Handler string
 }
 
+// Option func signature
 type Option func(o *Options)
 
+// NewOptions returns options struct filled by opts
 func NewOptions(opts ...Option) Options {
 	options := Options{
 		Context: context.Background(),
@@ -50,10 +60,10 @@ func WithHandler(h string) Option {
 	}
 }
 
-// WithRegistry sets the registry
+// WithRegister sets the register
-func WithRegistry(r registry.Registry) Option {
+func WithRegister(r register.Register) Option {
 	return func(o *Options) {
-		o.Registry = r
+		o.Register = r
 	}
 }
 

api/router/router.go

@@ -7,10 +7,17 @@ import (
 	"github.com/unistack-org/micro/v3/api"
 )
 
+var (
+	// DefaultRouter contains default router implementation
+	DefaultRouter Router
+)
+
 // Router is used to determine an endpoint for a request
 type Router interface {
 	// Returns options
 	Options() Options
+	// Init initialize router
+	Init(...Option) error
 	// Stop the router
 	Close() error
 	// Endpoint returns an api.Service endpoint or an error if it does not exist
@@ -21,4 +28,6 @@ type Router interface {
 	Deregister(ep *api.Endpoint) error
 	// Route returns an api.Service route
 	Route(r *http.Request) (*api.Service, error)
+	// String representation of router
+	String() string
 }

api/server/acme/acme.go

@@ -1,29 +0,0 @@
-// Package acme abstracts away various ACME libraries
-package acme
-
-import (
-	"crypto/tls"
-	"errors"
-	"net"
-)
-
-var (
-	// ErrProviderNotImplemented can be returned when attempting to
-	// instantiate an unimplemented provider
-	ErrProviderNotImplemented = errors.New("Provider not implemented")
-)
-
-// Provider is a ACME provider interface
-type Provider interface {
-	Init(...Option) error
-	// Listen returns a new listener
-	Listen(...string) (net.Listener, error)
-	// TLSConfig returns a tls config
-	TLSConfig(...string) (*tls.Config, error)
-}
-
-// The Let's Encrypt ACME endpoints
-const (
-	LetsEncryptStagingCA    = "https://acme-staging-v02.api.letsencrypt.org/directory"
-	LetsEncryptProductionCA = "https://acme-v02.api.letsencrypt.org/directory"
-)

api/server/acme/autocert/autocert.go

@@ -1,50 +0,0 @@
-// Package autocert is the ACME provider from golang.org/x/crypto/acme/autocert
-// This provider does not take any config.
-package autocert
-
-import (
-	"crypto/tls"
-	"net"
-	"os"
-
-	"github.com/unistack-org/micro/v3/api/server/acme"
-	"github.com/unistack-org/micro/v3/logger"
-	"golang.org/x/crypto/acme/autocert"
-)
-
-// autoCertACME is the ACME provider from golang.org/x/crypto/acme/autocert
-type autocertProvider struct{}
-
-func (a *autocertProvider) Init(opts ...acme.Option) error {
-	return nil
-}
-
-// Listen implements acme.Provider
-func (a *autocertProvider) Listen(hosts ...string) (net.Listener, error) {
-	return autocert.NewListener(hosts...), nil
-}
-
-// TLSConfig returns a new tls config
-func (a *autocertProvider) TLSConfig(hosts ...string) (*tls.Config, error) {
-	// create a new manager
-	m := &autocert.Manager{
-		Prompt: autocert.AcceptTOS,
-	}
-	if len(hosts) > 0 {
-		m.HostPolicy = autocert.HostWhitelist(hosts...)
-	}
-	dir := cacheDir()
-	if err := os.MkdirAll(dir, 0700); err != nil {
-		if logger.V(logger.InfoLevel) {
-			logger.Info("warning: autocert not using a cache: %v", err)
-		}
-	} else {
-		m.Cache = autocert.DirCache(dir)
-	}
-	return m.TLSConfig(), nil
-}
-
-// New returns an autocert acme.Provider
-func NewProvider() acme.Provider {
-	return &autocertProvider{}
-}

api/server/acme/autocert/autocert_test.go

@@ -1,16 +0,0 @@
-package autocert
-
-import (
-	"testing"
-)
-
-func TestAutocert(t *testing.T) {
-	l := NewProvider()
-	if _, ok := l.(*autocertProvider); !ok {
-		t.Error("NewProvider() didn't return an autocertProvider")
-	}
-	// TODO: Travis CI doesn't let us bind :443
-	// if _, err := l.NewListener(); err != nil {
-	// 	t.Error(err.Error())
-	// }
-}

api/server/acme/autocert/cache.go

@@ -1,37 +0,0 @@
-package autocert
-
-import (
-	"os"
-	"path/filepath"
-	"runtime"
-)
-
-func homeDir() string {
-	if runtime.GOOS == "windows" {
-		return os.Getenv("HOMEDRIVE") + os.Getenv("HOMEPATH")
-	}
-	if h := os.Getenv("HOME"); h != "" {
-		return h
-	}
-	return "/"
-}
-
-func cacheDir() string {
-	const base = "golang-autocert"
-	switch runtime.GOOS {
-	case "darwin":
-		return filepath.Join(homeDir(), "Library", "Caches", base)
-	case "windows":
-		for _, ev := range []string{"APPDATA", "CSIDL_APPDATA", "TEMP", "TMP"} {
-			if v := os.Getenv(ev); v != "" {
-				return filepath.Join(v, base)
-			}
-		}
-		// Worst case:
-		return filepath.Join(homeDir(), base)
-	}
-	if xdg := os.Getenv("XDG_CACHE_HOME"); xdg != "" {
-		return filepath.Join(xdg, base)
-	}
-	return filepath.Join(homeDir(), ".cache", base)
-}

api/server/acme/certmagic/certmagic.go

@@ -1,71 +0,0 @@
-// Package certmagic is the ACME provider from github.com/caddyserver/certmagic
-package certmagic
-
-import (
-	"crypto/tls"
-	"fmt"
-	"math/rand"
-	"net"
-	"time"
-
-	"github.com/caddyserver/certmagic"
-	"github.com/unistack-org/micro/v3/api/server/acme"
-)
-
-type certmagicProvider struct {
-	opts acme.Options
-}
-
-// TODO: set self-contained options
-func (c *certmagicProvider) setup() {
-	certmagic.DefaultACME.CA = c.opts.CA
-	if c.opts.ChallengeProvider != nil {
-		// Enabling DNS Challenge disables the other challenges
-		certmagic.DefaultACME.DNSProvider = c.opts.ChallengeProvider
-	}
-	if c.opts.OnDemand {
-		certmagic.Default.OnDemand = new(certmagic.OnDemandConfig)
-	}
-	if c.opts.Cache != nil {
-		// already validated by new()
-		certmagic.Default.Storage = c.opts.Cache.(certmagic.Storage)
-	}
-	// If multiple instances of the provider are running, inject some
-	// randomness so they don't collide
-	// RenewalWindowRatio [0.33 - 0.50)
-	rand.Seed(time.Now().UnixNano())
-	randomRatio := float64(rand.Intn(17)+33) * 0.01
-	certmagic.Default.RenewalWindowRatio = randomRatio
-}
-
-func (c *certmagicProvider) Listen(hosts ...string) (net.Listener, error) {
-	c.setup()
-	return certmagic.Listen(hosts)
-}
-
-func (c *certmagicProvider) TLSConfig(hosts ...string) (*tls.Config, error) {
-	c.setup()
-	return certmagic.TLS(hosts)
-}
-
-func (p *certmagicProvider) Init(opts ...acme.Option) error {
-	if p.opts.Cache != nil {
-		if _, ok := p.opts.Cache.(certmagic.Storage); !ok {
-			return fmt.Errorf("ACME: cache provided doesn't implement certmagic's Storage interface")
-		}
-	}
-	return nil
-}
-
-// NewProvider returns a certmagic provider
-func NewProvider(options ...acme.Option) acme.Provider {
-	opts := acme.DefaultOptions()
-
-	for _, o := range options {
-		o(&opts)
-	}
-
-	return &certmagicProvider{
-		opts: opts,
-	}
-}

api/server/acme/certmagic/storage.go

@@ -1,147 +0,0 @@
-package certmagic
-
-import (
-	"bytes"
-	"encoding/gob"
-	"errors"
-	"fmt"
-	"path"
-	"strings"
-	"time"
-
-	"github.com/caddyserver/certmagic"
-	"github.com/unistack-org/micro/v3/store"
-	"github.com/unistack-org/micro/v3/sync"
-)
-
-// File represents a "File" that will be stored in store.Store - the contents and last modified time
-type File struct {
-	// last modified time
-	LastModified time.Time
-	// Contents
-	Contents []byte
-}
-
-// storage is an implementation of certmagic.Storage using micro's sync.Map and store.Store interfaces.
-// As certmagic storage expects a filesystem (with stat() abilities) we have to implement
-// the bare minimum of metadata.
-type storage struct {
-	lock  sync.Sync
-	store store.Store
-}
-
-func (s *storage) Lock(key string) error {
-	return s.lock.Lock(key, sync.LockTTL(10*time.Minute))
-}
-
-func (s *storage) Unlock(key string) error {
-	return s.lock.Unlock(key)
-}
-
-func (s *storage) Store(key string, value []byte) error {
-	f := File{
-		LastModified: time.Now(),
-		Contents:     value,
-	}
-	buf := &bytes.Buffer{}
-	e := gob.NewEncoder(buf)
-	if err := e.Encode(f); err != nil {
-		return err
-	}
-	r := &store.Record{
-		Key:   key,
-		Value: buf.Bytes(),
-	}
-	return s.store.Write(s.store.Options().Context, r)
-}
-
-func (s *storage) Load(key string) ([]byte, error) {
-	if !s.Exists(key) {
-		return nil, certmagic.ErrNotExist(errors.New(key + " doesn't exist"))
-	}
-	records, err := s.store.Read(s.store.Options().Context, key)
-	if err != nil {
-		return nil, err
-	}
-	if len(records) != 1 {
-		return nil, fmt.Errorf("ACME Storage: multiple records matched key %s", key)
-	}
-	b := bytes.NewBuffer(records[0].Value)
-	d := gob.NewDecoder(b)
-	var f File
-	err = d.Decode(&f)
-	if err != nil {
-		return nil, err
-	}
-	return f.Contents, nil
-}
-
-func (s *storage) Delete(key string) error {
-	return s.store.Delete(s.store.Options().Context, key)
-}
-
-func (s *storage) Exists(key string) bool {
-	if _, err := s.store.Read(s.store.Options().Context, key); err != nil {
-		return false
-	}
-	return true
-}
-
-func (s *storage) List(prefix string, recursive bool) ([]string, error) {
-	keys, err := s.store.List(s.store.Options().Context)
-	if err != nil {
-		return nil, err
-	}
-
-	//nolint:prealloc
-	var results []string
-	for _, k := range keys {
-		if strings.HasPrefix(k, prefix) {
-			results = append(results, k)
-		}
-	}
-	if recursive {
-		return results, nil
-	}
-	keysMap := make(map[string]bool)
-	for _, key := range results {
-		dir := strings.Split(strings.TrimPrefix(key, prefix+"/"), "/")
-		keysMap[dir[0]] = true
-	}
-	results = make([]string, 0)
-	for k := range keysMap {
-		results = append(results, path.Join(prefix, k))
-	}
-	return results, nil
-}
-
-func (s *storage) Stat(key string) (certmagic.KeyInfo, error) {
-	records, err := s.store.Read(s.store.Options().Context, key)
-	if err != nil {
-		return certmagic.KeyInfo{}, err
-	}
-	if len(records) != 1 {
-		return certmagic.KeyInfo{}, fmt.Errorf("ACME Storage: multiple records matched key %s", key)
-	}
-	b := bytes.NewBuffer(records[0].Value)
-	d := gob.NewDecoder(b)
-	var f File
-	err = d.Decode(&f)
-	if err != nil {
-		return certmagic.KeyInfo{}, err
-	}
-	return certmagic.KeyInfo{
-		Key:        key,
-		Modified:   f.LastModified,
-		Size:       int64(len(f.Contents)),
-		IsTerminal: false,
-	}, nil
-}
-
-// NewStorage returns a certmagic.Storage backed by a go-micro/lock and go-micro/store
-func NewStorage(lock sync.Sync, store store.Store) certmagic.Storage {
-	return &storage{
-		lock:  lock,
-		store: store,
-	}
-}

api/server/acme/options.go

@@ -1,73 +0,0 @@
-package acme
-
-import "github.com/go-acme/lego/v3/challenge"
-
-// Option (or Options) are passed to New() to configure providers
-type Option func(o *Options)
-
-// Options represents various options you can present to ACME providers
-type Options struct {
-	// AcceptTLS must be set to true to indicate that you have read your
-	// provider's terms of service.
-	AcceptToS bool
-	// CA is the CA to use
-	CA string
-	// ChallengeProvider is a go-acme/lego challenge provider. Set this if you
-	// want to use DNS Challenges. Otherwise, tls-alpn-01 will be used
-	ChallengeProvider challenge.Provider
-	// Issue certificates for domains on demand. Otherwise, certs will be
-	// retrieved / issued on start-up.
-	OnDemand bool
-	// Cache is a storage interface. Most ACME libraries have an cache, but
-	// there's no defined interface, so if you consume this option
-	// sanity check it before using.
-	Cache interface{}
-}
-
-// AcceptToS indicates whether you accept your CA's terms of service
-func AcceptToS(b bool) Option {
-	return func(o *Options) {
-		o.AcceptToS = b
-	}
-}
-
-// CA sets the CA of an acme.Options
-func CA(CA string) Option {
-	return func(o *Options) {
-		o.CA = CA
-	}
-}
-
-// ChallengeProvider sets the Challenge provider of an acme.Options
-// if set, it enables the DNS challenge, otherwise tls-alpn-01 will be used.
-func ChallengeProvider(p challenge.Provider) Option {
-	return func(o *Options) {
-		o.ChallengeProvider = p
-	}
-}
-
-// OnDemand enables on-demand certificate issuance. Not recommended for use
-// with the DNS challenge, as the first connection may be very slow.
-func OnDemand(b bool) Option {
-	return func(o *Options) {
-		o.OnDemand = b
-	}
-}
-
-// Cache provides a cache / storage interface to the underlying ACME library
-// as there is no standard, this needs to be validated by the underlying
-// implementation
-func Cache(c interface{}) Option {
-	return func(o *Options) {
-		o.Cache = c
-	}
-}
-
-// DefaultOptions uses the Let's Encrypt Production CA, with DNS Challenge disabled.
-func DefaultOptions() Options {
-	return Options{
-		AcceptToS: true,
-		CA:        LetsEncryptProductionCA,
-		OnDemand:  true,
-	}
-}

api/server/cors/cors.go

@@ -1,44 +0,0 @@
-package cors
-
-import (
-	"net/http"
-)
-
-// CombinedCORSHandler wraps a server and provides CORS headers
-func CombinedCORSHandler(h http.Handler) http.Handler {
-	return corsHandler{h}
-}
-
-type corsHandler struct {
-	handler http.Handler
-}
-
-func (c corsHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
-	SetHeaders(w, r)
-
-	if r.Method == "OPTIONS" {
-		return
-	}
-
-	c.handler.ServeHTTP(w, r)
-}
-
-// SetHeaders sets the CORS headers
-func SetHeaders(w http.ResponseWriter, r *http.Request) {
-	set := func(w http.ResponseWriter, k, v string) {
-		if v := w.Header().Get(k); len(v) > 0 {
-			return
-		}
-		w.Header().Set(k, v)
-	}
-
-	if origin := r.Header.Get("Origin"); len(origin) > 0 {
-		set(w, "Access-Control-Allow-Origin", origin)
-	} else {
-		set(w, "Access-Control-Allow-Origin", "*")
-	}
-
-	set(w, "Access-Control-Allow-Credentials", "true")
-	set(w, "Access-Control-Allow-Methods", "POST, PATCH, GET, OPTIONS, PUT, DELETE")
-	set(w, "Access-Control-Allow-Headers", "Accept, Content-Type, Content-Length, Accept-Encoding, X-CSRF-Token, Authorization")
-}

api/server/http/http.go

@@ -1,110 +0,0 @@
-// Package http provides a http server with features; acme, cors, etc
-package http
-
-import (
-	"crypto/tls"
-	"net"
-	"net/http"
-	"sync"
-
-	"github.com/unistack-org/micro/v3/api/server"
-	"github.com/unistack-org/micro/v3/logger"
-)
-
-type httpServer struct {
-	mux  *http.ServeMux
-	opts server.Options
-
-	sync.RWMutex
-	address string
-	exit    chan chan error
-}
-
-func NewServer(address string, opts ...server.Option) server.Server {
-	return &httpServer{
-		opts:    server.NewOptions(opts...),
-		mux:     http.NewServeMux(),
-		address: address,
-		exit:    make(chan chan error),
-	}
-}
-
-func (s *httpServer) Address() string {
-	s.RLock()
-	defer s.RUnlock()
-	return s.address
-}
-
-func (s *httpServer) Init(opts ...server.Option) error {
-	for _, o := range opts {
-		o(&s.opts)
-	}
-	return nil
-}
-
-func (s *httpServer) Handle(path string, handler http.Handler) {
-	// TODO: move this stuff out to one place with ServeHTTP
-
-	// apply the wrappers, e.g. auth
-	for _, wrapper := range s.opts.Wrappers {
-		handler = wrapper(handler)
-	}
-
-	s.mux.Handle(path, handler)
-}
-
-func (s *httpServer) Start() error {
-	var l net.Listener
-	var err error
-
-	s.RLock()
-	config := s.opts
-	s.RUnlock()
-	if s.opts.EnableACME && s.opts.ACMEProvider != nil {
-		// should we check the address to make sure its using :443?
-		l, err = s.opts.ACMEProvider.Listen(s.opts.ACMEHosts...)
-	} else if s.opts.EnableTLS && s.opts.TLSConfig != nil {
-		l, err = tls.Listen("tcp", s.address, s.opts.TLSConfig)
-	} else {
-		// otherwise plain listen
-		l, err = net.Listen("tcp", s.address)
-	}
-	if err != nil {
-		return err
-	}
-
-	if config.Logger.V(logger.InfoLevel) {
-		config.Logger.Info("HTTP API Listening on %s", l.Addr().String())
-	}
-
-	s.Lock()
-	s.address = l.Addr().String()
-	s.Unlock()
-
-	go func() {
-		if err := http.Serve(l, s.mux); err != nil {
-			// temporary fix
-			if config.Logger.V(logger.ErrorLevel) {
-				config.Logger.Error("serve err: %v", err)
-			}
-			s.Stop()
-		}
-	}()
-
-	go func() {
-		ch := <-s.exit
-		ch <- l.Close()
-	}()
-
-	return nil
-}
-
-func (s *httpServer) Stop() error {
-	ch := make(chan error)
-	s.exit <- ch
-	return <-ch
-}
-
-func (s *httpServer) String() string {
-	return "http"
-}

api/server/http/http_test.go

@@ -1,41 +0,0 @@
-package http
-
-import (
-	"fmt"
-	"io/ioutil"
-	"net/http"
-	"testing"
-)
-
-func TestHTTPServer(t *testing.T) {
-	testResponse := "hello world"
-
-	s := NewServer("localhost:0")
-
-	s.Handle("/", http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		fmt.Fprint(w, testResponse)
-	}))
-
-	if err := s.Start(); err != nil {
-		t.Fatal(err)
-	}
-
-	rsp, err := http.Get(fmt.Sprintf("http://%s/", s.Address()))
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer rsp.Body.Close()
-
-	b, err := ioutil.ReadAll(rsp.Body)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	if string(b) != testResponse {
-		t.Fatalf("Unexpected response, got %s, expected %s", string(b), testResponse)
-	}
-
-	if err := s.Stop(); err != nil {
-		t.Fatal(err)
-	}
-}

api/server/options.go

@@ -1,93 +0,0 @@
-package server
-
-import (
-	"crypto/tls"
-	"net/http"
-
-	"github.com/unistack-org/micro/v3/api/resolver"
-	"github.com/unistack-org/micro/v3/api/server/acme"
-	"github.com/unistack-org/micro/v3/logger"
-)
-
-// Option func
-type Option func(o *Options)
-
-// Options for api server
-type Options struct {
-	EnableACME   bool
-	EnableCORS   bool
-	ACMEProvider acme.Provider
-	EnableTLS    bool
-	ACMEHosts    []string
-	TLSConfig    *tls.Config
-	Resolver     resolver.Resolver
-	Wrappers     []Wrapper
-	Logger       logger.Logger
-}
-
-// NewOptions returns new Options
-func NewOptions(opts ...Option) Options {
-	options := Options{
-		Logger: logger.DefaultLogger,
-	}
-	for _, o := range opts {
-		o(&options)
-	}
-	return options
-}
-
-type Wrapper func(h http.Handler) http.Handler
-
-func WrapHandler(w ...Wrapper) Option {
-	return func(o *Options) {
-		o.Wrappers = append(o.Wrappers, w...)
-	}
-}
-
-func EnableCORS(b bool) Option {
-	return func(o *Options) {
-		o.EnableCORS = b
-	}
-}
-
-func EnableACME(b bool) Option {
-	return func(o *Options) {
-		o.EnableACME = b
-	}
-}
-
-func ACMEHosts(hosts ...string) Option {
-	return func(o *Options) {
-		o.ACMEHosts = hosts
-	}
-}
-
-func ACMEProvider(p acme.Provider) Option {
-	return func(o *Options) {
-		o.ACMEProvider = p
-	}
-}
-
-func EnableTLS(b bool) Option {
-	return func(o *Options) {
-		o.EnableTLS = b
-	}
-}
-
-func TLSConfig(t *tls.Config) Option {
-	return func(o *Options) {
-		o.TLSConfig = t
-	}
-}
-
-func Resolver(r resolver.Resolver) Option {
-	return func(o *Options) {
-		o.Resolver = r
-	}
-}
-
-func Logger(l logger.Logger) Option {
-	return func(o *Options) {
-		o.Logger = l
-	}
-}

api/server/server.go

@@ -1,15 +0,0 @@
-// Package server provides an API gateway server which handles inbound requests
-package server
-
-import (
-	"net/http"
-)
-
-// Server serves api requests
-type Server interface {
-	Address() string
-	Init(opts ...Option) error
-	Handle(path string, handler http.Handler)
-	Start() error
-	Stop() error
-}

auth/auth.go

@@ -5,6 +5,8 @@ import (
 	"context"
 	"errors"
 	"time"
+
+	"github.com/unistack-org/micro/v3/metadata"
 )
 
 const (
@@ -17,7 +19,8 @@ const (
 )
 
 var (
-	DefaultAuth Auth = &NoopAuth{opts: NewOptions()}
+	// DefaultAuth holds default auth implementation
+	DefaultAuth Auth = NewAuth()
 	// ErrInvalidToken is when the token provided is not valid
 	ErrInvalidToken = errors.New("invalid token provided")
 	// ErrForbidden is when a user does not have the necessary scope to access a resource
@@ -50,30 +53,30 @@ type Auth interface {
 
 // Account provided by an auth provider
 type Account struct {
-	// ID of the account e.g. email
+	// Metadata any other associated metadata
+	Metadata metadata.Metadata `json:"metadata"`
+	// ID of the account e.g. email or uuid
 	ID string `json:"id"`
 	// Type of the account, e.g. service
 	Type string `json:"type"`
 	// Issuer of the account
 	Issuer string `json:"issuer"`
-	// Any other associated metadata
-	Metadata map[string]string `json:"metadata"`
-	// Scopes the account has access to
-	Scopes []string `json:"scopes"`
 	// Secret for the account, e.g. the password
 	Secret string `json:"secret"`
+	// Scopes the account has access to
+	Scopes []string `json:"scopes"`
 }
 
 // Token can be short or long lived
 type Token struct {
-	// The token to be used for accessing resources
-	AccessToken string `json:"access_token"`
-	// RefreshToken to be used to generate a new token
-	RefreshToken string `json:"refresh_token"`
 	// Time of token creation
 	Created time.Time `json:"created"`
 	// Time of token expiry
 	Expiry time.Time `json:"expiry"`
+	// The token to be used for accessing resources
+	AccessToken string `json:"access_token"`
+	// RefreshToken to be used to generate a new token
+	RefreshToken string `json:"refresh_token"`
 }
 
 // Expired returns a boolean indicating if the token needs to be refreshed
@@ -103,17 +106,15 @@ const (
 
 // Rule is used to verify access to a resource
 type Rule struct {
-	// ID of the rule, e.g. "public"
+	// Resource that rule belongs to
-	ID string
-	// Scope the rule requires, a blank scope indicates open to the public and * indicates the rule
-	// applies to any valid account
-	Scope string
-	// Resource the rule applies to
 	Resource *Resource
-	// Access determines if the rule grants or denies access to the resource
+	// ID of the rule
+	ID string
+	// Scope of the rule
+	Scope string
+	// Access flag allow/deny
 	Access Access
-	// Priority the rule should take when verifying a request, the higher the value the sooner the
+	// Priority holds the rule priority
-	// rule will be applied
 	Priority int32
 }
 
@@ -124,11 +125,17 @@ type accountKey struct{}
 // is not set, a nil account will be returned. The error is only returned
 // when there was a problem retrieving an account
 func AccountFromContext(ctx context.Context) (*Account, bool) {
+	if ctx == nil {
+		return nil, false
+	}
 	acc, ok := ctx.Value(accountKey{}).(*Account)
 	return acc, ok
 }
 
 // ContextWithAccount sets the account in the context
 func ContextWithAccount(ctx context.Context, account *Account) context.Context {
+	if ctx == nil {
+		ctx = context.Background()
+	}
 	return context.WithValue(ctx, accountKey{}, account)
 }

auth/noop.go

@@ -4,29 +4,29 @@ import (
 	"github.com/google/uuid"
 )
 
-type NoopAuth struct {
+type noopAuth struct {
 	opts Options
 }
 
 // String returns the name of the implementation
-func (n *NoopAuth) String() string {
+func (n *noopAuth) String() string {
 	return "noop"
 }
 
 // Init the auth
-func (n *NoopAuth) Init(opts ...Option) {
+func (n *noopAuth) Init(opts ...Option) {
 	for _, o := range opts {
 		o(&n.opts)
 	}
 }
 
 // Options set for auth
-func (n *NoopAuth) Options() Options {
+func (n *noopAuth) Options() Options {
 	return n.opts
 }
 
 // Generate a new account
-func (n *NoopAuth) Generate(id string, opts ...GenerateOption) (*Account, error) {
+func (n *noopAuth) Generate(id string, opts ...GenerateOption) (*Account, error) {
 	options := NewGenerateOptions(opts...)
 
 	return &Account{
@@ -39,27 +39,27 @@ func (n *NoopAuth) Generate(id string, opts ...GenerateOption) (*Account, error)
 }
 
 // Grant access to a resource
-func (n *NoopAuth) Grant(rule *Rule) error {
+func (n *noopAuth) Grant(rule *Rule) error {
 	return nil
 }
 
 // Revoke access to a resource
-func (n *NoopAuth) Revoke(rule *Rule) error {
+func (n *noopAuth) Revoke(rule *Rule) error {
 	return nil
 }
 
 // Rules used to verify requests
-func (n *NoopAuth) Rules(opts ...RulesOption) ([]*Rule, error) {
+func (n *noopAuth) Rules(opts ...RulesOption) ([]*Rule, error) {
 	return []*Rule{}, nil
 }
 
 // Verify an account has access to a resource
-func (n *NoopAuth) Verify(acc *Account, res *Resource, opts ...VerifyOption) error {
+func (n *noopAuth) Verify(acc *Account, res *Resource, opts ...VerifyOption) error {
 	return nil
 }
 
 // Inspect a token
-func (n *NoopAuth) Inspect(token string) (*Account, error) {
+func (n *noopAuth) Inspect(token string) (*Account, error) {
 	uid, err := uuid.NewRandom()
 	if err != nil {
 		return nil, err
@@ -68,6 +68,11 @@ func (n *NoopAuth) Inspect(token string) (*Account, error) {
 }
 
 // Token generation using an account id and secret
-func (n *NoopAuth) Token(opts ...TokenOption) (*Token, error) {
+func (n *noopAuth) Token(opts ...TokenOption) (*Token, error) {
 	return &Token{}, nil
 }
+
+// NewAuth returns new noop auth
+func NewAuth(opts ...Option) Auth {
+	return &noopAuth{opts: NewOptions(opts...)}
+}

auth/options.go

@@ -5,42 +5,58 @@ import (
 	"time"
 
 	"github.com/unistack-org/micro/v3/logger"
+	"github.com/unistack-org/micro/v3/metadata"
+	"github.com/unistack-org/micro/v3/meter"
 	"github.com/unistack-org/micro/v3/store"
+	"github.com/unistack-org/micro/v3/tracer"
 )
 
+// NewOptions creates Options struct from slice of options
 func NewOptions(opts ...Option) Options {
-	var options Options
+	options := Options{
+		Tracer: tracer.DefaultTracer,
+		Logger: logger.DefaultLogger,
+		Meter:  meter.DefaultMeter,
+	}
 	for _, o := range opts {
 		o(&options)
 	}
 	return options
 }
 
+// Options struct holds auth options
 type Options struct {
-	// Issuer of the service's account
+	// Context holds the external options
-	Issuer string
+	Context context.Context
-	// ID is the services auth ID
+	// Meter used for metrics
-	ID string
+	Meter meter.Meter
-	// Secret is used to authenticate the service
+	// Logger used for logging
-	Secret string
+	Logger logger.Logger
+	// Tracer used for tracing
+	Tracer tracer.Tracer
+	// Store used for stre data
+	Store store.Store
 	// Token is the services token used to authenticate itself
 	Token *Token
-	// PublicKey for decoding JWTs
-	PublicKey string
-	// PrivateKey for encoding JWTs
-	PrivateKey string
 	// LoginURL is the relative url path where a user can login
 	LoginURL string
-	// Store to back auth
+	// PrivateKey for encoding JWTs
-	Store store.Store
+	PrivateKey string
+	// PublicKey for decoding JWTs
+	PublicKey string
+	// Secret is used to authenticate the service
+	Secret string
+	// ID is the services auth ID
+	ID string
+	// Issuer of the service's account
+	Issuer string
+	// Name holds the auth name
+	Name string
 	// Addrs sets the addresses of auth
 	Addrs []string
-	// Logger sets the logger
-	Logger logger.Logger
-	// Context to store other options
-	Context context.Context
 }
 
+// Option func
 type Option func(o *Options)
 
 // Addrs is the auth addresses to use
@@ -50,6 +66,13 @@ func Addrs(addrs ...string) Option {
 	}
 }
 
+// Name sets the name
+func Name(n string) Option {
+	return func(o *Options) {
+		o.Name = n
+	}
+}
+
 // Issuer of the services account
 func Issuer(i string) Option {
 	return func(o *Options) {
@@ -100,21 +123,17 @@ func LoginURL(url string) Option {
 	}
 }
 
+// GenerateOptions struct
 type GenerateOptions struct {
-	// Metadata associated with the account
+	Metadata metadata.Metadata
-	Metadata map[string]string
-	// Scopes the account has access too
-	Scopes []string
-	// Provider of the account, e.g. oauth
 	Provider string
-	// Type of the account, e.g. user
+	Type     string
-	Type string
+	Secret   string
-	// Secret used to authenticate the account
+	Issuer   string
-	Secret string
+	Scopes   []string
-	// Issuer of the account, e.g. micro
-	Issuer string
 }
 
+// GenerateOption func
 type GenerateOption func(o *GenerateOptions)
 
 // WithSecret for the generated account
@@ -132,9 +151,9 @@ func WithType(t string) GenerateOption {
 }
 
 // WithMetadata for the generated account
-func WithMetadata(md map[string]string) GenerateOption {
+func WithMetadata(md metadata.Metadata) GenerateOption {
 	return func(o *GenerateOptions) {
-		o.Metadata = md
+		o.Metadata = metadata.Copy(md)
 	}
 }
 
@@ -168,19 +187,16 @@ func NewGenerateOptions(opts ...GenerateOption) GenerateOptions {
 	return options
 }
 
+// TokenOptions struct
 type TokenOptions struct {
-	// ID for the account
+	ID           string
-	ID string
+	Secret       string
-	// Secret for the account
-	Secret string
-	// RefreshToken is used to refesh a token
 	RefreshToken string
-	// Expiry is the time the token should live for
+	Issuer       string
-	Expiry time.Duration
+	Expiry       time.Duration
-	// Issuer of the account
-	Issuer string
 }
 
+// TokenOption func
 type TokenOption func(o *TokenOptions)
 
 // WithExpiry for the token
@@ -190,6 +206,7 @@ func WithExpiry(ex time.Duration) TokenOption {
 	}
 }
 
+// WithCredentials sets tye id and secret
 func WithCredentials(id, secret string) TokenOption {
 	return func(o *TokenOptions) {
 		o.ID = id
@@ -197,12 +214,14 @@ func WithCredentials(id, secret string) TokenOption {
 	}
 }
 
+// WithToken sets the refresh token
 func WithToken(rt string) TokenOption {
 	return func(o *TokenOptions) {
 		o.RefreshToken = rt
 	}
 }
 
+// WithTokenIssuer sets the token issuer option
 func WithTokenIssuer(iss string) TokenOption {
 	return func(o *TokenOptions) {
 		o.Issuer = iss
@@ -224,39 +243,69 @@ func NewTokenOptions(opts ...TokenOption) TokenOptions {
 	return options
 }
 
+// VerifyOptions struct
 type VerifyOptions struct {
 	Context   context.Context
 	Namespace string
 }
 
+// VerifyOption func
 type VerifyOption func(o *VerifyOptions)
 
+// VerifyContext pass context to verify
 func VerifyContext(ctx context.Context) VerifyOption {
 	return func(o *VerifyOptions) {
 		o.Context = ctx
 	}
 }
+
+// VerifyNamespace sets thhe namespace for verify
 func VerifyNamespace(ns string) VerifyOption {
 	return func(o *VerifyOptions) {
 		o.Namespace = ns
 	}
 }
 
+// RulesOptions struct
 type RulesOptions struct {
 	Context   context.Context
 	Namespace string
 }
 
+// RulesOption func
 type RulesOption func(o *RulesOptions)
 
+// RulesContext pass rules context
 func RulesContext(ctx context.Context) RulesOption {
 	return func(o *RulesOptions) {
 		o.Context = ctx
 	}
 }
 
+// RulesNamespace sets the rule namespace
 func RulesNamespace(ns string) RulesOption {
 	return func(o *RulesOptions) {
 		o.Namespace = ns
 	}
 }
+
+// Logger sets the logger
+func Logger(l logger.Logger) Option {
+	return func(o *Options) {
+		o.Logger = l
+	}
+}
+
+// Meter sets the meter
+func Meter(m meter.Meter) Option {
+	return func(o *Options) {
+		o.Meter = m
+	}
+}
+
+// Tracer sets the meter
+func Tracer(t tracer.Tracer) Option {
+	return func(o *Options) {
+		o.Tracer = t
+	}
+}

auth/rules.go

@@ -9,6 +9,7 @@ import (
 // VerifyAccess an account has access to a resource using the rules provided. If the account does not have
 // access an error will be returned. If there are no rules provided which match the resource, an error
 // will be returned
+//nolint:gocyclo
 func VerifyAccess(rules []*Rule, acc *Account, res *Resource) error {
 	// the rule is only to be applied if the type matches the resource or is catch-all (*)
 	validTypes := []string{"*", res.Type}

broker/broker.go

@@ -1,14 +1,20 @@
 // Package broker is an interface used for asynchronous messaging
 package broker
 
-import "context"
+import (
+	"context"
+
+	"github.com/unistack-org/micro/v3/metadata"
+)
 
 var (
+	// DefaultBroker default broker
 	DefaultBroker Broker = NewBroker()
 )
 
 // Broker is an interface used for asynchronous messaging.
 type Broker interface {
+	Name() string
 	Init(...Option) error
 	Options() Options
 	Address() string
@@ -32,7 +38,7 @@ type Event interface {
 
 // Message is used to transfer data
 type Message struct {
-	Header map[string]string // contains message metadata
+	Header metadata.Metadata // contains message metadata
 	Body   []byte            // contains message body
 }
 

broker/context.go

@@ -6,12 +6,20 @@ import (
 
 type brokerKey struct{}
 
+// FromContext returns broker from passed context
 func FromContext(ctx context.Context) (Broker, bool) {
+	if ctx == nil {
+		return nil, false
+	}
 	c, ok := ctx.Value(brokerKey{}).(Broker)
 	return c, ok
 }
 
+// NewContext savess broker in context
 func NewContext(ctx context.Context, s Broker) context.Context {
+	if ctx == nil {
+		ctx = context.Background()
+	}
 	return context.WithValue(ctx, brokerKey{}, s)
 }
 

broker/memory.go

@@ -0,0 +1,243 @@
+package broker
+
+import (
+	"context"
+	"errors"
+	"sync"
+
+	"github.com/google/uuid"
+	"github.com/unistack-org/micro/v3/logger"
+	maddr "github.com/unistack-org/micro/v3/util/addr"
+	mnet "github.com/unistack-org/micro/v3/util/net"
+	"github.com/unistack-org/micro/v3/util/rand"
+)
+
+type memoryBroker struct {
+	opts        Options
+	Subscribers map[string][]*memorySubscriber
+	addr        string
+	sync.RWMutex
+	connected bool
+}
+
+type memoryEvent struct {
+	opts    Options
+	err     error
+	message interface{}
+	topic   string
+}
+
+type memorySubscriber struct {
+	opts    SubscribeOptions
+	ctx     context.Context
+	exit    chan bool
+	handler Handler
+	id      string
+	topic   string
+}
+
+func (m *memoryBroker) Options() Options {
+	return m.opts
+}
+
+func (m *memoryBroker) Address() string {
+	return m.addr
+}
+
+func (m *memoryBroker) Connect(ctx context.Context) error {
+	m.Lock()
+	defer m.Unlock()
+
+	if m.connected {
+		return nil
+	}
+
+	// use 127.0.0.1 to avoid scan of all network interfaces
+	addr, err := maddr.Extract("127.0.0.1")
+	if err != nil {
+		return err
+	}
+	var rng rand.Rand
+	i := rng.Intn(20000)
+	// set addr with port
+	addr = mnet.HostPort(addr, 10000+i)
+
+	m.addr = addr
+	m.connected = true
+
+	return nil
+}
+
+func (m *memoryBroker) Disconnect(ctx context.Context) error {
+	m.Lock()
+	defer m.Unlock()
+
+	if !m.connected {
+		return nil
+	}
+
+	m.connected = false
+
+	return nil
+}
+
+func (m *memoryBroker) Init(opts ...Option) error {
+	for _, o := range opts {
+		o(&m.opts)
+	}
+	return nil
+}
+
+func (m *memoryBroker) Publish(ctx context.Context, topic string, msg *Message, opts ...PublishOption) error {
+	m.RLock()
+	if !m.connected {
+		m.RUnlock()
+		return errors.New("not connected")
+	}
+
+	subs, ok := m.Subscribers[topic]
+	m.RUnlock()
+	if !ok {
+		return nil
+	}
+
+	var v interface{}
+	if m.opts.Codec != nil {
+		buf, err := m.opts.Codec.Marshal(msg)
+		if err != nil {
+			return err
+		}
+		v = buf
+	} else {
+		v = msg
+	}
+
+	p := &memoryEvent{
+		topic:   topic,
+		message: v,
+		opts:    m.opts,
+	}
+
+	eh := m.opts.ErrorHandler
+
+	for _, sub := range subs {
+		if err := sub.handler(p); err != nil {
+			p.err = err
+			if sub.opts.ErrorHandler != nil {
+				eh = sub.opts.ErrorHandler
+			}
+			if eh != nil {
+				eh(p)
+			} else if m.opts.Logger.V(logger.ErrorLevel) {
+				m.opts.Logger.Error(m.opts.Context, err.Error())
+			}
+			continue
+		}
+	}
+
+	return nil
+}
+
+func (m *memoryBroker) Subscribe(ctx context.Context, topic string, handler Handler, opts ...SubscribeOption) (Subscriber, error) {
+	m.RLock()
+	if !m.connected {
+		m.RUnlock()
+		return nil, errors.New("not connected")
+	}
+	m.RUnlock()
+
+	options := NewSubscribeOptions(opts...)
+
+	id, err := uuid.NewRandom()
+	if err != nil {
+		return nil, err
+	}
+
+	sub := &memorySubscriber{
+		exit:    make(chan bool, 1),
+		id:      id.String(),
+		topic:   topic,
+		handler: handler,
+		opts:    options,
+		ctx:     ctx,
+	}
+
+	m.Lock()
+	m.Subscribers[topic] = append(m.Subscribers[topic], sub)
+	m.Unlock()
+
+	go func() {
+		<-sub.exit
+		m.Lock()
+		var newSubscribers []*memorySubscriber
+		for _, sb := range m.Subscribers[topic] {
+			if sb.id == sub.id {
+				continue
+			}
+			newSubscribers = append(newSubscribers, sb)
+		}
+		m.Subscribers[topic] = newSubscribers
+		m.Unlock()
+	}()
+
+	return sub, nil
+}
+
+func (m *memoryBroker) String() string {
+	return "memory"
+}
+
+func (m *memoryBroker) Name() string {
+	return m.opts.Name
+}
+
+func (m *memoryEvent) Topic() string {
+	return m.topic
+}
+
+func (m *memoryEvent) Message() *Message {
+	switch v := m.message.(type) {
+	case *Message:
+		return v
+	case []byte:
+		msg := &Message{}
+		if err := m.opts.Codec.Unmarshal(v, msg); err != nil {
+			if m.opts.Logger.V(logger.ErrorLevel) {
+				m.opts.Logger.Error(m.opts.Context, "[memory]: failed to unmarshal: %v", err)
+			}
+			return nil
+		}
+		return msg
+	}
+
+	return nil
+}
+
+func (m *memoryEvent) Ack() error {
+	return nil
+}
+
+func (m *memoryEvent) Error() error {
+	return m.err
+}
+
+func (m *memorySubscriber) Options() SubscribeOptions {
+	return m.opts
+}
+
+func (m *memorySubscriber) Topic() string {
+	return m.topic
+}
+
+func (m *memorySubscriber) Unsubscribe(ctx context.Context) error {
+	m.exit <- true
+	return nil
+}
+
+// NewBroker return new memory broker
+func NewBroker(opts ...Option) Broker {
+	return &memoryBroker{
+		opts:        NewOptions(opts...),
+		Subscribers: make(map[string][]*memorySubscriber),
+	}
+}

broker/memory_test.go

@@ -0,0 +1,50 @@
+package broker
+
+import (
+	"context"
+	"fmt"
+	"testing"
+)
+
+func TestMemoryBroker(t *testing.T) {
+	b := NewBroker()
+	ctx := context.Background()
+
+	if err := b.Connect(ctx); err != nil {
+		t.Fatalf("Unexpected connect error %v", err)
+	}
+
+	topic := "test"
+	count := 10
+
+	fn := func(p Event) error {
+		return nil
+	}
+
+	sub, err := b.Subscribe(ctx, topic, fn)
+	if err != nil {
+		t.Fatalf("Unexpected error subscribing %v", err)
+	}
+
+	for i := 0; i < count; i++ {
+		message := &Message{
+			Header: map[string]string{
+				"foo": "bar",
+				"id":  fmt.Sprintf("%d", i),
+			},
+			Body: []byte(`hello world`),
+		}
+
+		if err := b.Publish(ctx, topic, message); err != nil {
+			t.Fatalf("Unexpected error publishing %d", i)
+		}
+	}
+
+	if err := sub.Unsubscribe(ctx); err != nil {
+		t.Fatalf("Unexpected error unsubscribing from %s: %v", topic, err)
+	}
+
+	if err := b.Disconnect(ctx); err != nil {
+		t.Fatalf("Unexpected connect error %v", err)
+	}
+}

broker/noop.go

@@ -1,77 +0,0 @@
-package broker
-
-import "context"
-
-type noopBroker struct {
-	opts Options
-}
-
-type noopSubscriber struct {
-	topic string
-	opts  SubscribeOptions
-}
-
-// NewBroker returns new noop broker
-func NewBroker(opts ...Option) Broker {
-	return &noopBroker{opts: NewOptions(opts...)}
-}
-
-// Init initialize broker
-func (n *noopBroker) Init(opts ...Option) error {
-	for _, o := range opts {
-		o(&n.opts)
-	}
-
-	return nil
-}
-
-// Options returns broker Options
-func (n *noopBroker) Options() Options {
-	return n.opts
-}
-
-// Address returns broker address
-func (n *noopBroker) Address() string {
-	return ""
-}
-
-// Connect connects to broker
-func (n *noopBroker) Connect(ctx context.Context) error {
-	return nil
-}
-
-// Disconnect disconnects from broker
-func (n *noopBroker) Disconnect(ctx context.Context) error {
-	return nil
-}
-
-// Publish publishes message to broker
-func (n *noopBroker) Publish(ctx context.Context, topic string, m *Message, opts ...PublishOption) error {
-	return nil
-}
-
-// Subscribe subscribes to broker topic
-func (n *noopBroker) Subscribe(ctx context.Context, topic string, h Handler, opts ...SubscribeOption) (Subscriber, error) {
-	options := NewSubscribeOptions(opts...)
-	return &noopSubscriber{topic: topic, opts: options}, nil
-}
-
-// String return broker string representation
-func (n *noopBroker) String() string {
-	return "noop"
-}
-
-// Options returns subscriber options
-func (n *noopSubscriber) Options() SubscribeOptions {
-	return n.opts
-}
-
-// TOpic returns subscriber topic
-func (n *noopSubscriber) Topic() string {
-	return n.topic
-}
-
-// Unsubscribe unsbscribes from broker topic
-func (n *noopSubscriber) Unsubscribe(ctx context.Context) error {
-	return nil
-}

broker/options.go

@@ -6,34 +6,44 @@ import (
 
 	"github.com/unistack-org/micro/v3/codec"
 	"github.com/unistack-org/micro/v3/logger"
-	"github.com/unistack-org/micro/v3/registry"
+	"github.com/unistack-org/micro/v3/meter"
+	"github.com/unistack-org/micro/v3/register"
+	"github.com/unistack-org/micro/v3/tracer"
 )
 
 // Options struct
 type Options struct {
-	Addrs  []string
+	// Tracer used for tracing
-	Secure bool
+	Tracer tracer.Tracer
-	Codec  codec.Marshaler
+	// Register can be used for clustering
-
+	Register register.Register
-	// Logger
+	// Codec holds the codec for marshal/unmarshal
+	Codec codec.Codec
+	// Logger used for logging
 	Logger logger.Logger
-	// Handler executed when errors occur processing messages
+	// Meter used for metrics
-	ErrorHandler Handler
+	Meter meter.Meter
-
+	// Context holds external options
-	TLSConfig *tls.Config
-	// Registry used for clustering
-	Registry registry.Registry
-	// Other options for implementations of the interface
-	// can be stored in a context
 	Context context.Context
+	// TLSConfig holds tls.TLSConfig options
+	TLSConfig *tls.Config
+	// ErrorHandler used when broker can't unmarshal incoming message
+	ErrorHandler Handler
+	// Name holds the broker name
+	Name string
+	// Addrs holds the broker address
+	Addrs []string
 }
 
 // NewOptions create new Options
 func NewOptions(opts ...Option) Options {
 	options := Options{
-		Registry: registry.DefaultRegistry,
+		Register: register.DefaultRegister,
 		Logger:   logger.DefaultLogger,
 		Context:  context.Background(),
+		Meter:    meter.DefaultMeter,
+		Codec:    codec.DefaultCodec,
+		Tracer:   tracer.DefaultTracer,
 	}
 	for _, o := range opts {
 		o(&options)
@@ -50,9 +60,10 @@ func Context(ctx context.Context) Option {
 
 // PublishOptions struct
 type PublishOptions struct {
-	// Other options for implementations of the interface
+	// Context holds external options
-	// can be stored in a context
 	Context context.Context
+	// BodyOnly flag says the message contains raw body bytes
+	BodyOnly bool
 }
 
 // NewPublishOptions creates PublishOptions struct
@@ -70,20 +81,16 @@ func NewPublishOptions(opts ...PublishOption) PublishOptions {
 
 // SubscribeOptions struct
 type SubscribeOptions struct {
-	// AutoAck ack messages if handler returns nil err
+	// Context holds external options
-	AutoAck bool
-
-	// Handler executed when errors occur processing messages
-	ErrorHandler Handler
-
-	// Subscribers with the same group name
-	// will create a shared subscription where each
-	// receives a subset of messages.
-	Group string
-
-	// Other options for implementations of the interface
-	// can be stored in a context
 	Context context.Context
+	// ErrorHandler used when broker can't unmarshal incoming message
+	ErrorHandler Handler
+	// Group holds consumer group
+	Group string
+	// AutoAck flag specifies auto ack of incoming message when no error happens
+	AutoAck bool
+	// BodyOnly flag specifies that message contains only body bytes without header
+	BodyOnly bool
 }
 
 // Option func
@@ -92,6 +99,13 @@ type Option func(*Options)
 // PublishOption func
 type PublishOption func(*PublishOptions)
 
+// PublishBodyOnly publish only body of the message
+func PublishBodyOnly(b bool) PublishOption {
+	return func(o *PublishOptions) {
+		o.BodyOnly = b
+	}
+}
+
 // PublishContext sets the context
 func PublishContext(ctx context.Context) PublishOption {
 	return func(o *PublishOptions) {
@@ -125,7 +139,7 @@ func Addrs(addrs ...string) Option {
 
 // Codec sets the codec used for encoding/decoding used where
 // a broker does not support headers
-func Codec(c codec.Marshaler) Option {
+func Codec(c codec.Codec) Option {
 	return func(o *Options) {
 		o.Codec = c
 	}
@@ -146,6 +160,13 @@ func SubscribeAutoAck(b bool) SubscribeOption {
 	}
 }
 
+// SubscribeBodyOnly consumes only body of the message
+func SubscribeBodyOnly(b bool) SubscribeOption {
+	return func(o *SubscribeOptions) {
+		o.BodyOnly = b
+	}
+}
+
 // ErrorHandler will catch all broker errors that cant be handled
 // in normal way, for example Codec errors
 func ErrorHandler(h Handler) Option {
@@ -162,7 +183,8 @@ func SubscribeErrorHandler(h Handler) SubscribeOption {
 	}
 }
 
-// Queue sets the subscribers sueue
+// Queue sets the subscribers queue
+// Deprecated
 func Queue(name string) SubscribeOption {
 	return func(o *SubscribeOptions) {
 		o.Group = name
@@ -176,17 +198,10 @@ func SubscribeGroup(name string) SubscribeOption {
 	}
 }
 
-// Registry sets registry option
+// Register sets register option
-func Registry(r registry.Registry) Option {
+func Register(r register.Register) Option {
 	return func(o *Options) {
-		o.Registry = r
+		o.Register = r
-	}
-}
-
-// Secure communication with the broker
-func Secure(b bool) Option {
-	return func(o *Options) {
-		o.Secure = b
 	}
 }
 
@@ -204,6 +219,27 @@ func Logger(l logger.Logger) Option {
 	}
 }
 
+// Tracer to be used for tracing
+func Tracer(t tracer.Tracer) Option {
+	return func(o *Options) {
+		o.Tracer = t
+	}
+}
+
+// Meter sets the meter
+func Meter(m meter.Meter) Option {
+	return func(o *Options) {
+		o.Meter = m
+	}
+}
+
+// Name sets the name
+func Name(n string) Option {
+	return func(o *Options) {
+		o.Name = n
+	}
+}
+
 // SubscribeContext set context
 func SubscribeContext(ctx context.Context) SubscribeOption {
 	return func(o *SubscribeOptions) {

build/build.go

@@ -21,12 +21,12 @@ type Source struct {
 
 // Package is packaged format for source
 type Package struct {
+	// Source of the package
+	Source *Source
 	// Name of the package
 	Name string
 	// Location of the package
 	Path string
 	// Type of package e.g tarball, binary, docker
 	Type string
-	// Source of the package
-	Source *Source
 }

client/client.go

@@ -6,21 +6,37 @@ import (
 	"time"
 
 	"github.com/unistack-org/micro/v3/codec"
+	"github.com/unistack-org/micro/v3/metadata"
 )
 
 var (
 	// DefaultClient is the global default client
 	DefaultClient Client = NewClient()
+	// DefaultContentType is the default content-type if not specified
+	DefaultContentType = "application/json"
+	// DefaultBackoff is the default backoff function for retries
+	DefaultBackoff = exponentialBackoff
+	// DefaultRetry is the default check-for-retry function for retries
+	DefaultRetry = RetryNever
+	// DefaultRetries is the default number of times a request is tried
+	DefaultRetries = 0
+	// DefaultRequestTimeout is the default request timeout
+	DefaultRequestTimeout = time.Second * 5
+	// DefaultPoolSize sets the connection pool size
+	DefaultPoolSize = 100
+	// DefaultPoolTTL sets the connection pool ttl
+	DefaultPoolTTL = time.Minute
 )
 
 // Client is the interface used to make requests to services.
 // It supports Request/Response via Transport and Publishing via the Broker.
 // It also supports bidirectional streaming of requests.
 type Client interface {
-	Init(...Option) error
+	Name() string
+	Init(opts ...Option) error
 	Options() Options
 	NewMessage(topic string, msg interface{}, opts ...MessageOption) Message
-	NewRequest(service, endpoint string, req interface{}, reqOpts ...RequestOption) Request
+	NewRequest(service string, endpoint string, req interface{}, opts ...RequestOption) Request
 	Call(ctx context.Context, req Request, rsp interface{}, opts ...CallOption) error
 	Stream(ctx context.Context, req Request, opts ...CallOption) (Stream, error)
 	Publish(ctx context.Context, msg Message, opts ...PublishOption) error
@@ -47,7 +63,7 @@ type Request interface {
 	// The unencoded request body
 	Body() interface{}
 	// Write to the encoded request writer. This is nil before a call is made
-	Codec() codec.Writer
+	Codec() codec.Codec
 	// indicates whether the request will be a streaming one rather than unary
 	Stream() bool
 }
@@ -55,9 +71,9 @@ type Request interface {
 // Response is the response received from a service
 type Response interface {
 	// Read the response
-	Codec() codec.Reader
+	Codec() codec.Codec
 	// read the header
-	Header() map[string]string
+	Header() metadata.Metadata
 	// Read the undecoded response
 	Read() ([]byte, error)
 }
@@ -71,9 +87,9 @@ type Stream interface {
 	// The response read
 	Response() Response
 	// Send will encode and send a request
-	Send(interface{}) error
+	Send(msg interface{}) error
 	// Recv will decode and read a response
-	Recv(interface{}) error
+	Recv(msg interface{}) error
 	// Error returns the stream error
 	Error() error
 	// Close closes the stream
@@ -94,18 +110,3 @@ type MessageOption func(*MessageOptions)
 
 // RequestOption used by NewRequest
 type RequestOption func(*RequestOptions)
-
-var (
-	// DefaultBackoff is the default backoff function for retries
-	DefaultBackoff = exponentialBackoff
-	// DefaultRetry is the default check-for-retry function for retries
-	DefaultRetry = RetryOnError
-	// DefaultRetries is the default number of times a request is tried
-	DefaultRetries = 1
-	// DefaultRequestTimeout is the default request timeout
-	DefaultRequestTimeout = time.Second * 5
-	// DefaultPoolSize sets the connection pool size
-	DefaultPoolSize = 100
-	// DefaultPoolTTL sets the connection pool ttl
-	DefaultPoolTTL = time.Minute
-)

client/client_call_options.go

@@ -0,0 +1,23 @@
+package client
+
+import (
+	"context"
+)
+
+type clientCallOptions struct {
+	Client
+	opts []CallOption
+}
+
+func (s *clientCallOptions) Call(ctx context.Context, req Request, rsp interface{}, opts ...CallOption) error {
+	return s.Client.Call(ctx, req, rsp, append(s.opts, opts...)...)
+}
+
+func (s *clientCallOptions) Stream(ctx context.Context, req Request, opts ...CallOption) (Stream, error) {
+	return s.Client.Stream(ctx, req, append(s.opts, opts...)...)
+}
+
+// NewClientCallOptions add CallOption to every call
+func NewClientCallOptions(c Client, opts ...CallOption) Client {
+	return &clientCallOptions{c, opts}
+}

client/context.go

@@ -6,12 +6,20 @@ import (
 
 type clientKey struct{}
 
+// FromContext get client from context
 func FromContext(ctx context.Context) (Client, bool) {
+	if ctx == nil {
+		return nil, false
+	}
 	c, ok := ctx.Value(clientKey{}).(Client)
 	return c, ok
 }
 
+// NewContext put client in context
 func NewContext(ctx context.Context, c Client) context.Context {
+	if ctx == nil {
+		ctx = context.Background()
+	}
 	return context.WithValue(ctx, clientKey{}, c)
 }
 
@@ -24,3 +32,23 @@ func SetPublishOption(k, v interface{}) PublishOption {
 		o.Context = context.WithValue(o.Context, k, v)
 	}
 }
+
+// SetCallOption returns a function to setup a context with given value
+func SetCallOption(k, v interface{}) CallOption {
+	return func(o *CallOptions) {
+		if o.Context == nil {
+			o.Context = context.Background()
+		}
+		o.Context = context.WithValue(o.Context, k, v)
+	}
+}
+
+// SetOption returns a function to setup a context with given value
+func SetOption(k, v interface{}) Option {
+	return func(o *Options) {
+		if o.Context == nil {
+			o.Context = context.Background()
+		}
+		o.Context = context.WithValue(o.Context, k, v)
+	}
+}

client/lookup.go

@@ -18,6 +18,10 @@ func LookupRoute(ctx context.Context, req Request, opts CallOptions) ([]string,
 		return opts.Address, nil
 	}
 
+	if opts.Router == nil {
+		return nil, router.ErrRouteNotFound
+	}
+
 	// construct the router query
 	query := []router.QueryOption{router.QueryService(req.Service())}
 

client/noop.go

@@ -3,14 +3,23 @@ package client
 import (
 	"context"
 
-	raw "github.com/unistack-org/micro-codec-bytes"
-	json "github.com/unistack-org/micro-codec-json"
 	"github.com/unistack-org/micro/v3/broker"
 	"github.com/unistack-org/micro/v3/codec"
 	"github.com/unistack-org/micro/v3/errors"
 	"github.com/unistack-org/micro/v3/metadata"
 )
 
+var (
+	// DefaultCodecs will be used to encode/decode data
+	DefaultCodecs = map[string]codec.Codec{
+		//"application/json":         cjson.NewCodec,
+		//"application/json-rpc":     cjsonrpc.NewCodec,
+		//"application/protobuf":     cproto.NewCodec,
+		//"application/proto-rpc":    cprotorpc.NewCodec,
+		"application/octet-stream": codec.NewCodec(),
+	}
+)
+
 type noopClient struct {
 	opts Options
 }
@@ -22,18 +31,31 @@ type noopMessage struct {
 }
 
 type noopRequest struct {
+	body        interface{}
+	codec       codec.Codec
 	service     string
 	method      string
 	endpoint    string
 	contentType string
-	body        interface{}
-	codec       codec.Writer
 	stream      bool
 }
 
 // NewClient returns new noop client
 func NewClient(opts ...Option) Client {
-	return &noopClient{opts: NewOptions(opts...)}
+	nc := &noopClient{opts: NewOptions(opts...)}
+	// wrap in reverse
+
+	c := Client(nc)
+
+	for i := len(nc.opts.Wrappers); i > 0; i-- {
+		c = nc.opts.Wrappers[i-1](c)
+	}
+
+	return c
+}
+
+func (n *noopClient) Name() string {
+	return n.opts.Name
 }
 
 func (n *noopRequest) Service() string {
@@ -56,7 +78,7 @@ func (n *noopRequest) Body() interface{} {
 	return n.body
 }
 
-func (n *noopRequest) Codec() codec.Writer {
+func (n *noopRequest) Codec() codec.Codec {
 	return n.codec
 }
 
@@ -65,15 +87,15 @@ func (n *noopRequest) Stream() bool {
 }
 
 type noopResponse struct {
-	codec  codec.Reader
+	codec  codec.Codec
-	header map[string]string
+	header metadata.Metadata
 }
 
-func (n *noopResponse) Codec() codec.Reader {
+func (n *noopResponse) Codec() codec.Codec {
 	return n.codec
 }
 
-func (n *noopResponse) Header() map[string]string {
+func (n *noopResponse) Header() metadata.Metadata {
 	return n.header
 }
 
@@ -123,6 +145,16 @@ func (n *noopMessage) ContentType() string {
 	return n.opts.ContentType
 }
 
+func (n *noopClient) newCodec(contentType string) (codec.Codec, error) {
+	if cf, ok := n.opts.Codecs[contentType]; ok {
+		return cf, nil
+	}
+	if cf, ok := DefaultCodecs[contentType]; ok {
+		return cf, nil
+	}
+	return nil, codec.ErrUnknownContentType
+}
+
 func (n *noopClient) Init(opts ...Option) error {
 	for _, o := range opts {
 		o(&n.opts)
@@ -143,7 +175,7 @@ func (n *noopClient) Call(ctx context.Context, req Request, rsp interface{}, opt
 }
 
 func (n *noopClient) NewRequest(service, endpoint string, req interface{}, opts ...RequestOption) Request {
-	return &noopRequest{}
+	return &noopRequest{service: service, endpoint: endpoint}
 }
 
 func (n *noopClient) NewMessage(topic string, msg interface{}, opts ...MessageOption) Message {
@@ -160,7 +192,7 @@ func (n *noopClient) Publish(ctx context.Context, p Message, opts ...PublishOpti
 
 	options := NewPublishOptions(opts...)
 
-	md, ok := metadata.FromContext(ctx)
+	md, ok := metadata.FromOutgoingContext(ctx)
 	if !ok {
 		md = metadata.New(0)
 	}
@@ -168,21 +200,15 @@ func (n *noopClient) Publish(ctx context.Context, p Message, opts ...PublishOpti
 	md["Micro-Topic"] = p.Topic()
 
 	// passed in raw data
-	if d, ok := p.Payload().(*raw.Frame); ok {
+	if d, ok := p.Payload().(*codec.Frame); ok {
 		body = d.Data
 	} else {
-		cf := n.opts.Broker.Options().Codec
+		// use codec for payload
-		if cf == nil {
+		cf, err := n.newCodec(p.ContentType())
-			cf = json.Marshaler{}
+		if err != nil {
+			return errors.InternalServerError("go.micro.client", err.Error())
 		}
 
-		/*
-			// use codec for payload
-			cf, err := n.opts.Codecs[p.ContentType()]
-			if err != nil {
-				return errors.InternalServerError("go.micro.client", err.Error())
-			}
-		*/
 		// set the body
 		b, err := cf.Marshal(p.Payload())
 		if err != nil {

client/options.go

@@ -7,44 +7,54 @@ import (
 	"github.com/unistack-org/micro/v3/broker"
 	"github.com/unistack-org/micro/v3/codec"
 	"github.com/unistack-org/micro/v3/logger"
+	"github.com/unistack-org/micro/v3/meter"
 	"github.com/unistack-org/micro/v3/network/transport"
-	"github.com/unistack-org/micro/v3/registry"
+	"github.com/unistack-org/micro/v3/register"
 	"github.com/unistack-org/micro/v3/router"
 	"github.com/unistack-org/micro/v3/selector"
 	"github.com/unistack-org/micro/v3/selector/random"
+	"github.com/unistack-org/micro/v3/tracer"
 )
 
+// Options holds client options
 type Options struct {
-	// Used to select codec
+	// CallOptions contains default CallOptions
-	ContentType string
-	// Proxy address to send requests via
-	Proxy string
-
-	// Plugged interfaces
-	Broker    broker.Broker
-	Codecs    map[string]codec.NewCodec
-	Router    router.Router
-	Selector  selector.Selector
-	Transport transport.Transport
-	Logger    logger.Logger
-	// Lookup used for looking up routes
-	Lookup LookupFunc
-
-	// Connection Pool
-	PoolSize int
-	PoolTTL  time.Duration
-
-	// Middleware for client
-	Wrappers []Wrapper
-
-	// Default Call Options
 	CallOptions CallOptions
-
+	// Logger used to log messages
-	// Other options for implementations of the interface
+	Logger logger.Logger
-	// can be stored in a context
+	// Tracer used for tracing
+	Tracer tracer.Tracer
+	// Broker used to publish messages
+	Broker broker.Broker
+	// Meter used for metrics
+	Meter meter.Meter
+	// Router used to get route
+	Router router.Router
+	// Selector used to select needed address
+	Selector selector.Selector
+	// Transport used for transfer messages
+	Transport transport.Transport
+	// Context is used for external options
 	Context context.Context
+	// Codecs map
+	Codecs map[string]codec.Codec
+	// Lookup func used to get destination addr
+	Lookup LookupFunc
+	// Proxy is used for proxy requests
+	Proxy string
+	// ContentType is Used to select codec
+	ContentType string
+	// Name is the client name
+	Name string
+	// Wrappers contains wrappers
+	Wrappers []Wrapper
+	// PoolSize connection pool size
+	PoolSize int
+	// PoolTTL connection pool ttl
+	PoolTTL time.Duration
 }
 
+// NewCallOptions creates new call options struct
 func NewCallOptions(opts ...CallOption) CallOptions {
 	options := CallOptions{}
 	for _, o := range opts {
@@ -53,46 +63,46 @@ func NewCallOptions(opts ...CallOption) CallOptions {
 	return options
 }
 
+// CallOptions holds client call options
 type CallOptions struct {
-	// Address of remote hosts
+	// Router used for route
-	Address []string
-	// Backoff func
-	Backoff BackoffFunc
-	// Transport Dial Timeout
-	DialTimeout time.Duration
-	// Number of Call attempts
-	Retries int
-	// Check if retriable func
-	Retry RetryFunc
-	// Request/Response timeout
-	RequestTimeout time.Duration
-	// Router to use for this call
 	Router router.Router
-	// Selector to use for the call
+	// Selector selects addr
 	Selector selector.Selector
-	// SelectOptions to use when selecting a route
+	// Context used for deadline
-	SelectOptions []selector.SelectOption
-	// Stream timeout for the stream
-	StreamTimeout time.Duration
-	// Use the auth token as the authorization header
-	AuthToken bool
-	// Network to lookup the route within
-	Network string
-
-	// Middleware for low level call func
-	CallWrappers []CallWrapper
-
-	// Other options for implementations of the interface
-	// can be stored in a context
 	Context context.Context
+	// Retry func used for retries
+	Retry RetryFunc
+	// Backoff func used for backoff when retry
+	Backoff BackoffFunc
+	// Network name
+	Network string
+	// CallWrappers call wrappers
+	CallWrappers []CallWrapper
+	// SelectOptions selector options
+	SelectOptions []selector.SelectOption
+	// Address specifies static addr list
+	Address []string
+	// Retries specifies retries num
+	Retries int
+	// StreamTimeout stream timeout
+	StreamTimeout time.Duration
+	// RequestTimeout request timeout
+	RequestTimeout time.Duration
+	// DialTimeout dial timeout
+	DialTimeout time.Duration
+	// AuthToken flag
+	AuthToken bool
 }
 
+// Context pass context to client
 func Context(ctx context.Context) Option {
 	return func(o *Options) {
 		o.Context = ctx
 	}
 }
 
+// NewPublishOptions create new PublishOptions struct from option
 func NewPublishOptions(opts ...PublishOption) PublishOptions {
 	options := PublishOptions{}
 	for _, o := range opts {
@@ -101,14 +111,15 @@ func NewPublishOptions(opts ...PublishOption) PublishOptions {
 	return options
 }
 
+// PublishOptions holds publish options
 type PublishOptions struct {
-	// Exchange is the routing exchange for the message
+	// Context used for external options
-	Exchange string
-	// Other options for implementations of the interface
-	// can be stored in a context
 	Context context.Context
+	// Exchange topic exchange name
+	Exchange string
 }
 
+// NewMessageOptions creates message options struct
 func NewMessageOptions(opts ...MessageOption) MessageOptions {
 	options := MessageOptions{}
 	for _, o := range opts {
@@ -117,10 +128,13 @@ func NewMessageOptions(opts ...MessageOption) MessageOptions {
 	return options
 }
 
+// MessageOptions holds client message options
 type MessageOptions struct {
+	// ContentType specify content-type of message
 	ContentType string
 }
 
+// NewRequestOptions creates new RequestOptions struct
 func NewRequestOptions(opts ...RequestOption) RequestOptions {
 	options := RequestOptions{}
 	for _, o := range opts {
@@ -129,21 +143,24 @@ func NewRequestOptions(opts ...RequestOption) RequestOptions {
 	return options
 }
 
+// RequestOptions holds client request options
 type RequestOptions struct {
-	ContentType string
+	// Context used for external options
-	Stream      bool
-
-	// Other options for implementations of the interface
-	// can be stored in a context
 	Context context.Context
+	// ContentType specify content-type of message
+	ContentType string
+	// Stream flag
+	Stream bool
 }
 
+// NewOptions creates new options struct
 func NewOptions(opts ...Option) Options {
 	options := Options{
 		Context:     context.Background(),
-		ContentType: "application/protobuf",
+		ContentType: DefaultContentType,
-		Codecs:      make(map[string]codec.NewCodec),
+		Codecs:      make(map[string]codec.Codec),
 		CallOptions: CallOptions{
+			Context:        context.Background(),
 			Backoff:        DefaultBackoff,
 			Retry:          DefaultRetry,
 			Retries:        DefaultRetries,
@@ -156,6 +173,8 @@ func NewOptions(opts ...Option) Options {
 		Selector: random.NewSelector(),
 		Logger:   logger.DefaultLogger,
 		Broker:   broker.DefaultBroker,
+		Meter:    meter.DefaultMeter,
+		Tracer:   tracer.DefaultTracer,
 	}
 
 	for _, o := range opts {
@@ -172,20 +191,35 @@ func Broker(b broker.Broker) Option {
 	}
 }
 
+// Tracer to be used for tracing
+func Tracer(t tracer.Tracer) Option {
+	return func(o *Options) {
+		o.Tracer = t
+	}
+}
+
+// Logger to be used for log mesages
 func Logger(l logger.Logger) Option {
 	return func(o *Options) {
 		o.Logger = l
 	}
 }
 
+// Meter to be used for metrics
+func Meter(m meter.Meter) Option {
+	return func(o *Options) {
+		o.Meter = m
+	}
+}
+
 // Codec to be used to encode/decode requests for a given content type
-func Codec(contentType string, c codec.NewCodec) Option {
+func Codec(contentType string, c codec.Codec) Option {
 	return func(o *Options) {
 		o.Codecs[contentType] = c
 	}
 }
 
-// Default content type of the client
+// ContentType used by default if not specified
 func ContentType(ct string) Option {
 	return func(o *Options) {
 		o.ContentType = ct
@@ -220,11 +254,11 @@ func Transport(t transport.Transport) Option {
 	}
 }
 
-// Registry sets the routers registry
+// Register sets the routers register
-func Registry(r registry.Registry) Option {
+func Register(r register.Register) Option {
 	return func(o *Options) {
 		if o.Router != nil {
-			o.Router.Init(router.Registry(r))
+			o.Router.Init(router.Register(r))
 		}
 	}
 }
@@ -243,28 +277,34 @@ func Selector(s selector.Selector) Option {
 	}
 }
 
-// Adds a Wrapper to a list of options passed into the client
+// Wrap adds a wrapper to the list of options passed into the client
 func Wrap(w Wrapper) Option {
 	return func(o *Options) {
 		o.Wrappers = append(o.Wrappers, w)
 	}
 }
 
-// Adds a Wrapper to the list of CallFunc wrappers
+// WrapCall adds a wrapper to the list of CallFunc wrappers
 func WrapCall(cw ...CallWrapper) Option {
 	return func(o *Options) {
 		o.CallOptions.CallWrappers = append(o.CallOptions.CallWrappers, cw...)
 	}
 }
 
-// Backoff is used to set the backoff function used
+// Backoff is used to set the backoff function used when retrying Calls
-// when retrying Calls
 func Backoff(fn BackoffFunc) Option {
 	return func(o *Options) {
 		o.CallOptions.Backoff = fn
 	}
 }
 
+// Name sets the client name
+func Name(n string) Option {
+	return func(o *Options) {
+		o.Name = n
+	}
+}
+
 // Lookup sets the lookup function to use for resolving service names
 func Lookup(l LookupFunc) Option {
 	return func(o *Options) {
@@ -272,8 +312,7 @@ func Lookup(l LookupFunc) Option {
 	}
 }
 
-// Number of retries when making the request.
+// Retries sets the retry count when making the request.
-// Should this be a Call Option?
 func Retries(i int) Option {
 	return func(o *Options) {
 		o.CallOptions.Retries = i
@@ -287,8 +326,7 @@ func Retry(fn RetryFunc) Option {
 	}
 }
 
-// The request timeout.
+// RequestTimeout is the request timeout.
-// Should this be a Call Option?
 func RequestTimeout(d time.Duration) Option {
 	return func(o *Options) {
 		o.CallOptions.RequestTimeout = d
@@ -302,15 +340,13 @@ func StreamTimeout(d time.Duration) Option {
 	}
 }
 
-// Transport dial timeout
+// DialTimeout sets the dial timeout
 func DialTimeout(d time.Duration) Option {
 	return func(o *Options) {
 		o.CallOptions.DialTimeout = d
 	}
 }
 
-// Call Options
-
 // WithExchange sets the exchange to route a message through
 func WithExchange(e string) PublishOption {
 	return func(o *PublishOptions) {
@@ -422,20 +458,21 @@ func WithSelectOptions(sops ...selector.SelectOption) CallOption {
 	}
 }
 
+// WithMessageContentType sets the message content type
 func WithMessageContentType(ct string) MessageOption {
 	return func(o *MessageOptions) {
 		o.ContentType = ct
 	}
 }
 
-// Request Options
+// WithContentType specifies request content type
-
 func WithContentType(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

client/retry.go

@@ -14,22 +14,23 @@ func RetryAlways(ctx context.Context, req Request, retryCount int, err error) (b
 	return true, nil
 }
 
+// RetryNever never retry on error
+func RetryNever(ctx context.Context, req Request, retryCount int, err error) (bool, error) {
+	return false, nil
+}
+
 // RetryOnError retries a request on a 500 or timeout error
 func RetryOnError(ctx context.Context, req Request, retryCount int, err error) (bool, error) {
 	if err == nil {
 		return false, nil
 	}
 
-	e := errors.Parse(err.Error())
+	me := errors.FromError(err)
-	if e == nil {
+	switch me.Code {
-		return false, nil
-	}
-
-	switch e.Code {
 	// retry on timeout or internal server error
 	case 408, 500:
 		return true, nil
-	default:
-		return false, nil
 	}
+
+	return false, nil
 }

client/test_request.go

@@ -5,13 +5,13 @@ import (
 )
 
 type testRequest struct {
-	service     string
+	opts        RequestOptions
+	codec       codec.Codec
+	body        interface{}
 	method      string
 	endpoint    string
 	contentType string
-	codec       codec.Codec
+	service     string
-	body        interface{}
-	opts        RequestOptions
 }
 
 func (r *testRequest) ContentType() string {
@@ -34,7 +34,7 @@ func (r *testRequest) Body() interface{} {
 	return r.body
 }
 
-func (r *testRequest) Codec() codec.Writer {
+func (r *testRequest) Codec() codec.Codec {
 	return r.codec
 }
 

codec/codec.go

@@ -4,8 +4,11 @@ package codec
 import (
 	"errors"
 	"io"
+
+	"github.com/unistack-org/micro/v3/metadata"
 )
 
+// Message types
 const (
 	Error MessageType = iota
 	Request
@@ -16,40 +19,29 @@ const (
 var (
 	// ErrInvalidMessage returned when invalid messge passed to codec
 	ErrInvalidMessage = errors.New("invalid message")
+	// ErrUnknownContentType returned when content-type is unknown
+	ErrUnknownContentType = errors.New("unknown content-type")
 )
 
-// MessageType
+var (
+	// DefaultMaxMsgSize specifies how much data codec can handle
+	DefaultMaxMsgSize int = 1024 * 1024 * 4 // 4Mb
+	// DefaultCodec is the global default codec
+	DefaultCodec Codec = NewCodec()
+)
+
+// MessageType specifies message type for codec
 type MessageType int
 
-// NewCodec takes in a connection/buffer and returns a new Codec
+// Codec encodes/decodes various types of messages used within micro.
-type NewCodec func(io.ReadWriteCloser) Codec
-
-// Codec encodes/decodes various types of messages used within go-micro.
 // ReadHeader and ReadBody are called in pairs to read requests/responses
 // from the connection. Close is called when finished with the
 // connection. ReadBody may be called with a nil argument to force the
 // body to be read and discarded.
 type Codec interface {
-	Reader
+	ReadHeader(io.Reader, *Message, MessageType) error
-	Writer
+	ReadBody(io.Reader, interface{}) error
-	Close() error
+	Write(io.Writer, *Message, interface{}) error
-	String() string
-}
-
-// Reader interface
-type Reader interface {
-	ReadHeader(*Message, MessageType) error
-	ReadBody(interface{}) error
-}
-
-// Writer interface
-type Writer interface {
-	Write(*Message, interface{}) error
-}
-
-// Marshaler is a simple encoding interface used for the broker/transport
-// where headers are not supported by the underlying implementation.
-type Marshaler interface {
 	Marshal(interface{}) ([]byte, error)
 	Unmarshal([]byte, interface{}) error
 	String() string
@@ -59,14 +51,17 @@ type Marshaler interface {
 // the communication, likely followed by the body.
 // In the case of an error, body may be nil.
 type Message struct {
-	Id       string
+	Header   metadata.Metadata
-	Type     MessageType
 	Target   string
 	Method   string
 	Endpoint string
 	Error    string
-
+	Id       string
-	// The values read from the socket
+	Body     []byte
-	Header map[string]string
+	Type     MessageType
-	Body   []byte
+}
+
+// NewMessage creates new codec message
+func NewMessage(t MessageType) *Message {
+	return &Message{Type: t, Header: metadata.New(0)}
 }

codec/frame.go

@@ -0,0 +1,6 @@
+package codec
+
+// Frame gives us the ability to define raw data to send over the pipes
+type Frame struct {
+	Data []byte
+}

codec/frame.proto

@@ -0,0 +1,28 @@
+// Copyright 2021 Unistack LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+syntax = "proto3";
+
+package micro.codec;
+
+option cc_enable_arenas = true;
+option go_package = "github.com/unistack-org/micro/v3/codec;codec";
+option java_multiple_files = true;
+option java_outer_classname = "MicroCodec";
+option java_package = "micro.codec";
+option objc_class_prefix = "MCODEC";
+
+message Frame {
+  bytes data = 1;
+}

codec/noop.go

@@ -0,0 +1,120 @@
+package codec
+
+import (
+	"encoding/json"
+	"io"
+)
+
+type noopCodec struct {
+}
+
+func (c *noopCodec) ReadHeader(conn io.Reader, m *Message, t MessageType) error {
+	return nil
+}
+
+func (c *noopCodec) ReadBody(conn io.Reader, b interface{}) error {
+	// read bytes
+	buf, err := io.ReadAll(conn)
+	if err != nil {
+		return err
+	}
+
+	if b == nil {
+		return nil
+	}
+
+	switch v := b.(type) {
+	case *string:
+		*v = string(buf)
+	case *[]byte:
+		*v = buf
+	case *Frame:
+		v.Data = buf
+	default:
+		return json.Unmarshal(buf, v)
+	}
+
+	return nil
+}
+
+func (c *noopCodec) Write(conn io.Writer, m *Message, b interface{}) error {
+	if b == nil {
+		return nil
+	}
+
+	var v []byte
+	switch vb := b.(type) {
+	case *Frame:
+		v = vb.Data
+	case string:
+		v = []byte(vb)
+	case *string:
+		v = []byte(*vb)
+	case *[]byte:
+		v = *vb
+	case []byte:
+		v = vb
+	default:
+		var err error
+		v, err = json.Marshal(vb)
+		if err != nil {
+			return err
+		}
+	}
+	_, err := conn.Write(v)
+	return err
+}
+
+func (c *noopCodec) String() string {
+	return "noop"
+}
+
+// NewCodec returns new noop codec
+func NewCodec() Codec {
+	return &noopCodec{}
+}
+
+func (c *noopCodec) Marshal(v interface{}) ([]byte, error) {
+	if v == nil {
+		return nil, nil
+	}
+
+	switch ve := v.(type) {
+	case string:
+		return []byte(ve), nil
+	case *string:
+		return []byte(*ve), nil
+	case *[]byte:
+		return *ve, nil
+	case []byte:
+		return ve, nil
+	case *Frame:
+		return ve.Data, nil
+	case *Message:
+		return ve.Body, nil
+	}
+
+	return json.Marshal(v)
+}
+
+func (c *noopCodec) Unmarshal(d []byte, v interface{}) error {
+	if v == nil {
+		return nil
+	}
+	switch ve := v.(type) {
+	case *string:
+		*ve = string(d)
+		return nil
+	case *[]byte:
+		*ve = d
+		return nil
+	case *Frame:
+		ve.Data = d
+		return nil
+	case *Message:
+		ve.Body = d
+		return nil
+	}
+
+	return json.Unmarshal(d, v)
+}

codec/noop_test.go

@@ -0,0 +1,34 @@
+package codec
+
+import (
+	"bytes"
+	"testing"
+)
+
+func TestNoopBytes(t *testing.T) {
+	req := []byte("test req")
+	rsp := make([]byte, len(req))
+
+	nc := NewCodec()
+	if err := nc.Unmarshal(req, &rsp); err != nil {
+		t.Fatal(err)
+	}
+
+	if !bytes.Equal(req, rsp) {
+		t.Fatalf("req not eq rsp: %s != %s", req, rsp)
+	}
+}
+
+func TestNoopString(t *testing.T) {
+	req := []byte("test req")
+	var rsp string
+
+	nc := NewCodec()
+	if err := nc.Unmarshal(req, &rsp); err != nil {
+		t.Fatal(err)
+	}
+
+	if !bytes.Equal(req, []byte(rsp)) {
+		t.Fatalf("req not eq rsp: %s != %s", req, rsp)
+	}
+}

codec/options.go

@@ -0,0 +1,66 @@
+package codec
+
+import (
+	"github.com/unistack-org/micro/v3/logger"
+	"github.com/unistack-org/micro/v3/meter"
+	"github.com/unistack-org/micro/v3/tracer"
+)
+
+// Option func
+type Option func(*Options)
+
+// Options contains codec options
+type Options struct {
+	// Meter used for metrics
+	Meter meter.Meter
+	// Logger used for logging
+	Logger logger.Logger
+	// Tracer used for tracing
+	Tracer tracer.Tracer
+	// MaxMsgSize specifies max messages size that reads by codec
+	MaxMsgSize int
+}
+
+// MaxMsgSize sets the max message size
+func MaxMsgSize(n int) Option {
+	return func(o *Options) {
+		o.MaxMsgSize = n
+	}
+}
+
+// Logger sets the logger
+func Logger(l logger.Logger) Option {
+	return func(o *Options) {
+		o.Logger = l
+	}
+}
+
+// Tracer to be used for tracing
+func Tracer(t tracer.Tracer) Option {
+	return func(o *Options) {
+		o.Tracer = t
+	}
+}
+
+// Meter sets the meter
+func Meter(m meter.Meter) Option {
+	return func(o *Options) {
+		o.Meter = m
+	}
+}
+
+// NewOptions returns new options
+func NewOptions(opts ...Option) Options {
+	options := Options{
+		Logger:     logger.DefaultLogger,
+		Meter:      meter.DefaultMeter,
+		Tracer:     tracer.DefaultTracer,
+		MaxMsgSize: DefaultMaxMsgSize,
+	}
+
+	for _, o := range opts {
+		o(&options)
+	}
+
+	return options
+}

config/config.go

@@ -3,52 +3,55 @@ package config
 
 import (
 	"context"
-
+	"errors"
-	"github.com/unistack-org/micro/v3/config/loader"
-	"github.com/unistack-org/micro/v3/config/reader"
-	"github.com/unistack-org/micro/v3/config/source"
 )
 
 var (
-	DefaultConfig Config
+	// DefaultConfig default config
+	DefaultConfig Config = NewConfig()
+)
+
+var (
+	// ErrCodecMissing is returned when codec needed and not specified
+	ErrCodecMissing = errors.New("codec missing")
+	// ErrInvalidStruct is returned when the target struct is invalid
+	ErrInvalidStruct = errors.New("invalid struct specified")
+	// ErrWatcherStopped is returned when source watcher has been stopped
+	ErrWatcherStopped = errors.New("watcher stopped")
 )
 
 // Config is an interface abstraction for dynamic configuration
 type Config interface {
-	// provide the reader.Values interface
+	Name() string
-	reader.Values
 	// Init the config
 	Init(opts ...Option) error
 	// Options in the config
 	Options() Options
-	// Stop the config loader/watcher
+	// Load config from sources
-	Close() error
+	Load(context.Context) error
-	// Load config sources
+	// Save config to sources
-	Load(source ...source.Source) error
+	Save(context.Context) error
-	// Force a source changeset sync
-	Sync() error
 	// Watch a value for changes
-	Watch(path ...string) (Watcher, error)
+	//	Watch(interface{}) (Watcher, error)
+	String() string
 }
 
 // Watcher is the config watcher
-type Watcher interface {
+//type Watcher interface {
-	Next() (reader.Value, error)
+//	Next() (, error)
-	Stop() error
+//	Stop() error
-}
+//}
-
+
-type Options struct {
+// Load loads config from config sources
-	Loader loader.Loader
+func Load(ctx context.Context, cs ...Config) error {
-	Reader reader.Reader
+	var err error
-	Source []source.Source
+	for _, c := range cs {
-
+		if err = c.Init(); err != nil {
-	// for alternative data
+			return err
-	Context context.Context
+		}
-}
+		if err = c.Load(ctx); err != nil {
-
+			return err
-type Option func(o *Options)
+		}
-
+	}
-// NewConfig returns new config
+	return nil
-func NewConfig(opts ...Option) (Config, error) {
-	return newConfig(opts...)
 }

config/context.go

@@ -0,0 +1,34 @@
+package config
+
+import (
+	"context"
+)
+
+type configKey struct{}
+
+// FromContext returns store from context
+func FromContext(ctx context.Context) (Config, bool) {
+	if ctx == nil {
+		return nil, false
+	}
+	c, ok := ctx.Value(configKey{}).(Config)
+	return c, ok
+}
+
+// NewContext put store in context
+func NewContext(ctx context.Context, c Config) context.Context {
+	if ctx == nil {
+		ctx = context.Background()
+	}
+	return context.WithValue(ctx, configKey{}, c)
+}
+
+// SetOption returns a function to setup a context with given value
+func SetOption(k, v interface{}) Option {
+	return func(o *Options) {
+		if o.Context == nil {
+			o.Context = context.Background()
+		}
+		o.Context = context.WithValue(o.Context, k, v)
+	}
+}

config/default.go

@@ -1,294 +1,266 @@
 package config
 
 import (
-	"bytes"
+	"context"
-	"fmt"
+	"reflect"
-	"sync"
+	"strconv"
-	"time"
+	"strings"
 
-	"github.com/unistack-org/micro/v3/config/loader"
+	"github.com/imdario/mergo"
-	"github.com/unistack-org/micro/v3/config/reader"
+	rutil "github.com/unistack-org/micro/v3/util/reflect"
-	"github.com/unistack-org/micro/v3/config/source"
 )
 
-type config struct {
+type defaultConfig struct {
-	exit chan bool
 	opts Options
-
-	sync.RWMutex
-	// the current snapshot
-	snap *loader.Snapshot
-	// the current values
-	vals reader.Values
 }
 
-type watcher struct {
+func (c *defaultConfig) Options() Options {
-	lw    loader.Watcher
-	rd    reader.Reader
-	path  []string
-	value reader.Value
-}
-
-func newConfig(opts ...Option) (Config, error) {
-	var c config
-
-	if err := c.Init(opts...); err != nil {
-		return nil, err
-	}
-
-	go c.run()
-	return &c, nil
-}
-
-func (c *config) Init(opts ...Option) error {
-	c.opts = Options{}
-	c.exit = make(chan bool)
-	for _, o := range opts {
-		o(&c.opts)
-	}
-
-	err := c.opts.Loader.Load(c.opts.Source...)
-	if err != nil {
-		return err
-	}
-
-	c.snap, err = c.opts.Loader.Snapshot()
-	if err != nil {
-		return err
-	}
-
-	c.vals, err = c.opts.Reader.Values(c.snap.ChangeSet)
-	if err != nil {
-		return err
-	}
-
-	return nil
-}
-
-func (c *config) Options() Options {
 	return c.opts
 }
 
-func (c *config) run() {
+func (c *defaultConfig) Init(opts ...Option) error {
-	watch := func(w loader.Watcher) error {
+	for _, o := range opts {
-		for {
+		o(&c.opts)
-			// get changeset
+	}
-			snap, err := w.Next()
+	return nil
-			if err != nil {
+}
+
+func (c *defaultConfig) Load(ctx context.Context) error {
+	for _, fn := range c.opts.BeforeLoad {
+		if err := fn(ctx, c); err != nil && !c.opts.AllowFail {
+			return err
+		}
+	}
+
+	src, err := rutil.Zero(c.opts.Struct)
+	if err == nil {
+		valueOf := reflect.ValueOf(src)
+		if err = c.fillValues(ctx, valueOf); err == nil {
+			err = mergo.Merge(c.opts.Struct, src, mergo.WithOverride, mergo.WithTypeCheck, mergo.WithAppendSlice)
+		}
+	}
+
+	if err != nil && !c.opts.AllowFail {
+		return err
+	}
+
+	for _, fn := range c.opts.AfterLoad {
+		if err := fn(ctx, c); err != nil && !c.opts.AllowFail {
+			return err
+		}
+	}
+
+	return nil
+}
+
+//nolint:gocyclo
+func (c *defaultConfig) fillValue(ctx context.Context, value reflect.Value, val string) error {
+	if !rutil.IsEmpty(value) {
+		return nil
+	}
+	switch value.Kind() {
+	case reflect.Map:
+		t := value.Type()
+		nvals := strings.FieldsFunc(val, func(c rune) bool { return c == ',' || c == ';' })
+		if value.IsNil() {
+			value.Set(reflect.MakeMapWithSize(t, len(nvals)))
+		}
+		kt := t.Key()
+		et := t.Elem()
+		for _, nval := range nvals {
+			kv := strings.FieldsFunc(nval, func(c rune) bool { return c == '=' })
+			mkey := reflect.Indirect(reflect.New(kt))
+			mval := reflect.Indirect(reflect.New(et))
+			if err := c.fillValue(ctx, mkey, kv[0]); err != nil {
 				return err
 			}
-
+			if err := c.fillValue(ctx, mval, kv[1]); err != nil {
-			c.Lock()
+				return err
-
-			if c.snap != nil && c.snap.Version >= snap.Version {
-				c.Unlock()
-				continue
 			}
-
+			value.SetMapIndex(mkey, mval)
-			// save
-			c.snap = snap
-
-			// set values
-			c.vals, _ = c.opts.Reader.Values(snap.ChangeSet)
-
-			c.Unlock()
 		}
+	case reflect.Slice, reflect.Array:
+		nvals := strings.FieldsFunc(val, func(c rune) bool { return c == ',' || c == ';' })
+		value.Set(reflect.MakeSlice(reflect.SliceOf(value.Type().Elem()), len(nvals), len(nvals)))
+		for idx, nval := range nvals {
+			nvalue := reflect.Indirect(reflect.New(value.Type().Elem()))
+			if err := c.fillValue(ctx, nvalue, nval); err != nil {
+				return err
+			}
+			value.Index(idx).Set(nvalue)
+		}
+	case reflect.Bool:
+		v, err := strconv.ParseBool(val)
+		if err != nil {
+			return err
+		}
+		value.Set(reflect.ValueOf(v))
+	case reflect.String:
+		value.Set(reflect.ValueOf(val))
+	case reflect.Float32:
+		v, err := strconv.ParseFloat(val, 32)
+		if err != nil {
+			return err
+		}
+		value.Set(reflect.ValueOf(float32(v)))
+	case reflect.Float64:
+		v, err := strconv.ParseFloat(val, 64)
+		if err != nil {
+			return err
+		}
+		value.Set(reflect.ValueOf(v))
+	case reflect.Int:
+		v, err := strconv.ParseInt(val, 10, 0)
+		if err != nil {
+			return err
+		}
+		value.Set(reflect.ValueOf(int(v)))
+	case reflect.Int8:
+		v, err := strconv.ParseInt(val, 10, 8)
+		if err != nil {
+			return err
+		}
+		value.Set(reflect.ValueOf(v))
+	case reflect.Int16:
+		v, err := strconv.ParseInt(val, 10, 16)
+		if err != nil {
+			return err
+		}
+		value.Set(reflect.ValueOf(int16(v)))
+	case reflect.Int32:
+		v, err := strconv.ParseInt(val, 10, 32)
+		if err != nil {
+			return err
+		}
+		value.Set(reflect.ValueOf(int32(v)))
+	case reflect.Int64:
+		v, err := strconv.ParseInt(val, 10, 64)
+		if err != nil {
+			return err
+		}
+		value.Set(reflect.ValueOf(v))
+	case reflect.Uint:
+		v, err := strconv.ParseUint(val, 10, 0)
+		if err != nil {
+			return err
+		}
+		value.Set(reflect.ValueOf(uint(v)))
+	case reflect.Uint8:
+		v, err := strconv.ParseUint(val, 10, 8)
+		if err != nil {
+			return err
+		}
+		value.Set(reflect.ValueOf(uint8(v)))
+	case reflect.Uint16:
+		v, err := strconv.ParseUint(val, 10, 16)
+		if err != nil {
+			return err
+		}
+		value.Set(reflect.ValueOf(uint16(v)))
+	case reflect.Uint32:
+		v, err := strconv.ParseUint(val, 10, 32)
+		if err != nil {
+			return err
+		}
+		value.Set(reflect.ValueOf(uint32(v)))
+	case reflect.Uint64:
+		v, err := strconv.ParseUint(val, 10, 64)
+		if err != nil {
+			return err
+		}
+		value.Set(reflect.ValueOf(v))
+	}
+	return nil
+}
+
+func (c *defaultConfig) fillValues(ctx context.Context, valueOf reflect.Value) error {
+	var values reflect.Value
+
+	if valueOf.Kind() == reflect.Ptr {
+		values = valueOf.Elem()
+	} else {
+		values = valueOf
 	}
 
-	for {
+	if values.Kind() == reflect.Invalid {
-		w, err := c.opts.Loader.Watch()
+		return ErrInvalidStruct
-		if err != nil {
+	}
-			time.Sleep(time.Second)
+
+	fields := values.Type()
+
+	for idx := 0; idx < fields.NumField(); idx++ {
+		field := fields.Field(idx)
+		value := values.Field(idx)
+		if !value.CanSet() {
+			continue
+		}
+		if len(field.PkgPath) != 0 {
+			continue
+		}
+		switch value.Kind() {
+		case reflect.Struct:
+			value.Set(reflect.Indirect(reflect.New(value.Type())))
+			if err := c.fillValues(ctx, value); err != nil {
+				return err
+			}
+			continue
+		case reflect.Ptr:
+			if value.IsNil() {
+				if value.Type().Elem().Kind() != reflect.Struct {
+					// nil pointer to a non-struct: leave it alone
+					break
+				}
+				// nil pointer to struct: create a zero instance
+				value.Set(reflect.New(value.Type().Elem()))
+			}
+			value = value.Elem()
+			if err := c.fillValues(ctx, value); err != nil {
+				return err
+			}
+			continue
+		}
+		tag, ok := field.Tag.Lookup(c.opts.StructTag)
+		if !ok {
 			continue
 		}
 
-		done := make(chan bool)
+		if err := c.fillValue(ctx, value, tag); err != nil {
-
+			return err
-		// the stop watch func
-		go func() {
-			select {
-			case <-done:
-			case <-c.exit:
-			}
-			w.Stop()
-		}()
-
-		// block watch
-		if err := watch(w); err != nil {
-			// do something better
-			time.Sleep(time.Second)
 		}
-
-		// close done chan
-		close(done)
-
-		// if the config is closed exit
-		select {
-		case <-c.exit:
-			return
-		default:
-		}
-	}
-}
-
-func (c *config) Map() map[string]interface{} {
-	c.RLock()
-	defer c.RUnlock()
-	return c.vals.Map()
-}
-
-func (c *config) Scan(v interface{}) error {
-	c.RLock()
-	defer c.RUnlock()
-	return c.vals.Scan(v)
-}
-
-// sync loads all the sources, calls the parser and updates the config
-func (c *config) Sync() error {
-	if err := c.opts.Loader.Sync(); err != nil {
-		return err
-	}
-
-	snap, err := c.opts.Loader.Snapshot()
-	if err != nil {
-		return err
-	}
-
-	c.Lock()
-	defer c.Unlock()
-
-	c.snap = snap
-	vals, err := c.opts.Reader.Values(snap.ChangeSet)
-	if err != nil {
-		return err
-	}
-	c.vals = vals
-
-	return nil
-}
-
-func (c *config) Close() error {
-	select {
-	case <-c.exit:
-		return nil
-	default:
-		close(c.exit)
-	}
-	return nil
-}
-
-func (c *config) Get(path ...string) (reader.Value, error) {
-	c.RLock()
-	defer c.RUnlock()
-
-	// did sync actually work?
-	if c.vals != nil {
-		return c.vals.Get(path...)
-	}
-
-	// no value
-	return nil, fmt.Errorf("no value")
-}
-
-func (c *config) Set(val interface{}, path ...string) error {
-	c.Lock()
-	defer c.Unlock()
-
-	if c.vals != nil {
-		c.vals.Set(val, path...)
-	}
-	return nil
-}
-
-func (c *config) Del(path ...string) error {
-	c.Lock()
-	defer c.Unlock()
-
-	if c.vals != nil {
-		c.vals.Del(path...)
 	}
 
 	return nil
 }
 
-func (c *config) Bytes() []byte {
+func (c *defaultConfig) Save(ctx context.Context) error {
-	c.RLock()
+	for _, fn := range c.opts.BeforeSave {
-	defer c.RUnlock()
+		if err := fn(ctx, c); err != nil && !c.opts.AllowFail {
-
+			return err
-	if c.vals == nil {
+		}
-		return []byte{}
 	}
 
-	return c.vals.Bytes()
+	for _, fn := range c.opts.AfterSave {
-}
+		if err := fn(ctx, c); err != nil && !c.opts.AllowFail {
-
+			return err
-func (c *config) Load(sources ...source.Source) error {
+		}
-	if err := c.opts.Loader.Load(sources...); err != nil {
-		return err
 	}
 
-	snap, err := c.opts.Loader.Snapshot()
-	if err != nil {
-		return err
-	}
-
-	c.Lock()
-	defer c.Unlock()
-
-	c.snap = snap
-	vals, err := c.opts.Reader.Values(snap.ChangeSet)
-	if err != nil {
-		return err
-	}
-	c.vals = vals
-
 	return nil
 }
 
-func (c *config) Watch(path ...string) (Watcher, error) {
+func (c *defaultConfig) String() string {
-	value, err := c.Get(path...)
+	return "default"
-	if err != nil {
+}
-		return nil, err
+
+func (c *defaultConfig) Name() string {
+	return c.opts.Name
+}
+
+// NewConfig returns new default config source
+func NewConfig(opts ...Option) Config {
+	options := NewOptions(opts...)
+	if len(options.StructTag) == 0 {
+		options.StructTag = "default"
 	}
-
+	return &defaultConfig{opts: options}
-	w, err := c.opts.Loader.Watch(path...)
-	if err != nil {
-		return nil, err
-	}
-
-	return &watcher{
-		lw:    w,
-		rd:    c.opts.Reader,
-		path:  path,
-		value: value,
-	}, nil
-}
-
-func (c *config) String() string {
-	return "config"
-}
-
-func (w *watcher) Next() (reader.Value, error) {
-	for {
-		s, err := w.lw.Next()
-		if err != nil {
-			return nil, err
-		}
-
-		// only process changes
-		if bytes.Equal(w.value.Bytes(), s.ChangeSet.Data) {
-			continue
-		}
-
-		v, err := w.rd.Values(s.ChangeSet)
-		if err != nil {
-			return nil, err
-		}
-
-		return v.Get()
-	}
-}
-
-func (w *watcher) Stop() error {
-	return w.lw.Stop()
 }

config/default_test.go

@@ -1,168 +1,52 @@
-// +build ignore
+package config_test
-
-package config
 
 import (
+	"context"
 	"fmt"
-	"os"
-	"path/filepath"
-	"runtime"
-	"strings"
 	"testing"
-	"time"
 
-	"github.com/unistack-org/micro/v3/config/source"
+	"github.com/unistack-org/micro/v3/config"
-	"github.com/unistack-org/micro/v3/config/source/env"
-	"github.com/unistack-org/micro/v3/config/source/file"
-	"github.com/unistack-org/micro/v3/config/source/memory"
 )
 
-func createFileForIssue18(t *testing.T, content string) *os.File {
+type Cfg struct {
-	data := []byte(content)
+	StringValue string `default:"string_value"`
-	path := filepath.Join(os.TempDir(), fmt.Sprintf("file.%d", time.Now().UnixNano()))
+	IntValue    int    `default:"99"`
-	fh, err := os.Create(path)
+	IgnoreValue string `json:"-"`
-	if err != nil {
+	StructValue struct {
-		t.Error(err)
+		StringValue string `default:"string_value"`
-	}
-	_, err = fh.Write(data)
-	if err != nil {
-		t.Error(err)
-	}
-
-	return fh
-}
-
-func createFileForTest(t *testing.T) *os.File {
-	data := []byte(`{"foo": "bar"}`)
-	path := filepath.Join(os.TempDir(), fmt.Sprintf("file.%d", time.Now().UnixNano()))
-	fh, err := os.Create(path)
-	if err != nil {
-		t.Error(err)
-	}
-	_, err = fh.Write(data)
-	if err != nil {
-		t.Error(err)
-	}
-
-	return fh
-}
-
-func TestConfigLoadWithGoodFile(t *testing.T) {
-	fh := createFileForTest(t)
-	path := fh.Name()
-	defer func() {
-		fh.Close()
-		os.Remove(path)
-	}()
-
-	// Create new config
-	conf, err := NewConfig()
-	if err != nil {
-		t.Fatalf("Expected no error but got %v", err)
-	}
-	// Load file source
-	if err := conf.Load(file.NewSource(
-		file.WithPath(path),
-	)); err != nil {
-		t.Fatalf("Expected no error but got %v", err)
 	}
 }
 
-func TestConfigLoadWithInvalidFile(t *testing.T) {
+func TestDefault(t *testing.T) {
-	fh := createFileForTest(t)
+	ctx := context.Background()
-	path := fh.Name()
+	conf := &Cfg{IntValue: 10}
-	defer func() {
+	blfn := func(ctx context.Context, cfg config.Config) error {
-		fh.Close()
+		conf, ok := cfg.Options().Struct.(*Cfg)
-		os.Remove(path)
+		if !ok {
-	}()
+			return fmt.Errorf("failed to get Struct from options: %v", cfg.Options())
+		}
+		conf.StringValue = "before_load"
+		return nil
+	}
+	alfn := func(ctx context.Context, cfg config.Config) error {
+		conf, ok := cfg.Options().Struct.(*Cfg)
+		if !ok {
+			return fmt.Errorf("failed to get Struct from options: %v", cfg.Options())
+		}
+		conf.StringValue = "after_load"
+		return nil
+	}
 
-	// Create new config
+	cfg := config.NewConfig(config.Struct(conf), config.BeforeLoad(blfn), config.AfterLoad(alfn))
-	conf, err := NewConfig()
+	if err := cfg.Init(); err != nil {
-	if err != nil {
+		t.Fatal(err)
-		t.Fatalf("Expected no error but got %v", err)
+	}
+	if err := cfg.Load(ctx); err != nil {
+		t.Fatal(err)
+	}
+	if conf.StringValue != "after_load" {
+		t.Fatal("AfterLoad option not working")
 	}
-	// Load file source
-	err = conf.Load(file.NewSource(
-		file.WithPath(path),
-		file.WithPath("/i/do/not/exists.json"),
-	))
 
-	if err == nil {
+	t.Logf("%#+v\n", conf)
-		t.Fatal("Expected error but none !")
-	}
-	if !strings.Contains(fmt.Sprintf("%v", err), "/i/do/not/exists.json") {
-		t.Fatalf("Expected error to contain the unexisting file but got %v", err)
-	}
-}
-
-func TestConfigMerge(t *testing.T) {
-	fh := createFileForIssue18(t, `{
-  "amqp": {
-    "host": "rabbit.platform",
-    "port": 80
-  },
-  "handler": {
-    "exchange": "springCloudBus"
-  }
-}`)
-	path := fh.Name()
-	defer func() {
-		fh.Close()
-		os.Remove(path)
-	}()
-	os.Setenv("AMQP_HOST", "rabbit.testing.com")
-
-	conf, err := NewConfig()
-	if err != nil {
-		t.Fatalf("Expected no error but got %v", err)
-	}
-	if err := conf.Load(
-		file.NewSource(
-			file.WithPath(path),
-		),
-		env.NewSource(),
-	); err != nil {
-		t.Fatalf("Expected no error but got %v", err)
-	}
-
-	actualHost := conf.Get("amqp", "host").String("backup")
-	if actualHost != "rabbit.testing.com" {
-		t.Fatalf("Expected %v but got %v",
-			"rabbit.testing.com",
-			actualHost)
-	}
-}
-
-func equalS(t *testing.T, actual, expect string) {
-	if actual != expect {
-		t.Errorf("Expected %s but got %s", actual, expect)
-	}
-}
-
-func TestConfigWatcherDirtyOverrite(t *testing.T) {
-	n := runtime.GOMAXPROCS(0)
-	defer runtime.GOMAXPROCS(n)
-
-	runtime.GOMAXPROCS(1)
-
-	l := 100
-
-	ss := make([]source.Source, l)
-
-	for i := 0; i < l; i++ {
-		ss[i] = memory.NewSource(memory.WithJSON([]byte(fmt.Sprintf(`{"key%d": "val%d"}`, i, i))))
-	}
-
-	conf, _ := NewConfig()
-
-	for _, s := range ss {
-		_ = conf.Load(s)
-	}
-	runtime.Gosched()
-
-	for i := range ss {
-		k := fmt.Sprintf("key%d", i)
-		v := fmt.Sprintf("val%d", i)
-		equalS(t, conf.Get(k).String(""), v)
-	}
 }

config/encoder/encoder.go

@@ -1,8 +0,0 @@
-// Package encoder handles source encoding formats
-package encoder
-
-type Encoder interface {
-	Encode(interface{}) ([]byte, error)
-	Decode([]byte, interface{}) error
-	String() string
-}

config/encoder/hcl/hcl.go

@@ -1,26 +0,0 @@
-package hcl
-
-import (
-	"encoding/json"
-
-	"github.com/hashicorp/hcl"
-	"github.com/unistack-org/micro/v3/config/encoder"
-)
-
-type hclEncoder struct{}
-
-func (h hclEncoder) Encode(v interface{}) ([]byte, error) {
-	return json.Marshal(v)
-}
-
-func (h hclEncoder) Decode(d []byte, v interface{}) error {
-	return hcl.Unmarshal(d, v)
-}
-
-func (h hclEncoder) String() string {
-	return "hcl"
-}
-
-func NewEncoder() encoder.Encoder {
-	return hclEncoder{}
-}

config/encoder/json/json.go

@@ -1,25 +0,0 @@
-package json
-
-import (
-	"encoding/json"
-
-	"github.com/unistack-org/micro/v3/config/encoder"
-)
-
-type jsonEncoder struct{}
-
-func (j jsonEncoder) Encode(v interface{}) ([]byte, error) {
-	return json.Marshal(v)
-}
-
-func (j jsonEncoder) Decode(d []byte, v interface{}) error {
-	return json.Unmarshal(d, v)
-}
-
-func (j jsonEncoder) String() string {
-	return "json"
-}
-
-func NewEncoder() encoder.Encoder {
-	return jsonEncoder{}
-}

config/encoder/toml/toml.go

@@ -1,32 +0,0 @@
-package toml
-
-import (
-	"bytes"
-
-	"github.com/BurntSushi/toml"
-	"github.com/unistack-org/micro/v3/config/encoder"
-)
-
-type tomlEncoder struct{}
-
-func (t tomlEncoder) Encode(v interface{}) ([]byte, error) {
-	b := bytes.NewBuffer(nil)
-	defer b.Reset()
-	err := toml.NewEncoder(b).Encode(v)
-	if err != nil {
-		return nil, err
-	}
-	return b.Bytes(), nil
-}
-
-func (t tomlEncoder) Decode(d []byte, v interface{}) error {
-	return toml.Unmarshal(d, v)
-}
-
-func (t tomlEncoder) String() string {
-	return "toml"
-}
-
-func NewEncoder() encoder.Encoder {
-	return tomlEncoder{}
-}

config/encoder/xml/xml.go

@@ -1,25 +0,0 @@
-package xml
-
-import (
-	"encoding/xml"
-
-	"github.com/unistack-org/micro/v3/config/encoder"
-)
-
-type xmlEncoder struct{}
-
-func (x xmlEncoder) Encode(v interface{}) ([]byte, error) {
-	return xml.Marshal(v)
-}
-
-func (x xmlEncoder) Decode(d []byte, v interface{}) error {
-	return xml.Unmarshal(d, v)
-}
-
-func (x xmlEncoder) String() string {
-	return "xml"
-}
-
-func NewEncoder() encoder.Encoder {
-	return xmlEncoder{}
-}

config/encoder/yaml/yaml.go

@@ -1,24 +0,0 @@
-package yaml
-
-import (
-	"github.com/ghodss/yaml"
-	"github.com/unistack-org/micro/v3/config/encoder"
-)
-
-type yamlEncoder struct{}
-
-func (y yamlEncoder) Encode(v interface{}) ([]byte, error) {
-	return yaml.Marshal(v)
-}
-
-func (y yamlEncoder) Decode(d []byte, v interface{}) error {
-	return yaml.Unmarshal(d, v)
-}
-
-func (y yamlEncoder) String() string {
-	return "yaml"
-}
-
-func NewEncoder() encoder.Encoder {
-	return yamlEncoder{}
-}

config/loader/loader.go

@@ -1,63 +0,0 @@
-// package loader manages loading from multiple sources
-package loader
-
-import (
-	"context"
-
-	"github.com/unistack-org/micro/v3/config/reader"
-	"github.com/unistack-org/micro/v3/config/source"
-)
-
-// Loader manages loading sources
-type Loader interface {
-	// Stop the loader
-	Close() error
-	// Load the sources
-	Load(...source.Source) error
-	// A Snapshot of loaded config
-	Snapshot() (*Snapshot, error)
-	// Force sync of sources
-	Sync() error
-	// Watch for changes
-	Watch(...string) (Watcher, error)
-	// Name of loader
-	String() string
-}
-
-// Watcher lets you watch sources and returns a merged ChangeSet
-type Watcher interface {
-	// First call to next may return the current Snapshot
-	// If you are watching a path then only the data from
-	// that path is returned.
-	Next() (*Snapshot, error)
-	// Stop watching for changes
-	Stop() error
-}
-
-// Snapshot is a merged ChangeSet
-type Snapshot struct {
-	// The merged ChangeSet
-	ChangeSet *source.ChangeSet
-	// Deterministic and comparable version of the snapshot
-	Version string
-}
-
-type Options struct {
-	Reader reader.Reader
-	Source []source.Source
-
-	// for alternative data
-	Context context.Context
-}
-
-type Option func(o *Options)
-
-// Copy snapshot
-func Copy(s *Snapshot) *Snapshot {
-	cs := *(s.ChangeSet)
-
-	return &Snapshot{
-		ChangeSet: &cs,
-		Version:   s.Version,
-	}
-}

config/options.go

@@ -1,28 +1,142 @@
 package config
 
 import (
-	"github.com/unistack-org/micro/v3/config/loader"
+	"context"
-	"github.com/unistack-org/micro/v3/config/reader"
+
-	"github.com/unistack-org/micro/v3/config/source"
+	"github.com/unistack-org/micro/v3/codec"
+	"github.com/unistack-org/micro/v3/logger"
+	"github.com/unistack-org/micro/v3/meter"
+	"github.com/unistack-org/micro/v3/tracer"
 )
 
-// WithLoader sets the loader for manager config
+// Options hold the config options
-func WithLoader(l loader.Loader) Option {
+type Options struct {
+	// Struct holds the destination config struct
+	Struct interface{}
+	// Codec that used for load/save
+	Codec codec.Codec
+	// Tracer that will be used
+	Tracer tracer.Tracer
+	// Meter that will be used
+	Meter meter.Meter
+	// Logger that will be used
+	Logger logger.Logger
+	// Context used for external options
+	Context context.Context
+	// Name of the config
+	Name string
+	// StructTag name
+	StructTag string
+	// BeforeSave contains slice of funcs that runs before save
+	BeforeSave []func(context.Context, Config) error
+	// AfterLoad contains slice of funcs that runs after load
+	AfterLoad []func(context.Context, Config) error
+	// BeforeLoad contains slice of funcs that runs before load
+	BeforeLoad []func(context.Context, Config) error
+	// AfterSave contains slice of funcs that runs after save
+	AfterSave []func(context.Context, Config) error
+	// AllowFail flag to allow fail in config source
+	AllowFail bool
+}
+
+// Option function signature
+type Option func(o *Options)
+
+// NewOptions new options struct with filed values
+func NewOptions(opts ...Option) Options {
+	options := Options{
+		Logger:  logger.DefaultLogger,
+		Meter:   meter.DefaultMeter,
+		Tracer:  tracer.DefaultTracer,
+		Context: context.Background(),
+	}
+	for _, o := range opts {
+		o(&options)
+	}
+
+	return options
+}
+
+// AllowFail allows config source to fail
+func AllowFail(b bool) Option {
 	return func(o *Options) {
-		o.Loader = l
+		o.AllowFail = b
 	}
 }
 
-// WithSource appends a source to list of sources
+// BeforeLoad run funcs before config load
-func WithSource(s source.Source) Option {
+func BeforeLoad(fn ...func(context.Context, Config) error) Option {
 	return func(o *Options) {
-		o.Source = append(o.Source, s)
+		o.BeforeLoad = fn
 	}
 }
 
-// WithReader sets the config reader
+// AfterLoad run funcs after config load
-func WithReader(r reader.Reader) Option {
+func AfterLoad(fn ...func(context.Context, Config) error) Option {
 	return func(o *Options) {
-		o.Reader = r
+		o.AfterLoad = fn
+	}
+}
+
+// BeforeSave run funcs before save
+func BeforeSave(fn ...func(context.Context, Config) error) Option {
+	return func(o *Options) {
+		o.BeforeSave = fn
+	}
+}
+
+// AfterSave run fncs after save
+func AfterSave(fn ...func(context.Context, Config) error) Option {
+	return func(o *Options) {
+		o.AfterSave = fn
+	}
+}
+
+// Context pass context
+func Context(ctx context.Context) Option {
+	return func(o *Options) {
+		o.Context = ctx
+	}
+}
+
+// Codec sets the source codec
+func Codec(c codec.Codec) Option {
+	return func(o *Options) {
+		o.Codec = c
+	}
+}
+
+// Logger sets the logger
+func Logger(l logger.Logger) Option {
+	return func(o *Options) {
+		o.Logger = l
+	}
+}
+
+// Tracer to be used for tracing
+func Tracer(t tracer.Tracer) Option {
+	return func(o *Options) {
+		o.Tracer = t
+	}
+}
+
+// Struct used as config
+func Struct(v interface{}) Option {
+	return func(o *Options) {
+		o.Struct = v
+	}
+}
+
+// StructTag sets the struct tag that used for filling
+func StructTag(name string) Option {
+	return func(o *Options) {
+		o.StructTag = name
+	}
+}
+
+// Name sets the name
+func Name(n string) Option {
+	return func(o *Options) {
+		o.Name = n
 	}
 }

config/reader/options.go

@@ -1,50 +0,0 @@
-package reader
-
-import (
-	"github.com/unistack-org/micro/v3/config/encoder"
-	"github.com/unistack-org/micro/v3/config/encoder/hcl"
-	"github.com/unistack-org/micro/v3/config/encoder/json"
-	"github.com/unistack-org/micro/v3/config/encoder/toml"
-	"github.com/unistack-org/micro/v3/config/encoder/xml"
-	"github.com/unistack-org/micro/v3/config/encoder/yaml"
-)
-
-type Options struct {
-	Encoding              map[string]encoder.Encoder
-	DisableReplaceEnvVars bool
-}
-
-type Option func(o *Options)
-
-func NewOptions(opts ...Option) Options {
-	options := Options{
-		Encoding: map[string]encoder.Encoder{
-			"json": json.NewEncoder(),
-			"yaml": yaml.NewEncoder(),
-			"toml": toml.NewEncoder(),
-			"xml":  xml.NewEncoder(),
-			"hcl":  hcl.NewEncoder(),
-			"yml":  yaml.NewEncoder(),
-		},
-	}
-	for _, o := range opts {
-		o(&options)
-	}
-	return options
-}
-
-func WithEncoder(e encoder.Encoder) Option {
-	return func(o *Options) {
-		if o.Encoding == nil {
-			o.Encoding = make(map[string]encoder.Encoder)
-		}
-		o.Encoding[e.String()] = e
-	}
-}
-
-// WithDisableReplaceEnvVars disables the environment variable interpolation preprocessor
-func WithDisableReplaceEnvVars() Option {
-	return func(o *Options) {
-		o.DisableReplaceEnvVars = true
-	}
-}

config/reader/preprocessor.go

@@ -1,23 +0,0 @@
-package reader
-
-import (
-	"os"
-	"regexp"
-)
-
-func ReplaceEnvVars(raw []byte) ([]byte, error) {
-	re := regexp.MustCompile(`\$\{([A-Za-z0-9_]+)\}`)
-	if re.Match(raw) {
-		dataS := string(raw)
-		res := re.ReplaceAllStringFunc(dataS, replaceEnvVars)
-		return []byte(res), nil
-	} else {
-		return raw, nil
-	}
-}
-
-func replaceEnvVars(element string) string {
-	v := element[2 : len(element)-1]
-	el := os.Getenv(v)
-	return el
-}

config/reader/preprocessor_test.go

@@ -1,73 +0,0 @@
-package reader
-
-import (
-	"os"
-	"strings"
-	"testing"
-)
-
-func TestReplaceEnvVars(t *testing.T) {
-	os.Setenv("myBar", "cat")
-	os.Setenv("MYBAR", "cat")
-	os.Setenv("my_Bar", "cat")
-	os.Setenv("myBar_", "cat")
-
-	testData := []struct {
-		expected string
-		data     []byte
-	}{
-		// Right use cases
-		{
-			`{"foo": "bar", "baz": {"bar": "cat"}}`,
-			[]byte(`{"foo": "bar", "baz": {"bar": "${myBar}"}}`),
-		},
-		{
-			`{"foo": "bar", "baz": {"bar": "cat"}}`,
-			[]byte(`{"foo": "bar", "baz": {"bar": "${MYBAR}"}}`),
-		},
-		{
-			`{"foo": "bar", "baz": {"bar": "cat"}}`,
-			[]byte(`{"foo": "bar", "baz": {"bar": "${my_Bar}"}}`),
-		},
-		{
-			`{"foo": "bar", "baz": {"bar": "cat"}}`,
-			[]byte(`{"foo": "bar", "baz": {"bar": "${myBar_}"}}`),
-		},
-		// Wrong use cases
-		{
-			`{"foo": "bar", "baz": {"bar": "${myBar-}"}}`,
-			[]byte(`{"foo": "bar", "baz": {"bar": "${myBar-}"}}`),
-		},
-		{
-			`{"foo": "bar", "baz": {"bar": "${}"}}`,
-			[]byte(`{"foo": "bar", "baz": {"bar": "${}"}}`),
-		},
-		{
-			`{"foo": "bar", "baz": {"bar": "$sss}"}}`,
-			[]byte(`{"foo": "bar", "baz": {"bar": "$sss}"}}`),
-		},
-		{
-			`{"foo": "bar", "baz": {"bar": "${sss"}}`,
-			[]byte(`{"foo": "bar", "baz": {"bar": "${sss"}}`),
-		},
-		{
-			`{"foo": "bar", "baz": {"bar": "{something}"}}`,
-			[]byte(`{"foo": "bar", "baz": {"bar": "{something}"}}`),
-		},
-		// Use cases without replace env vars
-		{
-			`{"foo": "bar", "baz": {"bar": "cat"}}`,
-			[]byte(`{"foo": "bar", "baz": {"bar": "cat"}}`),
-		},
-	}
-
-	for _, test := range testData {
-		res, err := ReplaceEnvVars(test.data)
-		if err != nil {
-			t.Fatal(err)
-		}
-		if strings.Compare(test.expected, string(res)) != 0 {
-			t.Fatalf("Expected %s got %s", test.expected, res)
-		}
-	}
-}

config/reader/reader.go

@@ -1,38 +0,0 @@
-// Package reader parses change sets and provides config values
-package reader
-
-import (
-	"time"
-
-	"github.com/unistack-org/micro/v3/config/source"
-)
-
-// Reader is an interface for merging changesets
-type Reader interface {
-	Merge(...*source.ChangeSet) (*source.ChangeSet, error)
-	Values(*source.ChangeSet) (Values, error)
-	String() string
-}
-
-// Values is returned by the reader
-type Values interface {
-	Bytes() []byte
-	Get(path ...string) (Value, error)
-	Set(val interface{}, path ...string) error
-	Del(path ...string) error
-	Map() map[string]interface{}
-	Scan(v interface{}) error
-}
-
-// Value represents a value of any type
-type Value interface {
-	Bool(def bool) bool
-	Int(def int) int
-	String(def string) string
-	Float64(def float64) float64
-	Duration(def time.Duration) time.Duration
-	StringSlice(def []string) []string
-	StringMap(def map[string]string) map[string]string
-	Scan(val interface{}) error
-	Bytes() []byte
-}

config/reflect_test.go

@@ -0,0 +1,26 @@
+package config_test
+
+import (
+	"testing"
+
+	rutil "github.com/unistack-org/micro/v3/util/reflect"
+)
+
+type Config struct {
+	Value     string
+	SubConfig *SubConfig
+	Config    *Config
+}
+
+type SubConfig struct {
+	Value string
+}
+
+func TestReflect(t *testing.T) {
+	cfg1 := &Config{Value: "cfg1", Config: &Config{Value: "cfg1_1"}, SubConfig: &SubConfig{Value: "cfg1"}}
+	cfg2, err := rutil.Zero(cfg1)
+	if err != nil {
+		t.Fatal(err)
+	}
+	t.Logf("dst: %#+v\n", cfg2)
+}

config/source/changeset.go

@@ -1,13 +0,0 @@
-package source
-
-import (
-	"crypto/md5"
-	"fmt"
-)
-
-// Sum returns the md5 checksum of the ChangeSet data
-func (c *ChangeSet) Sum() string {
-	h := md5.New()
-	h.Write(c.Data)
-	return fmt.Sprintf("%x", h.Sum(nil))
-}

config/source/noop.go

@@ -1,25 +0,0 @@
-package source
-
-import (
-	"errors"
-)
-
-type noopWatcher struct {
-	exit chan struct{}
-}
-
-func (w *noopWatcher) Next() (*ChangeSet, error) {
-	<-w.exit
-
-	return nil, errors.New("noopWatcher stopped")
-}
-
-func (w *noopWatcher) Stop() error {
-	close(w.exit)
-	return nil
-}
-
-// NewNoopWatcher returns a watcher that blocks on Next() until Stop() is called.
-func NewNoopWatcher() (Watcher, error) {
-	return &noopWatcher{exit: make(chan struct{})}, nil
-}

config/source/options.go

@@ -1,49 +0,0 @@
-package source
-
-import (
-	"context"
-
-	"github.com/unistack-org/micro/v3/client"
-	"github.com/unistack-org/micro/v3/config/encoder"
-	"github.com/unistack-org/micro/v3/config/encoder/json"
-)
-
-type Options struct {
-	// Encoder
-	Encoder encoder.Encoder
-
-	// for alternative data
-	Context context.Context
-
-	// Client to use for RPC
-	Client client.Client
-}
-
-type Option func(o *Options)
-
-func NewOptions(opts ...Option) Options {
-	options := Options{
-		Encoder: json.NewEncoder(),
-		Context: context.Background(),
-	}
-
-	for _, o := range opts {
-		o(&options)
-	}
-
-	return options
-}
-
-// WithEncoder sets the source encoder
-func WithEncoder(e encoder.Encoder) Option {
-	return func(o *Options) {
-		o.Encoder = e
-	}
-}
-
-// WithClient sets the source client
-func WithClient(c client.Client) Option {
-	return func(o *Options) {
-		o.Client = c
-	}
-}

config/source/source.go

@@ -1,35 +0,0 @@
-// Package source is the interface for sources
-package source
-
-import (
-	"errors"
-	"time"
-)
-
-var (
-	// ErrWatcherStopped is returned when source watcher has been stopped
-	ErrWatcherStopped = errors.New("watcher stopped")
-)
-
-// Source is the source from which config is loaded
-type Source interface {
-	Read() (*ChangeSet, error)
-	Write(*ChangeSet) error
-	Watch() (Watcher, error)
-	String() string
-}
-
-// ChangeSet represents a set of changes from a source
-type ChangeSet struct {
-	Data      []byte
-	Checksum  string
-	Format    string
-	Source    string
-	Timestamp time.Time
-}
-
-// Watcher watches a source for changes
-type Watcher interface {
-	Next() (*ChangeSet, error)
-	Stop() error
-}

config/value.go

@@ -1,49 +0,0 @@
-package config
-
-import (
-	"time"
-
-	"github.com/unistack-org/micro/v3/config/reader"
-)
-
-type value struct{}
-
-func newValue() reader.Value {
-	return new(value)
-}
-
-func (v *value) Bool(def bool) bool {
-	return false
-}
-
-func (v *value) Int(def int) int {
-	return 0
-}
-
-func (v *value) String(def string) string {
-	return ""
-}
-
-func (v *value) Float64(def float64) float64 {
-	return 0.0
-}
-
-func (v *value) Duration(def time.Duration) time.Duration {
-	return time.Duration(0)
-}
-
-func (v *value) StringSlice(def []string) []string {
-	return nil
-}
-
-func (v *value) StringMap(def map[string]string) map[string]string {
-	return map[string]string{}
-}
-
-func (v *value) Scan(val interface{}) error {
-	return nil
-}
-
-func (v *value) Bytes() []byte {
-	return nil
-}

context.go

@@ -0,0 +1,22 @@
+package micro
+
+import "context"
+
+type serviceKey struct{}
+
+// FromContext retrieves a Service from the Context.
+func FromContext(ctx context.Context) (Service, bool) {
+	if ctx == nil {
+		return nil, false
+	}
+	s, ok := ctx.Value(serviceKey{}).(Service)
+	return s, ok
+}
+
+// NewContext returns a new Context with the Service embedded within it.
+func NewContext(ctx context.Context, s Service) context.Context {
+	if ctx == nil {
+		ctx = context.Background()
+	}
+	return context.WithValue(ctx, serviceKey{}, s)
+}

debug/debug.go

@@ -1,2 +0,0 @@
-// Package debug provides interfaces for service debugging
-package debug

debug/log/kubernetes/kubernetes.go

@@ -1,189 +0,0 @@
-// Package kubernetes is a logger implementing (github.com/unistack-org/micro/v3/debug/log).Log
-package kubernetes
-
-import (
-	"bufio"
-	"encoding/json"
-	"fmt"
-	"os"
-	"sort"
-	"strconv"
-	"time"
-
-	"github.com/unistack-org/micro/v3/debug/log"
-	"github.com/unistack-org/micro/v3/util/kubernetes/client"
-)
-
-type klog struct {
-	client client.Client
-
-	log.Options
-}
-
-func (k *klog) podLogStream(podName string, stream *kubeStream) {
-	p := make(map[string]string)
-	p["follow"] = "true"
-
-	// get the logs for the pod
-	body, err := k.client.Log(&client.Resource{
-		Name: podName,
-		Kind: "pod",
-	}, client.LogParams(p))
-
-	if err != nil {
-		fmt.Fprintf(os.Stderr, "%v", err)
-		return
-	}
-
-	s := bufio.NewScanner(body)
-	defer body.Close()
-
-	for {
-		select {
-		case <-stream.stop:
-			return
-		default:
-			if s.Scan() {
-				record := k.parse(s.Text())
-				stream.stream <- record
-			} else {
-				// TODO: is there a blocking call
-				// rather than a sleep loop?
-				time.Sleep(time.Second)
-			}
-		}
-	}
-}
-
-func (k *klog) getMatchingPods() ([]string, error) {
-	r := &client.Resource{
-		Kind:  "pod",
-		Value: new(client.PodList),
-	}
-
-	l := make(map[string]string)
-
-	l["name"] = client.Format(k.Options.Name)
-	// TODO: specify micro:service
-	// l["micro"] = "service"
-
-	if err := k.client.Get(r, client.GetLabels(l)); err != nil {
-		return nil, err
-	}
-
-	var matches []string
-
-	for _, p := range r.Value.(*client.PodList).Items {
-		// find labels that match the name
-		if p.Metadata.Labels["name"] == client.Format(k.Options.Name) {
-			matches = append(matches, p.Metadata.Name)
-		}
-	}
-
-	return matches, nil
-}
-
-func (k *klog) parse(line string) log.Record {
-	record := log.Record{}
-
-	if err := json.Unmarshal([]byte(line), &record); err != nil {
-		record.Timestamp = time.Now().UTC()
-		record.Message = line
-		record.Metadata = make(map[string]string)
-	}
-
-	record.Metadata["service"] = k.Options.Name
-
-	return record
-}
-
-func (k *klog) Read(options ...log.ReadOption) ([]log.Record, error) {
-	opts := &log.ReadOptions{}
-	for _, o := range options {
-		o(opts)
-	}
-	pods, err := k.getMatchingPods()
-	if err != nil {
-		return nil, err
-	}
-
-	var records []log.Record
-
-	for _, pod := range pods {
-		logParams := make(map[string]string)
-
-		if !opts.Since.Equal(time.Time{}) {
-			logParams["sinceSeconds"] = strconv.Itoa(int(time.Since(opts.Since).Seconds()))
-		}
-
-		if opts.Count != 0 {
-			logParams["tailLines"] = strconv.Itoa(opts.Count)
-		}
-
-		if opts.Stream {
-			logParams["follow"] = "true"
-		}
-
-		logs, err := k.client.Log(&client.Resource{
-			Name: pod,
-			Kind: "pod",
-		}, client.LogParams(logParams))
-
-		if err != nil {
-			return nil, err
-		}
-		defer logs.Close()
-
-		s := bufio.NewScanner(logs)
-
-		for s.Scan() {
-			record := k.parse(s.Text())
-			record.Metadata["pod"] = pod
-			records = append(records, record)
-		}
-	}
-
-	// sort the records
-	sort.Slice(records, func(i, j int) bool { return records[i].Timestamp.Before(records[j].Timestamp) })
-
-	return records, nil
-}
-
-func (k *klog) Write(l log.Record) error {
-	return write(l)
-}
-
-func (k *klog) Stream() (log.Stream, error) {
-	// find the matching pods
-	pods, err := k.getMatchingPods()
-	if err != nil {
-		return nil, err
-	}
-
-	stream := &kubeStream{
-		stream: make(chan log.Record),
-		stop:   make(chan bool),
-	}
-
-	// stream from the individual pods
-	for _, pod := range pods {
-		go k.podLogStream(pod, stream)
-	}
-
-	return stream, nil
-}
-
-// NewLog returns a configured Kubernetes logger
-func NewLog(opts ...log.Option) log.Log {
-	klog := &klog{}
-	for _, o := range opts {
-		o(&klog.Options)
-	}
-
-	if len(os.Getenv("KUBERNETES_SERVICE_HOST")) > 0 {
-		klog.client = client.NewClusterClient()
-	} else {
-		klog.client = client.NewLocalClient()
-	}
-	return klog
-}

debug/log/kubernetes/kubernetes_test.go

@@ -1,71 +0,0 @@
-package kubernetes
-
-import (
-	"bytes"
-	"encoding/json"
-	"io"
-	"os"
-	"testing"
-	"time"
-
-	"github.com/stretchr/testify/assert"
-	"github.com/unistack-org/micro/v3/debug/log"
-)
-
-func TestKubernetes(t *testing.T) {
-	if len(os.Getenv("INTEGRATION_TESTS")) > 0 {
-		t.Skip()
-	}
-
-	k := NewLog(log.Name("micro-network"))
-
-	r, w, err := os.Pipe()
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	s := os.Stderr
-	os.Stderr = w
-	meta := make(map[string]string)
-
-	write := log.Record{
-		Timestamp: time.Unix(0, 0).UTC(),
-		Message:   "Test log entry",
-		Metadata:  meta,
-	}
-
-	meta["foo"] = "bar"
-
-	k.Write(write)
-	b := &bytes.Buffer{}
-	w.Close()
-	io.Copy(b, r)
-	os.Stderr = s
-
-	var read log.Record
-
-	if err := json.Unmarshal(b.Bytes(), &read); err != nil {
-		t.Fatalf("json.Unmarshal failed: %s", err.Error())
-	}
-
-	assert.Equal(t, write, read, "Write was not equal")
-
-	records, err := k.Read()
-	assert.Nil(t, err, "Read should not error")
-	assert.NotNil(t, records, "Read should return records")
-
-	stream, err := k.Stream()
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	records = nil
-
-	go stream.Stop()
-
-	for s := range stream.Chan() {
-		records = append(records, s)
-	}
-
-	assert.Equal(t, 0, len(records), "Stream should return nothing")
-}

debug/log/kubernetes/stream.go

@@ -1,44 +0,0 @@
-package kubernetes
-
-import (
-	"encoding/json"
-	"fmt"
-	"os"
-	"sync"
-
-	"github.com/unistack-org/micro/v3/debug/log"
-)
-
-func write(l log.Record) error {
-	m, err := json.Marshal(l)
-	if err == nil {
-		_, err := fmt.Fprintf(os.Stderr, "%s", m)
-		return err
-	}
-	return err
-}
-
-type kubeStream struct {
-	// the k8s log stream
-	stream chan log.Record
-	sync.Mutex
-	// the stop chan
-	stop chan bool
-}
-
-func (k *kubeStream) Chan() <-chan log.Record {
-	return k.stream
-}
-
-func (k *kubeStream) Stop() error {
-	k.Lock()
-	defer k.Unlock()
-	select {
-	case <-k.stop:
-		return nil
-	default:
-		close(k.stop)
-		close(k.stream)
-	}
-	return nil
-}

debug/log/log.go

@@ -1,56 +0,0 @@
-// Package log provides debug logging
-package log
-
-import (
-	"encoding/json"
-	"fmt"
-	"time"
-)
-
-var (
-	// Default buffer size if any
-	DefaultSize = 256
-	// Default formatter
-	DefaultFormat = TextFormat
-)
-
-// Log is debug log interface for reading and writing logs
-type Log interface {
-	// Read reads log entries from the logger
-	Read(...ReadOption) ([]Record, error)
-	// Write writes records to log
-	Write(Record) error
-	// Stream log records
-	Stream() (Stream, error)
-}
-
-// Record is log record entry
-type Record struct {
-	// Timestamp of logged event
-	Timestamp time.Time `json:"timestamp"`
-	// Metadata to enrich log record
-	Metadata map[string]string `json:"metadata"`
-	// Value contains log entry
-	Message interface{} `json:"message"`
-}
-
-// Stream returns a log stream
-type Stream interface {
-	Chan() <-chan Record
-	Stop() error
-}
-
-// Format is a function which formats the output
-type FormatFunc func(Record) string
-
-// TextFormat returns text format
-func TextFormat(r Record) string {
-	t := r.Timestamp.Format("2006-01-02 15:04:05")
-	return fmt.Sprintf("%s %v", t, r.Message)
-}
-
-// JSONFormat is a json Format func
-func JSONFormat(r Record) string {
-	b, _ := json.Marshal(r)
-	return string(b)
-}

debug/log/memory/memory.go

@@ -1,115 +0,0 @@
-// Package memory provides an in memory log buffer
-package memory
-
-import (
-	"fmt"
-
-	"github.com/unistack-org/micro/v3/debug/log"
-	"github.com/unistack-org/micro/v3/metadata"
-	"github.com/unistack-org/micro/v3/util/ring"
-)
-
-// memoryLog is default micro log
-type memoryLog struct {
-	*ring.Buffer
-}
-
-// NewLog returns default Logger with
-func NewLog(opts ...log.Option) log.Log {
-	// get default options
-	options := log.DefaultOptions()
-
-	// apply requested options
-	for _, o := range opts {
-		o(&options)
-	}
-
-	return &memoryLog{
-		Buffer: ring.New(options.Size),
-	}
-}
-
-// Write writes logs into logger
-func (l *memoryLog) Write(r log.Record) error {
-	l.Buffer.Put(fmt.Sprint(r.Message))
-	return nil
-}
-
-// Read reads logs and returns them
-func (l *memoryLog) Read(opts ...log.ReadOption) ([]log.Record, error) {
-	options := log.ReadOptions{}
-	// initialize the read options
-	for _, o := range opts {
-		o(&options)
-	}
-
-	var entries []*ring.Entry
-	// if Since options ha sbeen specified we honor it
-	if !options.Since.IsZero() {
-		entries = l.Buffer.Since(options.Since)
-	}
-
-	// only if we specified valid count constraint
-	// do we end up doing some serious if-else kung-fu
-	// if since constraint has been provided
-	// we return *count* number of logs since the given timestamp;
-	// otherwise we return last count number of logs
-	if options.Count > 0 {
-		switch len(entries) > 0 {
-		case true:
-			// if we request fewer logs than what since constraint gives us
-			if options.Count < len(entries) {
-				entries = entries[0:options.Count]
-			}
-		default:
-			entries = l.Buffer.Get(options.Count)
-		}
-	}
-
-	records := make([]log.Record, 0, len(entries))
-	for _, entry := range entries {
-		record := log.Record{
-			Timestamp: entry.Timestamp,
-			Message:   entry.Value,
-		}
-		records = append(records, record)
-	}
-
-	return records, nil
-}
-
-// Stream returns channel for reading log records
-// along with a stop channel, close it when done
-func (l *memoryLog) Stream() (log.Stream, error) {
-	// get stream channel from ring buffer
-	stream, stop := l.Buffer.Stream()
-	// make a buffered channel
-	records := make(chan log.Record, 128)
-	// get last 10 records
-	last10 := l.Buffer.Get(10)
-
-	// stream the log records
-	go func() {
-		// first send last 10 records
-		for _, entry := range last10 {
-			records <- log.Record{
-				Timestamp: entry.Timestamp,
-				Message:   entry.Value,
-				Metadata:  metadata.New(0),
-			}
-		}
-		// now stream continuously
-		for entry := range stream {
-			records <- log.Record{
-				Timestamp: entry.Timestamp,
-				Message:   entry.Value,
-				Metadata:  metadata.New(0),
-			}
-		}
-	}()
-
-	return &logStream{
-		stream: records,
-		stop:   stop,
-	}, nil
-}

debug/log/memory/memory_test.go

@@ -1,32 +0,0 @@
-package memory
-
-import (
-	"reflect"
-	"testing"
-
-	"github.com/unistack-org/micro/v3/debug/log"
-)
-
-func TestLogger(t *testing.T) {
-	// set size to some value
-	size := 100
-	// override the global logger
-	lg := NewLog(log.Size(size))
-	// make sure we have the right size of the logger ring buffer
-	if lg.(*memoryLog).Size() != size {
-		t.Errorf("expected buffer size: %d, got: %d", size, lg.(*memoryLog).Size())
-	}
-
-	// Log some cruft
-	lg.Write(log.Record{Message: "foobar"})
-	lg.Write(log.Record{Message: "foo bar"})
-
-	// Check if the logs are stored in the logger ring buffer
-	expected := []string{"foobar", "foo bar"}
-	entries, _ := lg.Read(log.Count(len(expected)))
-	for i, entry := range entries {
-		if !reflect.DeepEqual(entry.Message, expected[i]) {
-			t.Errorf("expected %s, got %s", expected[i], entry.Message)
-		}
-	}
-}

debug/log/memory/stream.go

@@ -1,24 +0,0 @@
-package memory
-
-import (
-	"github.com/unistack-org/micro/v3/debug/log"
-)
-
-type logStream struct {
-	stream <-chan log.Record
-	stop   chan bool
-}
-
-func (l *logStream) Chan() <-chan log.Record {
-	return l.stream
-}
-
-func (l *logStream) Stop() error {
-	select {
-	case <-l.stop:
-		return nil
-	default:
-		close(l.stop)
-	}
-	return nil
-}

debug/log/noop/noop.go

@@ -1,23 +0,0 @@
-package noop
-
-import (
-	"github.com/unistack-org/micro/v3/debug/log"
-)
-
-type noop struct{}
-
-func (n *noop) Read(...log.ReadOption) ([]log.Record, error) {
-	return nil, nil
-}
-
-func (n *noop) Write(log.Record) error {
-	return nil
-}
-
-func (n *noop) Stream() (log.Stream, error) {
-	return nil, nil
-}
-
-func NewLog(opts ...log.Option) log.Log {
-	return new(noop)
-}

debug/log/options.go

@@ -1,70 +0,0 @@
-package log
-
-import "time"
-
-// Option used by the logger
-type Option func(*Options)
-
-// Options are logger options
-type Options struct {
-	// Name of the log
-	Name string
-	// Size is the size of ring buffer
-	Size int
-	// Format specifies the output format
-	Format FormatFunc
-}
-
-// Name of the log
-func Name(n string) Option {
-	return func(o *Options) {
-		o.Name = n
-	}
-}
-
-// Size sets the size of the ring buffer
-func Size(s int) Option {
-	return func(o *Options) {
-		o.Size = s
-	}
-}
-
-func Format(f FormatFunc) Option {
-	return func(o *Options) {
-		o.Format = f
-	}
-}
-
-// DefaultOptions returns default options
-func DefaultOptions() Options {
-	return Options{
-		Size: DefaultSize,
-	}
-}
-
-// ReadOptions for querying the logs
-type ReadOptions struct {
-	// Since what time in past to return the logs
-	Since time.Time
-	// Count specifies number of logs to return
-	Count int
-	// Stream requests continuous log stream
-	Stream bool
-}
-
-// ReadOption used for reading the logs
-type ReadOption func(*ReadOptions)
-
-// Since sets the time since which to return the log records
-func Since(s time.Time) ReadOption {
-	return func(o *ReadOptions) {
-		o.Since = s
-	}
-}
-
-// Count sets the number of log records to return
-func Count(c int) ReadOption {
-	return func(o *ReadOptions) {
-		o.Count = c
-	}
-}

debug/stats/memory/memory.go

@@ -1,89 +0,0 @@
-package stats
-
-import (
-	"runtime"
-	"sync"
-	"time"
-
-	"github.com/unistack-org/micro/v3/debug/stats"
-	"github.com/unistack-org/micro/v3/util/ring"
-)
-
-type memoryStats struct {
-	// used to store past stats
-	buffer *ring.Buffer
-
-	sync.RWMutex
-	started  int64
-	requests uint64
-	errors   uint64
-}
-
-func (s *memoryStats) snapshot() *stats.Stat {
-	s.RLock()
-	defer s.RUnlock()
-
-	var mstat runtime.MemStats
-	runtime.ReadMemStats(&mstat)
-
-	now := time.Now().Unix()
-
-	return &stats.Stat{
-		Timestamp: now,
-		Started:   s.started,
-		Uptime:    now - s.started,
-		Memory:    mstat.Alloc,
-		GC:        mstat.PauseTotalNs,
-		Threads:   uint64(runtime.NumGoroutine()),
-		Requests:  s.requests,
-		Errors:    s.errors,
-	}
-}
-
-func (s *memoryStats) Read() ([]*stats.Stat, error) {
-	buf := s.buffer.Get(s.buffer.Size())
-	var buffer []*stats.Stat
-
-	// get a value from the buffer if it exists
-	for _, b := range buf {
-		stat, ok := b.Value.(*stats.Stat)
-		if !ok {
-			continue
-		}
-		buffer = append(buffer, stat)
-	}
-
-	// get a snapshot
-	buffer = append(buffer, s.snapshot())
-
-	return buffer, nil
-}
-
-func (s *memoryStats) Write(stat *stats.Stat) error {
-	s.buffer.Put(stat)
-	return nil
-}
-
-func (s *memoryStats) Record(err error) error {
-	s.Lock()
-	defer s.Unlock()
-
-	// increment the total request count
-	s.requests++
-
-	// increment the error count
-	if err != nil {
-		s.errors++
-	}
-
-	return nil
-}
-
-// NewStats returns a new in memory stats buffer
-// TODO add options
-func NewStats() stats.Stats {
-	return &memoryStats{
-		started: time.Now().Unix(),
-		buffer:  ring.New(1),
-	}
-}