add noop broker and noop store (#30)

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

.github/FUNDING.yml

@@ -1,3 +0,0 @@
-# These are supported funding model platforms
-
-github: micro

.github/generate.sh

@@ -9,7 +9,7 @@ curl -s -o proto/google/api/http.proto -L https://raw.githubusercontent.com/goog
 
 for PROTO in $PROTOS; do
   echo $PROTO
-  protoc -I./proto -I. -I$(dirname $PROTO) --go_out=plugins=grpc,paths=source_relative:. --micro_out=paths=source_relative:. $PROTO
+  protoc -I./proto -I. -I$(dirname $PROTO) --go-grpc_out=paths=source_relative:. --go_out=paths=source_relative:. --micro_out=paths=source_relative:. $PROTO
 done
 
 rm -r proto

.github/stale.sh

@@ -0,0 +1,13 @@
+#!/bin/bash -ex
+
+export PATH=$PATH:$(pwd)/bin
+export GO111MODULE=on
+export GOBIN=$(pwd)/bin
+
+#go get github.com/rvflash/goup@v0.4.1
+
+#goup -v ./...
+#go get github.com/psampaz/go-mod-outdated@v0.6.0
+go list -u -m -mod=mod -json all | go-mod-outdated -update -direct -ci || true
+
+#go list -u -m -json all | go-mod-outdated -update

.github/workflows/build.yml

@@ -0,0 +1,46 @@
+name: build
+on:
+ push:
+    branches:
+    - master
+jobs:
+  test:
+    name: test
+    runs-on: ubuntu-latest
+    steps:
+    - name: setup
+      uses: actions/setup-go@v1
+      with:
+        go-version: 1.15
+    - name: checkout
+      uses: actions/checkout@v2
+    - name: cache
+      uses: actions/cache@v2
+      with:
+        path: ~/go/pkg/mod
+        key: ${{ runner.os }}-go-${{ hashFiles('**/go.sum') }}
+        restore-keys: ${{ runner.os }}-go-
+    - name: deps
+      run: go get -v -t -d ./...
+    - name: test
+      env:
+        INTEGRATION_TESTS: yes
+      run: go test -mod readonly -v ./...
+  lint:
+    name: lint
+    runs-on: ubuntu-latest
+    steps:
+      - name: checkout
+        uses: actions/checkout@v2
+      - name: lint
+        uses: golangci/golangci-lint-action@v1
+        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.
+          version: v1.30
+          # Optional: working directory, useful for monorepos
+          # working-directory: somedir
+          # Optional: golangci-lint command line arguments.
+          # args: --issues-exit-code=0
+          # Optional: show only new issues if it's a pull request. The default value is `false`.
+          # only-new-issues: true

.github/workflows/docker.yml

@@ -1,22 +0,0 @@
-name: Docker
-
-on:
-  push:
-    branches:
-    - master
-    tags:
-    - v2.*
-    - v3.*
-jobs:
-  build:
-     runs-on: ubuntu-latest
-     steps:
-       - uses: actions/checkout@v2
-         name: Check out repository
-       - uses: elgohr/Publish-Docker-Github-Action@2.12
-         name: Build and Push Docker Image
-         with:
-           name: micro/go-micro
-           username: ${{ secrets.DOCKER_USERNAME }}
-           password: ${{ secrets.DOCKER_PASSWORD }}
-           tag_names: true

.github/workflows/pr.yml

@@ -1,35 +1,46 @@
-name: PR Sanity Check
+name: prbuild
-on: pull_request
+on:
-
+  pull_request:
+    branches:
+    - master
 jobs:
-
+  test:
-  prtest:
+    name: test
-    name: PR sanity check
     runs-on: ubuntu-latest
     steps:
-
+    - name: setup
-    - name: Set up Go 1.13
       uses: actions/setup-go@v1
       with:
-        go-version: 1.13
+        go-version: 1.15
-      id: go
+    - name: checkout
-
-    - name: Check out code into the Go module directory
       uses: actions/checkout@v2
-
+    - name: cache
-    - name: Get dependencies
+      uses: actions/cache@v2
-      run: |
+      with:
-        go get -v -t -d ./...
+        path: ~/go/pkg/mod
-
+        key: ${{ runner.os }}-go-${{ hashFiles('**/go.sum') }}
-    - name: Run tests
+        restore-keys: ${{ runner.os }}-go-
-      id: tests
+    - name: deps
+      run: go get -v -t -d ./...
+    - name: test
       env:
-        IN_TRAVIS_CI: yes
+        INTEGRATION_TESTS: yes
-        S3_BLOB_STORE_REGION: ${{ secrets.SCALEWAY_REGION }}
+      run: go test -mod readonly -v ./...
-        S3_BLOB_STORE_ENDPOINT: ${{ secrets.SCALEWAY_ENDPOINT }}
+  lint:
-        S3_BLOB_STORE_ACCESS_KEY: ${{ secrets.SCALEWAY_ACCESS_KEY }}
+    name: lint
-        S3_BLOB_STORE_SECRET_KEY: ${{ secrets.SCALEWAY_SECRET_KEY }}
+    runs-on: ubuntu-latest
-      run: |
+    steps:
-        wget -qO- https://binaries.cockroachdb.com/cockroach-v20.1.4.linux-amd64.tgz | tar  xvz
+      - name: checkout
-        cockroach-v20.1.4.linux-amd64/cockroach start-single-node --insecure &
+        uses: actions/checkout@v2
-        go test -v ./...
+      - name: lint
+        uses: golangci/golangci-lint-action@v1
+        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.
+          version: v1.30
+          # Optional: working directory, useful for monorepos
+          # working-directory: somedir
+          # Optional: golangci-lint command line arguments.
+          # args: --issues-exit-code=0
+          # Optional: show only new issues if it's a pull request. The default value is `false`.
+          # only-new-issues: true

.github/workflows/scripts/build-all-examples.sh

@@ -1,41 +0,0 @@
-#!/bin/bash
-# set -x
-
-function build_binary {
-    echo building $1
-    pushd $1
-    go build -o _main
-    local ret=$?
-    if [ $ret -gt 0 ]; then 
-        failed=1
-        failed_arr+=($1)
-    fi
-    popd
-}
-
-function is_main {
-    grep "package main" -l -dskip $1/*.go > /dev/null 2>&1
-}
-
-
-function check_dir {
-    is_main $1
-    local ret=$?
-    if [ $ret == 0 ]; then
-        build_binary $1 $2
-    fi
-    for filename in $1/*; do
-        if [ -d $filename ]; then
-            check_dir $filename $2
-        fi
-    done
-}
-failed_arr=()
-failed=0
-go mod edit -replace github.com/micro/go-micro/v2=github.com/$2/v2@$1 
-check_dir . $1
-if [ $failed -gt 0 ]; then
-    echo Some builds failed
-    printf '%s\n' "${failed_arr[@]}"
-fi
-exit $failed

.github/workflows/scripts/build-micro.sh

@@ -1,19 +0,0 @@
-#!/bin/bash
-# set -x
-
-failed=0
-go mod edit -replace github.com/micro/go-micro/v2=github.com/$2/v2@$1 
-# basic test, build the binary
-go install
-failed=$?
-if [ $failed -gt 0 ]; then
-    exit $failed
-fi
-# unit tests
-IN_TRAVIS_CI=yes go test -v ./...
-
-./scripts/test-docker.sh
-# Generate keys for JWT tests
-ssh-keygen -f /tmp/sshkey -m pkcs8 -q -N ""
-ssh-keygen -f /tmp/sshkey -e  -m pkcs8 > /tmp/sshkey.pub
-go clean -testcache && IN_TRAVIS_CI=yes go test --tags=integration -v ./test

.github/workflows/tests.yml

@@ -1,48 +0,0 @@
-name: Run tests
-on: [push]
-
-jobs:
-
-  test:
-    name: Test repo
-    runs-on: ubuntu-latest
-    steps:
-    - name: Set up Go 1.13
-      uses: actions/setup-go@v1
-      with:
-        go-version: 1.13
-      id: go
-
-    - name: Setup Kind
-      uses: engineerd/setup-kind@v0.4.0
-      with:
-        version: v0.8.1
-
-    - name: Check out code into the Go module directory
-      uses: actions/checkout@v2
-
-    - name: Get dependencies
-      run: |
-        go get -v -t -d ./...
-
-    - name: Run tests
-      id: tests
-      env:
-        IN_TRAVIS_CI: yes
-        S3_BLOB_STORE_REGION: ${{ secrets.SCALEWAY_REGION }}
-        S3_BLOB_STORE_ENDPOINT: ${{ secrets.SCALEWAY_ENDPOINT }}
-        S3_BLOB_STORE_ACCESS_KEY: ${{ secrets.SCALEWAY_ACCESS_KEY }}
-        S3_BLOB_STORE_SECRET_KEY: ${{ secrets.SCALEWAY_SECRET_KEY }}
-      run: |
-        kubectl apply -f runtime/kubernetes/test/test.yaml
-        sudo mkdir -p /var/run/secrets/kubernetes.io/serviceaccount
-        sudo chmod 777 /var/run/secrets/kubernetes.io/serviceaccount
-        wget -qO- https://binaries.cockroachdb.com/cockroach-v20.1.4.linux-amd64.tgz | tar -xvz
-        cockroach-v20.1.4.linux-amd64/cockroach start-single-node --insecure &
-        wget -q https://github.com/nats-io/nats-streaming-server/releases/download/v0.18.0/nats-streaming-server-v0.18.0-linux-amd64.zip
-        unzip ./nats-streaming-server-v0.18.0-linux-amd64.zip
-        export PATH=$PATH:./nats-streaming-server-v0.18.0-linux-amd64
-        nats-streaming-server &
-        go test -tags kubernetes,nats -v ./...
-  
-

.golangci.yml

@@ -1,5 +1,11 @@
 run:
-  deadline: 10m
+  deadline: 5m
+  modules-download-mode: readonly
+  skip-dirs:
+    - util/mdns.new
+  skip-files:
+    - ".*\\.pb\\.go$"
+    - ".*\\.pb\\.micro\\.go$"
 linters:
   disable-all: false
   enable-all: false
@@ -24,3 +30,11 @@ 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

CNAME

@@ -1 +0,0 @@
-go-micro.dev

Dockerfile

@@ -1,13 +0,0 @@
-FROM golang:1.13-alpine
-
-RUN mkdir /user && \
-    echo 'nobody:x:65534:65534:nobody:/:' > /user/passwd && \
-    echo 'nobody:x:65534:' > /user/group
-
-ENV GO111MODULE=on
-RUN apk --no-cache add make git gcc libtool musl-dev ca-certificates dumb-init && \
-    rm -rf /var/cache/apk/* /tmp/*
-
-WORKDIR /
-COPY ./go.mod ./go.sum ./
-RUN go mod download && rm go.mod go.sum

LICENSE

@@ -176,7 +176,8 @@
 
    END OF TERMS AND CONDITIONS
 
-   Copyright 2015 Asim Aslam.
+   Copyright 2015-2020 Asim Aslam.
+   Copyright 2019-2020 Unistack LLC.
 
    Licensed under the Apache License, Version 2.0 (the "License");
    you may not use this file except in compliance with the License.

README.md

@@ -1,16 +1,14 @@
-# Go Micro [![License](https://img.shields.io/:license-apache-blue.svg)](https://opensource.org/licenses/Apache-2.0) [![Go.Dev reference](https://img.shields.io/badge/go.dev-reference-007d9c?logo=go&logoColor=white&style=flat-square)](https://pkg.go.dev/github.com/micro/go-micro/v3?tab=overview) [![Travis CI](https://api.travis-ci.org/micro/go-micro.svg?branch=master)](https://travis-ci.org/micro/go-micro) [![Go Report Card](https://goreportcard.com/badge/micro/go-micro)](https://goreportcard.com/report/github.com/micro/go-micro) 
+# Micro [![License](https://img.shields.io/:license-apache-blue.svg)](https://opensource.org/licenses/Apache-2.0) [![Doc](https://img.shields.io/badge/go.dev-reference-007d9c?logo=go&logoColor=white&style=flat-square)](https://pkg.go.dev/github.com/unistack-org/micro/v3?tab=overview) [![Status](https://github.com/unistack-org/micro/workflows/build/badge.svg?branch=master)](https://github.com/unistack-org/micro/actions?query=workflow%3Abuild+branch%3Amaster+event%3Apush) [![Lint](https://goreportcard.com/badge/github.com/unistack-org/micro)](https://goreportcard.com/report/github.com/unistack-org/micro)
 
-Go Micro is a standard library for microservices.
+Micro is a standard library for microservices.
 
 ## Overview
 
-Go Micro provides the core requirements for distributed systems development including RPC and Event driven communication. 
+Micro provides the core requirements for distributed systems development including RPC and Event driven communication. 
-The **Micro** philosophy is sane defaults with a pluggable architecture. We provide defaults to get you started quickly 
-but everything can be easily swapped out. 
 
 ## Features
 
-Go Micro abstracts away the details of distributed systems. Here are the main features.
+Micro abstracts away the details of distributed systems. Here are the main features.
 
 - **Authentication** - Auth is built in as a first class citizen. Authentication and authorization enable secure 
 zero trust networking by providing every service an identity and certificates. This additionally includes rule 
@@ -23,8 +21,7 @@ level config from any source such as env vars, file, etcd. You can merge the sou
 CockroachDB by default. State and persistence becomes a core requirement beyond prototyping and Micro looks to build that into the framework.
 
 - **Service Discovery** - Automatic service registration and name resolution. Service discovery is at the core of micro service 
-development. When service A needs to speak to service B it needs the location of that service. The default discovery mechanism is 
+development. When service A needs to speak to service B it needs the location of that service.
-multicast DNS (mdns), a zeroconf system.
 
 - **Load Balancing** - Client side load balancing built on service discovery. Once we have the addresses of any number of instances 
 of a service we now need a way to decide which node to route to. We use random hashed load balancing to provide even distribution 
@@ -32,25 +29,24 @@ across the services and retry a different node if there's a problem.
 
 - **Message Encoding** - Dynamic message encoding based on content-type. The client and server will use codecs along with content-type 
 to seamlessly encode and decode Go types for you. Any variety of messages could be encoded and sent from different clients. The client 
-and server handle this by default. This includes protobuf and json by default.
+and server handle this by default.
 
-- **gRPC Transport** - gRPC based request/response with support for bidirectional streaming. We provide an abstraction for synchronous communication. A request made to a service will be automatically resolved, load balanced, dialled and streamed.
+- **Transport** - gRPC or http based request/response with support for bidirectional streaming. We provide an abstraction for synchronous communication. A request made to a service will be automatically resolved, load balanced, dialled and streamed.
 
-- **Async Messaging** - PubSub is built in as a first class citizen for asynchronous communication and event driven architectures. 
+- **Async Messaging** - PubSub is built in as a first class citizen for asynchronous communication and event driven architectures.
-Event notifications are a core pattern in micro service development. The default messaging system is a HTTP event message broker.
+Event notifications are a core pattern in micro service development.
 
 - **Synchronization** - Distributed systems are often built in an eventually consistent manner. Support for distributed locking and 
 leadership are built in as a Sync interface. When using an eventually consistent database or scheduling use the Sync interface.
 
-- **Pluggable Interfaces** - Go Micro makes use of Go interfaces for each distributed system abstraction. Because of this these interfaces 
+- **Pluggable Interfaces** - Micro makes use of Go interfaces for each system abstraction. Because of this these interfaces 
-are pluggable and allows Go Micro to be runtime agnostic. You can plugin any underlying technology. Find plugins in 
+are pluggable and allows Micro to be runtime agnostic.
-[github.com/micro/go-plugins](https://github.com/micro/go-plugins).
 
 ## Getting Started
 
-See [pkg.go.dev](https://pkg.go.dev/github.com/micro/go-micro/v3?tab=overview) for usage.
+To be created.
 
 ## License
 
-Go Micro is Apache 2.0 licensed.
+Micro is Apache 2.0 licensed.
 

_config.yml

@@ -1 +0,0 @@
-theme: jekyll-theme-architect

api/api.go

@@ -5,8 +5,8 @@ import (
 	"regexp"
 	"strings"
 
-	"github.com/micro/go-micro/v3/registry"
+	"github.com/unistack-org/micro/v3/registry"
-	"github.com/micro/go-micro/v3/server"
+	"github.com/unistack-org/micro/v3/server"
 )
 
 type Api interface {

api/handler/api/api.go

@@ -4,13 +4,13 @@ package api
 import (
 	"net/http"
 
-	goapi "github.com/micro/go-micro/v3/api"
+	goapi "github.com/unistack-org/micro/v3/api"
-	"github.com/micro/go-micro/v3/api/handler"
+	"github.com/unistack-org/micro/v3/api/handler"
-	api "github.com/micro/go-micro/v3/api/proto"
+	api "github.com/unistack-org/micro/v3/api/proto"
-	"github.com/micro/go-micro/v3/client"
+	"github.com/unistack-org/micro/v3/client"
-	"github.com/micro/go-micro/v3/errors"
+	"github.com/unistack-org/micro/v3/errors"
-	"github.com/micro/go-micro/v3/util/ctx"
+	"github.com/unistack-org/micro/v3/util/ctx"
-	"github.com/micro/go-micro/v3/util/router"
+	"github.com/unistack-org/micro/v3/util/router"
 )
 
 type apiHandler struct {

api/handler/api/util.go

@@ -7,8 +7,8 @@ import (
 	"net/http"
 	"strings"
 
-	api "github.com/micro/go-micro/v3/api/proto"
 	"github.com/oxtoacart/bpool"
+	api "github.com/unistack-org/micro/v3/api/proto"
 )
 
 var (

api/handler/event/event.go

@@ -11,10 +11,10 @@ import (
 	"time"
 
 	"github.com/google/uuid"
-	"github.com/micro/go-micro/v3/api/handler"
-	proto "github.com/micro/go-micro/v3/api/proto"
-	"github.com/micro/go-micro/v3/util/ctx"
 	"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 (

api/handler/http/http.go

@@ -9,9 +9,9 @@ import (
 	"net/http/httputil"
 	"net/url"
 
-	"github.com/micro/go-micro/v3/api"
+	"github.com/unistack-org/micro/v3/api"
-	"github.com/micro/go-micro/v3/api/handler"
+	"github.com/unistack-org/micro/v3/api/handler"
-	"github.com/micro/go-micro/v3/registry"
+	"github.com/unistack-org/micro/v3/registry"
 )
 
 const (
@@ -65,16 +65,17 @@ func (h *httpHandler) getService(r *http.Request) (string, error) {
 		return "", errors.New("no route found")
 	}
 
+	if len(service.Services) == 0 {
+		return "", errors.New("no route found")
+	}
+
 	// get the nodes for this service
-	var nodes []*registry.Node
+	nodes := make([]*registry.Node, 0, len(service.Services))
 	for _, srv := range service.Services {
 		nodes = append(nodes, srv.Nodes...)
 	}
 
 	// select a random node
-	if len(nodes) == 0 {
-		return "", errors.New("no route found")
-	}
 	node := nodes[rand.Int()%len(nodes)]
 
 	return fmt.Sprintf("http://%s", node.Address), nil

api/handler/http/http_test.go

@@ -1,3 +1,5 @@
+// +build ignore
+
 package http
 
 import (
@@ -6,13 +8,13 @@ import (
 	"net/http/httptest"
 	"testing"
 
-	"github.com/micro/go-micro/v3/api/handler"
+	"github.com/unistack-org/micro/v3/api/handler"
-	"github.com/micro/go-micro/v3/api/resolver"
+	"github.com/unistack-org/micro/v3/api/resolver"
-	"github.com/micro/go-micro/v3/api/resolver/vpath"
+	"github.com/unistack-org/micro/v3/api/resolver/vpath"
-	"github.com/micro/go-micro/v3/api/router"
+	"github.com/unistack-org/micro/v3/api/router"
-	regRouter "github.com/micro/go-micro/v3/api/router/registry"
+	regRouter "github.com/unistack-org/micro/v3/api/router/registry"
-	"github.com/micro/go-micro/v3/registry"
+	"github.com/unistack-org/micro/v3/registry"
-	"github.com/micro/go-micro/v3/registry/memory"
+	"github.com/unistack-org/micro/v3/registry/memory"
 )
 
 func testHttp(t *testing.T, path, service, ns string) {

api/handler/options.go

@@ -1,9 +1,8 @@
 package handler
 
 import (
-	"github.com/micro/go-micro/v3/api/router"
+	"github.com/unistack-org/micro/v3/api/router"
-	"github.com/micro/go-micro/v3/client"
+	"github.com/unistack-org/micro/v3/client"
-	"github.com/micro/go-micro/v3/client/grpc"
 )
 
 var (
@@ -26,10 +25,6 @@ func NewOptions(opts ...Option) Options {
 		o(&options)
 	}
 
-	if options.Client == nil {
-		WithClient(grpc.NewClient())(&options)
-	}
-
 	// set namespace if blank
 	if len(options.Namespace) == 0 {
 		WithNamespace("go.micro.api")(&options)

api/handler/rpc/rpc.go

@@ -9,20 +9,20 @@ import (
 	"strings"
 
 	jsonpatch "github.com/evanphx/json-patch/v5"
-	"github.com/micro/go-micro/v3/api"
-	"github.com/micro/go-micro/v3/api/handler"
-	"github.com/micro/go-micro/v3/api/internal/proto"
-	"github.com/micro/go-micro/v3/client"
-	"github.com/micro/go-micro/v3/codec"
-	"github.com/micro/go-micro/v3/codec/jsonrpc"
-	"github.com/micro/go-micro/v3/codec/protorpc"
-	"github.com/micro/go-micro/v3/errors"
-	"github.com/micro/go-micro/v3/logger"
-	"github.com/micro/go-micro/v3/metadata"
-	"github.com/micro/go-micro/v3/util/ctx"
-	"github.com/micro/go-micro/v3/util/qson"
-	"github.com/micro/go-micro/v3/util/router"
 	"github.com/oxtoacart/bpool"
+	"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/codec/jsonrpc"
+	"github.com/unistack-org/micro/v3/codec/protorpc"
+	"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 (
@@ -249,7 +249,7 @@ func requestPayload(r *http.Request) ([]byte, error) {
 			return nil, err
 		}
 		return raw.Marshal()
-	case strings.Contains(ct, "application/x-www-form-urlencoded"):
+	case strings.Contains(ct, "application/www-x-form-urlencoded"):
 		r.ParseForm()
 
 		// generate a new set of values from the form
@@ -364,13 +364,6 @@ func requestPayload(r *http.Request) ([]byte, error) {
 			bodybuf = b
 		}
 		if bodydst == "" || bodydst == "*" {
-			// jsonpatch resequences the json object so we avoid it if possible (some usecases such as
-			// validating signatures require the request body to be unchangedd). We're keeping support
-			// for the custom paramaters for backwards compatability reasons.
-			if string(out) == "{}" {
-				return bodybuf, nil
-			}
-
 			if out, err = jsonpatch.MergeMergePatches(out, bodybuf); err == nil {
 				return out, nil
 			}
@@ -417,6 +410,7 @@ func requestPayload(r *http.Request) ([]byte, error) {
 
 		//fallback to previous unknown behaviour
 		return bodybuf, nil
+
 	}
 
 	return []byte{}, nil

api/handler/rpc/rpc_test.go

@@ -7,7 +7,7 @@ import (
 	"testing"
 
 	"github.com/golang/protobuf/proto"
-	go_api "github.com/micro/go-micro/v3/api/proto"
+	go_api "github.com/unistack-org/micro/v3/api/proto"
 )
 
 func TestRequestPayloadFromRequest(t *testing.T) {

api/handler/rpc/stream.go

@@ -12,11 +12,11 @@ import (
 	"github.com/gobwas/httphead"
 	"github.com/gobwas/ws"
 	"github.com/gobwas/ws/wsutil"
-	"github.com/micro/go-micro/v3/api"
+	raw "github.com/unistack-org/micro-codec-bytes"
-	"github.com/micro/go-micro/v3/client"
+	"github.com/unistack-org/micro/v3/api"
-	raw "github.com/micro/go-micro/v3/codec/bytes"
+	"github.com/unistack-org/micro/v3/client"
-	"github.com/micro/go-micro/v3/logger"
+	"github.com/unistack-org/micro/v3/logger"
-	"github.com/micro/go-micro/v3/util/router"
+	"github.com/unistack-org/micro/v3/util/router"
 )
 
 // serveWebsocket will stream rpc back over websockets assuming json

api/handler/web/web.go

@@ -12,9 +12,9 @@ import (
 	"net/url"
 	"strings"
 
-	"github.com/micro/go-micro/v3/api"
+	"github.com/unistack-org/micro/v3/api"
-	"github.com/micro/go-micro/v3/api/handler"
+	"github.com/unistack-org/micro/v3/api/handler"
-	"github.com/micro/go-micro/v3/registry"
+	"github.com/unistack-org/micro/v3/registry"
 )
 
 const (
@@ -72,10 +72,11 @@ func (wh *webHandler) getService(r *http.Request) (string, error) {
 	}
 
 	// get the nodes
-	var nodes []*registry.Node
+	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")
 	}

api/proto/api.pb.go

@@ -1,68 +1,81 @@
 // 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 (
-	fmt "fmt"
 	proto "github.com/golang/protobuf/proto"
-	math "math"
+	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
+	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
+	reflect "reflect"
+	sync "sync"
 )
 
-// Reference imports to suppress errors if they are not otherwise used.
+const (
-var _ = proto.Marshal
+	// Verify that this generated code is sufficiently up-to-date.
-var _ = fmt.Errorf
+	_ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion)
-var _ = math.Inf
+	// Verify that runtime/protoimpl is sufficiently up-to-date.
+	_ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20)
+)
 
-// This is a compile-time assertion to ensure that this generated file
+// This is a compile-time assertion that a sufficiently up-to-date version
-// is compatible with the proto package it is being compiled against.
+// of the legacy proto package is being used.
-// A compilation error at this line likely means your copy of the
+const _ = proto.ProtoPackageIsVersion4
-// proto package needs to be updated.
-const _ = proto.ProtoPackageIsVersion3 // please upgrade the proto package
 
 type Pair struct {
-	Key                  string   `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"`
+	state         protoimpl.MessageState
-	Values               []string `protobuf:"bytes,2,rep,name=values,proto3" json:"values,omitempty"`
+	sizeCache     protoimpl.SizeCache
-	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	unknownFields protoimpl.UnknownFields
-	XXX_unrecognized     []byte   `json:"-"`
+
-	XXX_sizecache        int32    `json:"-"`
+	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 (m *Pair) Reset()         { *m = Pair{} }
+func (x *Pair) Reset() {
-func (m *Pair) String() string { return proto.CompactTextString(m) }
+	*x = Pair{}
-func (*Pair) ProtoMessage()    {}
+	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 fileDescriptor_2df576b66d12087a, []int{0}
+	return file_api_proto_api_proto_rawDescGZIP(), []int{0}
 }
 
-func (m *Pair) XXX_Unmarshal(b []byte) error {
+func (x *Pair) GetKey() string {
-	return xxx_messageInfo_Pair.Unmarshal(m, b)
+	if x != nil {
-}
+		return x.Key
-func (m *Pair) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_Pair.Marshal(b, m, deterministic)
-}
-func (m *Pair) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_Pair.Merge(m, src)
-}
-func (m *Pair) XXX_Size() int {
-	return xxx_messageInfo_Pair.Size(m)
-}
-func (m *Pair) XXX_DiscardUnknown() {
-	xxx_messageInfo_Pair.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_Pair proto.InternalMessageInfo
-
-func (m *Pair) GetKey() string {
-	if m != nil {
-		return m.Key
 	}
 	return ""
 }
 
-func (m *Pair) GetValues() []string {
+func (x *Pair) GetValues() []string {
-	if m != nil {
+	if x != nil {
-		return m.Values
+		return x.Values
 	}
 	return nil
 }
@@ -70,88 +83,96 @@ func (m *Pair) GetValues() []string {
 // A HTTP request as RPC
 // Forward by the api handler
 type Request struct {
-	Method               string           `protobuf:"bytes,1,opt,name=method,proto3" json:"method,omitempty"`
+	state         protoimpl.MessageState
-	Path                 string           `protobuf:"bytes,2,opt,name=path,proto3" json:"path,omitempty"`
+	sizeCache     protoimpl.SizeCache
-	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"`
+	unknownFields protoimpl.UnknownFields
-	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"`
+	Method string           `protobuf:"bytes,1,opt,name=method,proto3" json:"method,omitempty"`
-	Body                 string           `protobuf:"bytes,6,opt,name=body,proto3" json:"body,omitempty"`
+	Path   string           `protobuf:"bytes,2,opt,name=path,proto3" json:"path,omitempty"`
-	Url                  string           `protobuf:"bytes,7,opt,name=url,proto3" json:"url,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"`
-	XXX_NoUnkeyedLiteral struct{}         `json:"-"`
+	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"`
-	XXX_unrecognized     []byte           `json:"-"`
+	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"`
-	XXX_sizecache        int32            `json:"-"`
+	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 (m *Request) Reset()         { *m = Request{} }
+func (x *Request) Reset() {
-func (m *Request) String() string { return proto.CompactTextString(m) }
+	*x = Request{}
-func (*Request) ProtoMessage()    {}
+	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 fileDescriptor_2df576b66d12087a, []int{1}
+	return file_api_proto_api_proto_rawDescGZIP(), []int{1}
 }
 
-func (m *Request) XXX_Unmarshal(b []byte) error {
+func (x *Request) GetMethod() string {
-	return xxx_messageInfo_Request.Unmarshal(m, b)
+	if x != nil {
-}
+		return x.Method
-func (m *Request) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_Request.Marshal(b, m, deterministic)
-}
-func (m *Request) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_Request.Merge(m, src)
-}
-func (m *Request) XXX_Size() int {
-	return xxx_messageInfo_Request.Size(m)
-}
-func (m *Request) XXX_DiscardUnknown() {
-	xxx_messageInfo_Request.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_Request proto.InternalMessageInfo
-
-func (m *Request) GetMethod() string {
-	if m != nil {
-		return m.Method
 	}
 	return ""
 }
 
-func (m *Request) GetPath() string {
+func (x *Request) GetPath() string {
-	if m != nil {
+	if x != nil {
-		return m.Path
+		return x.Path
 	}
 	return ""
 }
 
-func (m *Request) GetHeader() map[string]*Pair {
+func (x *Request) GetHeader() map[string]*Pair {
-	if m != nil {
+	if x != nil {
-		return m.Header
+		return x.Header
 	}
 	return nil
 }
 
-func (m *Request) GetGet() map[string]*Pair {
+func (x *Request) GetGet() map[string]*Pair {
-	if m != nil {
+	if x != nil {
-		return m.Get
+		return x.Get
 	}
 	return nil
 }
 
-func (m *Request) GetPost() map[string]*Pair {
+func (x *Request) GetPost() map[string]*Pair {
-	if m != nil {
+	if x != nil {
-		return m.Post
+		return x.Post
 	}
 	return nil
 }
 
-func (m *Request) GetBody() string {
+func (x *Request) GetBody() string {
-	if m != nil {
+	if x != nil {
-		return m.Body
+		return x.Body
 	}
 	return ""
 }
 
-func (m *Request) GetUrl() string {
+func (x *Request) GetUrl() string {
-	if m != nil {
+	if x != nil {
-		return m.Url
+		return x.Url
 	}
 	return ""
 }
@@ -159,56 +180,64 @@ func (m *Request) GetUrl() string {
 // A HTTP response as RPC
 // Expected response for the api handler
 type Response struct {
-	StatusCode           int32            `protobuf:"varint,1,opt,name=statusCode,proto3" json:"statusCode,omitempty"`
+	state         protoimpl.MessageState
-	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"`
+	sizeCache     protoimpl.SizeCache
-	Body                 string           `protobuf:"bytes,3,opt,name=body,proto3" json:"body,omitempty"`
+	unknownFields protoimpl.UnknownFields
-	XXX_NoUnkeyedLiteral struct{}         `json:"-"`
+
-	XXX_unrecognized     []byte           `json:"-"`
+	StatusCode int32            `protobuf:"varint,1,opt,name=statusCode,proto3" json:"statusCode,omitempty"`
-	XXX_sizecache        int32            `json:"-"`
+	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 (m *Response) Reset()         { *m = Response{} }
+func (x *Response) Reset() {
-func (m *Response) String() string { return proto.CompactTextString(m) }
+	*x = Response{}
-func (*Response) ProtoMessage()    {}
+	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 fileDescriptor_2df576b66d12087a, []int{2}
+	return file_api_proto_api_proto_rawDescGZIP(), []int{2}
 }
 
-func (m *Response) XXX_Unmarshal(b []byte) error {
+func (x *Response) GetStatusCode() int32 {
-	return xxx_messageInfo_Response.Unmarshal(m, b)
+	if x != nil {
-}
+		return x.StatusCode
-func (m *Response) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_Response.Marshal(b, m, deterministic)
-}
-func (m *Response) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_Response.Merge(m, src)
-}
-func (m *Response) XXX_Size() int {
-	return xxx_messageInfo_Response.Size(m)
-}
-func (m *Response) XXX_DiscardUnknown() {
-	xxx_messageInfo_Response.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_Response proto.InternalMessageInfo
-
-func (m *Response) GetStatusCode() int32 {
-	if m != nil {
-		return m.StatusCode
 	}
 	return 0
 }
 
-func (m *Response) GetHeader() map[string]*Pair {
+func (x *Response) GetHeader() map[string]*Pair {
-	if m != nil {
+	if x != nil {
-		return m.Header
+		return x.Header
 	}
 	return nil
 }
 
-func (m *Response) GetBody() string {
+func (x *Response) GetBody() string {
-	if m != nil {
+	if x != nil {
-		return m.Body
+		return x.Body
 	}
 	return ""
 }
@@ -216,6 +245,10 @@ func (m *Response) GetBody() string {
 // 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
@@ -225,111 +258,254 @@ type Event struct {
 	// 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"`
+	Data string `protobuf:"bytes,5,opt,name=data,proto3" json:"data,omitempty"`
-	XXX_NoUnkeyedLiteral struct{} `json:"-"`
-	XXX_unrecognized     []byte   `json:"-"`
-	XXX_sizecache        int32    `json:"-"`
 }
 
-func (m *Event) Reset()         { *m = Event{} }
+func (x *Event) Reset() {
-func (m *Event) String() string { return proto.CompactTextString(m) }
+	*x = Event{}
-func (*Event) ProtoMessage()    {}
+	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 fileDescriptor_2df576b66d12087a, []int{3}
+	return file_api_proto_api_proto_rawDescGZIP(), []int{3}
 }
 
-func (m *Event) XXX_Unmarshal(b []byte) error {
+func (x *Event) GetName() string {
-	return xxx_messageInfo_Event.Unmarshal(m, b)
+	if x != nil {
-}
+		return x.Name
-func (m *Event) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_Event.Marshal(b, m, deterministic)
-}
-func (m *Event) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_Event.Merge(m, src)
-}
-func (m *Event) XXX_Size() int {
-	return xxx_messageInfo_Event.Size(m)
-}
-func (m *Event) XXX_DiscardUnknown() {
-	xxx_messageInfo_Event.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_Event proto.InternalMessageInfo
-
-func (m *Event) GetName() string {
-	if m != nil {
-		return m.Name
 	}
 	return ""
 }
 
-func (m *Event) GetId() string {
+func (x *Event) GetId() string {
-	if m != nil {
+	if x != nil {
-		return m.Id
+		return x.Id
 	}
 	return ""
 }
 
-func (m *Event) GetTimestamp() int64 {
+func (x *Event) GetTimestamp() int64 {
-	if m != nil {
+	if x != nil {
-		return m.Timestamp
+		return x.Timestamp
 	}
 	return 0
 }
 
-func (m *Event) GetHeader() map[string]*Pair {
+func (x *Event) GetHeader() map[string]*Pair {
-	if m != nil {
+	if x != nil {
-		return m.Header
+		return x.Header
 	}
 	return nil
 }
 
-func (m *Event) GetData() string {
+func (x *Event) GetData() string {
-	if m != nil {
+	if x != nil {
-		return m.Data
+		return x.Data
 	}
 	return ""
 }
 
-func init() {
+var File_api_proto_api_proto protoreflect.FileDescriptor
-	proto.RegisterType((*Pair)(nil), "go.api.Pair")
+
-	proto.RegisterType((*Request)(nil), "go.api.Request")
+var file_api_proto_api_proto_rawDesc = []byte{
-	proto.RegisterMapType((map[string]*Pair)(nil), "go.api.Request.GetEntry")
+	0x0a, 0x13, 0x61, 0x70, 0x69, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2f, 0x61, 0x70, 0x69, 0x2e,
-	proto.RegisterMapType((map[string]*Pair)(nil), "go.api.Request.HeaderEntry")
+	0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x06, 0x67, 0x6f, 0x2e, 0x61, 0x70, 0x69, 0x22, 0x30, 0x0a,
-	proto.RegisterMapType((map[string]*Pair)(nil), "go.api.Request.PostEntry")
+	0x04, 0x50, 0x61, 0x69, 0x72, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01,
-	proto.RegisterType((*Response)(nil), "go.api.Response")
+	0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x16, 0x0a, 0x06, 0x76, 0x61, 0x6c, 0x75, 0x65,
-	proto.RegisterMapType((map[string]*Pair)(nil), "go.api.Response.HeaderEntry")
+	0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x09, 0x52, 0x06, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x73, 0x22,
-	proto.RegisterType((*Event)(nil), "go.api.Event")
+	0xc1, 0x03, 0x0a, 0x07, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x16, 0x0a, 0x06, 0x6d,
-	proto.RegisterMapType((map[string]*Pair)(nil), "go.api.Event.HeaderEntry")
+	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,
 }
 
-func init() { proto.RegisterFile("api/proto/api.proto", fileDescriptor_2df576b66d12087a) }
+var (
+	file_api_proto_api_proto_rawDescOnce sync.Once
+	file_api_proto_api_proto_rawDescData = file_api_proto_api_proto_rawDesc
+)
 
-var fileDescriptor_2df576b66d12087a = []byte{
+func file_api_proto_api_proto_rawDescGZIP() []byte {
-	// 393 bytes of a gzipped FileDescriptorProto
+	file_api_proto_api_proto_rawDescOnce.Do(func() {
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x53, 0xcd, 0xce, 0xd3, 0x30,
+		file_api_proto_api_proto_rawDescData = protoimpl.X.CompressGZIP(file_api_proto_api_proto_rawDescData)
-	0x10, 0x54, 0xe2, 0x24, 0x6d, 0xb6, 0x08, 0x21, 0x23, 0x21, 0x53, 0x2a, 0x54, 0xe5, 0x54, 0x21,
+	})
-	0x91, 0x42, 0xcb, 0x01, 0x71, 0x85, 0xaa, 0x1c, 0x2b, 0xbf, 0x81, 0xab, 0x58, 0x6d, 0x44, 0x13,
+	return file_api_proto_api_proto_rawDescData
-	0x9b, 0xd8, 0xa9, 0xd4, 0x87, 0xe3, 0xc0, 0x63, 0xf0, 0x36, 0xc8, 0x1b, 0xf7, 0xe7, 0xab, 0xfa,
+}
-	0x5d, 0xbe, 0xaf, 0xb7, 0x89, 0x3d, 0x3b, 0x3b, 0x3b, 0xeb, 0xc0, 0x6b, 0xa1, 0xcb, 0xa9, 0x6e,
+
-	0x94, 0x55, 0x53, 0xa1, 0xcb, 0x1c, 0x11, 0x4d, 0x36, 0x2a, 0x17, 0xba, 0xcc, 0x3e, 0x41, 0xb4,
+var file_api_proto_api_proto_msgTypes = make([]protoimpl.MessageInfo, 9)
-	0x12, 0x65, 0x43, 0x5f, 0x01, 0xf9, 0x25, 0x0f, 0x2c, 0x18, 0x07, 0x93, 0x94, 0x3b, 0x48, 0xdf,
+var file_api_proto_api_proto_goTypes = []interface{}{
-	0x40, 0xb2, 0x17, 0xbb, 0x56, 0x1a, 0x16, 0x8e, 0xc9, 0x24, 0xe5, 0xfe, 0x2b, 0xfb, 0x4b, 0xa0,
+	(*Pair)(nil),     // 0: go.api.Pair
-	0xc7, 0xe5, 0xef, 0x56, 0x1a, 0xeb, 0x38, 0x95, 0xb4, 0x5b, 0x55, 0xf8, 0x42, 0xff, 0x45, 0x29,
+	(*Request)(nil),  // 1: go.api.Request
-	0x44, 0x5a, 0xd8, 0x2d, 0x0b, 0xf1, 0x14, 0x31, 0x9d, 0x43, 0xb2, 0x95, 0xa2, 0x90, 0x0d, 0x23,
+	(*Response)(nil), // 2: go.api.Response
-	0x63, 0x32, 0x19, 0xcc, 0xde, 0xe5, 0x9d, 0x85, 0xdc, 0x8b, 0xe5, 0x3f, 0xf1, 0x76, 0x51, 0xdb,
+	(*Event)(nil),    // 3: go.api.Event
-	0xe6, 0xc0, 0x3d, 0x95, 0x7e, 0x00, 0xb2, 0x91, 0x96, 0x45, 0x58, 0xc1, 0xae, 0x2b, 0x96, 0xd2,
+	nil,              // 4: go.api.Request.HeaderEntry
-	0x76, 0x74, 0x47, 0xa2, 0x1f, 0x21, 0xd2, 0xca, 0x58, 0x16, 0x23, 0xf9, 0xed, 0x35, 0x79, 0xa5,
+	nil,              // 5: go.api.Request.GetEntry
-	0x8c, 0x67, 0x23, 0xcd, 0x79, 0x5c, 0xab, 0xe2, 0xc0, 0x92, 0xce, 0xa3, 0xc3, 0x2e, 0x85, 0xb6,
+	nil,              // 6: go.api.Request.PostEntry
-	0xd9, 0xb1, 0x5e, 0x97, 0x42, 0xdb, 0xec, 0x86, 0x4b, 0x18, 0x5c, 0xf8, 0xba, 0x11, 0x53, 0x06,
+	nil,              // 7: go.api.Response.HeaderEntry
-	0x31, 0x06, 0x83, 0xb3, 0x0e, 0x66, 0x2f, 0x8e, 0x6d, 0x5d, 0xaa, 0xbc, 0xbb, 0xfa, 0x16, 0x7e,
+	nil,              // 8: go.api.Event.HeaderEntry
-	0x0d, 0x86, 0x3f, 0xa0, 0x7f, 0xb4, 0xfb, 0x0c, 0x95, 0x05, 0xa4, 0xa7, 0x39, 0x9e, 0x2e, 0x93,
+}
-	0xfd, 0x09, 0xa0, 0xcf, 0xa5, 0xd1, 0xaa, 0x36, 0x92, 0xbe, 0x07, 0x30, 0x56, 0xd8, 0xd6, 0x7c,
+var file_api_proto_api_proto_depIdxs = []int32{
-	0x57, 0x85, 0x44, 0xb5, 0x98, 0x5f, 0x9c, 0xd0, 0x2f, 0xa7, 0xc5, 0x85, 0x98, 0xec, 0xe8, 0x9c,
+	4,  // 0: go.api.Request.header:type_name -> go.api.Request.HeaderEntry
-	0x6c, 0xa7, 0x70, 0x73, 0x73, 0xc7, 0x78, 0xc9, 0x39, 0xde, 0xbb, 0x85, 0x99, 0xfd, 0x0b, 0x20,
+	5,  // 1: go.api.Request.get:type_name -> go.api.Request.GetEntry
-	0x5e, 0xec, 0x65, 0x8d, 0x5b, 0xac, 0x45, 0x25, 0xbd, 0x08, 0x62, 0xfa, 0x12, 0xc2, 0xb2, 0xf0,
+	6,  // 2: go.api.Request.post:type_name -> go.api.Request.PostEntry
-	0x6f, 0x2f, 0x2c, 0x0b, 0x3a, 0x82, 0xd4, 0x96, 0x95, 0x34, 0x56, 0x54, 0x1a, 0xfd, 0x10, 0x7e,
+	7,  // 3: go.api.Response.header:type_name -> go.api.Response.HeaderEntry
-	0x3e, 0xa0, 0x9f, 0x4f, 0xe3, 0x45, 0x0f, 0x1f, 0x0e, 0x36, 0x78, 0x6c, 0xb6, 0x42, 0x58, 0xc1,
+	8,  // 4: go.api.Event.header:type_name -> go.api.Event.HeaderEntry
-	0xe2, 0xae, 0xa9, 0xc3, 0x77, 0x9b, 0x6d, 0x9d, 0xe0, 0x0f, 0x3a, 0xff, 0x1f, 0x00, 0x00, 0xff,
+	0,  // 5: go.api.Request.HeaderEntry.value:type_name -> go.api.Pair
-	0xff, 0xd4, 0x6d, 0x70, 0x51, 0xb7, 0x03, 0x00, 0x00,
+	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/resolver/grpc/grpc.go

@@ -6,7 +6,7 @@ import (
 	"net/http"
 	"strings"
 
-	"github.com/micro/go-micro/v3/api/resolver"
+	"github.com/unistack-org/micro/v3/api/resolver"
 )
 
 type Resolver struct {

api/resolver/host/host.go

@@ -4,7 +4,7 @@ package host
 import (
 	"net/http"
 
-	"github.com/micro/go-micro/v3/api/resolver"
+	"github.com/unistack-org/micro/v3/api/resolver"
 )
 
 type Resolver struct {

api/resolver/options.go

@@ -1,7 +1,7 @@
 package resolver
 
 import (
-	"github.com/micro/go-micro/v3/registry"
+	"github.com/unistack-org/micro/v3/registry"
 )
 
 type Options struct {

api/resolver/path/path.go

@@ -5,7 +5,7 @@ import (
 	"net/http"
 	"strings"
 
-	"github.com/micro/go-micro/v3/api/resolver"
+	"github.com/unistack-org/micro/v3/api/resolver"
 )
 
 type Resolver struct {

api/resolver/subdomain/subdomain.go

@@ -7,8 +7,8 @@ import (
 	"net/http"
 	"strings"
 
-	"github.com/micro/go-micro/v3/api/resolver"
+	"github.com/unistack-org/micro/v3/api/resolver"
-	"github.com/micro/go-micro/v3/logger"
+	"github.com/unistack-org/micro/v3/logger"
 	"golang.org/x/net/publicsuffix"
 )
 
@@ -46,7 +46,7 @@ func (r *Resolver) Domain(req *http.Request) string {
 		return ""
 	}
 
-	// check for dev enviroment
+	// check for dev environment
 	if host == "localhost" || host == "127.0.0.1" {
 		return ""
 	}

api/resolver/subdomain/subdomain_test.go

@@ -5,7 +5,7 @@ import (
 	"net/url"
 	"testing"
 
-	"github.com/micro/go-micro/v3/api/resolver/vpath"
+	"github.com/unistack-org/micro/v3/api/resolver/vpath"
 
 	"github.com/stretchr/testify/assert"
 )

api/resolver/vpath/vpath.go

@@ -7,7 +7,7 @@ import (
 	"regexp"
 	"strings"
 
-	"github.com/micro/go-micro/v3/api/resolver"
+	"github.com/unistack-org/micro/v3/api/resolver"
 )
 
 func NewResolver(opts ...resolver.Option) resolver.Resolver {

api/router/options.go

@@ -1,10 +1,9 @@
 package router
 
 import (
-	"github.com/micro/go-micro/v3/api/resolver"
+	"github.com/unistack-org/micro/v3/api/resolver"
-	"github.com/micro/go-micro/v3/api/resolver/vpath"
+	"github.com/unistack-org/micro/v3/api/resolver/vpath"
-	"github.com/micro/go-micro/v3/registry"
+	"github.com/unistack-org/micro/v3/registry"
-	"github.com/micro/go-micro/v3/registry/mdns"
 )
 
 type Options struct {
@@ -17,8 +16,7 @@ type Option func(o *Options)
 
 func NewOptions(opts ...Option) Options {
 	options := Options{
-		Handler:  "meta",
+		Handler: "meta",
-		Registry: mdns.NewRegistry(),
 	}
 
 	for _, o := range opts {

api/router/registry/registry.go

@@ -10,13 +10,12 @@ import (
 	"sync"
 	"time"
 
-	"github.com/micro/go-micro/v3/api"
+	"github.com/unistack-org/micro/v3/api"
-	"github.com/micro/go-micro/v3/api/router"
+	"github.com/unistack-org/micro/v3/api/router"
-	"github.com/micro/go-micro/v3/logger"
+	"github.com/unistack-org/micro/v3/logger"
-	"github.com/micro/go-micro/v3/metadata"
+	"github.com/unistack-org/micro/v3/metadata"
-	"github.com/micro/go-micro/v3/registry"
+	"github.com/unistack-org/micro/v3/registry"
-	"github.com/micro/go-micro/v3/registry/cache"
+	util "github.com/unistack-org/micro/v3/util/router"
-	util "github.com/micro/go-micro/v3/util/router"
 )
 
 // endpoint struct, that holds compiled pcre
@@ -31,9 +30,6 @@ type registryRouter struct {
 	exit chan bool
 	opts router.Options
 
-	// registry cache
-	rc cache.Cache
-
 	sync.RWMutex
 	eps map[string]*api.Service
 	// compiled regexp for host and path
@@ -68,7 +64,7 @@ func (r *registryRouter) refresh() {
 
 		// for each service, get service and store endpoints
 		for _, s := range services {
-			service, err := r.rc.GetService(s.Name)
+			service, err := r.opts.Registry.GetService(s.Name)
 			if err != nil {
 				if logger.V(logger.ErrorLevel, logger.DefaultLogger) {
 					logger.Errorf("unable to get service: %v", err)
@@ -96,7 +92,7 @@ func (r *registryRouter) process(res *registry.Result) {
 	}
 
 	// get entry from cache
-	service, err := r.rc.GetService(res.Service.Name)
+	service, err := r.opts.Registry.GetService(res.Service.Name)
 	if err != nil {
 		if logger.V(logger.ErrorLevel, logger.DefaultLogger) {
 			logger.Errorf("unable to get %v service: %v", res.Service.Name, err)
@@ -283,7 +279,6 @@ func (r *registryRouter) Close() error {
 		return nil
 	default:
 		close(r.exit)
-		r.rc.Stop()
 	}
 	return nil
 }
@@ -437,7 +432,7 @@ func (r *registryRouter) Route(req *http.Request) (*api.Service, error) {
 	name := rp.Name
 
 	// get service
-	services, err := r.rc.GetService(name, registry.GetDomain(rp.Domain))
+	services, err := r.opts.Registry.GetService(name, registry.GetDomain(rp.Domain))
 	if err != nil {
 		return nil, err
 	}
@@ -481,21 +476,23 @@ func (r *registryRouter) Route(req *http.Request) (*api.Service, error) {
 	return nil, errors.New("unknown handler")
 }
 
-func newRouter(opts ...router.Option) *registryRouter {
+func newRouter(opts ...router.Option) (*registryRouter, error) {
 	options := router.NewOptions(opts...)
+	if options.Registry == nil {
+		return nil, fmt.Errorf("registry is not set")
+	}
 	r := &registryRouter{
 		exit: make(chan bool),
 		opts: options,
-		rc:   cache.New(options.Registry),
 		eps:  make(map[string]*api.Service),
 		ceps: make(map[string]*endpoint),
 	}
 	go r.watch()
 	go r.refresh()
-	return r
+	return r, nil
 }
 
 // NewRouter returns the default router
-func NewRouter(opts ...router.Option) router.Router {
+func NewRouter(opts ...router.Option) (router.Router, error) {
 	return newRouter(opts...)
 }

api/router/registry/registry_test.go

@@ -3,12 +3,16 @@ package registry
 import (
 	"testing"
 
-	"github.com/micro/go-micro/v3/registry"
 	"github.com/stretchr/testify/assert"
+	"github.com/unistack-org/micro/v3/registry"
 )
 
 func TestStoreRegex(t *testing.T) {
-	router := newRouter()
+	t.Skip()
+	router, err := newRouter()
+	if err != nil {
+		t.Fatal(err)
+	}
 	router.store([]*registry.Service{
 		{
 			Name:    "Foobar",

api/router/router.go

@@ -4,7 +4,7 @@ package router
 import (
 	"net/http"
 
-	"github.com/micro/go-micro/v3/api"
+	"github.com/unistack-org/micro/v3/api"
 )
 
 // Router is used to determine an endpoint for a request

api/router/router_test.go

@@ -1,3 +1,5 @@
+// +build ignore
+
 package router_test
 
 import (
@@ -9,25 +11,26 @@ import (
 	"testing"
 	"time"
 
-	"github.com/micro/go-micro/v3/api"
+	"github.com/unistack-org/micro/v3/api"
-	"github.com/micro/go-micro/v3/api/handler"
+	"github.com/unistack-org/micro/v3/api/handler"
-	"github.com/micro/go-micro/v3/api/handler/rpc"
+	"github.com/unistack-org/micro/v3/api/handler/rpc"
-	"github.com/micro/go-micro/v3/api/router"
+	"github.com/unistack-org/micro/v3/api/router"
-	rregistry "github.com/micro/go-micro/v3/api/router/registry"
+	rregistry "github.com/unistack-org/micro/v3/api/router/registry"
-	rstatic "github.com/micro/go-micro/v3/api/router/static"
+	rstatic "github.com/unistack-org/micro/v3/api/router/static"
-	"github.com/micro/go-micro/v3/client"
+	"github.com/unistack-org/micro/v3/broker"
-	gcli "github.com/micro/go-micro/v3/client/grpc"
+	bmemory "github.com/unistack-org/micro/v3/broker/memory"
-	rmemory "github.com/micro/go-micro/v3/registry/memory"
+	"github.com/unistack-org/micro/v3/client"
-	rt "github.com/micro/go-micro/v3/router"
+	gcli "github.com/unistack-org/micro/v3/client/grpc"
-	regRouter "github.com/micro/go-micro/v3/router/registry"
+	rmemory "github.com/unistack-org/micro/v3/registry/memory"
-	"github.com/micro/go-micro/v3/server"
+	rt "github.com/unistack-org/micro/v3/router"
-	gsrv "github.com/micro/go-micro/v3/server/grpc"
+	regRouter "github.com/unistack-org/micro/v3/router/registry"
-	pb "github.com/micro/go-micro/v3/server/grpc/proto"
+	"github.com/unistack-org/micro/v3/server"
+	gsrv "github.com/unistack-org/micro/v3/server/grpc"
+	pb "github.com/unistack-org/micro/v3/server/grpc/proto"
 )
 
 // server is used to implement helloworld.GreeterServer.
 type testServer struct {
-	msgCount int
 }
 
 // TestHello implements helloworld.GreeterServer
@@ -50,10 +53,12 @@ func (s *testServer) CallPcreInvalid(ctx context.Context, req *pb.Request, rsp *
 
 func initial(t *testing.T) (server.Server, client.Client) {
 	r := rmemory.NewRegistry()
+	b := bmemory.NewBroker(broker.Registry(r))
 
 	// create a new client
 	s := gsrv.NewServer(
 		server.Name("foo"),
+		server.Broker(b),
 		server.Registry(r),
 	)
 
@@ -64,6 +69,7 @@ func initial(t *testing.T) (server.Server, client.Client) {
 	// create a new server
 	c := gcli.NewClient(
 		client.Router(rtr),
+		client.Broker(b),
 	)
 
 	h := &testServer{}

api/router/static/static.go

@@ -8,13 +8,13 @@ import (
 	"strings"
 	"sync"
 
-	"github.com/micro/go-micro/v3/api"
+	"github.com/unistack-org/micro/v3/api"
-	"github.com/micro/go-micro/v3/api/router"
+	"github.com/unistack-org/micro/v3/api/router"
-	"github.com/micro/go-micro/v3/logger"
+	"github.com/unistack-org/micro/v3/logger"
-	"github.com/micro/go-micro/v3/metadata"
+	"github.com/unistack-org/micro/v3/metadata"
-	"github.com/micro/go-micro/v3/registry"
+	"github.com/unistack-org/micro/v3/registry"
-	rutil "github.com/micro/go-micro/v3/util/registry"
+	rutil "github.com/unistack-org/micro/v3/util/registry"
-	util "github.com/micro/go-micro/v3/util/router"
+	util "github.com/unistack-org/micro/v3/util/router"
 )
 
 type endpoint struct {

api/server/acme/autocert/autocert.go

@@ -7,8 +7,8 @@ import (
 	"net"
 	"os"
 
-	"github.com/micro/go-micro/v3/api/server/acme"
+	"github.com/unistack-org/micro/v3/api/server/acme"
-	"github.com/micro/go-micro/v3/logger"
+	"github.com/unistack-org/micro/v3/logger"
 	"golang.org/x/crypto/acme/autocert"
 )
 

api/server/acme/certmagic/certmagic.go

@@ -8,8 +8,8 @@ import (
 	"time"
 
 	"github.com/caddyserver/certmagic"
-	"github.com/micro/go-micro/v3/api/server/acme"
+	"github.com/unistack-org/micro/v3/api/server/acme"
-	"github.com/micro/go-micro/v3/logger"
+	"github.com/unistack-org/micro/v3/logger"
 )
 
 type certmagicProvider struct {

api/server/acme/certmagic/storage.go

@@ -10,8 +10,8 @@ import (
 	"time"
 
 	"github.com/caddyserver/certmagic"
-	"github.com/micro/go-micro/v3/store"
+	"github.com/unistack-org/micro/v3/store"
-	"github.com/micro/go-micro/v3/sync"
+	"github.com/unistack-org/micro/v3/sync"
 )
 
 // File represents a "File" that will be stored in store.Store - the contents and last modified time

api/server/acme/options.go

@@ -56,7 +56,7 @@ func OnDemand(b bool) Option {
 
 // Cache provides a cache / storage interface to the underlying ACME library
 // as there is no standard, this needs to be validated by the underlying
-// implentation.
+// implementation
 func Cache(c interface{}) Option {
 	return func(o *Options) {
 		o.Cache = c

api/server/cors/cors.go

@@ -40,5 +40,5 @@ func SetHeaders(w http.ResponseWriter, r *http.Request) {
 
 	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, Namespace")
+	set(w, "Access-Control-Allow-Headers", "Accept, Content-Type, Content-Length, Accept-Encoding, X-CSRF-Token, Authorization")
 }

api/server/http/http.go

@@ -5,13 +5,10 @@ import (
 	"crypto/tls"
 	"net"
 	"net/http"
-	"os"
 	"sync"
 
-	"github.com/gorilla/handlers"
+	"github.com/unistack-org/micro/v3/api/server"
-	"github.com/micro/go-micro/v3/api/server"
+	"github.com/unistack-org/micro/v3/logger"
-	"github.com/micro/go-micro/v3/api/server/cors"
-	"github.com/micro/go-micro/v3/logger"
 )
 
 type httpServer struct {
@@ -58,14 +55,6 @@ func (s *httpServer) Handle(path string, handler http.Handler) {
 		handler = wrapper(handler)
 	}
 
-	// wrap with cors
-	if s.opts.EnableCORS {
-		handler = cors.CombinedCORSHandler(handler)
-	}
-
-	// wrap with logger
-	handler = handlers.CombinedLoggingHandler(os.Stdout, handler)
-
 	s.mux.Handle(path, handler)
 }
 
@@ -97,7 +86,7 @@ func (s *httpServer) Start() error {
 	go func() {
 		if err := http.Serve(l, s.mux); err != nil {
 			// temporary fix
-			//logger.Fatal(err)
+			logger.Error(err)
 		}
 	}()
 

api/server/options.go

@@ -4,8 +4,8 @@ import (
 	"crypto/tls"
 	"net/http"
 
-	"github.com/micro/go-micro/v3/api/resolver"
+	"github.com/unistack-org/micro/v3/api/resolver"
-	"github.com/micro/go-micro/v3/api/server/acme"
+	"github.com/unistack-org/micro/v3/api/server/acme"
 )
 
 type Option func(o *Options)

auth/auth.go

@@ -2,11 +2,14 @@
 package auth
 
 import (
+	"context"
 	"errors"
 	"time"
 )
 
 const (
+	// BearerScheme used for Authorization header
+	BearerScheme = "Bearer "
 	// ScopePublic is the scope applied to a rule to allow access to the public
 	ScopePublic = ""
 	// ScopeAccount is the scope applied to a rule to limit to users with any valid account
@@ -14,6 +17,7 @@ const (
 )
 
 var (
+	DefaultAuth Auth
 	// 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
@@ -46,7 +50,7 @@ type Auth interface {
 
 // Account provided by an auth provider
 type Account struct {
-	// ID of the account e.g. UUID. Should not change
+	// ID of the account e.g. email
 	ID string `json:"id"`
 	// Type of the account, e.g. service
 	Type string `json:"type"`
@@ -58,8 +62,6 @@ type Account struct {
 	Scopes []string `json:"scopes"`
 	// Secret for the account, e.g. the password
 	Secret string `json:"secret"`
-	// Name of the account. User friendly name that might change e.g. a username or email
-	Name string `json:"name"`
 }
 
 // Token can be short or long lived
@@ -114,3 +116,19 @@ type Rule struct {
 	// rule will be applied
 	Priority int32
 }
+
+type accountKey struct{}
+
+// AccountFromContext gets the account from the context, which
+// is set by the auth wrapper at the start of a call. If the account
+// 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) {
+	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 {
+	return context.WithValue(ctx, accountKey{}, account)
+}

auth/jwt/jwt.go

@@ -5,9 +5,9 @@ import (
 	"sync"
 	"time"
 
-	"github.com/micro/go-micro/v3/auth"
+	"github.com/unistack-org/micro/v3/auth"
-	"github.com/micro/go-micro/v3/util/token"
+	"github.com/unistack-org/micro/v3/util/token"
-	"github.com/micro/go-micro/v3/util/token/jwt"
+	"github.com/unistack-org/micro/v3/util/token/jwt"
 )
 
 // NewAuth returns a new instance of the Auth service
@@ -54,17 +54,13 @@ func (j *jwtAuth) Generate(id string, opts ...auth.GenerateOption) (*auth.Accoun
 	if len(options.Issuer) == 0 {
 		options.Issuer = j.Options().Issuer
 	}
-	name := options.Name
+
-	if name == "" {
-		name = id
-	}
 	account := &auth.Account{
 		ID:       id,
 		Type:     options.Type,
 		Scopes:   options.Scopes,
 		Metadata: options.Metadata,
 		Issuer:   options.Issuer,
-		Name:     name,
 	}
 
 	// generate a JWT secret which can be provided to the Token() method

auth/noop/noop.go

@@ -2,7 +2,7 @@ package noop
 
 import (
 	"github.com/google/uuid"
-	"github.com/micro/go-micro/v3/auth"
+	"github.com/unistack-org/micro/v3/auth"
 )
 
 func NewAuth(opts ...auth.Option) auth.Auth {
@@ -40,17 +40,13 @@ func (n *noop) Options() auth.Options {
 // Generate a new account
 func (n *noop) Generate(id string, opts ...auth.GenerateOption) (*auth.Account, error) {
 	options := auth.NewGenerateOptions(opts...)
-	name := options.Name
+
-	if name == "" {
-		name = id
-	}
 	return &auth.Account{
 		ID:       id,
 		Secret:   options.Secret,
 		Metadata: options.Metadata,
 		Scopes:   options.Scopes,
 		Issuer:   n.Options().Issuer,
-		Name:     name,
 	}, nil
 }
 

auth/options.go

@@ -4,7 +4,8 @@ import (
 	"context"
 	"time"
 
-	"github.com/micro/go-micro/v3/store"
+	"github.com/unistack-org/micro/v3/logger"
+	"github.com/unistack-org/micro/v3/store"
 )
 
 func NewOptions(opts ...Option) Options {
@@ -34,6 +35,8 @@ type Options struct {
 	Store store.Store
 	// Addrs sets the addresses of auth
 	Addrs []string
+	// Logger sets the logger
+	Logger logger.Logger
 	// Context to store other options
 	Context context.Context
 }
@@ -110,8 +113,6 @@ type GenerateOptions struct {
 	Secret string
 	// Issuer of the account, e.g. micro
 	Issuer string
-	// Name of the acouunt e.g. an email or username
-	Name string
 }
 
 type GenerateOption func(o *GenerateOptions)
@@ -158,13 +159,6 @@ func WithIssuer(i string) GenerateOption {
 	}
 }
 
-// WithName for the generated account
-func WithName(n string) GenerateOption {
-	return func(o *GenerateOptions) {
-		o.Name = n
-	}
-}
-
 // NewGenerateOptions from a slice of options
 func NewGenerateOptions(opts ...GenerateOption) GenerateOptions {
 	var options GenerateOptions
@@ -222,7 +216,7 @@ func NewTokenOptions(opts ...TokenOption) TokenOptions {
 		o(&options)
 	}
 
-	// set defualt expiry of token
+	// set default expiry of token
 	if options.Expiry == 0 {
 		options.Expiry = time.Minute
 	}

auth/rules.go

@@ -83,7 +83,7 @@ func VerifyAccess(rules []*Rule, acc *Account, res *Resource) error {
 // not case sensitive.
 func include(slice []string, val string) bool {
 	for _, s := range slice {
-		if strings.ToLower(s) == strings.ToLower(val) {
+		if strings.EqualFold(s, val) {
 			return true
 		}
 	}

auth/rules_test.go

@@ -42,7 +42,7 @@ func TestVerify(t *testing.T) {
 			Account:  &Account{},
 			Resource: srvResource,
 			Rules: []*Rule{
-				&Rule{
+				{
 					Scope:    "",
 					Resource: catchallResource,
 				},
@@ -52,7 +52,7 @@ func TestVerify(t *testing.T) {
 			Name:     "CatchallPublicNoAccount",
 			Resource: srvResource,
 			Rules: []*Rule{
-				&Rule{
+				{
 					Scope:    "",
 					Resource: catchallResource,
 				},
@@ -63,7 +63,7 @@ func TestVerify(t *testing.T) {
 			Account:  &Account{},
 			Resource: srvResource,
 			Rules: []*Rule{
-				&Rule{
+				{
 					Scope:    "*",
 					Resource: catchallResource,
 				},
@@ -73,7 +73,7 @@ func TestVerify(t *testing.T) {
 			Name:     "CatchallPrivateNoAccount",
 			Resource: srvResource,
 			Rules: []*Rule{
-				&Rule{
+				{
 					Scope:    "*",
 					Resource: catchallResource,
 				},
@@ -85,7 +85,7 @@ func TestVerify(t *testing.T) {
 			Resource: srvResource,
 			Account:  &Account{},
 			Rules: []*Rule{
-				&Rule{
+				{
 					Scope: "*",
 					Resource: &Resource{
 						Type:     srvResource.Type,
@@ -100,7 +100,7 @@ func TestVerify(t *testing.T) {
 			Resource: srvResource,
 			Account:  &Account{},
 			Rules: []*Rule{
-				&Rule{
+				{
 					Scope: "*",
 					Resource: &Resource{
 						Type:     srvResource.Type,
@@ -118,7 +118,7 @@ func TestVerify(t *testing.T) {
 				Scopes: []string{"neededscope"},
 			},
 			Rules: []*Rule{
-				&Rule{
+				{
 					Scope:    "neededscope",
 					Resource: srvResource,
 				},
@@ -131,7 +131,7 @@ func TestVerify(t *testing.T) {
 				Scopes: []string{"neededscope"},
 			},
 			Rules: []*Rule{
-				&Rule{
+				{
 					Scope:    "invalidscope",
 					Resource: srvResource,
 				},
@@ -143,7 +143,7 @@ func TestVerify(t *testing.T) {
 			Resource: srvResource,
 			Account:  &Account{},
 			Rules: []*Rule{
-				&Rule{
+				{
 					Scope:    "*",
 					Resource: catchallResource,
 					Access:   AccessDenied,
@@ -156,7 +156,7 @@ func TestVerify(t *testing.T) {
 			Resource: srvResource,
 			Account:  &Account{},
 			Rules: []*Rule{
-				&Rule{
+				{
 					Scope:    "*",
 					Resource: catchallResource,
 					Access:   AccessDenied,
@@ -169,13 +169,13 @@ func TestVerify(t *testing.T) {
 			Resource: srvResource,
 			Account:  &Account{},
 			Rules: []*Rule{
-				&Rule{
+				{
 					Scope:    "*",
 					Resource: catchallResource,
 					Access:   AccessGranted,
 					Priority: 1,
 				},
-				&Rule{
+				{
 					Scope:    "*",
 					Resource: catchallResource,
 					Access:   AccessDenied,
@@ -188,13 +188,13 @@ func TestVerify(t *testing.T) {
 			Resource: srvResource,
 			Account:  &Account{},
 			Rules: []*Rule{
-				&Rule{
+				{
 					Scope:    "*",
 					Resource: catchallResource,
 					Access:   AccessGranted,
 					Priority: 0,
 				},
-				&Rule{
+				{
 					Scope:    "*",
 					Resource: catchallResource,
 					Access:   AccessDenied,
@@ -208,7 +208,7 @@ func TestVerify(t *testing.T) {
 			Resource: webResource,
 			Account:  &Account{},
 			Rules: []*Rule{
-				&Rule{
+				{
 					Scope:    "*",
 					Resource: webResource,
 				},
@@ -219,7 +219,7 @@ func TestVerify(t *testing.T) {
 			Resource: webResource,
 			Account:  &Account{},
 			Rules: []*Rule{
-				&Rule{
+				{
 					Scope: "*",
 					Resource: &Resource{
 						Type:     webResource.Type,
@@ -235,7 +235,7 @@ func TestVerify(t *testing.T) {
 			Resource: webResource,
 			Account:  &Account{},
 			Rules: []*Rule{
-				&Rule{
+				{
 					Scope: "*",
 					Resource: &Resource{
 						Type:     webResource.Type,
@@ -250,7 +250,7 @@ func TestVerify(t *testing.T) {
 			Resource: webResource,
 			Account:  &Account{},
 			Rules: []*Rule{
-				&Rule{
+				{
 					Scope: "*",
 					Resource: &Resource{
 						Type:     webResource.Type,
@@ -265,7 +265,7 @@ func TestVerify(t *testing.T) {
 			Resource: webResource,
 			Account:  &Account{},
 			Rules: []*Rule{
-				&Rule{
+				{
 					Scope: "*",
 					Resource: &Resource{
 						Type:     webResource.Type,

broker/broker.go

@@ -1,6 +1,10 @@
 // Package broker is an interface used for asynchronous messaging
 package broker
 
+var (
+	DefaultBroker Broker = newBroker()
+)
+
 // Broker is an interface used for asynchronous messaging.
 type Broker interface {
 	Init(...Option) error
@@ -14,13 +18,21 @@ type Broker interface {
 }
 
 // Handler is used to process messages via a subscription of a topic.
-type Handler func(*Message) error
+type Handler func(Event) error
 
-type ErrorHandler func(*Message, error)
+// Event is given to a subscription handler for processing
+type Event interface {
+	Topic() string
+	Message() *Message
+	Ack() error
+	Error() error
+}
 
+// Message is used to transfer data
 type Message struct {
 	Header map[string]string
 	Body   []byte
+	Error  error
 }
 
 // Subscriber is a convenience return type for the Subscribe method

broker/http/http.go

@@ -1,689 +0,0 @@
-// Package http provides a http based message broker
-package http
-
-import (
-	"bytes"
-	"context"
-	"crypto/tls"
-	"errors"
-	"fmt"
-	"io"
-	"io/ioutil"
-	"math/rand"
-	"net"
-	"net/http"
-	"net/url"
-	"runtime"
-	"sync"
-	"time"
-
-	"github.com/google/uuid"
-	"github.com/micro/go-micro/v3/broker"
-	"github.com/micro/go-micro/v3/codec/json"
-	merr "github.com/micro/go-micro/v3/errors"
-	"github.com/micro/go-micro/v3/registry"
-	"github.com/micro/go-micro/v3/registry/cache"
-	"github.com/micro/go-micro/v3/registry/mdns"
-	maddr "github.com/micro/go-micro/v3/util/addr"
-	mnet "github.com/micro/go-micro/v3/util/net"
-	mls "github.com/micro/go-micro/v3/util/tls"
-	"golang.org/x/net/http2"
-)
-
-// HTTP Broker is a point to point async broker
-type httpBroker struct {
-	id      string
-	address string
-	opts    broker.Options
-
-	mux *http.ServeMux
-
-	c *http.Client
-	r registry.Registry
-
-	sync.RWMutex
-	subscribers map[string][]*httpSubscriber
-	running     bool
-	exit        chan chan error
-
-	// offline message inbox
-	mtx   sync.RWMutex
-	inbox map[string][][]byte
-}
-
-type httpSubscriber struct {
-	opts  broker.SubscribeOptions
-	id    string
-	topic string
-	fn    broker.Handler
-	svc   *registry.Service
-	hb    *httpBroker
-}
-
-var (
-	DefaultPath      = "/"
-	DefaultAddress   = "127.0.0.1:0"
-	serviceName      = "micro.http.broker"
-	broadcastVersion = "ff.http.broadcast"
-	registerTTL      = time.Minute
-	registerInterval = time.Second * 30
-)
-
-func init() {
-	rand.Seed(time.Now().Unix())
-}
-
-func newTransport(config *tls.Config) *http.Transport {
-	if config == nil {
-		config = &tls.Config{
-			InsecureSkipVerify: true,
-		}
-	}
-
-	dialTLS := func(network string, addr string) (net.Conn, error) {
-		return tls.Dial(network, addr, config)
-	}
-
-	t := &http.Transport{
-		Proxy: http.ProxyFromEnvironment,
-		Dial: (&net.Dialer{
-			Timeout:   30 * time.Second,
-			KeepAlive: 30 * time.Second,
-		}).Dial,
-		TLSHandshakeTimeout: 10 * time.Second,
-		DialTLS:             dialTLS,
-	}
-	runtime.SetFinalizer(&t, func(tr **http.Transport) {
-		(*tr).CloseIdleConnections()
-	})
-
-	// setup http2
-	http2.ConfigureTransport(t)
-
-	return t
-}
-
-func newHttpBroker(opts ...broker.Option) broker.Broker {
-	options := broker.Options{
-		Codec:    json.Marshaler{},
-		Context:  context.TODO(),
-		Registry: mdns.NewRegistry(),
-	}
-
-	for _, o := range opts {
-		o(&options)
-	}
-
-	// set address
-	addr := DefaultAddress
-
-	if len(options.Addrs) > 0 && len(options.Addrs[0]) > 0 {
-		addr = options.Addrs[0]
-	}
-
-	h := &httpBroker{
-		id:          uuid.New().String(),
-		address:     addr,
-		opts:        options,
-		r:           options.Registry,
-		c:           &http.Client{Transport: newTransport(options.TLSConfig)},
-		subscribers: make(map[string][]*httpSubscriber),
-		exit:        make(chan chan error),
-		mux:         http.NewServeMux(),
-		inbox:       make(map[string][][]byte),
-	}
-
-	// specify the message handler
-	h.mux.Handle(DefaultPath, h)
-
-	// get optional handlers
-	if h.opts.Context != nil {
-		handlers, ok := h.opts.Context.Value("http_handlers").(map[string]http.Handler)
-		if ok {
-			for pattern, handler := range handlers {
-				h.mux.Handle(pattern, handler)
-			}
-		}
-	}
-
-	return h
-}
-
-func (h *httpSubscriber) Options() broker.SubscribeOptions {
-	return h.opts
-}
-
-func (h *httpSubscriber) Topic() string {
-	return h.topic
-}
-
-func (h *httpSubscriber) Unsubscribe() error {
-	return h.hb.unsubscribe(h)
-}
-
-func (h *httpBroker) saveMessage(topic string, msg []byte) {
-	h.mtx.Lock()
-	defer h.mtx.Unlock()
-
-	// get messages
-	c := h.inbox[topic]
-
-	// save message
-	c = append(c, msg)
-
-	// max length 64
-	if len(c) > 64 {
-		c = c[:64]
-	}
-
-	// save inbox
-	h.inbox[topic] = c
-}
-
-func (h *httpBroker) getMessage(topic string, num int) [][]byte {
-	h.mtx.Lock()
-	defer h.mtx.Unlock()
-
-	// get messages
-	c, ok := h.inbox[topic]
-	if !ok {
-		return nil
-	}
-
-	// more message than requests
-	if len(c) >= num {
-		msg := c[:num]
-		h.inbox[topic] = c[num:]
-		return msg
-	}
-
-	// reset inbox
-	h.inbox[topic] = nil
-
-	// return all messages
-	return c
-}
-
-func (h *httpBroker) subscribe(s *httpSubscriber) error {
-	h.Lock()
-	defer h.Unlock()
-
-	if err := h.r.Register(s.svc, registry.RegisterTTL(registerTTL)); err != nil {
-		return err
-	}
-
-	h.subscribers[s.topic] = append(h.subscribers[s.topic], s)
-	return nil
-}
-
-func (h *httpBroker) unsubscribe(s *httpSubscriber) error {
-	h.Lock()
-	defer h.Unlock()
-
-	//nolint:prealloc
-	var subscribers []*httpSubscriber
-
-	// look for subscriber
-	for _, sub := range h.subscribers[s.topic] {
-		// deregister and skip forward
-		if sub == s {
-			_ = h.r.Deregister(sub.svc)
-			continue
-		}
-		// keep subscriber
-		subscribers = append(subscribers, sub)
-	}
-
-	// set subscribers
-	h.subscribers[s.topic] = subscribers
-
-	return nil
-}
-
-func (h *httpBroker) run(l net.Listener) {
-	t := time.NewTicker(registerInterval)
-	defer t.Stop()
-
-	for {
-		select {
-		// heartbeat for each subscriber
-		case <-t.C:
-			h.RLock()
-			for _, subs := range h.subscribers {
-				for _, sub := range subs {
-					_ = h.r.Register(sub.svc, registry.RegisterTTL(registerTTL))
-				}
-			}
-			h.RUnlock()
-		// received exit signal
-		case ch := <-h.exit:
-			ch <- l.Close()
-			h.RLock()
-			for _, subs := range h.subscribers {
-				for _, sub := range subs {
-					_ = h.r.Deregister(sub.svc)
-				}
-			}
-			h.RUnlock()
-			return
-		}
-	}
-}
-
-func (h *httpBroker) ServeHTTP(w http.ResponseWriter, req *http.Request) {
-	if req.Method != "POST" {
-		err := merr.BadRequest("go.micro.broker", "Method not allowed")
-		http.Error(w, err.Error(), http.StatusMethodNotAllowed)
-		return
-	}
-	defer req.Body.Close()
-
-	req.ParseForm()
-
-	b, err := ioutil.ReadAll(req.Body)
-	if err != nil {
-		errr := merr.InternalServerError("go.micro.broker", "Error reading request body: %v", err)
-		w.WriteHeader(500)
-		w.Write([]byte(errr.Error()))
-		return
-	}
-
-	var msg *broker.Message
-	if err = h.opts.Codec.Unmarshal(b, &msg); err != nil {
-		errr := merr.InternalServerError("go.micro.broker", "Error parsing request body: %v", err)
-		w.WriteHeader(500)
-		w.Write([]byte(errr.Error()))
-		return
-	}
-
-	topic := msg.Header["Micro-Topic"]
-
-	if len(topic) == 0 {
-		errr := merr.InternalServerError("go.micro.broker", "Topic not found")
-		w.WriteHeader(500)
-		w.Write([]byte(errr.Error()))
-		return
-	}
-
-	id := req.Form.Get("id")
-
-	//nolint:prealloc
-	var subs []broker.Handler
-
-	h.RLock()
-	for _, subscriber := range h.subscribers[topic] {
-		if id != subscriber.id {
-			continue
-		}
-		subs = append(subs, subscriber.fn)
-	}
-	h.RUnlock()
-
-	// execute the handler
-	for _, fn := range subs {
-		fn(msg)
-	}
-}
-
-func (h *httpBroker) Address() string {
-	h.RLock()
-	defer h.RUnlock()
-	return h.address
-}
-
-func (h *httpBroker) Connect() error {
-	h.RLock()
-	if h.running {
-		h.RUnlock()
-		return nil
-	}
-	h.RUnlock()
-
-	h.Lock()
-	defer h.Unlock()
-
-	var l net.Listener
-	var err error
-
-	if h.opts.Secure || h.opts.TLSConfig != nil {
-		config := h.opts.TLSConfig
-
-		fn := func(addr string) (net.Listener, error) {
-			if config == nil {
-				hosts := []string{addr}
-
-				// check if its a valid host:port
-				if host, _, err := net.SplitHostPort(addr); err == nil {
-					if len(host) == 0 {
-						hosts = maddr.IPs()
-					} else {
-						hosts = []string{host}
-					}
-				}
-
-				// generate a certificate
-				cert, err := mls.Certificate(hosts...)
-				if err != nil {
-					return nil, err
-				}
-				config = &tls.Config{Certificates: []tls.Certificate{cert}}
-			}
-			return tls.Listen("tcp", addr, config)
-		}
-
-		l, err = mnet.Listen(h.address, fn)
-	} else {
-		fn := func(addr string) (net.Listener, error) {
-			return net.Listen("tcp", addr)
-		}
-
-		l, err = mnet.Listen(h.address, fn)
-	}
-
-	if err != nil {
-		return err
-	}
-
-	addr := h.address
-	h.address = l.Addr().String()
-
-	go http.Serve(l, h.mux)
-	go func() {
-		h.run(l)
-		h.Lock()
-		h.opts.Addrs = []string{addr}
-		h.address = addr
-		h.Unlock()
-	}()
-
-	// get registry
-	reg := h.opts.Registry
-	if reg == nil {
-		reg = mdns.NewRegistry()
-	}
-	// set cache
-	h.r = cache.New(reg)
-
-	// set running
-	h.running = true
-	return nil
-}
-
-func (h *httpBroker) Disconnect() error {
-	h.RLock()
-	if !h.running {
-		h.RUnlock()
-		return nil
-	}
-	h.RUnlock()
-
-	h.Lock()
-	defer h.Unlock()
-
-	// stop cache
-	rc, ok := h.r.(cache.Cache)
-	if ok {
-		rc.Stop()
-	}
-
-	// exit and return err
-	ch := make(chan error)
-	h.exit <- ch
-	err := <-ch
-
-	// set not running
-	h.running = false
-	return err
-}
-
-func (h *httpBroker) Init(opts ...broker.Option) error {
-	h.RLock()
-	if h.running {
-		h.RUnlock()
-		return errors.New("cannot init while connected")
-	}
-	h.RUnlock()
-
-	h.Lock()
-	defer h.Unlock()
-
-	for _, o := range opts {
-		o(&h.opts)
-	}
-
-	if len(h.opts.Addrs) > 0 && len(h.opts.Addrs[0]) > 0 {
-		h.address = h.opts.Addrs[0]
-	}
-
-	if len(h.id) == 0 {
-		h.id = "go.micro.http.broker-" + uuid.New().String()
-	}
-
-	// get registry
-	reg := h.opts.Registry
-	if reg == nil {
-		reg = mdns.NewRegistry()
-	}
-
-	// get cache
-	if rc, ok := h.r.(cache.Cache); ok {
-		rc.Stop()
-	}
-
-	// set registry
-	h.r = cache.New(reg)
-
-	// reconfigure tls config
-	if c := h.opts.TLSConfig; c != nil {
-		h.c = &http.Client{
-			Transport: newTransport(c),
-		}
-	}
-
-	return nil
-}
-
-func (h *httpBroker) Options() broker.Options {
-	return h.opts
-}
-
-func (h *httpBroker) Publish(topic string, msg *broker.Message, opts ...broker.PublishOption) error {
-	// create the message first
-	m := &broker.Message{
-		Header: make(map[string]string),
-		Body:   msg.Body,
-	}
-
-	for k, v := range msg.Header {
-		m.Header[k] = v
-	}
-
-	m.Header["Micro-Topic"] = topic
-
-	// encode the message
-	b, err := h.opts.Codec.Marshal(m)
-	if err != nil {
-		return err
-	}
-
-	// save the message
-	h.saveMessage(topic, b)
-
-	// now attempt to get the service
-	h.RLock()
-	s, err := h.r.GetService(serviceName)
-	if err != nil {
-		h.RUnlock()
-		return err
-	}
-	h.RUnlock()
-
-	pub := func(node *registry.Node, t string, b []byte) error {
-		scheme := "http"
-
-		// check if secure is added in metadata
-		if node.Metadata["secure"] == "true" {
-			scheme = "https"
-		}
-
-		vals := url.Values{}
-		vals.Add("id", node.Id)
-
-		uri := fmt.Sprintf("%s://%s%s?%s", scheme, node.Address, DefaultPath, vals.Encode())
-		r, err := h.c.Post(uri, "application/json", bytes.NewReader(b))
-		if err != nil {
-			return err
-		}
-
-		// discard response body
-		io.Copy(ioutil.Discard, r.Body)
-		r.Body.Close()
-		return nil
-	}
-
-	srv := func(s []*registry.Service, b []byte) {
-		for _, service := range s {
-			var nodes []*registry.Node
-
-			for _, node := range service.Nodes {
-				// only use nodes tagged with broker http
-				if node.Metadata["broker"] != "http" {
-					continue
-				}
-
-				// look for nodes for the topic
-				if node.Metadata["topic"] != topic {
-					continue
-				}
-
-				nodes = append(nodes, node)
-			}
-
-			// only process if we have nodes
-			if len(nodes) == 0 {
-				continue
-			}
-
-			switch service.Version {
-			// broadcast version means broadcast to all nodes
-			case broadcastVersion:
-				var success bool
-
-				// publish to all nodes
-				for _, node := range nodes {
-					// publish async
-					if err := pub(node, topic, b); err == nil {
-						success = true
-					}
-				}
-
-				// save if it failed to publish at least once
-				if !success {
-					h.saveMessage(topic, b)
-				}
-			default:
-				// select node to publish to
-				node := nodes[rand.Int()%len(nodes)]
-
-				// publish async to one node
-				if err := pub(node, topic, b); err != nil {
-					// if failed save it
-					h.saveMessage(topic, b)
-				}
-			}
-		}
-	}
-
-	// do the rest async
-	go func() {
-		// get a third of the backlog
-		messages := h.getMessage(topic, 8)
-		delay := (len(messages) > 1)
-
-		// publish all the messages
-		for _, msg := range messages {
-			// serialize here
-			srv(s, msg)
-
-			// sending a backlog of messages
-			if delay {
-				time.Sleep(time.Millisecond * 100)
-			}
-		}
-	}()
-
-	return nil
-}
-
-func (h *httpBroker) Subscribe(topic string, handler broker.Handler, opts ...broker.SubscribeOption) (broker.Subscriber, error) {
-	var err error
-	var host, port string
-	options := broker.NewSubscribeOptions(opts...)
-
-	// parse address for host, port
-	host, port, err = net.SplitHostPort(h.Address())
-	if err != nil {
-		return nil, err
-	}
-
-	addr, err := maddr.Extract(host)
-	if err != nil {
-		return nil, err
-	}
-
-	var secure bool
-
-	if h.opts.Secure || h.opts.TLSConfig != nil {
-		secure = true
-	}
-
-	// register service
-	node := &registry.Node{
-		Id:      topic + "-" + h.id,
-		Address: mnet.HostPort(addr, port),
-		Metadata: map[string]string{
-			"secure": fmt.Sprintf("%t", secure),
-			"broker": "http",
-			"topic":  topic,
-		},
-	}
-
-	// check for queue group or broadcast queue
-	version := options.Queue
-	if len(version) == 0 {
-		version = broadcastVersion
-	}
-
-	service := &registry.Service{
-		Name:    serviceName,
-		Version: version,
-		Nodes:   []*registry.Node{node},
-	}
-
-	// generate subscriber
-	subscriber := &httpSubscriber{
-		opts:  options,
-		hb:    h,
-		id:    node.Id,
-		topic: topic,
-		fn:    handler,
-		svc:   service,
-	}
-
-	// subscribe now
-	if err := h.subscribe(subscriber); err != nil {
-		return nil, err
-	}
-
-	// return the subscriber
-	return subscriber, nil
-}
-
-func (h *httpBroker) String() string {
-	return "http"
-}
-
-// NewBroker returns a new http broker
-func NewBroker(opts ...broker.Option) broker.Broker {
-	return newHttpBroker(opts...)
-}

broker/http/http_test.go

@@ -1,377 +0,0 @@
-package http
-
-import (
-	"sync"
-	"testing"
-	"time"
-
-	"github.com/google/uuid"
-	"github.com/micro/go-micro/v3/broker"
-	"github.com/micro/go-micro/v3/registry"
-	"github.com/micro/go-micro/v3/registry/memory"
-)
-
-var (
-	// mock data
-	testData = map[string][]*registry.Service{
-		"foo": {
-			{
-				Name:    "foo",
-				Version: "1.0.0",
-				Nodes: []*registry.Node{
-					{
-						Id:      "foo-1.0.0-123",
-						Address: "localhost:9999",
-					},
-					{
-						Id:      "foo-1.0.0-321",
-						Address: "localhost:9999",
-					},
-				},
-			},
-			{
-				Name:    "foo",
-				Version: "1.0.1",
-				Nodes: []*registry.Node{
-					{
-						Id:      "foo-1.0.1-321",
-						Address: "localhost:6666",
-					},
-				},
-			},
-			{
-				Name:    "foo",
-				Version: "1.0.3",
-				Nodes: []*registry.Node{
-					{
-						Id:      "foo-1.0.3-345",
-						Address: "localhost:8888",
-					},
-				},
-			},
-		},
-	}
-)
-
-func newTestRegistry() registry.Registry {
-	return memory.NewRegistry(memory.Services(testData))
-}
-
-func sub(be *testing.B, c int) {
-	be.StopTimer()
-	m := newTestRegistry()
-
-	b := NewBroker(broker.Registry(m))
-	topic := uuid.New().String()
-
-	if err := b.Init(); err != nil {
-		be.Fatalf("Unexpected init error: %v", err)
-	}
-
-	if err := b.Connect(); err != nil {
-		be.Fatalf("Unexpected connect error: %v", err)
-	}
-
-	msg := &broker.Message{
-		Header: map[string]string{
-			"Content-Type": "application/json",
-		},
-		Body: []byte(`{"message": "Hello World"}`),
-	}
-
-	var subs []broker.Subscriber
-	done := make(chan bool, c)
-
-	for i := 0; i < c; i++ {
-		sub, err := b.Subscribe(topic, func(m *broker.Message) error {
-			done <- true
-
-			if string(m.Body) != string(msg.Body) {
-				be.Fatalf("Unexpected msg %s, expected %s", string(m.Body), string(msg.Body))
-			}
-
-			return nil
-		}, broker.Queue("shared"))
-		if err != nil {
-			be.Fatalf("Unexpected subscribe error: %v", err)
-		}
-		subs = append(subs, sub)
-	}
-
-	for i := 0; i < be.N; i++ {
-		be.StartTimer()
-		if err := b.Publish(topic, msg); err != nil {
-			be.Fatalf("Unexpected publish error: %v", err)
-		}
-		<-done
-		be.StopTimer()
-	}
-
-	for _, sub := range subs {
-		sub.Unsubscribe()
-	}
-
-	if err := b.Disconnect(); err != nil {
-		be.Fatalf("Unexpected disconnect error: %v", err)
-	}
-}
-
-func pub(be *testing.B, c int) {
-	be.StopTimer()
-	m := newTestRegistry()
-	b := NewBroker(broker.Registry(m))
-	topic := uuid.New().String()
-
-	if err := b.Init(); err != nil {
-		be.Fatalf("Unexpected init error: %v", err)
-	}
-
-	if err := b.Connect(); err != nil {
-		be.Fatalf("Unexpected connect error: %v", err)
-	}
-
-	msg := &broker.Message{
-		Header: map[string]string{
-			"Content-Type": "application/json",
-		},
-		Body: []byte(`{"message": "Hello World"}`),
-	}
-
-	done := make(chan bool, c*4)
-
-	sub, err := b.Subscribe(topic, func(m *broker.Message) error {
-		done <- true
-		if string(m.Body) != string(msg.Body) {
-			be.Fatalf("Unexpected msg %s, expected %s", string(m.Body), string(msg.Body))
-		}
-		return nil
-	}, broker.Queue("shared"))
-	if err != nil {
-		be.Fatalf("Unexpected subscribe error: %v", err)
-	}
-
-	var wg sync.WaitGroup
-	ch := make(chan int, c*4)
-	be.StartTimer()
-
-	for i := 0; i < c; i++ {
-		go func() {
-			for range ch {
-				if err := b.Publish(topic, msg); err != nil {
-					be.Fatalf("Unexpected publish error: %v", err)
-				}
-				select {
-				case <-done:
-				case <-time.After(time.Second):
-				}
-				wg.Done()
-			}
-		}()
-	}
-
-	for i := 0; i < be.N; i++ {
-		wg.Add(1)
-		ch <- i
-	}
-
-	wg.Wait()
-	be.StopTimer()
-	sub.Unsubscribe()
-	close(ch)
-	close(done)
-
-	if err := b.Disconnect(); err != nil {
-		be.Fatalf("Unexpected disconnect error: %v", err)
-	}
-}
-
-func TestBroker(t *testing.T) {
-	m := newTestRegistry()
-	b := NewBroker(broker.Registry(m))
-
-	if err := b.Init(); err != nil {
-		t.Fatalf("Unexpected init error: %v", err)
-	}
-
-	if err := b.Connect(); err != nil {
-		t.Fatalf("Unexpected connect error: %v", err)
-	}
-
-	msg := &broker.Message{
-		Header: map[string]string{
-			"Content-Type": "application/json",
-		},
-		Body: []byte(`{"message": "Hello World"}`),
-	}
-
-	done := make(chan bool)
-
-	sub, err := b.Subscribe("test", func(m *broker.Message) error {
-
-		if string(m.Body) != string(msg.Body) {
-			t.Fatalf("Unexpected msg %s, expected %s", string(m.Body), string(msg.Body))
-		}
-
-		close(done)
-		return nil
-	})
-	if err != nil {
-		t.Fatalf("Unexpected subscribe error: %v", err)
-	}
-
-	if err := b.Publish("test", msg); err != nil {
-		t.Fatalf("Unexpected publish error: %v", err)
-	}
-
-	<-done
-	sub.Unsubscribe()
-
-	if err := b.Disconnect(); err != nil {
-		t.Fatalf("Unexpected disconnect error: %v", err)
-	}
-}
-
-func TestConcurrentSubBroker(t *testing.T) {
-	m := newTestRegistry()
-	b := NewBroker(broker.Registry(m))
-
-	if err := b.Init(); err != nil {
-		t.Fatalf("Unexpected init error: %v", err)
-	}
-
-	if err := b.Connect(); err != nil {
-		t.Fatalf("Unexpected connect error: %v", err)
-	}
-
-	msg := &broker.Message{
-		Header: map[string]string{
-			"Content-Type": "application/json",
-		},
-		Body: []byte(`{"message": "Hello World"}`),
-	}
-
-	var subs []broker.Subscriber
-	var wg sync.WaitGroup
-
-	for i := 0; i < 10; i++ {
-		sub, err := b.Subscribe("test", func(m *broker.Message) error {
-			defer wg.Done()
-
-			if string(m.Body) != string(msg.Body) {
-				t.Fatalf("Unexpected msg %s, expected %s", string(m.Body), string(msg.Body))
-			}
-
-			return nil
-		})
-		if err != nil {
-			t.Fatalf("Unexpected subscribe error: %v", err)
-		}
-
-		wg.Add(1)
-		subs = append(subs, sub)
-	}
-
-	if err := b.Publish("test", msg); err != nil {
-		t.Fatalf("Unexpected publish error: %v", err)
-	}
-
-	wg.Wait()
-
-	for _, sub := range subs {
-		sub.Unsubscribe()
-	}
-
-	if err := b.Disconnect(); err != nil {
-		t.Fatalf("Unexpected disconnect error: %v", err)
-	}
-}
-
-func TestConcurrentPubBroker(t *testing.T) {
-	m := newTestRegistry()
-	b := NewBroker(broker.Registry(m))
-
-	if err := b.Init(); err != nil {
-		t.Fatalf("Unexpected init error: %v", err)
-	}
-
-	if err := b.Connect(); err != nil {
-		t.Fatalf("Unexpected connect error: %v", err)
-	}
-
-	msg := &broker.Message{
-		Header: map[string]string{
-			"Content-Type": "application/json",
-		},
-		Body: []byte(`{"message": "Hello World"}`),
-	}
-
-	var wg sync.WaitGroup
-
-	sub, err := b.Subscribe("test", func(m *broker.Message) error {
-		defer wg.Done()
-
-		if string(m.Body) != string(msg.Body) {
-			t.Fatalf("Unexpected msg %s, expected %s", string(m.Body), string(msg.Body))
-		}
-
-		return nil
-	})
-	if err != nil {
-		t.Fatalf("Unexpected subscribe error: %v", err)
-	}
-
-	for i := 0; i < 10; i++ {
-		wg.Add(1)
-
-		if err := b.Publish("test", msg); err != nil {
-			t.Fatalf("Unexpected publish error: %v", err)
-		}
-	}
-
-	wg.Wait()
-
-	sub.Unsubscribe()
-
-	if err := b.Disconnect(); err != nil {
-		t.Fatalf("Unexpected disconnect error: %v", err)
-	}
-}
-
-func BenchmarkSub1(b *testing.B) {
-	sub(b, 1)
-}
-func BenchmarkSub8(b *testing.B) {
-	sub(b, 8)
-}
-
-func BenchmarkSub32(b *testing.B) {
-	sub(b, 32)
-}
-
-func BenchmarkSub64(b *testing.B) {
-	sub(b, 64)
-}
-
-func BenchmarkSub128(b *testing.B) {
-	sub(b, 128)
-}
-
-func BenchmarkPub1(b *testing.B) {
-	pub(b, 1)
-}
-
-func BenchmarkPub8(b *testing.B) {
-	pub(b, 8)
-}
-
-func BenchmarkPub32(b *testing.B) {
-	pub(b, 32)
-}
-
-func BenchmarkPub64(b *testing.B) {
-	pub(b, 64)
-}
-
-func BenchmarkPub128(b *testing.B) {
-	pub(b, 128)
-}

broker/http/options.go

@@ -1,23 +0,0 @@
-package http
-
-import (
-	"context"
-	"net/http"
-
-	"github.com/micro/go-micro/v3/broker"
-)
-
-// Handle registers the handler for the given pattern.
-func Handle(pattern string, handler http.Handler) broker.Option {
-	return func(o *broker.Options) {
-		if o.Context == nil {
-			o.Context = context.Background()
-		}
-		handlers, ok := o.Context.Value("http_handlers").(map[string]http.Handler)
-		if !ok {
-			handlers = make(map[string]http.Handler)
-		}
-		handlers[pattern] = handler
-		o.Context = context.WithValue(o.Context, "http_handlers", handlers)
-	}
-}

broker/memory/memory.go

@@ -1,183 +0,0 @@
-// Package memory provides a memory broker
-package memory
-
-import (
-	"context"
-	"errors"
-	"math/rand"
-	"sync"
-	"time"
-
-	"github.com/google/uuid"
-	"github.com/micro/go-micro/v3/broker"
-	maddr "github.com/micro/go-micro/v3/util/addr"
-	mnet "github.com/micro/go-micro/v3/util/net"
-)
-
-type memoryBroker struct {
-	opts broker.Options
-
-	addr string
-	sync.RWMutex
-	connected   bool
-	Subscribers map[string][]*memorySubscriber
-}
-
-type memorySubscriber struct {
-	id      string
-	topic   string
-	exit    chan bool
-	handler broker.Handler
-	opts    broker.SubscribeOptions
-}
-
-func (m *memoryBroker) Options() broker.Options {
-	return m.opts
-}
-
-func (m *memoryBroker) Address() string {
-	return m.addr
-}
-
-func (m *memoryBroker) Connect() 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
-	}
-	i := rand.Intn(20000)
-	// set addr with port
-	addr = mnet.HostPort(addr, 10000+i)
-
-	m.addr = addr
-	m.connected = true
-
-	return nil
-}
-
-func (m *memoryBroker) Disconnect() error {
-	m.Lock()
-	defer m.Unlock()
-
-	if !m.connected {
-		return nil
-	}
-
-	m.connected = false
-
-	return nil
-}
-
-func (m *memoryBroker) Init(opts ...broker.Option) error {
-	for _, o := range opts {
-		o(&m.opts)
-	}
-	return nil
-}
-
-func (m *memoryBroker) Publish(topic string, msg *broker.Message, opts ...broker.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
-	}
-
-	for _, sub := range subs {
-		if err := sub.handler(msg); err != nil {
-			if eh := sub.opts.ErrorHandler; eh != nil {
-				eh(msg, err)
-			}
-			continue
-		}
-	}
-
-	return nil
-}
-
-func (m *memoryBroker) Subscribe(topic string, handler broker.Handler, opts ...broker.SubscribeOption) (broker.Subscriber, error) {
-	m.RLock()
-	if !m.connected {
-		m.RUnlock()
-		return nil, errors.New("not connected")
-	}
-	m.RUnlock()
-
-	var options broker.SubscribeOptions
-	for _, o := range opts {
-		o(&options)
-	}
-
-	sub := &memorySubscriber{
-		exit:    make(chan bool, 1),
-		id:      uuid.New().String(),
-		topic:   topic,
-		handler: handler,
-		opts:    options,
-	}
-
-	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 *memorySubscriber) Options() broker.SubscribeOptions {
-	return m.opts
-}
-
-func (m *memorySubscriber) Topic() string {
-	return m.topic
-}
-
-func (m *memorySubscriber) Unsubscribe() error {
-	m.exit <- true
-	return nil
-}
-
-func NewBroker(opts ...broker.Option) broker.Broker {
-	options := broker.Options{
-		Context: context.Background(),
-	}
-
-	rand.Seed(time.Now().UnixNano())
-	for _, o := range opts {
-		o(&options)
-	}
-
-	return &memoryBroker{
-		opts:        options,
-		Subscribers: make(map[string][]*memorySubscriber),
-	}
-}

broker/memory/memory_test.go

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

broker/noop.go

@@ -0,0 +1,74 @@
+package broker
+
+type noopBroker struct {
+	opts Options
+}
+
+type noopSubscriber struct {
+	topic string
+	opts  SubscribeOptions
+}
+
+func (n *noopBroker) Init(opts ...Option) error {
+	for _, o := range opts {
+		o(&n.opts)
+	}
+
+	return nil
+}
+
+func (n *noopBroker) Options() Options {
+	return n.opts
+}
+
+func (n *noopBroker) Address() string {
+	return ""
+}
+
+func (n *noopBroker) Connect() error {
+	return nil
+}
+
+func (n *noopBroker) Disconnect() error {
+	return nil
+}
+
+func (n *noopBroker) Publish(topic string, m *Message, opts ...PublishOption) error {
+	return nil
+}
+
+func (n *noopBroker) Subscribe(topic string, h Handler, opts ...SubscribeOption) (Subscriber, error) {
+	options := NewSubscribeOptions()
+
+	for _, o := range opts {
+		o(&options)
+	}
+
+	return &noopSubscriber{topic: topic, opts: options}, nil
+}
+
+func (n *noopBroker) String() string {
+	return "noop"
+}
+
+func (n *noopSubscriber) Options() SubscribeOptions {
+	return n.opts
+}
+
+func (n *noopSubscriber) Topic() string {
+	return n.topic
+}
+
+func (n *noopSubscriber) Unsubscribe() error {
+	return nil
+}
+
+// newBroker returns a new noop broker
+func newBroker(opts ...Option) Broker {
+	options := NewOptions()
+
+	for _, o := range opts {
+		o(&options)
+	}
+	return &noopBroker{opts: options}
+}

broker/options.go

@@ -4,8 +4,9 @@ import (
 	"context"
 	"crypto/tls"
 
-	"github.com/micro/go-micro/v3/codec"
+	"github.com/unistack-org/micro/v3/codec"
-	"github.com/micro/go-micro/v3/registry"
+	"github.com/unistack-org/micro/v3/logger"
+	"github.com/unistack-org/micro/v3/registry"
 )
 
 type Options struct {
@@ -13,6 +14,11 @@ type Options struct {
 	Secure bool
 	Codec  codec.Marshaler
 
+	// Logger
+	Logger logger.Logger
+	// Handler executed when errors occur processing messages
+	ErrorHandler Handler
+
 	TLSConfig *tls.Config
 	// Registry used for clustering
 	Registry registry.Registry
@@ -21,6 +27,12 @@ type Options struct {
 	Context context.Context
 }
 
+func NewOptions() Options {
+	return Options{
+		Context: context.Background(),
+	}
+}
+
 type PublishOptions struct {
 	// Other options for implementations of the interface
 	// can be stored in a context
@@ -28,13 +40,16 @@ type PublishOptions struct {
 }
 
 type SubscribeOptions struct {
-	// Handler executed when errors occur processing messages
+	// AutoAck ack messages if handler returns nil err
-	ErrorHandler ErrorHandler
+	AutoAck bool
 
-	// Subscribers with the same queue name
+	// 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.
-	Queue string
+	Group string
 
 	// Other options for implementations of the interface
 	// can be stored in a context
@@ -55,7 +70,10 @@ func PublishContext(ctx context.Context) PublishOption {
 type SubscribeOption func(*SubscribeOptions)
 
 func NewSubscribeOptions(opts ...SubscribeOption) SubscribeOptions {
-	opt := SubscribeOptions{}
+	opt := SubscribeOptions{
+		AutoAck: true,
+		Context: context.Background(),
+	}
 
 	for _, o := range opts {
 		o(&opt)
@@ -79,18 +97,46 @@ func Codec(c codec.Marshaler) Option {
 	}
 }
 
+func DisableAutoAck() SubscribeOption {
+	return func(o *SubscribeOptions) {
+		o.AutoAck = false
+	}
+}
+
+// SubscribeAutoAck will disable auto acking of messages
+// after they have been handled.
+func SubscribeAutoAck(b bool) SubscribeOption {
+	return func(o *SubscribeOptions) {
+		o.AutoAck = b
+	}
+}
+
 // ErrorHandler will catch all broker errors that cant be handled
 // in normal way, for example Codec errors
-func HandleError(h ErrorHandler) SubscribeOption {
+func ErrorHandler(h Handler) Option {
+	return func(o *Options) {
+		o.ErrorHandler = h
+	}
+}
+
+// SubscribeErrorHandler will catch all broker errors that cant be handled
+// in normal way, for example Codec errors
+func SubscribeErrorHandler(h Handler) SubscribeOption {
 	return func(o *SubscribeOptions) {
 		o.ErrorHandler = h
 	}
 }
 
-// Queue sets the name of the queue to share messages on
 func Queue(name string) SubscribeOption {
 	return func(o *SubscribeOptions) {
-		o.Queue = name
+		o.Group = name
+	}
+}
+
+// SubscribeGroup sets the name of the queue to share messages on
+func SubscribeGroup(name string) SubscribeOption {
+	return func(o *SubscribeOptions) {
+		o.Group = name
 	}
 }
 
@@ -114,6 +160,13 @@ func TLSConfig(t *tls.Config) Option {
 	}
 }
 
+// Logger sets the logger
+func Logger(l logger.Logger) Option {
+	return func(o *Options) {
+		o.Logger = l
+	}
+}
+
 // SubscribeContext set context
 func SubscribeContext(ctx context.Context) SubscribeOption {
 	return func(o *SubscribeOptions) {

build/docker/docker.go

@@ -1,96 +0,0 @@
-// Package docker builds docker images
-package docker
-
-import (
-	"archive/tar"
-	"bytes"
-	"io/ioutil"
-	"os"
-	"path/filepath"
-
-	docker "github.com/fsouza/go-dockerclient"
-	"github.com/micro/go-micro/v3/build"
-	"github.com/micro/go-micro/v3/logger"
-)
-
-type dockerBuild struct {
-	Options build.Options
-	Client  *docker.Client
-}
-
-func (d *dockerBuild) Package(name string, s *build.Source) (*build.Package, error) {
-	image := name
-
-	buf := new(bytes.Buffer)
-	tw := tar.NewWriter(buf)
-	defer tw.Close()
-
-	dockerFile := "Dockerfile"
-
-	// open docker file
-	f, err := os.Open(filepath.Join(s.Path, dockerFile))
-	if err != nil {
-		return nil, err
-	}
-	// read docker file
-	by, err := ioutil.ReadAll(f)
-	if err != nil {
-		return nil, err
-	}
-
-	tarHeader := &tar.Header{
-		Name: dockerFile,
-		Size: int64(len(by)),
-	}
-	err = tw.WriteHeader(tarHeader)
-	if err != nil {
-		return nil, err
-	}
-	_, err = tw.Write(by)
-	if err != nil {
-		return nil, err
-	}
-	tr := bytes.NewReader(buf.Bytes())
-
-	err = d.Client.BuildImage(docker.BuildImageOptions{
-		Name:           image,
-		Dockerfile:     dockerFile,
-		InputStream:    tr,
-		OutputStream:   ioutil.Discard,
-		RmTmpContainer: true,
-		SuppressOutput: true,
-	})
-	if err != nil {
-		return nil, err
-	}
-	return &build.Package{
-		Name:   image,
-		Path:   image,
-		Type:   "docker",
-		Source: s,
-	}, nil
-}
-
-func (d *dockerBuild) Remove(b *build.Package) error {
-	return d.Client.RemoveImage(b.Name)
-}
-
-func (d *dockerBuild) String() string {
-	return "docker"
-}
-
-func NewBuild(opts ...build.Option) build.Build {
-	options := build.Options{}
-	for _, o := range opts {
-		o(&options)
-	}
-	endpoint := "unix:///var/run/docker.sock"
-	client, err := docker.NewClient(endpoint)
-	if err != nil {
-		logger.Fatal(err)
-	}
-	return &dockerBuild{
-		Options: options,
-		Client:  client,
-	}
-}

build/golang/golang.go

@@ -1,75 +0,0 @@
-// Package golang is a go package manager
-package golang
-
-import (
-	"os"
-	"os/exec"
-	"path/filepath"
-
-	"github.com/micro/go-micro/v3/build"
-)
-
-type goBuild struct {
-	Options build.Options
-	Cmd     string
-	Path    string
-}
-
-// whichGo locates the go command
-func whichGo() string {
-	// check GOROOT
-	if gr := os.Getenv("GOROOT"); len(gr) > 0 {
-		return filepath.Join(gr, "bin", "go")
-	}
-
-	// check path
-	for _, p := range filepath.SplitList(os.Getenv("PATH")) {
-		bin := filepath.Join(p, "go")
-		if _, err := os.Stat(bin); err == nil {
-			return bin
-		}
-	}
-
-	// best effort
-	return "go"
-}
-
-func (g *goBuild) Package(name string, src *build.Source) (*build.Package, error) {
-	binary := filepath.Join(g.Path, name)
-	source := src.Path
-
-	cmd := exec.Command(g.Cmd, "build", "-o", binary, source)
-	if err := cmd.Run(); err != nil {
-		return nil, err
-	}
-
-	return &build.Package{
-		Name:   name,
-		Path:   binary,
-		Type:   g.String(),
-		Source: src,
-	}, nil
-}
-
-func (g *goBuild) Remove(b *build.Package) error {
-	binary := filepath.Join(b.Path, b.Name)
-	return os.Remove(binary)
-}
-
-func (g *goBuild) String() string {
-	return "golang"
-}
-
-func NewBuild(opts ...build.Option) build.Build {
-	options := build.Options{
-		Path: os.TempDir(),
-	}
-	for _, o := range opts {
-		o(&options)
-	}
-	return &goBuild{
-		Options: options,
-		Cmd:     whichGo(),
-		Path:    options.Path,
-	}
-}

build/tar/tar.go

@@ -1,45 +0,0 @@
-// Package tar basically tarballs source code
-package tar
-
-import (
-	"os"
-	"path/filepath"
-
-	"github.com/micro/go-micro/v3/build"
-)
-
-type tarBuild struct{}
-
-func (t *tarBuild) Package(name string, src *build.Source) (*build.Package, error) {
-	pkg := name + ".tar.gz"
-	// path to the tarball
-	path := filepath.Join(os.TempDir(), src.Path, pkg)
-
-	// create a temp directory
-	if err := os.MkdirAll(filepath.Join(os.TempDir(), src.Path), 0755); err != nil {
-		return nil, err
-	}
-
-	if err := Compress(src.Path, path); err != nil {
-		return nil, err
-	}
-
-	return &build.Package{
-		Name:   name,
-		Path:   path,
-		Type:   t.String(),
-		Source: src,
-	}, nil
-}
-
-func (t *tarBuild) Remove(b *build.Package) error {
-	return os.Remove(b.Path)
-}
-
-func (t *tarBuild) String() string {
-	return "tar.gz"
-}
-
-func NewBuild(opts ...build.Option) build.Build {
-	return new(tarBuild)
-}

build/tar/util.go

@@ -1,92 +0,0 @@
-package tar
-
-import (
-	"archive/tar"
-	"bytes"
-	"compress/gzip"
-	"io"
-	"os"
-	"path/filepath"
-	"strings"
-)
-
-func Compress(source, dest string) error {
-	// tar + gzip
-	var buf bytes.Buffer
-	_ = compress(source, &buf)
-
-	// write the .tar.gzip
-	fileToWrite, err := os.OpenFile(dest, os.O_CREATE|os.O_RDWR, 0666)
-	if err != nil {
-		return err
-	}
-	_, err = io.Copy(fileToWrite, &buf)
-	return err
-}
-
-func compress(src string, buf io.Writer) error {
-	// tar > gzip > buf
-	zr := gzip.NewWriter(buf)
-	tw := tar.NewWriter(zr)
-
-	// walk through every file in the folder
-	filepath.Walk(src, func(file string, fi os.FileInfo, err error) error {
-
-		// generate tar header
-		header, err := tar.FileInfoHeader(fi, file)
-		if err != nil {
-			return err
-		}
-
-		// must provide real name
-		// (see https://golang.org/src/archive/tar/common.go?#L626)
-
-		srcWithSlash := src
-		if !strings.HasSuffix(src, string(filepath.Separator)) {
-			srcWithSlash = src + string(filepath.Separator)
-		}
-		header.Name = strings.ReplaceAll(file, srcWithSlash, "")
-		if header.Name == src || len(strings.TrimSpace(header.Name)) == 0 {
-			return nil
-		}
-
-		// @todo This is a quick hack to speed up whole repo uploads
-		// https://github.com/micro/micro/pull/956
-		if !fi.IsDir() && !strings.HasSuffix(header.Name, ".go") &&
-			!strings.HasSuffix(header.Name, ".mod") &&
-			!strings.HasSuffix(header.Name, ".sum") {
-			return nil
-		}
-
-		// write header
-		if err := tw.WriteHeader(header); err != nil {
-			return err
-		}
-		if fi.IsDir() {
-			return nil
-		}
-
-		// if not a dir, write file content
-
-		data, err := os.Open(file)
-		if err != nil {
-			return err
-		}
-		if _, err := io.Copy(tw, data); err != nil {
-			return err
-		}
-
-		return nil
-	})
-
-	// produce tar
-	if err := tw.Close(); err != nil {
-		return err
-	}
-	// produce gzip
-	if err := zr.Close(); err != nil {
-		return err
-	}
-	//
-	return nil
-}

cache/memory/memory.go

@@ -1,56 +0,0 @@
-// Package memory is an in memory cache
-package memory
-
-import (
-	"sync"
-
-	"github.com/micro/go-micro/v3/cache"
-	"github.com/micro/go-micro/v3/errors"
-)
-
-type memoryCache struct {
-	// TODO: use a decent caching library
-	sync.RWMutex
-	values map[string]interface{}
-}
-
-func (m *memoryCache) Init(opts ...cache.Option) error {
-	// TODO: implement
-	return nil
-}
-
-func (m *memoryCache) Get(key string) (interface{}, error) {
-	m.RLock()
-	defer m.RUnlock()
-
-	v, ok := m.values[key]
-	if !ok {
-		return nil, errors.NotFound("go.micro.cache", key+" not found")
-	}
-
-	return v, nil
-}
-
-func (m *memoryCache) Set(key string, val interface{}) error {
-	m.Lock()
-	m.values[key] = val
-	m.Unlock()
-	return nil
-}
-
-func (m *memoryCache) Delete(key string) error {
-	m.Lock()
-	delete(m.values, key)
-	m.Unlock()
-	return nil
-}
-
-func (m *memoryCache) String() string {
-	return "memory"
-}
-
-func NewCache(opts ...cache.Option) cache.Cache {
-	return &memoryCache{
-		values: make(map[string]interface{}),
-	}
-}

client/backoff.go

@@ -4,7 +4,7 @@ import (
 	"context"
 	"time"
 
-	"github.com/micro/go-micro/v3/util/backoff"
+	"github.com/unistack-org/micro/v3/util/backoff"
 )
 
 type BackoffFunc func(ctx context.Context, req Request, attempts int) (time.Duration, error)

client/backoff_test.go

@@ -4,8 +4,6 @@ import (
 	"context"
 	"testing"
 	"time"
-
-	"github.com/micro/go-micro/v3/codec"
 )
 
 func TestBackoff(t *testing.T) {
@@ -34,63 +32,3 @@ func TestBackoff(t *testing.T) {
 		}
 	}
 }
-
-type testRequest struct {
-	service     string
-	method      string
-	endpoint    string
-	contentType string
-	codec       codec.Codec
-	body        interface{}
-	opts        RequestOptions
-}
-
-func newRequest(service, endpoint string, request interface{}, contentType string, reqOpts ...RequestOption) Request {
-	var opts RequestOptions
-
-	for _, o := range reqOpts {
-		o(&opts)
-	}
-
-	// set the content-type specified
-	if len(opts.ContentType) > 0 {
-		contentType = opts.ContentType
-	}
-
-	return &testRequest{
-		service:     service,
-		method:      endpoint,
-		endpoint:    endpoint,
-		body:        request,
-		contentType: contentType,
-		opts:        opts,
-	}
-}
-
-func (r *testRequest) ContentType() string {
-	return r.contentType
-}
-
-func (r *testRequest) Service() string {
-	return r.service
-}
-
-func (r *testRequest) Method() string {
-	return r.method
-}
-
-func (r *testRequest) Endpoint() string {
-	return r.endpoint
-}
-
-func (r *testRequest) Body() interface{} {
-	return r.body
-}
-
-func (r *testRequest) Codec() codec.Writer {
-	return r.codec
-}
-
-func (r *testRequest) Stream() bool {
-	return r.opts.Stream
-}

client/cache.go

@@ -0,0 +1,66 @@
+package client
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"hash/fnv"
+	"time"
+
+	cache "github.com/patrickmn/go-cache"
+	"github.com/unistack-org/micro/v3/metadata"
+)
+
+// NewCache returns an initialised cache.
+func NewCache() *Cache {
+	return &Cache{
+		cache: cache.New(cache.NoExpiration, 30*time.Second),
+	}
+}
+
+// Cache for responses
+type Cache struct {
+	cache *cache.Cache
+}
+
+// Get a response from the cache
+func (c *Cache) Get(ctx context.Context, req Request) (interface{}, bool) {
+	return c.cache.Get(key(ctx, req))
+}
+
+// Set a response in the cache
+func (c *Cache) Set(ctx context.Context, req Request, rsp interface{}, expiry time.Duration) {
+	c.cache.Set(key(ctx, req), rsp, expiry)
+}
+
+// List the key value pairs in the cache
+func (c *Cache) List() map[string]string {
+	items := c.cache.Items()
+
+	rsp := make(map[string]string, len(items))
+	for k, v := range items {
+		bytes, _ := json.Marshal(v.Object)
+		rsp[k] = string(bytes)
+	}
+
+	return rsp
+}
+
+// key returns a hash for the context and request
+func key(ctx context.Context, req Request) string {
+	ns, _ := metadata.Get(ctx, "Micro-Namespace")
+
+	bytes, _ := json.Marshal(map[string]interface{}{
+		"namespace": ns,
+		"request": map[string]interface{}{
+			"service":  req.Service(),
+			"endpoint": req.Endpoint(),
+			"method":   req.Method(),
+			"body":     req.Body(),
+		},
+	})
+
+	h := fnv.New64()
+	h.Write(bytes)
+	return fmt.Sprintf("%x", h.Sum(nil))
+}

client/cache_test.go

@@ -0,0 +1,77 @@
+package client
+
+import (
+	"context"
+	"testing"
+	"time"
+
+	"github.com/unistack-org/micro/v3/metadata"
+)
+
+func TestCache(t *testing.T) {
+	ctx := context.TODO()
+	req := &testRequest{service: "go.micro.service.foo", method: "Foo.Bar"}
+
+	t.Run("CacheMiss", func(t *testing.T) {
+		if _, ok := NewCache().Get(ctx, req); ok {
+			t.Errorf("Expected to get no result from Get")
+		}
+	})
+
+	t.Run("CacheHit", func(t *testing.T) {
+		c := NewCache()
+
+		rsp := "theresponse"
+		c.Set(ctx, req, rsp, time.Minute)
+
+		if res, ok := c.Get(ctx, req); !ok {
+			t.Errorf("Expected a result, got nothing")
+		} else if res != rsp {
+			t.Errorf("Expected '%v' result, got '%v'", rsp, res)
+		}
+	})
+}
+
+func TestCacheKey(t *testing.T) {
+	ctx := context.TODO()
+
+	req1 := &testRequest{service: "go.micro.service.foo", method: "Foo.Bar"}
+	req2 := &testRequest{service: "go.micro.service.foo", method: "Foo.Baz"}
+	req3 := &testRequest{service: "go.micro.service.foo", method: "Foo.Bar", body: "customquery"}
+
+	t.Run("IdenticalRequests", func(t *testing.T) {
+		key1 := key(ctx, req1)
+		key2 := key(ctx, req1)
+		if key1 != key2 {
+			t.Errorf("Expected the keys to match for identical requests and context")
+		}
+	})
+
+	t.Run("DifferentRequestEndpoints", func(t *testing.T) {
+		key1 := key(ctx, req1)
+		key2 := key(ctx, req2)
+
+		if key1 == key2 {
+			t.Errorf("Expected the keys to differ for different request endpoints")
+		}
+	})
+
+	t.Run("DifferentRequestBody", func(t *testing.T) {
+		key1 := key(ctx, req2)
+		key2 := key(ctx, req3)
+
+		if key1 == key2 {
+			t.Errorf("Expected the keys to differ for different request bodies")
+		}
+	})
+
+	t.Run("DifferentMetadata", func(t *testing.T) {
+		mdCtx := metadata.Set(context.TODO(), "Micro-Namespace", "bar")
+		key1 := key(mdCtx, req1)
+		key2 := key(ctx, req1)
+
+		if key1 == key2 {
+			t.Errorf("Expected the keys to differ for different metadata")
+		}
+	})
+}

client/client.go

@@ -5,7 +5,11 @@ import (
 	"context"
 	"time"
 
-	"github.com/micro/go-micro/v3/codec"
+	"github.com/unistack-org/micro/v3/codec"
+)
+
+var (
+	DefaultClient Client
 )
 
 // Client is the interface used to make requests to services.

client/context.go

@@ -0,0 +1,16 @@
+package client
+
+import (
+	"context"
+)
+
+type clientKey struct{}
+
+func FromContext(ctx context.Context) (Client, bool) {
+	c, ok := ctx.Value(clientKey{}).(Client)
+	return c, ok
+}
+
+func NewContext(ctx context.Context, c Client) context.Context {
+	return context.WithValue(ctx, clientKey{}, c)
+}

client/grpc/README.md

@@ -1,25 +0,0 @@
-# GRPC Client
-
-The grpc client is a [micro.Client](https://godoc.org/github.com/micro/go-micro/client#Client) compatible client.
-
-## Overview
-
-The client makes use of the [google.golang.org/grpc](google.golang.org/grpc) framework for the underlying communication mechanism.
-
-## Usage
-
-Specify the client to your micro service
-
-```go
-import (
-	"github.com/micro/go-micro"
-	"github.com/micro/go-plugins/client/grpc"
-)
-
-func main() {
-	service := micro.NewService(
-		micro.Name("greeter"),
-		micro.Client(grpc.NewClient()),
-	)
-}
-```

client/grpc/codec.go

@@ -1,206 +0,0 @@
-package grpc
-
-import (
-	"encoding/json"
-	"fmt"
-	"strings"
-
-	b "bytes"
-
-	"github.com/golang/protobuf/jsonpb"
-	"github.com/golang/protobuf/proto"
-	"github.com/micro/go-micro/v3/codec"
-	"github.com/micro/go-micro/v3/codec/bytes"
-	"github.com/oxtoacart/bpool"
-	"google.golang.org/grpc"
-	"google.golang.org/grpc/encoding"
-)
-
-type jsonCodec struct{}
-type protoCodec struct{}
-type bytesCodec struct{}
-type wrapCodec struct{ encoding.Codec }
-
-var jsonpbMarshaler = &jsonpb.Marshaler{}
-var useNumber bool
-
-// create buffer pool with 16 instances each preallocated with 256 bytes
-var bufferPool = bpool.NewSizedBufferPool(16, 256)
-
-var (
-	defaultGRPCCodecs = map[string]encoding.Codec{
-		"application/json":         jsonCodec{},
-		"application/proto":        protoCodec{},
-		"application/protobuf":     protoCodec{},
-		"application/octet-stream": protoCodec{},
-		"application/grpc":         protoCodec{},
-		"application/grpc+json":    jsonCodec{},
-		"application/grpc+proto":   protoCodec{},
-		"application/grpc+bytes":   bytesCodec{},
-	}
-)
-
-// UseNumber fix unmarshal Number(8234567890123456789) to interface(8.234567890123457e+18)
-func UseNumber() {
-	useNumber = true
-}
-
-func (w wrapCodec) String() string {
-	return w.Codec.Name()
-}
-
-func (w wrapCodec) Marshal(v interface{}) ([]byte, error) {
-	b, ok := v.(*bytes.Frame)
-	if ok {
-		return b.Data, nil
-	}
-	return w.Codec.Marshal(v)
-}
-
-func (w wrapCodec) Unmarshal(data []byte, v interface{}) error {
-	b, ok := v.(*bytes.Frame)
-	if ok {
-		b.Data = data
-		return nil
-	}
-	return w.Codec.Unmarshal(data, v)
-}
-
-func (protoCodec) Marshal(v interface{}) ([]byte, error) {
-	switch m := v.(type) {
-	case *bytes.Frame:
-		return m.Data, nil
-	case proto.Message:
-		return proto.Marshal(m)
-	}
-	return nil, fmt.Errorf("failed to marshal: %v is not type of *bytes.Frame or proto.Message", v)
-}
-
-func (protoCodec) Unmarshal(data []byte, v interface{}) error {
-	m, ok := v.(proto.Message)
-	if !ok {
-		return fmt.Errorf("failed to unmarshal: %v is not type of proto.Message", v)
-	}
-	return proto.Unmarshal(data, m)
-}
-
-func (protoCodec) Name() string {
-	return "proto"
-}
-
-func (bytesCodec) Marshal(v interface{}) ([]byte, error) {
-	b, ok := v.(*[]byte)
-	if !ok {
-		return nil, fmt.Errorf("failed to marshal: %v is not type of *[]byte", v)
-	}
-	return *b, nil
-}
-
-func (bytesCodec) Unmarshal(data []byte, v interface{}) error {
-	b, ok := v.(*[]byte)
-	if !ok {
-		return fmt.Errorf("failed to unmarshal: %v is not type of *[]byte", v)
-	}
-	*b = data
-	return nil
-}
-
-func (bytesCodec) Name() string {
-	return "bytes"
-}
-
-func (jsonCodec) Marshal(v interface{}) ([]byte, error) {
-	if b, ok := v.(*bytes.Frame); ok {
-		return b.Data, nil
-	}
-
-	if pb, ok := v.(proto.Message); ok {
-		buf := bufferPool.Get()
-		defer bufferPool.Put(buf)
-		if err := jsonpbMarshaler.Marshal(buf, pb); err != nil {
-			return nil, err
-		}
-		return buf.Bytes(), nil
-	}
-
-	return json.Marshal(v)
-}
-
-func (jsonCodec) Unmarshal(data []byte, v interface{}) error {
-	if len(data) == 0 {
-		return nil
-	}
-	if b, ok := v.(*bytes.Frame); ok {
-		b.Data = data
-		return nil
-	}
-	if pb, ok := v.(proto.Message); ok {
-		return jsonpb.Unmarshal(b.NewReader(data), pb)
-	}
-
-	dec := json.NewDecoder(b.NewReader(data))
-	if useNumber {
-		dec.UseNumber()
-	}
-	return dec.Decode(v)
-}
-
-func (jsonCodec) Name() string {
-	return "json"
-}
-
-type grpcCodec struct {
-	// headers
-	id       string
-	target   string
-	method   string
-	endpoint string
-
-	s grpc.ClientStream
-	c encoding.Codec
-}
-
-func (g *grpcCodec) ReadHeader(m *codec.Message, mt codec.MessageType) error {
-	md, err := g.s.Header()
-	if err != nil {
-		return err
-	}
-	if m == nil {
-		m = new(codec.Message)
-	}
-	if m.Header == nil {
-		m.Header = make(map[string]string, len(md))
-	}
-	for k, v := range md {
-		m.Header[k] = strings.Join(v, ",")
-	}
-	m.Id = g.id
-	m.Target = g.target
-	m.Method = g.method
-	m.Endpoint = g.endpoint
-	return nil
-}
-
-func (g *grpcCodec) ReadBody(v interface{}) error {
-	if f, ok := v.(*bytes.Frame); ok {
-		return g.s.RecvMsg(f)
-	}
-	return g.s.RecvMsg(v)
-}
-
-func (g *grpcCodec) Write(m *codec.Message, v interface{}) error {
-	// if we don't have a body
-	if v != nil {
-		return g.s.SendMsg(v)
-	}
-	// write the body using the framing codec
-	return g.s.SendMsg(&bytes.Frame{Data: m.Body})
-}
-
-func (g *grpcCodec) Close() error {
-	return g.s.CloseSend()
-}
-
-func (g *grpcCodec) String() string {
-	return g.c.Name()
-}

client/grpc/error.go

@@ -1,39 +0,0 @@
-package grpc
-
-import (
-	"github.com/micro/go-micro/v3/errors"
-	"google.golang.org/grpc/status"
-)
-
-func microError(err error) error {
-	// no error
-	switch err {
-	case nil:
-		return nil
-	}
-
-	if verr, ok := err.(*errors.Error); ok {
-		return verr
-	}
-
-	// grpc error
-	s, ok := status.FromError(err)
-	if !ok {
-		return err
-	}
-
-	// return first error from details
-	if details := s.Details(); len(details) > 0 {
-		if verr, ok := details[0].(error); ok {
-			return microError(verr)
-		}
-	}
-
-	// try to decode micro *errors.Error
-	if e := errors.Parse(s.Message()); e.Code > 0 {
-		return e // actually a micro error
-	}
-
-	// fallback
-	return errors.InternalServerError("go.micro.client", s.Message())
-}

client/grpc/grpc.go

@@ -1,728 +0,0 @@
-// Package grpc provides a gRPC client
-package grpc
-
-import (
-	"context"
-	"crypto/tls"
-	"fmt"
-	"net"
-	"reflect"
-	"strings"
-	"sync/atomic"
-	"time"
-
-	"github.com/micro/go-micro/v3/broker"
-	"github.com/micro/go-micro/v3/client"
-	raw "github.com/micro/go-micro/v3/codec/bytes"
-	"github.com/micro/go-micro/v3/errors"
-	"github.com/micro/go-micro/v3/metadata"
-
-	"google.golang.org/grpc"
-	"google.golang.org/grpc/credentials"
-	"google.golang.org/grpc/encoding"
-	gmetadata "google.golang.org/grpc/metadata"
-)
-
-type grpcClient struct {
-	opts client.Options
-	pool *pool
-	once atomic.Value
-}
-
-func init() {
-	encoding.RegisterCodec(wrapCodec{jsonCodec{}})
-	encoding.RegisterCodec(wrapCodec{protoCodec{}})
-	encoding.RegisterCodec(wrapCodec{bytesCodec{}})
-}
-
-// secure returns the dial option for whether its a secure or insecure connection
-func (g *grpcClient) secure(addr string) grpc.DialOption {
-	// first we check if theres'a  tls config
-	if g.opts.Context != nil {
-		if v := g.opts.Context.Value(tlsAuth{}); v != nil {
-			tls := v.(*tls.Config)
-			creds := credentials.NewTLS(tls)
-			// return tls config if it exists
-			return grpc.WithTransportCredentials(creds)
-		}
-	}
-
-	// default config
-	tlsConfig := &tls.Config{}
-	defaultCreds := grpc.WithTransportCredentials(credentials.NewTLS(tlsConfig))
-
-	// check if the address is prepended with https
-	if strings.HasPrefix(addr, "https://") {
-		return defaultCreds
-	}
-
-	// if no port is specified or port is 443 default to tls
-	_, port, err := net.SplitHostPort(addr)
-	// assuming with no port its going to be secured
-	if port == "443" {
-		return defaultCreds
-	} else if err != nil && strings.Contains(err.Error(), "missing port in address") {
-		return defaultCreds
-	}
-
-	// other fallback to insecure
-	return grpc.WithInsecure()
-}
-
-func (g *grpcClient) call(ctx context.Context, addr string, req client.Request, rsp interface{}, opts client.CallOptions) error {
-	var header map[string]string
-
-	header = make(map[string]string)
-	if md, ok := metadata.FromContext(ctx); ok {
-		header = make(map[string]string, len(md))
-		for k, v := range md {
-			header[strings.ToLower(k)] = v
-		}
-	} else {
-		header = make(map[string]string)
-	}
-
-	// set timeout in nanoseconds
-	header["timeout"] = fmt.Sprintf("%d", opts.RequestTimeout)
-	// set the content type for the request
-	header["x-content-type"] = req.ContentType()
-
-	md := gmetadata.New(header)
-	ctx = gmetadata.NewOutgoingContext(ctx, md)
-
-	cf, err := g.newGRPCCodec(req.ContentType())
-	if err != nil {
-		return errors.InternalServerError("go.micro.client", err.Error())
-	}
-
-	maxRecvMsgSize := g.maxRecvMsgSizeValue()
-	maxSendMsgSize := g.maxSendMsgSizeValue()
-
-	var grr error
-
-	grpcDialOptions := []grpc.DialOption{
-		grpc.WithTimeout(opts.DialTimeout),
-		g.secure(addr),
-		grpc.WithDefaultCallOptions(
-			grpc.MaxCallRecvMsgSize(maxRecvMsgSize),
-			grpc.MaxCallSendMsgSize(maxSendMsgSize),
-		),
-	}
-
-	if opts := g.getGrpcDialOptions(); opts != nil {
-		grpcDialOptions = append(grpcDialOptions, opts...)
-	}
-
-	cc, err := g.pool.getConn(addr, grpcDialOptions...)
-	if err != nil {
-		return errors.InternalServerError("go.micro.client", fmt.Sprintf("Error sending request: %v", err))
-	}
-	defer func() {
-		// defer execution of release
-		g.pool.release(addr, cc, grr)
-	}()
-
-	ch := make(chan error, 1)
-
-	go func() {
-		grpcCallOptions := []grpc.CallOption{
-			grpc.ForceCodec(cf),
-			grpc.CallContentSubtype(cf.Name())}
-		if opts := g.getGrpcCallOptions(); opts != nil {
-			grpcCallOptions = append(grpcCallOptions, opts...)
-		}
-		err := cc.Invoke(ctx, methodToGRPC(req.Service(), req.Endpoint()), req.Body(), rsp, grpcCallOptions...)
-		ch <- microError(err)
-	}()
-
-	select {
-	case err := <-ch:
-		grr = err
-	case <-ctx.Done():
-		grr = errors.Timeout("go.micro.client", "%v", ctx.Err())
-	}
-
-	return grr
-}
-
-func (g *grpcClient) stream(ctx context.Context, addr string, req client.Request, rsp interface{}, opts client.CallOptions) error {
-	var header map[string]string
-
-	if md, ok := metadata.FromContext(ctx); ok {
-		header = make(map[string]string, len(md))
-		for k, v := range md {
-			header[k] = v
-		}
-	} else {
-		header = make(map[string]string)
-	}
-
-	// set timeout in nanoseconds
-	if opts.StreamTimeout > time.Duration(0) {
-		header["timeout"] = fmt.Sprintf("%d", opts.StreamTimeout)
-	}
-	// set the content type for the request
-	header["x-content-type"] = req.ContentType()
-
-	md := gmetadata.New(header)
-	ctx = gmetadata.NewOutgoingContext(ctx, md)
-
-	cf, err := g.newGRPCCodec(req.ContentType())
-	if err != nil {
-		return errors.InternalServerError("go.micro.client", err.Error())
-	}
-
-	wc := wrapCodec{cf}
-
-	grpcDialOptions := []grpc.DialOption{
-		grpc.WithTimeout(opts.DialTimeout),
-		g.secure(addr),
-	}
-
-	if opts := g.getGrpcDialOptions(); opts != nil {
-		grpcDialOptions = append(grpcDialOptions, opts...)
-	}
-
-	cc, err := g.pool.getConn(addr, grpcDialOptions...)
-	if err != nil {
-		return errors.InternalServerError("go.micro.client", fmt.Sprintf("Error sending request: %v", err))
-	}
-
-	desc := &grpc.StreamDesc{
-		StreamName:    req.Service() + req.Endpoint(),
-		ClientStreams: true,
-		ServerStreams: true,
-	}
-
-	grpcCallOptions := []grpc.CallOption{
-		grpc.ForceCodec(wc),
-		grpc.CallContentSubtype(cf.Name()),
-	}
-	if opts := g.getGrpcCallOptions(); opts != nil {
-		grpcCallOptions = append(grpcCallOptions, opts...)
-	}
-
-	var cancel context.CancelFunc
-	ctx, cancel = context.WithCancel(ctx)
-
-	st, err := cc.NewStream(ctx, desc, methodToGRPC(req.Service(), req.Endpoint()), grpcCallOptions...)
-	if err != nil {
-		// we need to cleanup as we dialled and created a context
-		// cancel the context
-		cancel()
-		// release the connection
-		g.pool.release(addr, cc, err)
-		// now return the error
-		return errors.InternalServerError("go.micro.client", fmt.Sprintf("Error creating stream: %v", err))
-	}
-
-	codec := &grpcCodec{
-		s: st,
-		c: wc,
-	}
-
-	// set request codec
-	if r, ok := req.(*grpcRequest); ok {
-		r.codec = codec
-	}
-
-	// setup the stream response
-	stream := &grpcStream{
-		ClientStream: st,
-		context:      ctx,
-		request:      req,
-		response: &response{
-			conn:   cc,
-			stream: st,
-			codec:  cf,
-			gcodec: codec,
-		},
-		conn: cc,
-		close: func(err error) {
-			// cancel the context if an error occured
-			if err != nil {
-				cancel()
-			}
-
-			// defer execution of release
-			g.pool.release(addr, cc, err)
-		},
-	}
-
-	// set the stream as the response
-	val := reflect.ValueOf(rsp).Elem()
-	val.Set(reflect.ValueOf(stream).Elem())
-	return nil
-}
-
-func (g *grpcClient) poolMaxStreams() int {
-	if g.opts.Context == nil {
-		return DefaultPoolMaxStreams
-	}
-	v := g.opts.Context.Value(poolMaxStreams{})
-	if v == nil {
-		return DefaultPoolMaxStreams
-	}
-	return v.(int)
-}
-
-func (g *grpcClient) poolMaxIdle() int {
-	if g.opts.Context == nil {
-		return DefaultPoolMaxIdle
-	}
-	v := g.opts.Context.Value(poolMaxIdle{})
-	if v == nil {
-		return DefaultPoolMaxIdle
-	}
-	return v.(int)
-}
-
-func (g *grpcClient) maxRecvMsgSizeValue() int {
-	if g.opts.Context == nil {
-		return DefaultMaxRecvMsgSize
-	}
-	v := g.opts.Context.Value(maxRecvMsgSizeKey{})
-	if v == nil {
-		return DefaultMaxRecvMsgSize
-	}
-	return v.(int)
-}
-
-func (g *grpcClient) maxSendMsgSizeValue() int {
-	if g.opts.Context == nil {
-		return DefaultMaxSendMsgSize
-	}
-	v := g.opts.Context.Value(maxSendMsgSizeKey{})
-	if v == nil {
-		return DefaultMaxSendMsgSize
-	}
-	return v.(int)
-}
-
-func (g *grpcClient) newGRPCCodec(contentType string) (encoding.Codec, error) {
-	codecs := make(map[string]encoding.Codec)
-	if g.opts.Context != nil {
-		if v := g.opts.Context.Value(codecsKey{}); v != nil {
-			codecs = v.(map[string]encoding.Codec)
-		}
-	}
-	if c, ok := codecs[contentType]; ok {
-		return wrapCodec{c}, nil
-	}
-	if c, ok := defaultGRPCCodecs[contentType]; ok {
-		return wrapCodec{c}, nil
-	}
-	return nil, fmt.Errorf("Unsupported Content-Type: %s", contentType)
-}
-
-func (g *grpcClient) Init(opts ...client.Option) error {
-	size := g.opts.PoolSize
-	ttl := g.opts.PoolTTL
-
-	for _, o := range opts {
-		o(&g.opts)
-	}
-
-	// update pool configuration if the options changed
-	if size != g.opts.PoolSize || ttl != g.opts.PoolTTL {
-		g.pool.Lock()
-		g.pool.size = g.opts.PoolSize
-		g.pool.ttl = int64(g.opts.PoolTTL.Seconds())
-		g.pool.Unlock()
-	}
-
-	return nil
-}
-
-func (g *grpcClient) Options() client.Options {
-	return g.opts
-}
-
-func (g *grpcClient) NewMessage(topic string, msg interface{}, opts ...client.MessageOption) client.Message {
-	return newGRPCEvent(topic, msg, g.opts.ContentType, opts...)
-}
-
-func (g *grpcClient) NewRequest(service, method string, req interface{}, reqOpts ...client.RequestOption) client.Request {
-	return newGRPCRequest(service, method, req, g.opts.ContentType, reqOpts...)
-}
-
-func (g *grpcClient) Call(ctx context.Context, req client.Request, rsp interface{}, opts ...client.CallOption) error {
-	if req == nil {
-		return errors.InternalServerError("go.micro.client", "req is nil")
-	} else if rsp == nil {
-		return errors.InternalServerError("go.micro.client", "rsp is nil")
-	}
-	// make a copy of call opts
-	callOpts := g.opts.CallOptions
-	for _, opt := range opts {
-		opt(&callOpts)
-	}
-
-	// check if we already have a deadline
-	d, ok := ctx.Deadline()
-	if !ok {
-		// no deadline so we create a new one
-		var cancel context.CancelFunc
-		ctx, cancel = context.WithTimeout(ctx, callOpts.RequestTimeout)
-		defer cancel()
-	} else {
-		// got a deadline so no need to setup context
-		// but we need to set the timeout we pass along
-		opt := client.WithRequestTimeout(time.Until(d))
-		opt(&callOpts)
-	}
-
-	// should we noop right here?
-	select {
-	case <-ctx.Done():
-		return errors.New("go.micro.client", fmt.Sprintf("%v", ctx.Err()), 408)
-	default:
-	}
-
-	// make copy of call method
-	gcall := g.call
-
-	// wrap the call in reverse
-	for i := len(callOpts.CallWrappers); i > 0; i-- {
-		gcall = callOpts.CallWrappers[i-1](gcall)
-	}
-
-	// use the router passed as a call option, or fallback to the rpc clients router
-	if callOpts.Router == nil {
-		callOpts.Router = g.opts.Router
-	}
-
-	if callOpts.Selector == nil {
-		callOpts.Selector = g.opts.Selector
-	}
-
-	// inject proxy address
-	// TODO: don't even bother using Lookup/Select in this case
-	if len(g.opts.Proxy) > 0 {
-		callOpts.Address = []string{g.opts.Proxy}
-	}
-
-	// lookup the route to send the reques to
-	// TODO apply any filtering here
-	routes, err := g.opts.Lookup(ctx, req, callOpts)
-	if err != nil {
-		return errors.InternalServerError("go.micro.client", err.Error())
-	}
-
-	// balance the list of nodes
-	next, err := callOpts.Selector.Select(routes)
-	if err != nil {
-		return err
-	}
-
-	// return errors.New("go.micro.client", "request timeout", 408)
-	call := func(i int) error {
-		// call backoff first. Someone may want an initial start delay
-		t, err := callOpts.Backoff(ctx, req, i)
-		if err != nil {
-			return errors.InternalServerError("go.micro.client", err.Error())
-		}
-
-		// only sleep if greater than 0
-		if t.Seconds() > 0 {
-			time.Sleep(t)
-		}
-
-		// get the next node
-		node := next()
-
-		// make the call
-		err = gcall(ctx, node, req, rsp, callOpts)
-
-		// record the result of the call to inform future routing decisions
-		g.opts.Selector.Record(node, err)
-
-		// try and transform the error to a go-micro error
-		if verr, ok := err.(*errors.Error); ok {
-			return verr
-		}
-
-		return err
-	}
-
-	ch := make(chan error, callOpts.Retries+1)
-	var gerr error
-
-	for i := 0; i <= callOpts.Retries; i++ {
-		go func(i int) {
-			ch <- call(i)
-		}(i)
-
-		select {
-		case <-ctx.Done():
-			return errors.New("go.micro.client", fmt.Sprintf("%v", ctx.Err()), 408)
-		case err := <-ch:
-			// if the call succeeded lets bail early
-			if err == nil {
-				return nil
-			}
-
-			retry, rerr := callOpts.Retry(ctx, req, i, err)
-			if rerr != nil {
-				return rerr
-			}
-
-			if !retry {
-				return err
-			}
-
-			gerr = err
-		}
-	}
-
-	return gerr
-}
-
-func (g *grpcClient) Stream(ctx context.Context, req client.Request, opts ...client.CallOption) (client.Stream, error) {
-	// make a copy of call opts
-	callOpts := g.opts.CallOptions
-	for _, opt := range opts {
-		opt(&callOpts)
-	}
-
-	// #200 - streams shouldn't have a request timeout set on the context
-
-	// should we noop right here?
-	select {
-	case <-ctx.Done():
-		return nil, errors.New("go.micro.client", fmt.Sprintf("%v", ctx.Err()), 408)
-	default:
-	}
-
-	// make a copy of stream
-	gstream := g.stream
-
-	// wrap the call in reverse
-	for i := len(callOpts.CallWrappers); i > 0; i-- {
-		gstream = callOpts.CallWrappers[i-1](gstream)
-	}
-
-	// use the router passed as a call option, or fallback to the rpc clients router
-	if callOpts.Router == nil {
-		callOpts.Router = g.opts.Router
-	}
-
-	if callOpts.Selector == nil {
-		callOpts.Selector = g.opts.Selector
-	}
-
-	// inject proxy address
-	// TODO: don't even bother using Lookup/Select in this case
-	if len(g.opts.Proxy) > 0 {
-		callOpts.Address = []string{g.opts.Proxy}
-	}
-
-	// lookup the route to send the reques to
-	// TODO: move to internal lookup func
-	routes, err := g.opts.Lookup(ctx, req, callOpts)
-	if err != nil {
-		return nil, errors.InternalServerError("go.micro.client", err.Error())
-	}
-
-	// balance the list of nodes
-	next, err := callOpts.Selector.Select(routes)
-	if err != nil {
-		return nil, err
-	}
-
-	call := func(i int) (client.Stream, error) {
-		// call backoff first. Someone may want an initial start delay
-		t, err := callOpts.Backoff(ctx, req, i)
-		if err != nil {
-			return nil, errors.InternalServerError("go.micro.client", err.Error())
-		}
-
-		// only sleep if greater than 0
-		if t.Seconds() > 0 {
-			time.Sleep(t)
-		}
-
-		// get the next node
-		node := next()
-
-		// make the call
-		stream := &grpcStream{}
-		err = g.stream(ctx, node, req, stream, callOpts)
-
-		// record the result of the call to inform future routing decisions
-		g.opts.Selector.Record(node, err)
-
-		// try and transform the error to a go-micro error
-		if verr, ok := err.(*errors.Error); ok {
-			return nil, verr
-		}
-
-		g.opts.Selector.Record(node, err)
-		return stream, err
-	}
-
-	type response struct {
-		stream client.Stream
-		err    error
-	}
-
-	ch := make(chan response, callOpts.Retries+1)
-	var grr error
-
-	for i := 0; i <= callOpts.Retries; i++ {
-		go func(i int) {
-			s, err := call(i)
-			ch <- response{s, err}
-		}(i)
-
-		select {
-		case <-ctx.Done():
-			return nil, errors.New("go.micro.client", fmt.Sprintf("%v", ctx.Err()), 408)
-		case rsp := <-ch:
-			// if the call succeeded lets bail early
-			if rsp.err == nil {
-				return rsp.stream, nil
-			}
-
-			retry, rerr := callOpts.Retry(ctx, req, i, grr)
-			if rerr != nil {
-				return nil, rerr
-			}
-
-			if !retry {
-				return nil, rsp.err
-			}
-
-			grr = rsp.err
-		}
-	}
-
-	return nil, grr
-}
-
-func (g *grpcClient) Publish(ctx context.Context, p client.Message, opts ...client.PublishOption) error {
-	var options client.PublishOptions
-	var body []byte
-
-	// fail early on connect error
-	if !g.once.Load().(bool) {
-		if err := g.opts.Broker.Connect(); err != nil {
-			return errors.InternalServerError("go.micro.client", err.Error())
-		}
-		g.once.Store(true)
-	}
-
-	for _, o := range opts {
-		o(&options)
-	}
-
-	md, ok := metadata.FromContext(ctx)
-	if !ok {
-		md = make(map[string]string)
-	}
-	md["Content-Type"] = p.ContentType()
-	md["Micro-Topic"] = p.Topic()
-
-	// passed in raw data
-	if d, ok := p.Payload().(*raw.Frame); ok {
-		body = d.Data
-	} else {
-		// use codec for payload
-		cf, err := g.newGRPCCodec(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 {
-			return errors.InternalServerError("go.micro.client", err.Error())
-		}
-		body = b
-	}
-
-	topic := p.Topic()
-
-	// get the exchange
-	if len(options.Exchange) > 0 {
-		topic = options.Exchange
-	}
-
-	return g.opts.Broker.Publish(topic, &broker.Message{
-		Header: md,
-		Body:   body,
-	}, broker.PublishContext(options.Context))
-}
-
-func (g *grpcClient) String() string {
-	return "grpc"
-}
-
-func (g *grpcClient) getGrpcDialOptions() []grpc.DialOption {
-	if g.opts.CallOptions.Context == nil {
-		return nil
-	}
-
-	v := g.opts.CallOptions.Context.Value(grpcDialOptions{})
-
-	if v == nil {
-		return nil
-	}
-
-	opts, ok := v.([]grpc.DialOption)
-
-	if !ok {
-		return nil
-	}
-
-	return opts
-}
-
-func (g *grpcClient) getGrpcCallOptions() []grpc.CallOption {
-	if g.opts.CallOptions.Context == nil {
-		return nil
-	}
-
-	v := g.opts.CallOptions.Context.Value(grpcCallOptions{})
-
-	if v == nil {
-		return nil
-	}
-
-	opts, ok := v.([]grpc.CallOption)
-
-	if !ok {
-		return nil
-	}
-
-	return opts
-}
-
-func newClient(opts ...client.Option) client.Client {
-	options := client.NewOptions()
-	// default content type for grpc
-	options.ContentType = "application/grpc+proto"
-
-	for _, o := range opts {
-		o(&options)
-	}
-
-	rc := &grpcClient{
-		opts: options,
-	}
-	rc.once.Store(false)
-
-	rc.pool = newPool(options.PoolSize, options.PoolTTL, rc.poolMaxIdle(), rc.poolMaxStreams())
-
-	c := client.Client(rc)
-
-	// wrap in reverse
-	for i := len(options.Wrappers); i > 0; i-- {
-		c = options.Wrappers[i-1](c)
-	}
-
-	return c
-}
-
-func NewClient(opts ...client.Option) client.Client {
-	return newClient(opts...)
-}

client/grpc/grpc_pool.go

@@ -1,218 +0,0 @@
-package grpc
-
-import (
-	"sync"
-	"time"
-
-	"google.golang.org/grpc"
-	"google.golang.org/grpc/connectivity"
-)
-
-type pool struct {
-	size int
-	ttl  int64
-
-	//  max streams on a *poolConn
-	maxStreams int
-	//  max idle conns
-	maxIdle int
-
-	sync.Mutex
-	conns map[string]*streamsPool
-}
-
-type streamsPool struct {
-	//  head of list
-	head *poolConn
-	//  busy conns list
-	busy *poolConn
-	//  the siza of list
-	count int
-	//  idle conn
-	idle int
-}
-
-type poolConn struct {
-	//  grpc conn
-	*grpc.ClientConn
-	err  error
-	addr string
-
-	//  pool and streams pool
-	pool    *pool
-	sp      *streamsPool
-	streams int
-	created int64
-
-	//  list
-	pre  *poolConn
-	next *poolConn
-	in   bool
-}
-
-func newPool(size int, ttl time.Duration, idle int, ms int) *pool {
-	if ms <= 0 {
-		ms = 1
-	}
-	if idle < 0 {
-		idle = 0
-	}
-	return &pool{
-		size:       size,
-		ttl:        int64(ttl.Seconds()),
-		maxStreams: ms,
-		maxIdle:    idle,
-		conns:      make(map[string]*streamsPool),
-	}
-}
-
-func (p *pool) getConn(addr string, opts ...grpc.DialOption) (*poolConn, error) {
-	now := time.Now().Unix()
-	p.Lock()
-	sp, ok := p.conns[addr]
-	if !ok {
-		sp = &streamsPool{head: &poolConn{}, busy: &poolConn{}, count: 0, idle: 0}
-		p.conns[addr] = sp
-	}
-	//  while we have conns check streams and then return one
-	//  otherwise we'll create a new conn
-	conn := sp.head.next
-	for conn != nil {
-		//  check conn state
-		// https://github.com/grpc/grpc/blob/master/doc/connectivity-semantics-and-api.md
-		switch conn.GetState() {
-		case connectivity.Connecting:
-			conn = conn.next
-			continue
-		case connectivity.Shutdown:
-			next := conn.next
-			if conn.streams == 0 {
-				removeConn(conn)
-				sp.idle--
-			}
-			conn = next
-			continue
-		case connectivity.TransientFailure:
-			next := conn.next
-			if conn.streams == 0 {
-				removeConn(conn)
-				conn.ClientConn.Close()
-				sp.idle--
-			}
-			conn = next
-			continue
-		case connectivity.Ready:
-		case connectivity.Idle:
-		}
-		//  a old conn
-		if now-conn.created > p.ttl {
-			next := conn.next
-			if conn.streams == 0 {
-				removeConn(conn)
-				conn.ClientConn.Close()
-				sp.idle--
-			}
-			conn = next
-			continue
-		}
-		//  a busy conn
-		if conn.streams >= p.maxStreams {
-			next := conn.next
-			removeConn(conn)
-			addConnAfter(conn, sp.busy)
-			conn = next
-			continue
-		}
-		//  a idle conn
-		if conn.streams == 0 {
-			sp.idle--
-		}
-		//  a good conn
-		conn.streams++
-		p.Unlock()
-		return conn, nil
-	}
-	p.Unlock()
-
-	//  create new conn
-	cc, err := grpc.Dial(addr, opts...)
-	if err != nil {
-		return nil, err
-	}
-	conn = &poolConn{cc, nil, addr, p, sp, 1, time.Now().Unix(), nil, nil, false}
-
-	//  add conn to streams pool
-	p.Lock()
-	if sp.count < p.size {
-		addConnAfter(conn, sp.head)
-	}
-	p.Unlock()
-
-	return conn, nil
-}
-
-func (p *pool) release(addr string, conn *poolConn, err error) {
-	p.Lock()
-	p, sp, created := conn.pool, conn.sp, conn.created
-	//  try to add conn
-	if !conn.in && sp.count < p.size {
-		addConnAfter(conn, sp.head)
-	}
-	if !conn.in {
-		p.Unlock()
-		conn.ClientConn.Close()
-		return
-	}
-	//  a busy conn
-	if conn.streams >= p.maxStreams {
-		removeConn(conn)
-		addConnAfter(conn, sp.head)
-	}
-	conn.streams--
-	//  if streams == 0, we can do something
-	if conn.streams == 0 {
-		//  1. it has errored
-		//  2. too many idle conn or
-		//  3. conn is too old
-		now := time.Now().Unix()
-		if err != nil || sp.idle >= p.maxIdle || now-created > p.ttl {
-			removeConn(conn)
-			p.Unlock()
-			conn.ClientConn.Close()
-			return
-		}
-		sp.idle++
-	}
-	p.Unlock()
-	return
-}
-
-func (conn *poolConn) Close() {
-	conn.pool.release(conn.addr, conn, conn.err)
-}
-
-func removeConn(conn *poolConn) {
-	if conn.pre != nil {
-		conn.pre.next = conn.next
-	}
-	if conn.next != nil {
-		conn.next.pre = conn.pre
-	}
-	conn.pre = nil
-	conn.next = nil
-	conn.in = false
-	conn.sp.count--
-	return
-}
-
-func addConnAfter(conn *poolConn, after *poolConn) {
-	conn.next = after.next
-	conn.pre = after
-	if after.next != nil {
-		after.next.pre = conn
-	}
-	after.next = conn
-	conn.in = true
-	conn.sp.count++
-	return
-}

client/grpc/grpc_pool_test.go

@@ -1,64 +0,0 @@
-package grpc
-
-import (
-	"context"
-	"net"
-	"testing"
-	"time"
-
-	"google.golang.org/grpc"
-	pgrpc "google.golang.org/grpc"
-	pb "google.golang.org/grpc/examples/helloworld/helloworld"
-)
-
-func testPool(t *testing.T, size int, ttl time.Duration, idle int, ms int) {
-	// setup server
-	l, err := net.Listen("tcp", ":0")
-	if err != nil {
-		t.Fatalf("failed to listen: %v", err)
-	}
-	defer l.Close()
-
-	s := pgrpc.NewServer()
-	pb.RegisterGreeterServer(s, &greeterServer{})
-
-	go s.Serve(l)
-	defer s.Stop()
-
-	// zero pool
-	p := newPool(size, ttl, idle, ms)
-
-	for i := 0; i < 10; i++ {
-		// get a conn
-		cc, err := p.getConn(l.Addr().String(), grpc.WithInsecure())
-		if err != nil {
-			t.Fatal(err)
-		}
-
-		rsp := pb.HelloReply{}
-
-		err = cc.Invoke(context.TODO(), "/helloworld.Greeter/SayHello", &pb.HelloRequest{Name: "John"}, &rsp)
-		if err != nil {
-			t.Fatal(err)
-		}
-
-		if rsp.Message != "Hello John" {
-			t.Fatalf("Got unexpected response %v", rsp.Message)
-		}
-
-		// release the conn
-		p.release(l.Addr().String(), cc, nil)
-
-		p.Lock()
-		if i := p.conns[l.Addr().String()].count; i > size {
-			p.Unlock()
-			t.Fatalf("pool size %d is greater than expected %d", i, size)
-		}
-		p.Unlock()
-	}
-}
-
-func TestGRPCPool(t *testing.T) {
-	testPool(t, 0, time.Minute, 10, 2)
-	testPool(t, 2, time.Minute, 10, 1)
-}

client/grpc/grpc_test.go

@@ -1,108 +0,0 @@
-package grpc
-
-import (
-	"context"
-	"net"
-	"testing"
-
-	"github.com/micro/go-micro/v3/client"
-	"github.com/micro/go-micro/v3/errors"
-	"github.com/micro/go-micro/v3/registry"
-	"github.com/micro/go-micro/v3/registry/memory"
-	"github.com/micro/go-micro/v3/router"
-	regRouter "github.com/micro/go-micro/v3/router/registry"
-	pgrpc "google.golang.org/grpc"
-	pb "google.golang.org/grpc/examples/helloworld/helloworld"
-)
-
-// server is used to implement helloworld.GreeterServer.
-type greeterServer struct{}
-
-// SayHello implements helloworld.GreeterServer
-func (g *greeterServer) SayHello(ctx context.Context, in *pb.HelloRequest) (*pb.HelloReply, error) {
-	if in.Name == "Error" {
-		return nil, &errors.Error{Id: "1", Code: 99, Detail: "detail"}
-	}
-	return &pb.HelloReply{Message: "Hello " + in.Name}, nil
-}
-
-func TestGRPCClient(t *testing.T) {
-	l, err := net.Listen("tcp", ":0")
-	if err != nil {
-		t.Fatalf("failed to listen: %v", err)
-	}
-	defer l.Close()
-
-	s := pgrpc.NewServer()
-	pb.RegisterGreeterServer(s, &greeterServer{})
-
-	go s.Serve(l)
-	defer s.Stop()
-
-	// create mock registry
-	r := memory.NewRegistry()
-
-	// register service
-	r.Register(&registry.Service{
-		Name:    "helloworld",
-		Version: "test",
-		Nodes: []*registry.Node{
-			{
-				Id:      "test-1",
-				Address: l.Addr().String(),
-				Metadata: map[string]string{
-					"protocol": "grpc",
-				},
-			},
-		},
-	})
-
-	// create router
-	rtr := regRouter.NewRouter(router.Registry(r))
-
-	// create client
-	c := NewClient(client.Router(rtr))
-
-	testMethods := []string{
-		"/helloworld.Greeter/SayHello",
-		"Greeter.SayHello",
-	}
-
-	for _, method := range testMethods {
-		req := c.NewRequest("helloworld", method, &pb.HelloRequest{
-			Name: "John",
-		})
-
-		rsp := pb.HelloReply{}
-
-		err = c.Call(context.TODO(), req, &rsp)
-		if err != nil {
-			t.Fatal(err)
-		}
-
-		if rsp.Message != "Hello John" {
-			t.Fatalf("Got unexpected response %v", rsp.Message)
-		}
-	}
-
-	req := c.NewRequest("helloworld", "/helloworld.Greeter/SayHello", &pb.HelloRequest{
-		Name: "Error",
-	})
-
-	rsp := pb.HelloReply{}
-
-	err = c.Call(context.TODO(), req, &rsp)
-	if err == nil {
-		t.Fatal("nil error received")
-	}
-
-	verr, ok := err.(*errors.Error)
-	if !ok {
-		t.Fatalf("invalid error received %#+v\n", err)
-	}
-
-	if verr.Code != 99 && verr.Id != "1" && verr.Detail != "detail" {
-		t.Fatalf("invalid error received %#+v\n", verr)
-	}
-
-}

client/grpc/message.go

@@ -1,40 +0,0 @@
-package grpc
-
-import (
-	"github.com/micro/go-micro/v3/client"
-)
-
-type grpcEvent struct {
-	topic       string
-	contentType string
-	payload     interface{}
-}
-
-func newGRPCEvent(topic string, payload interface{}, contentType string, opts ...client.MessageOption) client.Message {
-	var options client.MessageOptions
-	for _, o := range opts {
-		o(&options)
-	}
-
-	if len(options.ContentType) > 0 {
-		contentType = options.ContentType
-	}
-
-	return &grpcEvent{
-		payload:     payload,
-		topic:       topic,
-		contentType: contentType,
-	}
-}
-
-func (g *grpcEvent) ContentType() string {
-	return g.contentType
-}
-
-func (g *grpcEvent) Topic() string {
-	return g.topic
-}
-
-func (g *grpcEvent) Payload() interface{} {
-	return g.payload
-}

client/grpc/options.go

@@ -1,131 +0,0 @@
-// Package grpc provides a gRPC options
-package grpc
-
-import (
-	"context"
-	"crypto/tls"
-
-	"github.com/micro/go-micro/v3/client"
-	"google.golang.org/grpc"
-	"google.golang.org/grpc/encoding"
-)
-
-var (
-	// DefaultPoolMaxStreams maximum streams on a connectioin
-	// (20)
-	DefaultPoolMaxStreams = 20
-
-	// DefaultPoolMaxIdle maximum idle conns of a pool
-	// (50)
-	DefaultPoolMaxIdle = 50
-
-	// DefaultMaxRecvMsgSize maximum message that client can receive
-	// (4 MB).
-	DefaultMaxRecvMsgSize = 1024 * 1024 * 4
-
-	// DefaultMaxSendMsgSize maximum message that client can send
-	// (4 MB).
-	DefaultMaxSendMsgSize = 1024 * 1024 * 4
-)
-
-type poolMaxStreams struct{}
-type poolMaxIdle struct{}
-type codecsKey struct{}
-type tlsAuth struct{}
-type maxRecvMsgSizeKey struct{}
-type maxSendMsgSizeKey struct{}
-type grpcDialOptions struct{}
-type grpcCallOptions struct{}
-
-// maximum streams on a connectioin
-func PoolMaxStreams(n int) client.Option {
-	return func(o *client.Options) {
-		if o.Context == nil {
-			o.Context = context.Background()
-		}
-		o.Context = context.WithValue(o.Context, poolMaxStreams{}, n)
-	}
-}
-
-// maximum idle conns of a pool
-func PoolMaxIdle(d int) client.Option {
-	return func(o *client.Options) {
-		if o.Context == nil {
-			o.Context = context.Background()
-		}
-		o.Context = context.WithValue(o.Context, poolMaxIdle{}, d)
-	}
-}
-
-// gRPC Codec to be used to encode/decode requests for a given content type
-func Codec(contentType string, c encoding.Codec) client.Option {
-	return func(o *client.Options) {
-		codecs := make(map[string]encoding.Codec)
-		if o.Context == nil {
-			o.Context = context.Background()
-		}
-		if v := o.Context.Value(codecsKey{}); v != nil {
-			codecs = v.(map[string]encoding.Codec)
-		}
-		codecs[contentType] = c
-		o.Context = context.WithValue(o.Context, codecsKey{}, codecs)
-	}
-}
-
-// AuthTLS should be used to setup a secure authentication using TLS
-func AuthTLS(t *tls.Config) client.Option {
-	return func(o *client.Options) {
-		if o.Context == nil {
-			o.Context = context.Background()
-		}
-		o.Context = context.WithValue(o.Context, tlsAuth{}, t)
-	}
-}
-
-//
-// MaxRecvMsgSize set the maximum size of message that client can receive.
-//
-func MaxRecvMsgSize(s int) client.Option {
-	return func(o *client.Options) {
-		if o.Context == nil {
-			o.Context = context.Background()
-		}
-		o.Context = context.WithValue(o.Context, maxRecvMsgSizeKey{}, s)
-	}
-}
-
-//
-// MaxSendMsgSize set the maximum size of message that client can send.
-//
-func MaxSendMsgSize(s int) client.Option {
-	return func(o *client.Options) {
-		if o.Context == nil {
-			o.Context = context.Background()
-		}
-		o.Context = context.WithValue(o.Context, maxSendMsgSizeKey{}, s)
-	}
-}
-
-//
-// DialOptions to be used to configure gRPC dial options
-//
-func DialOptions(opts ...grpc.DialOption) client.CallOption {
-	return func(o *client.CallOptions) {
-		if o.Context == nil {
-			o.Context = context.Background()
-		}
-		o.Context = context.WithValue(o.Context, grpcDialOptions{}, opts)
-	}
-}
-
-//
-// CallOptions to be used to configure gRPC call options
-//
-func CallOptions(opts ...grpc.CallOption) client.CallOption {
-	return func(o *client.CallOptions) {
-		if o.Context == nil {
-			o.Context = context.Background()
-		}
-		o.Context = context.WithValue(o.Context, grpcCallOptions{}, opts)
-	}
-}

client/grpc/request.go

@@ -1,87 +0,0 @@
-package grpc
-
-import (
-	"fmt"
-	"strings"
-
-	"github.com/micro/go-micro/v3/client"
-	"github.com/micro/go-micro/v3/codec"
-)
-
-type grpcRequest struct {
-	service     string
-	method      string
-	contentType string
-	request     interface{}
-	opts        client.RequestOptions
-	codec       codec.Codec
-}
-
-// service Struct.Method /service.Struct/Method
-func methodToGRPC(service, method string) string {
-	// no method or already grpc method
-	if len(method) == 0 || method[0] == '/' {
-		return method
-	}
-
-	// assume method is Foo.Bar
-	mParts := strings.Split(method, ".")
-	if len(mParts) != 2 {
-		return method
-	}
-
-	if len(service) == 0 {
-		return fmt.Sprintf("/%s/%s", mParts[0], mParts[1])
-	}
-
-	// return /pkg.Foo/Bar
-	return fmt.Sprintf("/%s.%s/%s", service, mParts[0], mParts[1])
-}
-
-func newGRPCRequest(service, method string, request interface{}, contentType string, reqOpts ...client.RequestOption) client.Request {
-	var opts client.RequestOptions
-	for _, o := range reqOpts {
-		o(&opts)
-	}
-
-	// set the content-type specified
-	if len(opts.ContentType) > 0 {
-		contentType = opts.ContentType
-	}
-
-	return &grpcRequest{
-		service:     service,
-		method:      method,
-		request:     request,
-		contentType: contentType,
-		opts:        opts,
-	}
-}
-
-func (g *grpcRequest) ContentType() string {
-	return g.contentType
-}
-
-func (g *grpcRequest) Service() string {
-	return g.service
-}
-
-func (g *grpcRequest) Method() string {
-	return g.method
-}
-
-func (g *grpcRequest) Endpoint() string {
-	return g.method
-}
-
-func (g *grpcRequest) Codec() codec.Writer {
-	return g.codec
-}
-
-func (g *grpcRequest) Body() interface{} {
-	return g.request
-}
-
-func (g *grpcRequest) Stream() bool {
-	return g.opts.Stream
-}

client/grpc/request_test.go

@@ -1,41 +0,0 @@
-package grpc
-
-import (
-	"testing"
-)
-
-func TestMethodToGRPC(t *testing.T) {
-	testData := []struct {
-		service string
-		method  string
-		expect  string
-	}{
-		{
-			"helloworld",
-			"Greeter.SayHello",
-			"/helloworld.Greeter/SayHello",
-		},
-		{
-			"helloworld",
-			"/helloworld.Greeter/SayHello",
-			"/helloworld.Greeter/SayHello",
-		},
-		{
-			"",
-			"/helloworld.Greeter/SayHello",
-			"/helloworld.Greeter/SayHello",
-		},
-		{
-			"",
-			"Greeter.SayHello",
-			"/Greeter/SayHello",
-		},
-	}
-
-	for _, d := range testData {
-		method := methodToGRPC(d.service, d.method)
-		if method != d.expect {
-			t.Fatalf("expected %s got %s", d.expect, method)
-		}
-	}
-}

client/grpc/response.go

@@ -1,44 +0,0 @@
-package grpc
-
-import (
-	"strings"
-
-	"github.com/micro/go-micro/v3/codec"
-	"github.com/micro/go-micro/v3/codec/bytes"
-	"google.golang.org/grpc"
-	"google.golang.org/grpc/encoding"
-)
-
-type response struct {
-	conn   *poolConn
-	stream grpc.ClientStream
-	codec  encoding.Codec
-	gcodec codec.Codec
-}
-
-// Read the response
-func (r *response) Codec() codec.Reader {
-	return r.gcodec
-}
-
-// read the header
-func (r *response) Header() map[string]string {
-	md, err := r.stream.Header()
-	if err != nil {
-		return map[string]string{}
-	}
-	hdr := make(map[string]string, len(md))
-	for k, v := range md {
-		hdr[k] = strings.Join(v, ",")
-	}
-	return hdr
-}
-
-// Read the undecoded response
-func (r *response) Read() ([]byte, error) {
-	f := &bytes.Frame{}
-	if err := r.gcodec.ReadBody(f); err != nil {
-		return nil, err
-	}
-	return f.Data, nil
-}

client/grpc/stream.go

@@ -1,94 +0,0 @@
-package grpc
-
-import (
-	"context"
-	"io"
-	"sync"
-
-	"github.com/micro/go-micro/v3/client"
-	"google.golang.org/grpc"
-)
-
-// Implements the streamer interface
-type grpcStream struct {
-	// embed so we can access if need be
-	grpc.ClientStream
-
-	sync.RWMutex
-	closed   bool
-	err      error
-	conn     *poolConn
-	request  client.Request
-	response client.Response
-	context  context.Context
-	close    func(err error)
-}
-
-func (g *grpcStream) Context() context.Context {
-	return g.context
-}
-
-func (g *grpcStream) Request() client.Request {
-	return g.request
-}
-
-func (g *grpcStream) Response() client.Response {
-	return g.response
-}
-
-func (g *grpcStream) Send(msg interface{}) error {
-	if err := g.ClientStream.SendMsg(msg); err != nil {
-		g.setError(err)
-		return err
-	}
-	return nil
-}
-
-func (g *grpcStream) Recv(msg interface{}) (err error) {
-	defer g.setError(err)
-
-	if err = g.ClientStream.RecvMsg(msg); err != nil {
-		// #202 - inconsistent gRPC stream behavior
-		// the only way to tell if the stream is done is when we get a EOF on the Recv
-		// here we should close the underlying gRPC ClientConn
-		closeErr := g.Close()
-		if err == io.EOF && closeErr != nil {
-			err = closeErr
-		}
-
-		return err
-	}
-
-	return
-}
-
-func (g *grpcStream) Error() error {
-	g.RLock()
-	defer g.RUnlock()
-	return g.err
-}
-
-func (g *grpcStream) setError(e error) {
-	g.Lock()
-	g.err = e
-	g.Unlock()
-}
-
-// Close the gRPC send stream
-// #202 - inconsistent gRPC stream behavior
-// The underlying gRPC stream should not be closed here since the
-// stream should still be able to receive after this function call
-// TODO: should the conn be closed in another way?
-func (g *grpcStream) Close() error {
-	g.Lock()
-	defer g.Unlock()
-
-	if g.closed {
-		return nil
-	}
-
-	// close the connection
-	g.closed = true
-	g.close(g.err)
-	return g.ClientStream.CloseSend()
-}

client/lookup.go

@@ -4,8 +4,8 @@ import (
 	"context"
 	"sort"
 
-	"github.com/micro/go-micro/v3/errors"
+	"github.com/unistack-org/micro/v3/errors"
-	"github.com/micro/go-micro/v3/router"
+	"github.com/unistack-org/micro/v3/router"
 )
 
 // LookupFunc is used to lookup routes for a service
@@ -19,16 +19,16 @@ func LookupRoute(ctx context.Context, req Request, opts CallOptions) ([]string,
 	}
 
 	// construct the router query
-	query := []router.LookupOption{}
+	query := []router.QueryOption{router.QueryService(req.Service())}
 
 	// if a custom network was requested, pass this to the router. By default the router will use it's
 	// own network, which is set during initialisation.
 	if len(opts.Network) > 0 {
-		query = append(query, router.LookupNetwork(opts.Network))
+		query = append(query, router.QueryNetwork(opts.Network))
 	}
 
 	// lookup the routes which can be used to execute the request
-	routes, err := opts.Router.Lookup(req.Service(), query...)
+	routes, err := opts.Router.Lookup(query...)
 	if err == router.ErrRouteNotFound {
 		return nil, errors.InternalServerError("go.micro.client", "service %s: %s", req.Service(), err.Error())
 	} else if err != nil {
@@ -40,8 +40,7 @@ func LookupRoute(ctx context.Context, req Request, opts CallOptions) ([]string,
 		return routes[i].Metric < routes[j].Metric
 	})
 
-	var addrs []string
+	addrs := make([]string, 0, len(routes))
-
 	for _, route := range routes {
 		addrs = append(addrs, route.Address)
 	}

client/mucp/common_test.go

@@ -1,59 +0,0 @@
-package mucp
-
-import (
-	"github.com/micro/go-micro/v3/registry"
-)
-
-var (
-	// mock data
-	testData = map[string][]*registry.Service{
-		"foo": {
-			{
-				Name:    "foo",
-				Version: "1.0.0",
-				Nodes: []*registry.Node{
-					{
-						Id:      "foo-1.0.0-123",
-						Address: "localhost:9999",
-						Metadata: map[string]string{
-							"protocol": "mucp",
-						},
-					},
-					{
-						Id:      "foo-1.0.0-321",
-						Address: "localhost:9999",
-						Metadata: map[string]string{
-							"protocol": "mucp",
-						},
-					},
-				},
-			},
-			{
-				Name:    "foo",
-				Version: "1.0.1",
-				Nodes: []*registry.Node{
-					{
-						Id:      "foo-1.0.1-321",
-						Address: "localhost:6666",
-						Metadata: map[string]string{
-							"protocol": "mucp",
-						},
-					},
-				},
-			},
-			{
-				Name:    "foo",
-				Version: "1.0.3",
-				Nodes: []*registry.Node{
-					{
-						Id:      "foo-1.0.3-345",
-						Address: "localhost:8888",
-						Metadata: map[string]string{
-							"protocol": "mucp",
-						},
-					},
-				},
-			},
-		},
-	}
-)

client/mucp/mucp.go

@@ -1,626 +0,0 @@
-// Package mucp provides a transport agnostic RPC client
-package mucp
-
-import (
-	"context"
-	"fmt"
-	"sync/atomic"
-	"time"
-
-	"github.com/google/uuid"
-	"github.com/micro/go-micro/v3/broker"
-	"github.com/micro/go-micro/v3/client"
-	"github.com/micro/go-micro/v3/codec"
-	raw "github.com/micro/go-micro/v3/codec/bytes"
-	"github.com/micro/go-micro/v3/errors"
-	"github.com/micro/go-micro/v3/metadata"
-	"github.com/micro/go-micro/v3/network/transport"
-	"github.com/micro/go-micro/v3/util/buf"
-	"github.com/micro/go-micro/v3/util/pool"
-)
-
-type rpcClient struct {
-	once atomic.Value
-	opts client.Options
-	pool pool.Pool
-	seq  uint64
-}
-
-// NewClient returns a new micro client interface
-func NewClient(opt ...client.Option) client.Client {
-	opts := client.NewOptions(opt...)
-
-	p := pool.NewPool(
-		pool.Size(opts.PoolSize),
-		pool.TTL(opts.PoolTTL),
-		pool.Transport(opts.Transport),
-	)
-
-	rc := &rpcClient{
-		opts: opts,
-		pool: p,
-		seq:  0,
-	}
-	rc.once.Store(false)
-
-	c := client.Client(rc)
-
-	// wrap in reverse
-	for i := len(opts.Wrappers); i > 0; i-- {
-		c = opts.Wrappers[i-1](c)
-	}
-
-	return c
-}
-
-func (r *rpcClient) newCodec(contentType string) (codec.NewCodec, error) {
-	if c, ok := r.opts.Codecs[contentType]; ok {
-		return c, nil
-	}
-	if cf, ok := DefaultCodecs[contentType]; ok {
-		return cf, nil
-	}
-	return nil, fmt.Errorf("Unsupported Content-Type: %s", contentType)
-}
-
-func (r *rpcClient) call(ctx context.Context, addr string, req client.Request, resp interface{}, opts client.CallOptions) error {
-	msg := &transport.Message{
-		Header: make(map[string]string),
-	}
-
-	md, ok := metadata.FromContext(ctx)
-	if ok {
-		for k, v := range md {
-			// don't copy Micro-Topic header, that used for pub/sub
-			// this fix case then client uses the same context that received in subscriber
-			if k == "Micro-Topic" {
-				continue
-			}
-			msg.Header[k] = v
-		}
-	}
-
-	// set timeout in nanoseconds
-	msg.Header["Timeout"] = fmt.Sprintf("%d", opts.RequestTimeout)
-	// set the content type for the request
-	msg.Header["Content-Type"] = req.ContentType()
-	// set the accept header
-	msg.Header["Accept"] = req.ContentType()
-
-	cf, err := r.newCodec(req.ContentType())
-	if err != nil {
-		return errors.InternalServerError("go.micro.client", err.Error())
-	}
-
-	dOpts := []transport.DialOption{
-		transport.WithStream(),
-	}
-
-	if opts.DialTimeout >= 0 {
-		dOpts = append(dOpts, transport.WithTimeout(opts.DialTimeout))
-	}
-
-	c, err := r.pool.Get(addr, dOpts...)
-	if err != nil {
-		return errors.InternalServerError("go.micro.client", "connection error: %v", err)
-	}
-
-	seq := atomic.AddUint64(&r.seq, 1) - 1
-	codec := newRpcCodec(msg, c, cf, "")
-
-	rsp := &rpcResponse{
-		socket: c,
-		codec:  codec,
-	}
-
-	stream := &rpcStream{
-		id:       fmt.Sprintf("%v", seq),
-		context:  ctx,
-		request:  req,
-		response: rsp,
-		codec:    codec,
-		closed:   make(chan bool),
-		release:  func(err error) { r.pool.Release(c, err) },
-		sendEOS:  false,
-	}
-	// close the stream on exiting this function
-	defer stream.Close()
-
-	// wait for error response
-	ch := make(chan error, 1)
-
-	go func() {
-		defer func() {
-			if r := recover(); r != nil {
-				ch <- errors.InternalServerError("go.micro.client", "panic recovered: %v", r)
-			}
-		}()
-
-		// send request
-		if err := stream.Send(req.Body()); err != nil {
-			ch <- err
-			return
-		}
-
-		// recv request
-		if err := stream.Recv(resp); err != nil {
-			ch <- err
-			return
-		}
-
-		// success
-		ch <- nil
-	}()
-
-	var grr error
-
-	select {
-	case err := <-ch:
-		return err
-	case <-ctx.Done():
-		grr = errors.Timeout("go.micro.client", fmt.Sprintf("%v", ctx.Err()))
-	}
-
-	// set the stream error
-	if grr != nil {
-		stream.Lock()
-		stream.err = grr
-		stream.Unlock()
-
-		return grr
-	}
-
-	return nil
-}
-
-func (r *rpcClient) stream(ctx context.Context, addr string, req client.Request, opts client.CallOptions) (client.Stream, error) {
-	msg := &transport.Message{
-		Header: make(map[string]string),
-	}
-
-	md, ok := metadata.FromContext(ctx)
-	if ok {
-		for k, v := range md {
-			msg.Header[k] = v
-		}
-	}
-
-	// set timeout in nanoseconds
-	if opts.StreamTimeout > time.Duration(0) {
-		msg.Header["Timeout"] = fmt.Sprintf("%d", opts.StreamTimeout)
-	}
-	// set the content type for the request
-	msg.Header["Content-Type"] = req.ContentType()
-	// set the accept header
-	msg.Header["Accept"] = req.ContentType()
-
-	cf, err := r.newCodec(req.ContentType())
-	if err != nil {
-		return nil, errors.InternalServerError("go.micro.client", err.Error())
-	}
-
-	dOpts := []transport.DialOption{
-		transport.WithStream(),
-	}
-
-	if opts.DialTimeout >= 0 {
-		dOpts = append(dOpts, transport.WithTimeout(opts.DialTimeout))
-	}
-
-	c, err := r.opts.Transport.Dial(addr, dOpts...)
-	if err != nil {
-		return nil, errors.InternalServerError("go.micro.client", "connection error: %v", err)
-	}
-
-	// increment the sequence number
-	seq := atomic.AddUint64(&r.seq, 1) - 1
-	id := fmt.Sprintf("%v", seq)
-
-	// create codec with stream id
-	codec := newRpcCodec(msg, c, cf, id)
-
-	rsp := &rpcResponse{
-		socket: c,
-		codec:  codec,
-	}
-
-	// set request codec
-	if r, ok := req.(*rpcRequest); ok {
-		r.codec = codec
-	}
-
-	stream := &rpcStream{
-		id:       id,
-		context:  ctx,
-		request:  req,
-		response: rsp,
-		codec:    codec,
-		// used to close the stream
-		closed: make(chan bool),
-		// signal the end of stream,
-		sendEOS: true,
-		// release func
-		release: func(err error) { c.Close() },
-	}
-
-	// wait for error response
-	ch := make(chan error, 1)
-
-	go func() {
-		// send the first message
-		ch <- stream.Send(req.Body())
-	}()
-
-	var grr error
-
-	select {
-	case err := <-ch:
-		grr = err
-	case <-ctx.Done():
-		grr = errors.Timeout("go.micro.client", fmt.Sprintf("%v", ctx.Err()))
-	}
-
-	if grr != nil {
-		// set the error
-		stream.Lock()
-		stream.err = grr
-		stream.Unlock()
-
-		// close the stream
-		stream.Close()
-		return nil, grr
-	}
-
-	return stream, nil
-}
-
-func (r *rpcClient) Init(opts ...client.Option) error {
-	size := r.opts.PoolSize
-	ttl := r.opts.PoolTTL
-	tr := r.opts.Transport
-
-	for _, o := range opts {
-		o(&r.opts)
-	}
-
-	// update pool configuration if the options changed
-	if size != r.opts.PoolSize || ttl != r.opts.PoolTTL || tr != r.opts.Transport {
-		// close existing pool
-		r.pool.Close()
-		// create new pool
-		r.pool = pool.NewPool(
-			pool.Size(r.opts.PoolSize),
-			pool.TTL(r.opts.PoolTTL),
-			pool.Transport(r.opts.Transport),
-		)
-	}
-
-	return nil
-}
-
-func (r *rpcClient) Options() client.Options {
-	return r.opts
-}
-
-func (r *rpcClient) Call(ctx context.Context, request client.Request, response interface{}, opts ...client.CallOption) error {
-	// make a copy of call opts
-	callOpts := r.opts.CallOptions
-	for _, opt := range opts {
-		opt(&callOpts)
-	}
-
-	// check if we already have a deadline
-	if d, ok := ctx.Deadline(); !ok {
-		// no deadline so we create a new one
-		var cancel context.CancelFunc
-		ctx, cancel = context.WithTimeout(ctx, callOpts.RequestTimeout)
-		defer cancel()
-	} else {
-		// got a deadline so no need to setup context
-		// but we need to set the timeout we pass along
-		remaining := d.Sub(time.Now())
-		client.WithRequestTimeout(remaining)(&callOpts)
-	}
-
-	// should we noop right here?
-	select {
-	case <-ctx.Done():
-		return errors.Timeout("go.micro.client", fmt.Sprintf("%v", ctx.Err()))
-	default:
-	}
-
-	// make copy of call method
-	rcall := r.call
-
-	// wrap the call in reverse
-	for i := len(callOpts.CallWrappers); i > 0; i-- {
-		rcall = callOpts.CallWrappers[i-1](rcall)
-	}
-
-	// use the router passed as a call option, or fallback to the rpc clients router
-	if callOpts.Router == nil {
-		callOpts.Router = r.opts.Router
-	}
-
-	if callOpts.Selector == nil {
-		callOpts.Selector = r.opts.Selector
-	}
-
-	// inject proxy address
-	// TODO: don't even bother using Lookup/Select in this case
-	if len(r.opts.Proxy) > 0 {
-		callOpts.Address = []string{r.opts.Proxy}
-	}
-
-	// lookup the route to send the reques to
-	// TODO apply any filtering here
-	routes, err := r.opts.Lookup(ctx, request, callOpts)
-	if err != nil {
-		return errors.InternalServerError("go.micro.client", err.Error())
-	}
-
-	// balance the list of nodes
-	next, err := callOpts.Selector.Select(routes)
-	if err != nil {
-		return err
-	}
-
-	// return errors.New("go.micro.client", "request timeout", 408)
-	call := func(i int) error {
-		// call backoff first. Someone may want an initial start delay
-		t, err := callOpts.Backoff(ctx, request, i)
-		if err != nil {
-			return errors.InternalServerError("go.micro.client", "backoff error: %v", err.Error())
-		}
-
-		// only sleep if greater than 0
-		if t.Seconds() > 0 {
-			time.Sleep(t)
-		}
-
-		// get the next node
-		node := next()
-
-		// make the call
-		err = rcall(ctx, node, request, response, callOpts)
-
-		// record the result of the call to inform future routing decisions
-		r.opts.Selector.Record(node, err)
-
-		return err
-	}
-
-	// get the retries
-	retries := callOpts.Retries
-
-	// disable retries when using a proxy
-	if len(r.opts.Proxy) > 0 {
-		retries = 0
-	}
-
-	ch := make(chan error, retries+1)
-	var gerr error
-
-	for i := 0; i <= retries; i++ {
-		go func(i int) {
-			ch <- call(i)
-		}(i)
-
-		select {
-		case <-ctx.Done():
-			return errors.Timeout("go.micro.client", fmt.Sprintf("call timeout: %v", ctx.Err()))
-		case err := <-ch:
-			// if the call succeeded lets bail early
-			if err == nil {
-				return nil
-			}
-
-			retry, rerr := callOpts.Retry(ctx, request, i, err)
-			if rerr != nil {
-				return rerr
-			}
-
-			if !retry {
-				return err
-			}
-
-			gerr = err
-		}
-	}
-
-	return gerr
-}
-
-func (r *rpcClient) Stream(ctx context.Context, request client.Request, opts ...client.CallOption) (client.Stream, error) {
-	// make a copy of call opts
-	callOpts := r.opts.CallOptions
-	for _, opt := range opts {
-		opt(&callOpts)
-	}
-
-	// should we noop right here?
-	select {
-	case <-ctx.Done():
-		return nil, errors.Timeout("go.micro.client", fmt.Sprintf("%v", ctx.Err()))
-	default:
-	}
-
-	// use the router passed as a call option, or fallback to the rpc clients router
-	if callOpts.Router == nil {
-		callOpts.Router = r.opts.Router
-	}
-
-	if callOpts.Selector == nil {
-		callOpts.Selector = r.opts.Selector
-	}
-
-	// inject proxy address
-	// TODO: don't even bother using Lookup/Select in this case
-	if len(r.opts.Proxy) > 0 {
-		callOpts.Address = []string{r.opts.Proxy}
-	}
-
-	// lookup the route to send the reques to
-	// TODO apply any filtering here
-	routes, err := r.opts.Lookup(ctx, request, callOpts)
-	if err != nil {
-		return nil, errors.InternalServerError("go.micro.client", err.Error())
-	}
-
-	// balance the list of nodes
-	next, err := callOpts.Selector.Select(routes)
-	if err != nil {
-		return nil, err
-	}
-
-	call := func(i int) (client.Stream, error) {
-		// call backoff first. Someone may want an initial start delay
-		t, err := callOpts.Backoff(ctx, request, i)
-		if err != nil {
-			return nil, errors.InternalServerError("go.micro.client", "backoff error: %v", err.Error())
-		}
-
-		// only sleep if greater than 0
-		if t.Seconds() > 0 {
-			time.Sleep(t)
-		}
-
-		// get the next node
-		node := next()
-
-		// perform the call
-		stream, err := r.stream(ctx, node, request, callOpts)
-
-		// record the result of the call to inform future routing decisions
-		r.opts.Selector.Record(node, err)
-
-		return stream, err
-	}
-
-	type response struct {
-		stream client.Stream
-		err    error
-	}
-
-	// get the retries
-	retries := callOpts.Retries
-
-	// disable retries when using a proxy
-	if len(r.opts.Proxy) > 0 {
-		retries = 0
-	}
-
-	ch := make(chan response, retries+1)
-	var grr error
-
-	for i := 0; i <= retries; i++ {
-		go func(i int) {
-			s, err := call(i)
-			ch <- response{s, err}
-		}(i)
-
-		select {
-		case <-ctx.Done():
-			return nil, errors.Timeout("go.micro.client", fmt.Sprintf("call timeout: %v", ctx.Err()))
-		case rsp := <-ch:
-			// if the call succeeded lets bail early
-			if rsp.err == nil {
-				return rsp.stream, nil
-			}
-
-			retry, rerr := callOpts.Retry(ctx, request, i, rsp.err)
-			if rerr != nil {
-				return nil, rerr
-			}
-
-			if !retry {
-				return nil, rsp.err
-			}
-
-			grr = rsp.err
-		}
-	}
-
-	return nil, grr
-}
-
-func (r *rpcClient) Publish(ctx context.Context, msg client.Message, opts ...client.PublishOption) error {
-	options := client.PublishOptions{
-		Context: context.Background(),
-	}
-	for _, o := range opts {
-		o(&options)
-	}
-
-	md, ok := metadata.FromContext(ctx)
-	if !ok {
-		md = make(map[string]string)
-	}
-
-	id := uuid.New().String()
-	md["Content-Type"] = msg.ContentType()
-	md["Micro-Topic"] = msg.Topic()
-	md["Micro-Id"] = id
-
-	// set the topic
-	topic := msg.Topic()
-
-	// get the exchange
-	if len(options.Exchange) > 0 {
-		topic = options.Exchange
-	}
-
-	// encode message body
-	cf, err := r.newCodec(msg.ContentType())
-	if err != nil {
-		return errors.InternalServerError("go.micro.client", err.Error())
-	}
-
-	var body []byte
-
-	// passed in raw data
-	if d, ok := msg.Payload().(*raw.Frame); ok {
-		body = d.Data
-	} else {
-		// new buffer
-		b := buf.New(nil)
-
-		if err := cf(b).Write(&codec.Message{
-			Target: topic,
-			Type:   codec.Event,
-			Header: map[string]string{
-				"Micro-Id":    id,
-				"Micro-Topic": msg.Topic(),
-			},
-		}, msg.Payload()); err != nil {
-			return errors.InternalServerError("go.micro.client", err.Error())
-		}
-
-		// set the body
-		body = b.Bytes()
-	}
-
-	if !r.once.Load().(bool) {
-		if err = r.opts.Broker.Connect(); err != nil {
-			return errors.InternalServerError("go.micro.client", err.Error())
-		}
-		r.once.Store(true)
-	}
-
-	return r.opts.Broker.Publish(topic, &broker.Message{
-		Header: md,
-		Body:   body,
-	}, broker.PublishContext(options.Context))
-}
-
-func (r *rpcClient) NewMessage(topic string, message interface{}, opts ...client.MessageOption) client.Message {
-	return newMessage(topic, message, r.opts.ContentType, opts...)
-}
-
-func (r *rpcClient) NewRequest(service, method string, request interface{}, reqOpts ...client.RequestOption) client.Request {
-	return newRequest(service, method, request, r.opts.ContentType, reqOpts...)
-}
-
-func (r *rpcClient) String() string {
-	return "mucp"
-}

client/mucp/mucp_codec.go

@@ -1,267 +0,0 @@
-package mucp
-
-import (
-	"bytes"
-	errs "errors"
-
-	"github.com/micro/go-micro/v3/codec"
-	raw "github.com/micro/go-micro/v3/codec/bytes"
-	"github.com/micro/go-micro/v3/codec/grpc"
-	"github.com/micro/go-micro/v3/codec/json"
-	"github.com/micro/go-micro/v3/codec/jsonrpc"
-	"github.com/micro/go-micro/v3/codec/proto"
-	"github.com/micro/go-micro/v3/codec/protorpc"
-	"github.com/micro/go-micro/v3/errors"
-	"github.com/micro/go-micro/v3/network/transport"
-	"github.com/micro/go-micro/v3/registry"
-)
-
-const (
-	lastStreamResponseError = "EOS"
-)
-
-// serverError represents an error that has been returned from
-// the remote side of the RPC connection.
-type serverError string
-
-func (e serverError) Error() string {
-	return string(e)
-}
-
-// errShutdown holds the specific error for closing/closed connections
-var (
-	errShutdown = errs.New("connection is shut down")
-)
-
-type rpcCodec struct {
-	client transport.Client
-	codec  codec.Codec
-
-	req *transport.Message
-	buf *readWriteCloser
-
-	// signify if its a stream
-	stream string
-}
-
-type readWriteCloser struct {
-	wbuf *bytes.Buffer
-	rbuf *bytes.Buffer
-}
-
-var (
-	DefaultContentType = "application/protobuf"
-
-	DefaultCodecs = map[string]codec.NewCodec{
-		"application/grpc":         grpc.NewCodec,
-		"application/grpc+json":    grpc.NewCodec,
-		"application/grpc+proto":   grpc.NewCodec,
-		"application/protobuf":     proto.NewCodec,
-		"application/json":         json.NewCodec,
-		"application/json-rpc":     jsonrpc.NewCodec,
-		"application/proto-rpc":    protorpc.NewCodec,
-		"application/octet-stream": raw.NewCodec,
-	}
-
-	// TODO: remove legacy codec list
-	defaultCodecs = map[string]codec.NewCodec{
-		"application/json":         jsonrpc.NewCodec,
-		"application/json-rpc":     jsonrpc.NewCodec,
-		"application/protobuf":     protorpc.NewCodec,
-		"application/proto-rpc":    protorpc.NewCodec,
-		"application/octet-stream": protorpc.NewCodec,
-	}
-)
-
-func (rwc *readWriteCloser) Read(p []byte) (n int, err error) {
-	return rwc.rbuf.Read(p)
-}
-
-func (rwc *readWriteCloser) Write(p []byte) (n int, err error) {
-	return rwc.wbuf.Write(p)
-}
-
-func (rwc *readWriteCloser) Close() error {
-	rwc.rbuf.Reset()
-	rwc.wbuf.Reset()
-	return nil
-}
-
-func getHeaders(m *codec.Message) {
-	set := func(v, hdr string) string {
-		if len(v) > 0 {
-			return v
-		}
-		return m.Header[hdr]
-	}
-
-	// check error in header
-	m.Error = set(m.Error, "Micro-Error")
-
-	// check endpoint in header
-	m.Endpoint = set(m.Endpoint, "Micro-Endpoint")
-
-	// check method in header
-	m.Method = set(m.Method, "Micro-Method")
-
-	// set the request id
-	m.Id = set(m.Id, "Micro-Id")
-}
-
-func setHeaders(m *codec.Message, stream string) {
-	set := func(hdr, v string) {
-		if len(v) == 0 {
-			return
-		}
-		m.Header[hdr] = v
-	}
-
-	set("Micro-Id", m.Id)
-	set("Micro-Service", m.Target)
-	set("Micro-Method", m.Method)
-	set("Micro-Endpoint", m.Endpoint)
-	set("Micro-Error", m.Error)
-
-	if len(stream) > 0 {
-		set("Micro-Stream", stream)
-	}
-}
-
-// setupProtocol sets up the old protocol
-func setupProtocol(msg *transport.Message, node *registry.Node) codec.NewCodec {
-	// get the protocol from node metadata
-	if protocol := node.Metadata["protocol"]; len(protocol) > 0 {
-		return nil
-	}
-
-	// processing topic publishing
-	if len(msg.Header["Micro-Topic"]) > 0 {
-		return nil
-	}
-
-	// no protocol use old codecs
-	switch msg.Header["Content-Type"] {
-	case "application/json":
-		msg.Header["Content-Type"] = "application/json-rpc"
-	case "application/protobuf":
-		msg.Header["Content-Type"] = "application/proto-rpc"
-	}
-
-	// now return codec
-	return defaultCodecs[msg.Header["Content-Type"]]
-}
-
-func newRpcCodec(req *transport.Message, client transport.Client, c codec.NewCodec, stream string) codec.Codec {
-	rwc := &readWriteCloser{
-		wbuf: bytes.NewBuffer(nil),
-		rbuf: bytes.NewBuffer(nil),
-	}
-	r := &rpcCodec{
-		buf:    rwc,
-		client: client,
-		codec:  c(rwc),
-		req:    req,
-		stream: stream,
-	}
-	return r
-}
-
-func (c *rpcCodec) Write(m *codec.Message, body interface{}) error {
-	c.buf.wbuf.Reset()
-
-	// create header
-	if m.Header == nil {
-		m.Header = map[string]string{}
-	}
-
-	// copy original header
-	for k, v := range c.req.Header {
-		m.Header[k] = v
-	}
-
-	// set the mucp headers
-	setHeaders(m, c.stream)
-
-	// if body is bytes Frame don't encode
-	if body != nil {
-		if b, ok := body.(*raw.Frame); ok {
-			// set body
-			m.Body = b.Data
-		} else {
-			// write to codec
-			if err := c.codec.Write(m, body); err != nil {
-				return errors.InternalServerError("go.micro.client.codec", err.Error())
-			}
-			// set body
-			m.Body = c.buf.wbuf.Bytes()
-		}
-	}
-
-	// create new transport message
-	msg := transport.Message{
-		Header: m.Header,
-		Body:   m.Body,
-	}
-
-	// send the request
-	if err := c.client.Send(&msg); err != nil {
-		return errors.InternalServerError("go.micro.client.transport", err.Error())
-	}
-
-	return nil
-}
-
-func (c *rpcCodec) ReadHeader(m *codec.Message, r codec.MessageType) error {
-	var tm transport.Message
-
-	// read message from transport
-	if err := c.client.Recv(&tm); err != nil {
-		return errors.InternalServerError("go.micro.client.transport", err.Error())
-	}
-
-	c.buf.rbuf.Reset()
-	c.buf.rbuf.Write(tm.Body)
-
-	// set headers from transport
-	m.Header = tm.Header
-
-	// read header
-	err := c.codec.ReadHeader(m, r)
-
-	// get headers
-	getHeaders(m)
-
-	// return header error
-	if err != nil {
-		return errors.InternalServerError("go.micro.client.codec", err.Error())
-	}
-
-	return nil
-}
-
-func (c *rpcCodec) ReadBody(b interface{}) error {
-	// read body
-	// read raw data
-	if v, ok := b.(*raw.Frame); ok {
-		v.Data = c.buf.rbuf.Bytes()
-		return nil
-	}
-
-	if err := c.codec.ReadBody(b); err != nil {
-		return errors.InternalServerError("go.micro.client.codec", err.Error())
-	}
-	return nil
-}
-
-func (c *rpcCodec) Close() error {
-	c.buf.Close()
-	c.codec.Close()
-	if err := c.client.Close(); err != nil {
-		return errors.InternalServerError("go.micro.client.transport", err.Error())
-	}
-	return nil
-}
-
-func (c *rpcCodec) String() string {
-	return "rpc"
-}

client/mucp/mucp_message.go

@@ -1,40 +0,0 @@
-package mucp
-
-import (
-	"github.com/micro/go-micro/v3/client"
-)
-
-type message struct {
-	topic       string
-	contentType string
-	payload     interface{}
-}
-
-func newMessage(topic string, payload interface{}, contentType string, opts ...client.MessageOption) client.Message {
-	var options client.MessageOptions
-	for _, o := range opts {
-		o(&options)
-	}
-
-	if len(options.ContentType) > 0 {
-		contentType = options.ContentType
-	}
-
-	return &message{
-		payload:     payload,
-		topic:       topic,
-		contentType: contentType,
-	}
-}
-
-func (m *message) ContentType() string {
-	return m.contentType
-}
-
-func (m *message) Topic() string {
-	return m.topic
-}
-
-func (m *message) Payload() interface{} {
-	return m.payload
-}

client/mucp/mucp_request_test.go

@@ -1,25 +0,0 @@
-package mucp
-
-import (
-	"testing"
-
-	"github.com/micro/go-micro/v3/client"
-)
-
-func TestRequestOptions(t *testing.T) {
-	r := newRequest("service", "endpoint", nil, "application/json")
-	if r.Service() != "service" {
-		t.Fatalf("expected 'service' got %s", r.Service())
-	}
-	if r.Endpoint() != "endpoint" {
-		t.Fatalf("expected 'endpoint' got %s", r.Endpoint())
-	}
-	if r.ContentType() != "application/json" {
-		t.Fatalf("expected 'endpoint' got %s", r.ContentType())
-	}
-
-	r2 := newRequest("service", "endpoint", nil, "application/json", client.WithContentType("application/protobuf"))
-	if r2.ContentType() != "application/protobuf" {
-		t.Fatalf("expected 'endpoint' got %s", r2.ContentType())
-	}
-}

client/mucp/mucp_response.go

@@ -1,35 +0,0 @@
-package mucp
-
-import (
-	"github.com/micro/go-micro/v3/codec"
-	"github.com/micro/go-micro/v3/network/transport"
-)
-
-type rpcResponse struct {
-	header map[string]string
-	body   []byte
-	socket transport.Socket
-	codec  codec.Codec
-}
-
-func (r *rpcResponse) Codec() codec.Reader {
-	return r.codec
-}
-
-func (r *rpcResponse) Header() map[string]string {
-	return r.header
-}
-
-func (r *rpcResponse) Read() ([]byte, error) {
-	var msg transport.Message
-
-	if err := r.socket.Recv(&msg); err != nil {
-		return nil, err
-	}
-
-	// set internals
-	r.header = msg.Header
-	r.body = msg.Body
-
-	return msg.Body, nil
-}

client/mucp/mucp_stream.go

@@ -1,165 +0,0 @@
-package mucp
-
-import (
-	"context"
-	"io"
-	"sync"
-
-	"github.com/micro/go-micro/v3/client"
-	"github.com/micro/go-micro/v3/codec"
-)
-
-// Implements the streamer interface
-type rpcStream struct {
-	sync.RWMutex
-	id       string
-	closed   chan bool
-	err      error
-	request  client.Request
-	response client.Response
-	codec    codec.Codec
-	context  context.Context
-
-	// signal whether we should send EOS
-	sendEOS bool
-
-	// release releases the connection back to the pool
-	release func(err error)
-}
-
-func (r *rpcStream) isClosed() bool {
-	select {
-	case <-r.closed:
-		return true
-	default:
-		return false
-	}
-}
-
-func (r *rpcStream) Context() context.Context {
-	return r.context
-}
-
-func (r *rpcStream) Request() client.Request {
-	return r.request
-}
-
-func (r *rpcStream) Response() client.Response {
-	return r.response
-}
-
-func (r *rpcStream) Send(msg interface{}) error {
-	r.Lock()
-	defer r.Unlock()
-
-	if r.isClosed() {
-		r.err = errShutdown
-		return errShutdown
-	}
-
-	req := codec.Message{
-		Id:       r.id,
-		Target:   r.request.Service(),
-		Method:   r.request.Method(),
-		Endpoint: r.request.Endpoint(),
-		Type:     codec.Request,
-	}
-
-	if err := r.codec.Write(&req, msg); err != nil {
-		r.err = err
-		return err
-	}
-
-	return nil
-}
-
-func (r *rpcStream) Recv(msg interface{}) error {
-	r.Lock()
-	defer r.Unlock()
-
-	if r.isClosed() {
-		r.err = errShutdown
-		return errShutdown
-	}
-
-	var resp codec.Message
-
-	r.Unlock()
-	err := r.codec.ReadHeader(&resp, codec.Response)
-	r.Lock()
-	if err != nil {
-		if err == io.EOF && !r.isClosed() {
-			r.err = io.ErrUnexpectedEOF
-			return io.ErrUnexpectedEOF
-		}
-		r.err = err
-		return err
-	}
-
-	switch {
-	case len(resp.Error) > 0:
-		// We've got an error response. Give this to the request;
-		// any subsequent requests will get the ReadResponseBody
-		// error if there is one.
-		if resp.Error != lastStreamResponseError {
-			r.err = serverError(resp.Error)
-		} else {
-			r.err = io.EOF
-		}
-		r.Unlock()
-		err = r.codec.ReadBody(nil)
-		r.Lock()
-		if err != nil {
-			r.err = err
-		}
-	default:
-		r.Unlock()
-		err = r.codec.ReadBody(msg)
-		r.Lock()
-		if err != nil {
-			r.err = err
-		}
-	}
-
-	return r.err
-}
-
-func (r *rpcStream) Error() error {
-	r.RLock()
-	defer r.RUnlock()
-	return r.err
-}
-
-func (r *rpcStream) Close() error {
-	r.Lock()
-
-	select {
-	case <-r.closed:
-		r.Unlock()
-		return nil
-	default:
-		close(r.closed)
-		r.Unlock()
-
-		// send the end of stream message
-		if r.sendEOS {
-			// no need to check for error
-			r.codec.Write(&codec.Message{
-				Id:       r.id,
-				Target:   r.request.Service(),
-				Method:   r.request.Method(),
-				Endpoint: r.request.Endpoint(),
-				Type:     codec.Error,
-				Error:    lastStreamResponseError,
-			}, nil)
-		}
-
-		err := r.codec.Close()
-
-		// release the connection
-		r.release(r.Error())
-
-		// return the codec error
-		return err
-	}
-}

client/mucp/mucp_test.go

@@ -1,159 +0,0 @@
-package mucp
-
-import (
-	"context"
-	"fmt"
-	"testing"
-
-	"github.com/micro/go-micro/v3/client"
-	"github.com/micro/go-micro/v3/errors"
-	"github.com/micro/go-micro/v3/registry"
-	"github.com/micro/go-micro/v3/registry/memory"
-	"github.com/micro/go-micro/v3/router"
-	regRouter "github.com/micro/go-micro/v3/router/registry"
-)
-
-func newTestRouter() router.Router {
-	reg := memory.NewRegistry(memory.Services(testData))
-	return regRouter.NewRouter(router.Registry(reg))
-}
-
-func TestCallAddress(t *testing.T) {
-	var called bool
-	service := "test.service"
-	endpoint := "Test.Endpoint"
-	address := "10.1.10.1:8080"
-
-	wrap := func(cf client.CallFunc) client.CallFunc {
-		return func(ctx context.Context, node string, req client.Request, rsp interface{}, opts client.CallOptions) error {
-			called = true
-
-			if req.Service() != service {
-				return fmt.Errorf("expected service: %s got %s", service, req.Service())
-			}
-
-			if req.Endpoint() != endpoint {
-				return fmt.Errorf("expected service: %s got %s", endpoint, req.Endpoint())
-			}
-
-			if node != address {
-				return fmt.Errorf("expected address: %s got %s", address, node)
-			}
-
-			// don't do the call
-			return nil
-		}
-	}
-
-	r := newTestRouter()
-
-	c := NewClient(
-		client.Router(r),
-		client.WrapCall(wrap),
-	)
-
-	req := c.NewRequest(service, endpoint, nil)
-
-	// test calling remote address
-	if err := c.Call(context.Background(), req, nil, client.WithAddress(address)); err != nil {
-		t.Fatal("call with address error", err)
-	}
-
-	if !called {
-		t.Fatal("wrapper not called")
-	}
-
-}
-
-func TestCallRetry(t *testing.T) {
-	service := "test.service"
-	endpoint := "Test.Endpoint"
-	address := "10.1.10.1"
-
-	var called int
-
-	wrap := func(cf client.CallFunc) client.CallFunc {
-		return func(ctx context.Context, node string, req client.Request, rsp interface{}, opts client.CallOptions) error {
-			called++
-			if called == 1 {
-				return errors.InternalServerError("test.error", "retry request")
-			}
-
-			// don't do the call
-			return nil
-		}
-	}
-
-	r := newTestRouter()
-	c := NewClient(
-		client.Router(r),
-		client.WrapCall(wrap),
-	)
-
-	req := c.NewRequest(service, endpoint, nil)
-
-	// test calling remote address
-	if err := c.Call(context.Background(), req, nil, client.WithAddress(address)); err != nil {
-		t.Fatal("call with address error", err)
-	}
-
-	// num calls
-	if called < c.Options().CallOptions.Retries+1 {
-		t.Fatal("request not retried")
-	}
-}
-
-func TestCallWrapper(t *testing.T) {
-	var called bool
-	id := "test.1"
-	service := "test.service"
-	endpoint := "Test.Endpoint"
-	address := "10.1.10.1:8080"
-
-	wrap := func(cf client.CallFunc) client.CallFunc {
-		return func(ctx context.Context, node string, req client.Request, rsp interface{}, opts client.CallOptions) error {
-			called = true
-
-			if req.Service() != service {
-				return fmt.Errorf("expected service: %s got %s", service, req.Service())
-			}
-
-			if req.Endpoint() != endpoint {
-				return fmt.Errorf("expected service: %s got %s", endpoint, req.Endpoint())
-			}
-
-			if node != address {
-				return fmt.Errorf("expected address: %s got %s", address, node)
-			}
-
-			// don't do the call
-			return nil
-		}
-	}
-
-	r := newTestRouter()
-	c := NewClient(
-		client.Router(r),
-		client.WrapCall(wrap),
-	)
-
-	r.Options().Registry.Register(&registry.Service{
-		Name:    service,
-		Version: "latest",
-		Nodes: []*registry.Node{
-			{
-				Id:      id,
-				Address: address,
-			},
-		},
-	})
-
-	req := c.NewRequest(service, endpoint, nil)
-	if err := c.Call(context.Background(), req, nil); err != nil {
-		t.Fatal("call wrapper error", err)
-	}
-
-	if !called {
-		t.Fatal("wrapper not called")
-	}
-}

client/mucp/options_test.go

@@ -1,86 +0,0 @@
-package mucp
-
-import (
-	"testing"
-	"time"
-
-	"github.com/micro/go-micro/v3/client"
-	"github.com/micro/go-micro/v3/network/transport"
-)
-
-func TestCallOptions(t *testing.T) {
-	testData := []struct {
-		set      bool
-		retries  int
-		rtimeout time.Duration
-		dtimeout time.Duration
-	}{
-		{false, client.DefaultRetries, client.DefaultRequestTimeout, transport.DefaultDialTimeout},
-		{true, 10, time.Second, time.Second * 2},
-	}
-
-	for _, d := range testData {
-		var opts client.Options
-		var cl client.Client
-
-		if d.set {
-			opts = client.NewOptions(
-				client.Retries(d.retries),
-				client.RequestTimeout(d.rtimeout),
-				client.DialTimeout(d.dtimeout),
-			)
-
-			cl = NewClient(
-				client.Retries(d.retries),
-				client.RequestTimeout(d.rtimeout),
-				client.DialTimeout(d.dtimeout),
-			)
-		} else {
-			opts = client.NewOptions()
-			cl = NewClient()
-		}
-
-		// test options and those set in client
-		for _, o := range []client.Options{opts, cl.Options()} {
-			if o.CallOptions.Retries != d.retries {
-				t.Fatalf("Expected retries %v got %v", d.retries, o.CallOptions.Retries)
-			}
-
-			if o.CallOptions.RequestTimeout != d.rtimeout {
-				t.Fatalf("Expected request timeout %v got %v", d.rtimeout, o.CallOptions.RequestTimeout)
-			}
-
-			if o.CallOptions.DialTimeout != d.dtimeout {
-				t.Fatalf("Expected %v got %v", d.dtimeout, o.CallOptions.DialTimeout)
-			}
-
-			// copy CallOptions
-			callOpts := o.CallOptions
-
-			// create new opts
-			cretries := client.WithRetries(o.CallOptions.Retries * 10)
-			crtimeout := client.WithRequestTimeout(o.CallOptions.RequestTimeout * (time.Second * 10))
-			cdtimeout := client.WithDialTimeout(o.CallOptions.DialTimeout * (time.Second * 10))
-
-			// set call options
-			for _, opt := range []client.CallOption{cretries, crtimeout, cdtimeout} {
-				opt(&callOpts)
-			}
-
-			// check call options
-			if e := o.CallOptions.Retries * 10; callOpts.Retries != e {
-				t.Fatalf("Expected retries %v got %v", e, callOpts.Retries)
-			}
-
-			if e := o.CallOptions.RequestTimeout * (time.Second * 10); callOpts.RequestTimeout != e {
-				t.Fatalf("Expected request timeout %v got %v", e, callOpts.RequestTimeout)
-			}
-
-			if e := o.CallOptions.DialTimeout * (time.Second * 10); callOpts.DialTimeout != e {
-				t.Fatalf("Expected %v got %v", e, callOpts.DialTimeout)
-			}
-
-		}
-
-	}
-}

client/options.go

@@ -4,16 +4,14 @@ import (
 	"context"
 	"time"
 
-	"github.com/micro/go-micro/v3/broker"
+	"github.com/unistack-org/micro/v3/broker"
-	"github.com/micro/go-micro/v3/broker/http"
+	"github.com/unistack-org/micro/v3/codec"
-	"github.com/micro/go-micro/v3/codec"
+	"github.com/unistack-org/micro/v3/logger"
-	"github.com/micro/go-micro/v3/network/transport"
+	"github.com/unistack-org/micro/v3/registry"
-	thttp "github.com/micro/go-micro/v3/network/transport/http"
+	"github.com/unistack-org/micro/v3/router"
-	"github.com/micro/go-micro/v3/registry"
+	"github.com/unistack-org/micro/v3/selector"
-	"github.com/micro/go-micro/v3/router"
+	"github.com/unistack-org/micro/v3/selector/random"
-	regRouter "github.com/micro/go-micro/v3/router/registry"
+	"github.com/unistack-org/micro/v3/transport"
-	"github.com/micro/go-micro/v3/selector"
-	"github.com/micro/go-micro/v3/selector/roundrobin"
 )
 
 type Options struct {
@@ -28,7 +26,7 @@ type Options struct {
 	Router    router.Router
 	Selector  selector.Selector
 	Transport transport.Transport
-
+	Logger    logger.Logger
 	// Lookup used for looking up routes
 	Lookup LookupFunc
 
@@ -36,6 +34,9 @@ type Options struct {
 	PoolSize int
 	PoolTTL  time.Duration
 
+	// Response cache
+	Cache *Cache
+
 	// Middleware for client
 	Wrappers []Wrapper
 
@@ -52,6 +53,8 @@ type CallOptions struct {
 	Address []string
 	// Backoff func
 	Backoff BackoffFunc
+	// Duration to cache the response for
+	CacheExpiry time.Duration
 	// Transport Dial Timeout
 	DialTimeout time.Duration
 	// Number of Call attempts
@@ -104,6 +107,7 @@ type RequestOptions struct {
 
 func NewOptions(options ...Option) Options {
 	opts := Options{
+		Cache:       NewCache(),
 		Context:     context.Background(),
 		ContentType: "application/protobuf",
 		Codecs:      make(map[string]codec.NewCodec),
@@ -114,13 +118,10 @@ func NewOptions(options ...Option) Options {
 			RequestTimeout: DefaultRequestTimeout,
 			DialTimeout:    transport.DefaultDialTimeout,
 		},
-		Lookup:    LookupRoute,
+		Lookup:   LookupRoute,
-		PoolSize:  DefaultPoolSize,
+		PoolSize: DefaultPoolSize,
-		PoolTTL:   DefaultPoolTTL,
+		PoolTTL:  DefaultPoolTTL,
-		Broker:    http.NewBroker(),
+		Selector: random.NewSelector(),
-		Router:    regRouter.NewRouter(),
-		Selector:  roundrobin.NewSelector(),
-		Transport: thttp.NewTransport(),
 	}
 
 	for _, o := range options {
@@ -137,6 +138,12 @@ func Broker(b broker.Broker) Option {
 	}
 }
 
+func Logger(l logger.Logger) Option {
+	return func(o *Options) {
+		o.Logger = l
+	}
+}
+
 // Codec to be used to encode/decode requests for a given content type
 func Codec(contentType string, c codec.NewCodec) Option {
 	return func(o *Options) {
@@ -182,7 +189,9 @@ func Transport(t transport.Transport) Option {
 // Registry sets the routers registry
 func Registry(r registry.Registry) Option {
 	return func(o *Options) {
-		o.Router.Init(router.Registry(r))
+		if o.Router != nil {
+			o.Router.Init(router.Registry(r))
+		}
 	}
 }
 
@@ -351,6 +360,14 @@ func WithAuthToken() CallOption {
 	}
 }
 
+// WithCache is a CallOption which sets the duration the response
+// shoull be cached for
+func WithCache(c time.Duration) CallOption {
+	return func(o *CallOptions) {
+		o.CacheExpiry = c
+	}
+}
+
 // WithNetwork is a CallOption which sets the network attribute
 func WithNetwork(n string) CallOption {
 	return func(o *CallOptions) {

client/retry.go

@@ -3,10 +3,10 @@ package client
 import (
 	"context"
 
-	"github.com/micro/go-micro/v3/errors"
+	"github.com/unistack-org/micro/v3/errors"
 )
 
-// note that returning either false or a non-nil error will result in the call not being retried
+// RetryFunc that returning either false or a non-nil error will result in the call not being retried
 type RetryFunc func(ctx context.Context, req Request, retryCount int, err error) (bool, error)
 
 // RetryAlways always retry on error

client/test_request.go

@@ -1,22 +1,21 @@
-package mucp
+package client
 
 import (
-	"github.com/micro/go-micro/v3/client"
+	"github.com/unistack-org/micro/v3/codec"
-	"github.com/micro/go-micro/v3/codec"
 )
 
-type rpcRequest struct {
+type testRequest struct {
 	service     string
 	method      string
 	endpoint    string
 	contentType string
 	codec       codec.Codec
 	body        interface{}
-	opts        client.RequestOptions
+	opts        RequestOptions
 }
 
-func newRequest(service, endpoint string, request interface{}, contentType string, reqOpts ...client.RequestOption) client.Request {
+func newRequest(service, endpoint string, request interface{}, contentType string, reqOpts ...RequestOption) Request {
-	var opts client.RequestOptions
+	var opts RequestOptions
 
 	for _, o := range reqOpts {
 		o(&opts)
@@ -27,7 +26,7 @@ func newRequest(service, endpoint string, request interface{}, contentType strin
 		contentType = opts.ContentType
 	}
 
-	return &rpcRequest{
+	return &testRequest{
 		service:     service,
 		method:      endpoint,
 		endpoint:    endpoint,
@@ -37,30 +36,30 @@ func newRequest(service, endpoint string, request interface{}, contentType strin
 	}
 }
 
-func (r *rpcRequest) ContentType() string {
+func (r *testRequest) ContentType() string {
 	return r.contentType
 }
 
-func (r *rpcRequest) Service() string {
+func (r *testRequest) Service() string {
 	return r.service
 }
 
-func (r *rpcRequest) Method() string {
+func (r *testRequest) Method() string {
 	return r.method
 }
 
-func (r *rpcRequest) Endpoint() string {
+func (r *testRequest) Endpoint() string {
 	return r.endpoint
 }
 
-func (r *rpcRequest) Body() interface{} {
+func (r *testRequest) Body() interface{} {
 	return r.body
 }
 
-func (r *rpcRequest) Codec() codec.Writer {
+func (r *testRequest) Codec() codec.Writer {
 	return r.codec
 }
 
-func (r *rpcRequest) Stream() bool {
+func (r *testRequest) Stream() bool {
 	return r.opts.Stream
 }

cmd/protoc-gen-micro/.gitignore

@@ -0,0 +1,33 @@
+# Compiled Object files, Static and Dynamic libs (Shared Objects)
+*.o
+*.a
+*.so
+
+# Folders
+_obj
+_test
+_build
+
+# Architecture specific extensions/prefixes
+*.[568vq]
+[568vq].out
+
+*.cgo1.go
+*.cgo2.c
+_cgo_defun.c
+_cgo_gotypes.go
+_cgo_export.*
+
+_testmain.go
+
+*.exe
+*.test
+*.prof
+
+# ignore go build and test outputs
+coverage.txt
+coverage.out
+
+# ignore locally built binaries
+protoc-gen-micro
+dist

cmd/protoc-gen-micro/README.md

@@ -0,0 +1,138 @@
+# protoc-gen-micro
+
+This is protobuf code generation for micro. We use protoc-gen-micro to reduce boilerplate code.
+
+## Install
+
+```
+go get github.com/micro/micro/v3/cmd/protoc-gen-micro@master
+```
+
+Also required: 
+
+- [protoc](https://github.com/google/protobuf)
+- [protoc-gen-go](https://github.com/golang/protobuf)
+
+## Usage
+
+Define your service as `greeter.proto`
+
+```
+syntax = "proto3";
+
+service Greeter {
+	rpc Hello(Request) returns (Response) {}
+}
+
+message Request {
+	string name = 1;
+}
+
+message Response {
+	string msg = 1;
+}
+```
+
+Generate the code
+
+```
+protoc --proto_path=$GOPATH/src:. --micro_out=. --go_out=. greeter.proto
+```
+
+Your output result should be:
+
+```
+./
+    greeter.proto	# original protobuf file
+    greeter.pb.go	# auto-generated by protoc-gen-go
+    greeter.micro.go	# auto-generated by protoc-gen-micro
+```
+
+The micro generated code includes clients and handlers which reduce boiler plate code
+
+### Server
+
+Register the handler with your micro server
+
+```go
+type Greeter struct{}
+
+func (g *Greeter) Hello(ctx context.Context, req *proto.Request, rsp *proto.Response) error {
+	rsp.Msg = "Hello " + req.Name
+	return nil
+}
+
+proto.RegisterGreeterHandler(service.Server(), &Greeter{})
+```
+
+### Client
+
+Create a service client with your micro client
+
+```go
+client := proto.NewGreeterService("greeter", service.Client())
+```
+
+### Errors
+
+If you see an error about `protoc-gen-micro` not being found or executable, it's likely your environment may not be configured correctly. If you've already installed `protoc`, `protoc-gen-go`, and `protoc-gen-micro` ensure you've included `$GOPATH/bin` in your `PATH`.
+
+Alternative specify the Go plugin paths as arguments to the `protoc` command
+
+```
+protoc --plugin=protoc-gen-go=$GOPATH/bin/protoc-gen-go --plugin=protoc-gen-micro=$GOPATH/bin/protoc-gen-micro --proto_path=$GOPATH/src:. --micro_out=. --go_out=. greeter.proto
+```
+
+### Endpoint
+
+Add a micro API endpoint which routes directly to an RPC method
+
+Usage:
+
+1. Clone `github.com/googleapis/googleapis` to use this feature as it requires http annotations.
+2. The protoc command must include `-I$GOPATH/src/github.com/googleapis/googleapis` for the annotations import.
+
+```diff
+syntax = "proto3";
+
+import "google/api/annotations.proto";
+
+service Greeter {
+	rpc Hello(Request) returns (Response) {
+		option (google.api.http) = { post: "/hello"; body: "*"; };
+	}
+}
+
+message Request {
+	string name = 1;
+}
+
+message Response {
+	string msg = 1;
+}
+```
+
+The proto generates a `RegisterGreeterHandler` function with a [api.Endpoint](https://godoc.org/github.com/micro/go-micro/api#Endpoint). 
+
+```diff
+func RegisterGreeterHandler(s server.Server, hdlr GreeterHandler, opts ...server.HandlerOption) error {
+	type greeter interface {
+		Hello(ctx context.Context, in *Request, out *Response) error
+	}
+	type Greeter struct {
+		greeter
+	}
+	h := &greeterHandler{hdlr}
+	opts = append(opts, api.WithEndpoint(&api.Endpoint{
+		Name:    "Greeter.Hello",
+		Path:    []string{"/hello"},
+		Method:  []string{"POST"},
+		Handler: "rpc",
+	}))
+	return s.Handle(s.NewHandler(&Greeter{h}, opts...))
+}
+```
+
+## LICENSE
+
+protoc-gen-micro is a liberal reuse of protoc-gen-go hence we maintain the original license