.gitea/ISSUE_TEMPLATE/bug_report.md

@@ -1,18 +0,0 @@
----
-name: Bug report
-about: For reporting bugs in micro
-title: "[BUG]"
-labels: ''
-assignees: ''
-
----
-
-**Describe the bug**
-
-1. What are you trying to do?
-2. What did you expect to happen?
-3. What happens instead?
-
-**How to reproduce the bug:**
-
-If possible, please include a minimal code snippet here.

.gitea/ISSUE_TEMPLATE/feature-request---enhancement.md

@@ -1,17 +0,0 @@
----
-name: Feature request / Enhancement
-about: If you have a need not served by micro
-title: "[FEATURE]"
-labels: ''
-assignees: ''
-
----
-
-**Is your feature request related to a problem? Please describe.**
-A clear and concise description of what the problem is. Ex. I'm always frustrated when [...]
-
-**Describe the solution you'd like**
-A clear and concise description of what you want to happen.
-
-**Additional context**
-Add any other context or screenshots about the feature request here.

.gitea/ISSUE_TEMPLATE/question.md

@@ -1,8 +0,0 @@
----
-name: Question
-about: Ask a question about micro
-title: ''
-labels: ''
-assignees: ''
-
----

.gitea/autoapprove.yml

@@ -1,28 +0,0 @@
-name: "autoapprove"
-
-on:
-  pull_request_target:
-    types: [assigned, opened, synchronize, reopened]
-  workflow_run:
-    workflows: ["prbuild"]
-    types:
-      - completed
-
-permissions:
-  pull-requests: write
-  contents: write
-
-jobs:
-  autoapprove:
-    runs-on: ubuntu-latest
-    steps:
-      - name: approve
-        run: [ "curl -o tea https://dl.gitea.com/tea/main/tea-main-linux-amd64",
-               "chmod +x ./tea",
-               "./tea login add --name unistack --token ${{ secrets.GITHUB_TOKEN }} --url https://git.unistack.org",
-               "./tea pr --repo ${{ github.event.repository.name }}"
-        ]
-        if: github.actor == 'vtolstov'
-        id: approve
-        with:
-          github-token: ${{ secrets.GITHUB_TOKEN }}

.gitea/pkgdashcli.yaml

@@ -1,3 +0,0 @@
-branches:
-  - master
-  - v3

.gitea/workflows/coverage.yml

@@ -1,30 +0,0 @@
-name: Go
-
-on:
-  push:
-    branches: [ master, v3 ]
-  pull_request:
-    branches: [ master, v3 ]
-  workflow_dispatch:
-
-jobs:
-  test:
-    runs-on: ubuntu-latest
-    steps:
-    - name: checkout
-      uses: actions/checkout@v4
-
-    - name: setup
-      uses: actions/setup-go@v4
-      with:
-        go-version: stable
-
-    - name: coverage
-      run: go test -v -coverprofile coverage.out ./...
-
-    - name: badge
-      uses: ncruces/go-coverage-report@main
-      with:
-        coverage-file: coverage.out
-        reuse-go: true
-        amend: true

.gitea/workflows/lint.yml

@@ -1,24 +0,0 @@
-name: lint
-on:
-  pull_request:
-    branches:
-    - master
-    - v3
-jobs:
-  lint:
-    name: lint
-    runs-on: ubuntu-latest
-    steps:
-    - name: setup-go
-      uses: https://gitea.com/actions/setup-go@v3
-      with:
-        go-version: 1.21
-    - name: checkout
-      uses: https://gitea.com/actions/checkout@v3
-    - name: deps
-      run: go get -v -d ./...
-    - name: lint
-      uses: https://github.com/golangci/golangci-lint-action@v3.4.0
-      continue-on-error: true
-      with:
-        version: v1.52

.gitea/workflows/pr.yml

@@ -1,23 +0,0 @@
-name: pr
-on:
-  pull_request:
-    branches:
-    - master
-    - v3
-jobs:
-  test:
-    name: test
-    runs-on: ubuntu-latest
-    steps:
-    - name: checkout
-      uses: https://gitea.com/actions/checkout@v3
-    - name: setup-go
-      uses: https://gitea.com/actions/setup-go@v3
-      with:
-        go-version: 1.21
-    - name: deps
-      run: go get -v -t -d ./...
-    - name: test
-      env:
-        INTEGRATION_TESTS: yes
-      run: go test -v -mod readonly -race -coverprofile=coverage.txt -covermode=atomic ./...

.github.old/PULL_REQUEST_TEMPLATE.md

@@ -1,9 +0,0 @@
-## Pull Request template
-Please, go through these steps before clicking submit on this PR.
-
-1. Give a descriptive title to your PR.
-2. Provide a description of your changes.
-3. Make sure you have some relevant tests.
-4. Put `closes #XXXX` in your comment to auto-close the issue that your PR fixes (if applicable).
-
-**PLEASE REMOVE THIS TEMPLATE BEFORE SUBMITTING**

.github.old/dependabot.yml

@@ -1,26 +0,0 @@
-# To get started with Dependabot version updates, you'll need to specify which
-# package ecosystems to update and where the package manifests are located.
-# Please see the documentation for all configuration options:
-# https://help.github.com/github/administering-a-repository/configuration-options-for-dependency-updates
-
-version: 2
-updates:
-
-  # Maintain dependencies for GitHub Actions
-  - package-ecosystem: "github-actions"
-    directory: "/"
-    schedule:
-      interval: "daily"
-    commit-message:
-      prefix: "chore"
-      include: "scope"
-
-  # Maintain dependencies for Golang
-  - package-ecosystem: "gomod"
-    directory: "/"
-    schedule:
-      interval: "daily"
-    commit-message:
-      prefix: "chore"
-      include: "scope"
-

.github.old/workflows/autoapprove.yml

@@ -1,24 +0,0 @@
-name: "autoapprove"
-
-on:
-  pull_request_target:
-    types: [assigned, opened, synchronize, reopened]
-  workflow_run:
-    workflows: ["prbuild"]
-    types:
-      - completed
-
-permissions:
-  pull-requests: write
-  contents: write
-
-jobs:
-  autoapprove:
-    runs-on: ubuntu-latest
-    steps:
-      - name: approve
-        uses: hmarr/auto-approve-action@v3
-        if: github.actor == 'vtolstov' || github.actor == 'dependabot[bot]'
-        id: approve
-        with:
-          github-token: ${{ secrets.GITHUB_TOKEN }}

.github.old/workflows/automerge.yml

@@ -1,21 +0,0 @@
-name: "automerge"
-
-on:
-  pull_request_target:
-    types: [assigned, opened, synchronize, reopened]
-
-permissions:
-  pull-requests: write
-  contents: write
-
-jobs:
-  automerge:
-    runs-on: ubuntu-latest
-    if: github.actor == 'vtolstov'
-    steps:
-      - name: merge
-        id: merge
-        run: gh pr merge --auto --merge "$PR_URL"
-        env:
-          PR_URL: ${{github.event.pull_request.html_url}}
-          GITHUB_TOKEN: ${{secrets.TOKEN}}

.github.old/workflows/codecov.yml

@@ -1,39 +0,0 @@
-name: "codecov"
-
-on:
-  workflow_run:
-    workflows: ["build"]
-    types:
-      - completed
-  push:
-    branches: [ v3 ]
-  pull_request:
-    branches: [ v3 ]
-  schedule:
-    - cron: '34 1 * * 0'
-
-jobs:
-  codecov:
-    name: codecov
-    runs-on: ubuntu-latest
-    permissions:
-      actions: read
-      contents: read
-      security-events: write
-
-    strategy:
-      fail-fast: false
-      matrix:
-        language: [ 'go' ]
-
-    steps:
-    - name: checkout
-      uses: actions/checkout@v3
-    - name: setup
-      uses: actions/setup-go@v3
-      with:
-        go-version: 1.17
-    - name: Run coverage
-      run: go test -v -race -coverprofile=coverage.out -covermode=atomic ./...
-    - name: codecov
-      uses: codecov/codecov-action@v3.1.1

.github.old/workflows/codeql-analysis.yml

@@ -1,78 +0,0 @@
-# For most projects, this workflow file will not need changing; you simply need
-# to commit it to your repository.
-#
-# You may wish to alter this file to override the set of languages analyzed,
-# or to provide custom queries or build logic.
-#
-# ******** NOTE ********
-# We have attempted to detect the languages in your repository. Please check
-# the `language` matrix defined below to confirm you have the correct set of
-# supported CodeQL languages.
-#
-name: "codeql"
-
-on:
-  workflow_run:
-    workflows: ["prbuild"]
-    types:
-      - completed
-  push:
-    branches: [ master, v3 ]
-  pull_request:
-    # The branches below must be a subset of the branches above
-    branches: [ master, v3 ]
-  schedule:
-    - cron: '34 1 * * 0'
-
-jobs:
-  analyze:
-    name: analyze
-    runs-on: ubuntu-latest
-    permissions:
-      actions: read
-      contents: read
-      security-events: write
-
-    strategy:
-      fail-fast: false
-      matrix:
-        language: [ 'go' ]
-        # CodeQL supports [ 'cpp', 'csharp', 'go', 'java', 'javascript', 'python' ]
-        # Learn more:
-        # https://docs.github.com/en/free-pro-team@latest/github/finding-security-vulnerabilities-and-errors-in-your-code/configuring-code-scanning#changing-the-languages-that-are-analyzed
-
-    steps:
-    - name: checkout
-      uses: actions/checkout@v3
-    - name: setup
-      uses: actions/setup-go@v3
-      with:
-        go-version: 1.17
-    # Initializes the CodeQL tools for scanning.
-    - name: init
-      uses: github/codeql-action/init@v2
-      with:
-        languages: ${{ matrix.language }}
-        # If you wish to specify custom queries, you can do so here or in a config file.
-        # By default, queries listed here will override any specified in a config file.
-        # Prefix the list here with "+" to use these queries and those in the config file.
-        # queries: ./path/to/local/query, your-org/your-repo/queries@main
-
-    # Autobuild attempts to build any compiled languages  (C/C++, C#, or Java).
-    # If this step fails, then you should remove it and run the build manually (see below)
-    - name: autobuild
-      uses: github/codeql-action/autobuild@v2
-
-    # ℹ️ Command-line programs to run using the OS shell.
-    # 📚 https://git.io/JvXDl
-
-    # ✏️ If the Autobuild fails above, remove it and uncomment the following three lines
-    #    and modify them (or add more) to build your code if your project
-    #    uses a compiled language
-
-    #- run: |
-    #   make bootstrap
-    #   make release
-
-    - name: analyze
-      uses: github/codeql-action/analyze@v2

.github.old/workflows/dependabot-automerge.yml

@@ -1,27 +0,0 @@
-name: "dependabot-automerge"
-
-on:
-  pull_request_target:
-    types: [assigned, opened, synchronize, reopened]
-
-permissions:
-  pull-requests: write
-  contents: write
-
-jobs:
-  automerge:
-    runs-on: ubuntu-latest
-    if: github.actor == 'dependabot[bot]'
-    steps:
-      - name: metadata
-        id: metadata
-        uses: dependabot/fetch-metadata@v1.3.6
-        with:
-          github-token: "${{ secrets.TOKEN }}"
-      - name: merge
-        id: merge
-        if: ${{contains(steps.metadata.outputs.dependency-names, 'go.unistack.org')}}
-        run: gh pr merge --auto --merge "$PR_URL"
-        env:
-          PR_URL: ${{github.event.pull_request.html_url}}
-          GITHUB_TOKEN: ${{secrets.TOKEN}}

.github.old/workflows/pr.yml

@@ -1,40 +0,0 @@
-name: prbuild
-on:
-  pull_request:
-    branches:
-    - master
-    - v3
-jobs:
-  test:
-    name: test
-    runs-on: ubuntu-latest
-    steps:
-    - name: setup
-      uses: actions/setup-go@v3
-      with:
-        go-version: 1.17
-    - name: checkout
-      uses: actions/checkout@v3
-    - name: cache
-      uses: actions/cache@v3
-      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@v3
-      - name: lint
-        uses: golangci/golangci-lint-action@v3.4.0
-        continue-on-error: true
-        with:
-          version: v1.30

.github/generate.sh

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

.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

@@ -1,40 +1,55 @@
 name: build
 on:
- push:
+  push:
     branches:
     - master
-    - v3
 jobs:
   test:
     name: test
     runs-on: ubuntu-latest
     steps:
     - name: setup
-      uses: actions/setup-go@v3
+      uses: actions/setup-go@v1
       with:
-        go-version: 1.17
+        go-version: 1.15
-    - name: checkout
-      uses: actions/checkout@v3
     - name: cache
-      uses: actions/cache@v3
+      uses: actions/cache@v2
       with:
         path: ~/go/pkg/mod
         key: ${{ runner.os }}-go-${{ hashFiles('**/go.sum') }}
         restore-keys: ${{ runner.os }}-go-
-    - name: deps
+    - name: sdk checkout
+      uses: actions/checkout@v2
+    - name: sdk deps
       run: go get -v -t -d ./...
-    - name: test
+    - name: sdk test
       env:
         INTEGRATION_TESTS: yes
       run: go test -mod readonly -v ./...
+    - name: tests checkout
+      uses: actions/checkout@v2
+      with:
+        repository: unistack-org/micro-tests
+        ref: refs/heads/master
+        path: micro-tests
+        fetch-depth: 1
+    - name: tests deps
+      run: |
+        cd micro-tests
+        go mod edit -replace="github.com/unistack-org/micro/v3=../"
+        go get -v -t -d ./...
+    - name: tests test
+      env:
+        INTEGRATION_TESTS: yes
+      run: cd micro-tests && go test -mod readonly -v ./...
   lint:
     name: lint
     runs-on: ubuntu-latest
     steps:
       - name: checkout
-        uses: actions/checkout@v3
+        uses: actions/checkout@v2
       - name: lint
-        uses: golangci/golangci-lint-action@v3.4.0
+        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.

.github/workflows/pr.yml

@@ -0,0 +1,62 @@
+name: prbuild
+on:
+  pull_request:
+    branches:
+    - master
+jobs:
+  test:
+    name: test
+    runs-on: ubuntu-latest
+    steps:
+    - name: setup
+      uses: actions/setup-go@v1
+      with:
+        go-version: 1.15
+    - name: cache
+      uses: actions/cache@v2
+      with:
+        path: ~/go/pkg/mod
+        key: ${{ runner.os }}-go-${{ hashFiles('**/go.sum') }}
+        restore-keys: ${{ runner.os }}-go-
+    - name: sdk checkout
+      uses: actions/checkout@v2
+    - name: sdk deps
+      run: go get -v -t -d ./...
+    - name: sdk test
+      env:
+        INTEGRATION_TESTS: yes
+      run: go test -mod readonly -v ./...
+    - name: tests checkout
+      uses: actions/checkout@v2
+      with:
+        repository: unistack-org/micro-tests
+        ref: refs/heads/master
+        path: micro-tests
+        fetch-depth: 1
+    - name: tests deps
+      run: |
+        cd micro-tests
+        go mod edit -replace="github.com/unistack-org/micro/v3=../"
+        go get -v -t -d ./...
+    - name: tests test
+      env:
+        INTEGRATION_TESTS: yes
+      run: cd micro-tests && 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

.gitignore

@@ -1,8 +1,6 @@
 # Develop tools
 /.vscode/
 /.idea/
-.idea
-.vscode
 
 # Binaries for programs and plugins
 *.exe
@@ -15,7 +13,6 @@
 _obj
 _test
 _build
-.DS_Store
 
 # Architecture specific extensions/prefixes
 *.[568vq]

.golangci.yml

@@ -1,42 +1,40 @@
 run:
-  concurrency: 4
+  deadline: 5m
-  issues-exit-code: 1
+  modules-download-mode: readonly
-  tests: true
+  skip-dirs:
-
+    - util/mdns.new
-linters-settings:
+  skip-files:
-  govet:
+    - ".*\\.pb\\.go$"
-    check-shadowing: true
+    - ".*\\.pb\\.micro\\.go$"
-    enable:
-      - fieldalignment
-
 linters:
-  enable:
-    - govet
-    - errcheck
-    - govet
-    - ineffassign
-    - staticcheck
-    - typecheck
-    - unused
-    - spancheck
-    - bodyclose
-    - gci
-    - goconst
-    - gocritic
-    - gosimple
-    - gofmt
-    - gofumpt
-    - goimports
-    - revive
-    - gosec
-    - makezero
-    - misspell
-    - nakedret
-    - nestif
-    - nilerr
-    - noctx
-    - prealloc
-    - unconvert
-    - unparam
-    - unused
   disable-all: false
+  enable-all: false
+  enable:
+    - megacheck
+    - staticcheck
+    - deadcode
+    - varcheck
+    - gosimple
+    - unused
+    - prealloc
+    - scopelint
+    - gocritic
+    - goimports
+    - unconvert
+    - govet
+    - nakedret
+    - structcheck
+    - gosec
+  disable:
+    - maligned
+    - 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

README.md

@@ -1,4 +1,4 @@
-# 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/go.unistack.org/micro/v4?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/go.unistack.org/micro/v4)](https://goreportcard.com/report/go.unistack.org/micro/v4) [![Coverage](https://codecov.io/gh/unistack-org/micro/branch/v4/graph/badge.svg?token=OZPO2LP7VS)](https://codecov.io/gh/unistack-org/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) [![Slack](https://img.shields.io/static/v1?label=micro&message=slack&color=blueviolet)](https://unistack-org.slack.com/messages/default)
 
 Micro is a standard library for microservices.
 

SECURITY.md

@@ -1,15 +0,0 @@
-# Security Policy
-
-## Supported Versions
-
-Use this section to tell people about which versions of your project are
-currently being supported with security updates.
-
-| Version | Supported          |
-| ------- | ------------------ |
-| 3.7.x   | :white_check_mark: |
-| < 3.7.0 | :x:                |
-
-## Reporting a Vulnerability
-
-If you find any issue, please create github issue in this repo

api/api.go

@@ -0,0 +1,187 @@
+package api
+
+import (
+	"errors"
+	"regexp"
+	"strings"
+
+	"github.com/unistack-org/micro/v3/registry"
+	"github.com/unistack-org/micro/v3/server"
+)
+
+type Api interface {
+	// Initialise options
+	Init(...Option) error
+	// Get the options
+	Options() Options
+	// Register a http handler
+	Register(*Endpoint) error
+	// Register a route
+	Deregister(*Endpoint) error
+	// Implementation of api
+	String() string
+}
+
+type Options struct{}
+
+type Option func(*Options) error
+
+// Endpoint is a mapping between an RPC method and HTTP endpoint
+type Endpoint struct {
+	// RPC Method e.g. Greeter.Hello
+	Name string
+	// Description e.g what's this endpoint for
+	Description string
+	// API Handler e.g rpc, proxy
+	Handler string
+	// HTTP Host e.g example.com
+	Host []string
+	// HTTP Methods e.g GET, POST
+	Method []string
+	// HTTP Path e.g /greeter. Expect POSIX regex
+	Path []string
+	// Body destination
+	// "*" or "" - top level message value
+	// "string" - inner message value
+	Body string
+	// Stream flag
+	Stream bool
+}
+
+// Service represents an API service
+type Service struct {
+	// Name of service
+	Name string
+	// The endpoint for this service
+	Endpoint *Endpoint
+	// Versions of this service
+	Services []*registry.Service
+}
+
+func strip(s string) string {
+	return strings.TrimSpace(s)
+}
+
+func slice(s string) []string {
+	var sl []string
+
+	for _, p := range strings.Split(s, ",") {
+		if str := strip(p); len(str) > 0 {
+			sl = append(sl, strip(p))
+		}
+	}
+
+	return sl
+}
+
+// Encode encodes an endpoint to endpoint metadata
+func Encode(e *Endpoint) map[string]string {
+	if e == nil {
+		return nil
+	}
+
+	// endpoint map
+	ep := make(map[string]string)
+
+	// set vals only if they exist
+	set := func(k, v string) {
+		if len(v) == 0 {
+			return
+		}
+		ep[k] = v
+	}
+
+	set("endpoint", e.Name)
+	set("description", e.Description)
+	set("handler", e.Handler)
+	set("method", strings.Join(e.Method, ","))
+	set("path", strings.Join(e.Path, ","))
+	set("host", strings.Join(e.Host, ","))
+
+	return ep
+}
+
+// Decode decodes endpoint metadata into an endpoint
+func Decode(e map[string]string) *Endpoint {
+	if e == nil {
+		return nil
+	}
+
+	return &Endpoint{
+		Name:        e["endpoint"],
+		Description: e["description"],
+		Method:      slice(e["method"]),
+		Path:        slice(e["path"]),
+		Host:        slice(e["host"]),
+		Handler:     e["handler"],
+	}
+}
+
+// Validate validates an endpoint to guarantee it won't blow up when being served
+func Validate(e *Endpoint) error {
+	if e == nil {
+		return errors.New("endpoint is nil")
+	}
+
+	if len(e.Name) == 0 {
+		return errors.New("name required")
+	}
+
+	for _, p := range e.Path {
+		ps := p[0]
+		pe := p[len(p)-1]
+
+		if ps == '^' && pe == '$' {
+			_, err := regexp.CompilePOSIX(p)
+			if err != nil {
+				return err
+			}
+		} else if ps == '^' && pe != '$' {
+			return errors.New("invalid path")
+		} else if ps != '^' && pe == '$' {
+			return errors.New("invalid path")
+		}
+	}
+
+	if len(e.Handler) == 0 {
+		return errors.New("invalid handler")
+	}
+
+	return nil
+}
+
+/*
+Design ideas
+
+// Gateway is an api gateway interface
+type Gateway interface {
+	// Register a http handler
+	Handle(pattern string, http.Handler)
+	// Register a route
+	RegisterRoute(r Route)
+	// Init initialises the command line.
+	// It also parses further options.
+	Init(...Option) error
+	// Run the gateway
+	Run() error
+}
+
+// NewGateway returns a new api gateway
+func NewGateway() Gateway {
+	return newGateway()
+}
+*/
+
+// WithEndpoint returns a server.HandlerOption with endpoint metadata set
+//
+// Usage:
+//
+// 	proto.RegisterHandler(service.Server(), new(Handler), api.WithEndpoint(
+//		&api.Endpoint{
+//			Name: "Greeter.Hello",
+//			Path: []string{"/greeter"},
+//		},
+//	))
+func WithEndpoint(e *Endpoint) server.HandlerOption {
+	return server.EndpointMetadata(e.Name, Encode(e))
+}

api/api_test.go

@@ -0,0 +1,152 @@
+package api
+
+import (
+	"strings"
+	"testing"
+)
+
+func TestEncoding(t *testing.T) {
+	testData := []*Endpoint{
+		nil,
+		{
+			Name:        "Foo.Bar",
+			Description: "A test endpoint",
+			Handler:     "meta",
+			Host:        []string{"foo.com"},
+			Method:      []string{"GET"},
+			Path:        []string{"/test"},
+		},
+	}
+
+	compare := func(expect, got []string) bool {
+		// no data to compare, return true
+		if len(expect) == 0 && len(got) == 0 {
+			return true
+		}
+		// no data expected but got some return false
+		if len(expect) == 0 && len(got) > 0 {
+			return false
+		}
+
+		// compare expected with what we got
+		for _, e := range expect {
+			var seen bool
+			for _, g := range got {
+				if e == g {
+					seen = true
+					break
+				}
+			}
+			if !seen {
+				return false
+			}
+		}
+
+		// we're done, return true
+		return true
+	}
+
+	for _, d := range testData {
+		// encode
+		e := Encode(d)
+		// decode
+		de := Decode(e)
+
+		// nil endpoint returns nil
+		if d == nil {
+			if e != nil {
+				t.Fatalf("expected nil got %v", e)
+			}
+			if de != nil {
+				t.Fatalf("expected nil got %v", de)
+			}
+
+			continue
+		}
+
+		// check encoded map
+		name := e["endpoint"]
+		desc := e["description"]
+		method := strings.Split(e["method"], ",")
+		path := strings.Split(e["path"], ",")
+		host := strings.Split(e["host"], ",")
+		handler := e["handler"]
+
+		if name != d.Name {
+			t.Fatalf("expected %v got %v", d.Name, name)
+		}
+		if desc != d.Description {
+			t.Fatalf("expected %v got %v", d.Description, desc)
+		}
+		if handler != d.Handler {
+			t.Fatalf("expected %v got %v", d.Handler, handler)
+		}
+		if ok := compare(d.Method, method); !ok {
+			t.Fatalf("expected %v got %v", d.Method, method)
+		}
+		if ok := compare(d.Path, path); !ok {
+			t.Fatalf("expected %v got %v", d.Path, path)
+		}
+		if ok := compare(d.Host, host); !ok {
+			t.Fatalf("expected %v got %v", d.Host, host)
+		}
+
+		if de.Name != d.Name {
+			t.Fatalf("expected %v got %v", d.Name, de.Name)
+		}
+		if de.Description != d.Description {
+			t.Fatalf("expected %v got %v", d.Description, de.Description)
+		}
+		if de.Handler != d.Handler {
+			t.Fatalf("expected %v got %v", d.Handler, de.Handler)
+		}
+		if ok := compare(d.Method, de.Method); !ok {
+			t.Fatalf("expected %v got %v", d.Method, de.Method)
+		}
+		if ok := compare(d.Path, de.Path); !ok {
+			t.Fatalf("expected %v got %v", d.Path, de.Path)
+		}
+		if ok := compare(d.Host, de.Host); !ok {
+			t.Fatalf("expected %v got %v", d.Host, de.Host)
+		}
+	}
+}
+
+func TestValidate(t *testing.T) {
+	epPcre := &Endpoint{
+		Name:        "Foo.Bar",
+		Description: "A test endpoint",
+		Handler:     "meta",
+		Host:        []string{"foo.com"},
+		Method:      []string{"GET"},
+		Path:        []string{"^/test/?$"},
+	}
+	if err := Validate(epPcre); err != nil {
+		t.Fatal(err)
+	}
+
+	epGpath := &Endpoint{
+		Name:        "Foo.Bar",
+		Description: "A test endpoint",
+		Handler:     "meta",
+		Host:        []string{"foo.com"},
+		Method:      []string{"GET"},
+		Path:        []string{"/test/{id}"},
+	}
+	if err := Validate(epGpath); err != nil {
+		t.Fatal(err)
+	}
+
+	epPcreInvalid := &Endpoint{
+		Name:        "Foo.Bar",
+		Description: "A test endpoint",
+		Handler:     "meta",
+		Host:        []string{"foo.com"},
+		Method:      []string{"GET"},
+		Path:        []string{"/test/?$"},
+	}
+	if err := Validate(epPcreInvalid); err == nil {
+		t.Fatalf("invalid pcre %v", epPcreInvalid.Path[0])
+	}
+
+}

api/handler/api/api.go

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

api/handler/api/util.go

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

api/handler/api/util_test.go

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

api/handler/event/event.go

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

api/handler/handler.go

@@ -0,0 +1,14 @@
+// Package handler provides http handlers
+package handler
+
+import (
+	"net/http"
+)
+
+// Handler represents a HTTP handler that manages a request
+type Handler interface {
+	// standard http handler
+	http.Handler
+	// name of handler
+	String() string
+}

api/handler/http/http.go

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

api/handler/http/http_test.go

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

api/handler/options.go

@@ -0,0 +1,65 @@
+package handler
+
+import (
+	"github.com/unistack-org/micro/v3/api/router"
+	"github.com/unistack-org/micro/v3/client"
+)
+
+var (
+	DefaultMaxRecvSize int64 = 1024 * 1024 * 100 // 10Mb
+)
+
+type Options struct {
+	MaxRecvSize int64
+	Namespace   string
+	Router      router.Router
+	Client      client.Client
+}
+
+type Option func(o *Options)
+
+// NewOptions fills in the blanks
+func NewOptions(opts ...Option) Options {
+	var options Options
+	for _, o := range opts {
+		o(&options)
+	}
+
+	// set namespace if blank
+	if len(options.Namespace) == 0 {
+		WithNamespace("go.micro.api")(&options)
+	}
+
+	if options.MaxRecvSize == 0 {
+		options.MaxRecvSize = DefaultMaxRecvSize
+	}
+
+	return options
+}
+
+// WithNamespace specifies the namespace for the handler
+func WithNamespace(s string) Option {
+	return func(o *Options) {
+		o.Namespace = s
+	}
+}
+
+// WithRouter specifies a router to be used by the handler
+func WithRouter(r router.Router) Option {
+	return func(o *Options) {
+		o.Router = r
+	}
+}
+
+func WithClient(c client.Client) Option {
+	return func(o *Options) {
+		o.Client = c
+	}
+}
+
+// WithMaxRecvSize specifies max body size
+func WithMaxRecvSize(size int64) Option {
+	return func(o *Options) {
+		o.MaxRecvSize = size
+	}
+}

api/handler/rpc/rpc.go

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

api/handler/rpc/rpc_test.go

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

api/handler/rpc/stream.go

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

api/handler/web/web.go

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

api/internal/proto/message.pb.go

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

api/proto/api.pb.go

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

api/proto/api.pb.micro.go

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

api/proto/api.proto

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

api/resolver/grpc/grpc.go

@@ -0,0 +1,47 @@
+// Package grpc resolves a grpc service like /greeter.Say/Hello to greeter service
+package grpc
+
+import (
+	"errors"
+	"net/http"
+	"strings"
+
+	"github.com/unistack-org/micro/v3/api/resolver"
+)
+
+// Resolver struct
+type Resolver struct {
+	opts resolver.Options
+}
+
+// Resolve func to resolve enndpoint
+func (r *Resolver) Resolve(req *http.Request, opts ...resolver.ResolveOption) (*resolver.Endpoint, error) {
+	// parse options
+	options := resolver.NewResolveOptions(opts...)
+
+	// /foo.Bar/Service
+	if req.URL.Path == "/" {
+		return nil, errors.New("unknown name")
+	}
+	// [foo.Bar, Service]
+	parts := strings.Split(req.URL.Path[1:], "/")
+	// [foo, Bar]
+	name := strings.Split(parts[0], ".")
+	// foo
+	return &resolver.Endpoint{
+		Name:   strings.Join(name[:len(name)-1], "."),
+		Host:   req.Host,
+		Method: req.Method,
+		Path:   req.URL.Path,
+		Domain: options.Domain,
+	}, nil
+}
+
+func (r *Resolver) String() string {
+	return "grpc"
+}
+
+// NewResolver is used to create new Resolver
+func NewResolver(opts ...resolver.Option) resolver.Resolver {
+	return &Resolver{opts: resolver.NewOptions(opts...)}
+}

api/resolver/host/host.go

@@ -0,0 +1,33 @@
+// Package host resolves using http host
+package host
+
+import (
+	"net/http"
+
+	"github.com/unistack-org/micro/v3/api/resolver"
+)
+
+type Resolver struct {
+	opts resolver.Options
+}
+
+func (r *Resolver) Resolve(req *http.Request, opts ...resolver.ResolveOption) (*resolver.Endpoint, error) {
+	// parse options
+	options := resolver.NewResolveOptions(opts...)
+
+	return &resolver.Endpoint{
+		Name:   req.Host,
+		Host:   req.Host,
+		Method: req.Method,
+		Path:   req.URL.Path,
+		Domain: options.Domain,
+	}, nil
+}
+
+func (r *Resolver) String() string {
+	return "host"
+}
+
+func NewResolver(opts ...resolver.Option) resolver.Resolver {
+	return &Resolver{opts: resolver.NewOptions(opts...)}
+}

api/resolver/options.go

@@ -0,0 +1,62 @@
+package resolver
+
+import (
+	"github.com/unistack-org/micro/v3/registry"
+)
+
+// Options struct
+type Options struct {
+	Handler       string
+	ServicePrefix string
+}
+
+// Option func
+type Option func(o *Options)
+
+// WithHandler sets the handler being used
+func WithHandler(h string) Option {
+	return func(o *Options) {
+		o.Handler = h
+	}
+}
+
+// WithServicePrefix sets the ServicePrefix option
+func WithServicePrefix(p string) Option {
+	return func(o *Options) {
+		o.ServicePrefix = p
+	}
+}
+
+// NewOptions returns new initialised options
+func NewOptions(opts ...Option) Options {
+	options := Options{}
+	for _, o := range opts {
+		o(&options)
+	}
+	return options
+}
+
+// ResolveOptions are used when resolving a request
+type ResolveOptions struct {
+	Domain string
+}
+
+// ResolveOption sets an option
+type ResolveOption func(*ResolveOptions)
+
+// Domain sets the resolve Domain option
+func Domain(n string) ResolveOption {
+	return func(o *ResolveOptions) {
+		o.Domain = n
+	}
+}
+
+// NewResolveOptions returns new initialised resolve options
+func NewResolveOptions(opts ...ResolveOption) ResolveOptions {
+	options := ResolveOptions{Domain: registry.DefaultDomain}
+	for _, o := range opts {
+		o(&options)
+	}
+
+	return options
+}

api/resolver/path/path.go

@@ -0,0 +1,40 @@
+// Package path resolves using http path
+package path
+
+import (
+	"net/http"
+	"strings"
+
+	"github.com/unistack-org/micro/v3/api/resolver"
+)
+
+type Resolver struct {
+	opts resolver.Options
+}
+
+func (r *Resolver) Resolve(req *http.Request, opts ...resolver.ResolveOption) (*resolver.Endpoint, error) {
+	// parse options
+	options := resolver.NewResolveOptions(opts...)
+
+	if req.URL.Path == "/" {
+		return nil, resolver.ErrNotFound
+	}
+
+	parts := strings.Split(req.URL.Path[1:], "/")
+
+	return &resolver.Endpoint{
+		Name:   r.opts.ServicePrefix + "." + parts[0],
+		Host:   req.Host,
+		Method: req.Method,
+		Path:   req.URL.Path,
+		Domain: options.Domain,
+	}, nil
+}
+
+func (r *Resolver) String() string {
+	return "path"
+}
+
+func NewResolver(opts ...resolver.Option) resolver.Resolver {
+	return &Resolver{opts: resolver.NewOptions(opts...)}
+}

api/resolver/resolver.go

@@ -0,0 +1,34 @@
+// Package resolver resolves a http request to an endpoint
+package resolver
+
+import (
+	"errors"
+	"net/http"
+)
+
+var (
+	// ErrNotFound returned when endpoint is not found
+	ErrNotFound = errors.New("not found")
+	// ErrInvalidPath returned on invalid path
+	ErrInvalidPath = errors.New("invalid path")
+)
+
+// Resolver resolves requests to endpoints
+type Resolver interface {
+	Resolve(r *http.Request, opts ...ResolveOption) (*Endpoint, error)
+	String() string
+}
+
+// Endpoint is the endpoint for a http request
+type Endpoint struct {
+	// Endpoint name e.g greeter
+	Name string
+	// HTTP Host e.g example.com
+	Host string
+	// HTTP Methods e.g GET, POST
+	Method string
+	// HTTP Path e.g /greeter.
+	Path string
+	// Domain endpoint exists within
+	Domain string
+}

api/resolver/subdomain/subdomain.go

@@ -0,0 +1,87 @@
+// Package subdomain is a resolver which uses the subdomain to determine the domain to route to. It
+// offloads the endpoint resolution to a child resolver which is provided in New.
+package subdomain
+
+import (
+	"net"
+	"net/http"
+	"strings"
+
+	"github.com/unistack-org/micro/v3/api/resolver"
+	"github.com/unistack-org/micro/v3/logger"
+	"golang.org/x/net/publicsuffix"
+)
+
+func NewResolver(parent resolver.Resolver, opts ...resolver.Option) resolver.Resolver {
+	options := resolver.NewOptions(opts...)
+	return &Resolver{options, parent}
+}
+
+type Resolver struct {
+	opts resolver.Options
+	resolver.Resolver
+}
+
+func (r *Resolver) Resolve(req *http.Request, opts ...resolver.ResolveOption) (*resolver.Endpoint, error) {
+	if dom := r.Domain(req); len(dom) > 0 {
+		opts = append(opts, resolver.Domain(dom))
+	}
+
+	return r.Resolver.Resolve(req, opts...)
+}
+
+func (r *Resolver) Domain(req *http.Request) string {
+	// determine the host, e.g. foobar.m3o.app
+	host := req.URL.Hostname()
+	if len(host) == 0 {
+		if h, _, err := net.SplitHostPort(req.Host); err == nil {
+			host = h // host does contain a port
+		} else if strings.Contains(err.Error(), "missing port in address") {
+			host = req.Host // host does not contain a port
+		}
+	}
+
+	// check for an ip address
+	if net.ParseIP(host) != nil {
+		return ""
+	}
+
+	// check for dev environment
+	if host == "localhost" || host == "127.0.0.1" {
+		return ""
+	}
+
+	// extract the top level domain plus one (e.g. 'myapp.com')
+	domain, err := publicsuffix.EffectiveTLDPlusOne(host)
+	if err != nil {
+		if logger.V(logger.DebugLevel) {
+			logger.Debug("Unable to extract domain from %v", host)
+		}
+		return ""
+	}
+
+	// there was no subdomain
+	if host == domain {
+		return ""
+	}
+
+	// remove the domain from the host, leaving the subdomain, e.g. "staging.foo.myapp.com" => "staging.foo"
+	subdomain := strings.TrimSuffix(host, "."+domain)
+
+	// ignore the API subdomain
+	if subdomain == "api" {
+		return ""
+	}
+
+	// return the reversed subdomain as the namespace, e.g. "staging.foo" => "foo-staging"
+	comps := strings.Split(subdomain, ".")
+	for i := len(comps)/2 - 1; i >= 0; i-- {
+		opp := len(comps) - 1 - i
+		comps[i], comps[opp] = comps[opp], comps[i]
+	}
+	return strings.Join(comps, "-")
+}
+
+func (r *Resolver) String() string {
+	return "subdomain"
+}

api/resolver/subdomain/subdomain_test.go

@@ -0,0 +1,71 @@
+package subdomain
+
+import (
+	"net/http"
+	"net/url"
+	"testing"
+
+	"github.com/unistack-org/micro/v3/api/resolver/vpath"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestResolve(t *testing.T) {
+	tt := []struct {
+		Name   string
+		Host   string
+		Result string
+	}{
+		{
+			Name:   "Top level domain",
+			Host:   "micro.mu",
+			Result: "micro",
+		},
+		{
+			Name:   "Effective top level domain",
+			Host:   "micro.com.au",
+			Result: "micro",
+		},
+		{
+			Name:   "Subdomain dev",
+			Host:   "dev.micro.mu",
+			Result: "dev",
+		},
+		{
+			Name:   "Subdomain foo",
+			Host:   "foo.micro.mu",
+			Result: "foo",
+		},
+		{
+			Name:   "Multi-level subdomain",
+			Host:   "staging.myapp.m3o.app",
+			Result: "myapp-staging",
+		},
+		{
+			Name:   "Dev host",
+			Host:   "127.0.0.1",
+			Result: "micro",
+		},
+		{
+			Name:   "Localhost",
+			Host:   "localhost",
+			Result: "micro",
+		},
+		{
+			Name:   "IP host",
+			Host:   "81.151.101.146",
+			Result: "micro",
+		},
+	}
+
+	for _, tc := range tt {
+		t.Run(tc.Name, func(t *testing.T) {
+			r := NewResolver(vpath.NewResolver())
+			result, err := r.Resolve(&http.Request{URL: &url.URL{Host: tc.Host, Path: "foo/bar"}})
+			assert.Nil(t, err, "Expecter err to be nil")
+			if result != nil {
+				assert.Equal(t, tc.Result, result.Domain, "Expected %v but got %v", tc.Result, result.Domain)
+			}
+		})
+	}
+}

api/resolver/vpath/vpath.go

@@ -0,0 +1,75 @@
+// Package vpath resolves using http path and recognised versioned urls
+package vpath
+
+import (
+	"errors"
+	"net/http"
+	"regexp"
+	"strings"
+
+	"github.com/unistack-org/micro/v3/api/resolver"
+)
+
+func NewResolver(opts ...resolver.Option) resolver.Resolver {
+	return &Resolver{opts: resolver.NewOptions(opts...)}
+}
+
+type Resolver struct {
+	opts resolver.Options
+}
+
+var (
+	re = regexp.MustCompile("^v[0-9]+$")
+)
+
+func (r *Resolver) Resolve(req *http.Request, opts ...resolver.ResolveOption) (*resolver.Endpoint, error) {
+	if req.URL.Path == "/" {
+		return nil, errors.New("unknown name")
+	}
+
+	options := resolver.NewResolveOptions(opts...)
+
+	parts := strings.Split(req.URL.Path[1:], "/")
+	if len(parts) == 1 {
+		return &resolver.Endpoint{
+			Name:   r.withPrefix(parts...),
+			Host:   req.Host,
+			Method: req.Method,
+			Path:   req.URL.Path,
+			Domain: options.Domain,
+		}, nil
+	}
+
+	// /v1/foo
+	if re.MatchString(parts[0]) {
+		return &resolver.Endpoint{
+			Name:   r.withPrefix(parts[0:2]...),
+			Host:   req.Host,
+			Method: req.Method,
+			Path:   req.URL.Path,
+			Domain: options.Domain,
+		}, nil
+	}
+
+	return &resolver.Endpoint{
+		Name:   r.withPrefix(parts[0]),
+		Host:   req.Host,
+		Method: req.Method,
+		Path:   req.URL.Path,
+		Domain: options.Domain,
+	}, nil
+}
+
+func (r *Resolver) String() string {
+	return "path"
+}
+
+// withPrefix transforms "foo" into "go.micro.api.foo"
+func (r *Resolver) withPrefix(parts ...string) string {
+	p := r.opts.ServicePrefix
+	if len(p) > 0 {
+		parts = append([]string{p}, parts...)
+	}
+
+	return strings.Join(parts, ".")
+}

api/router/options.go

@@ -0,0 +1,65 @@
+package router
+
+import (
+	"context"
+
+	"github.com/unistack-org/micro/v3/api/resolver"
+	"github.com/unistack-org/micro/v3/api/resolver/vpath"
+	"github.com/unistack-org/micro/v3/registry"
+)
+
+type Options struct {
+	Handler  string
+	Registry registry.Registry
+	Resolver resolver.Resolver
+	Context  context.Context
+}
+
+type Option func(o *Options)
+
+func NewOptions(opts ...Option) Options {
+	options := Options{
+		Context: context.Background(),
+		Handler: "meta",
+	}
+
+	for _, o := range opts {
+		o(&options)
+	}
+
+	if options.Resolver == nil {
+		options.Resolver = vpath.NewResolver(
+			resolver.WithHandler(options.Handler),
+		)
+	}
+
+	return options
+}
+
+// WithContext sets the context
+func WithContext(ctx context.Context) Option {
+	return func(o *Options) {
+		o.Context = ctx
+	}
+}
+
+// WithHandler sets the handler
+func WithHandler(h string) Option {
+	return func(o *Options) {
+		o.Handler = h
+	}
+}
+
+// WithRegistry sets the registry
+func WithRegistry(r registry.Registry) Option {
+	return func(o *Options) {
+		o.Registry = r
+	}
+}
+
+// WithResolver sets the resolver
+func WithResolver(r resolver.Resolver) Option {
+	return func(o *Options) {
+		o.Resolver = r
+	}
+}

api/router/router.go

@@ -0,0 +1,24 @@
+// Package router provides api service routing
+package router
+
+import (
+	"net/http"
+
+	"github.com/unistack-org/micro/v3/api"
+)
+
+// Router is used to determine an endpoint for a request
+type Router interface {
+	// Returns options
+	Options() Options
+	// Stop the router
+	Close() error
+	// Endpoint returns an api.Service endpoint or an error if it does not exist
+	Endpoint(r *http.Request) (*api.Service, error)
+	// Register endpoint in router
+	Register(ep *api.Endpoint) error
+	// Deregister endpoint from router
+	Deregister(ep *api.Endpoint) error
+	// Route returns an api.Service route
+	Route(r *http.Request) (*api.Service, error)
+}

api/server/acme/acme.go

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

api/server/acme/autocert/autocert.go

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

api/server/acme/autocert/autocert_test.go

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

api/server/acme/autocert/cache.go

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

api/server/acme/certmagic/certmagic.go

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

api/server/acme/certmagic/storage.go

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

api/server/acme/options.go

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

api/server/cors/cors.go

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

api/server/http/http.go

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

api/server/http/http_test.go

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

api/server/options.go

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

api/server/server.go

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

auth/auth.go

@@ -0,0 +1,134 @@
+// Package auth provides authentication and authorization capability
+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
+	ScopeAccount = "*"
+)
+
+var (
+	DefaultAuth Auth = &NoopAuth{opts: NewOptions()}
+	// 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
+	ErrForbidden = errors.New("resource forbidden")
+)
+
+// Auth provides authentication and authorization
+type Auth interface {
+	// Init the auth
+	Init(opts ...Option)
+	// Options set for auth
+	Options() Options
+	// Generate a new account
+	Generate(id string, opts ...GenerateOption) (*Account, error)
+	// Verify an account has access to a resource using the rules
+	Verify(acc *Account, res *Resource, opts ...VerifyOption) error
+	// Inspect a token
+	Inspect(token string) (*Account, error)
+	// Token generated using refresh token or credentials
+	Token(opts ...TokenOption) (*Token, error)
+	// Grant access to a resource
+	Grant(rule *Rule) error
+	// Revoke access to a resource
+	Revoke(rule *Rule) error
+	// Rules returns all the rules used to verify requests
+	Rules(...RulesOption) ([]*Rule, error)
+	// String returns the name of the implementation
+	String() string
+}
+
+// Account provided by an auth provider
+type Account struct {
+	// ID of the account e.g. email
+	ID string `json:"id"`
+	// Type of the account, e.g. service
+	Type string `json:"type"`
+	// Issuer of the account
+	Issuer string `json:"issuer"`
+	// Any other associated metadata
+	Metadata map[string]string `json:"metadata"`
+	// Scopes the account has access to
+	Scopes []string `json:"scopes"`
+	// Secret for the account, e.g. the password
+	Secret string `json:"secret"`
+}
+
+// Token can be short or long lived
+type Token struct {
+	// The token to be used for accessing resources
+	AccessToken string `json:"access_token"`
+	// RefreshToken to be used to generate a new token
+	RefreshToken string `json:"refresh_token"`
+	// Time of token creation
+	Created time.Time `json:"created"`
+	// Time of token expiry
+	Expiry time.Time `json:"expiry"`
+}
+
+// Expired returns a boolean indicating if the token needs to be refreshed
+func (t *Token) Expired() bool {
+	return t.Expiry.Unix() < time.Now().Unix()
+}
+
+// Resource is an entity such as a user or
+type Resource struct {
+	// Name of the resource, e.g. go.micro.service.notes
+	Name string `json:"name"`
+	// Type of resource, e.g. service
+	Type string `json:"type"`
+	// Endpoint resource e.g NotesService.Create
+	Endpoint string `json:"endpoint"`
+}
+
+// Access defines the type of access a rule grants
+type Access int
+
+const (
+	// AccessGranted to a resource
+	AccessGranted Access = iota
+	// AccessDenied to a resource
+	AccessDenied
+)
+
+// Rule is used to verify access to a resource
+type Rule struct {
+	// ID of the rule, e.g. "public"
+	ID string
+	// Scope the rule requires, a blank scope indicates open to the public and * indicates the rule
+	// applies to any valid account
+	Scope string
+	// Resource the rule applies to
+	Resource *Resource
+	// Access determines if the rule grants or denies access to the resource
+	Access Access
+	// Priority the rule should take when verifying a request, the higher the value the sooner the
+	// 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/noop.go

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

auth/options.go

@@ -0,0 +1,262 @@
+package auth
+
+import (
+	"context"
+	"time"
+
+	"github.com/unistack-org/micro/v3/logger"
+	"github.com/unistack-org/micro/v3/store"
+)
+
+func NewOptions(opts ...Option) Options {
+	var options Options
+	for _, o := range opts {
+		o(&options)
+	}
+	return options
+}
+
+type Options struct {
+	// Issuer of the service's account
+	Issuer string
+	// ID is the services auth ID
+	ID string
+	// Secret is used to authenticate the service
+	Secret string
+	// Token is the services token used to authenticate itself
+	Token *Token
+	// PublicKey for decoding JWTs
+	PublicKey string
+	// PrivateKey for encoding JWTs
+	PrivateKey string
+	// LoginURL is the relative url path where a user can login
+	LoginURL string
+	// Store to back auth
+	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
+}
+
+type Option func(o *Options)
+
+// Addrs is the auth addresses to use
+func Addrs(addrs ...string) Option {
+	return func(o *Options) {
+		o.Addrs = addrs
+	}
+}
+
+// Issuer of the services account
+func Issuer(i string) Option {
+	return func(o *Options) {
+		o.Issuer = i
+	}
+}
+
+// Store to back auth
+func Store(s store.Store) Option {
+	return func(o *Options) {
+		o.Store = s
+	}
+}
+
+// PublicKey is the JWT public key
+func PublicKey(key string) Option {
+	return func(o *Options) {
+		o.PublicKey = key
+	}
+}
+
+// PrivateKey is the JWT private key
+func PrivateKey(key string) Option {
+	return func(o *Options) {
+		o.PrivateKey = key
+	}
+}
+
+// Credentials sets the auth credentials
+func Credentials(id, secret string) Option {
+	return func(o *Options) {
+		o.ID = id
+		o.Secret = secret
+	}
+}
+
+// ClientToken sets the auth token to use when making requests
+func ClientToken(token *Token) Option {
+	return func(o *Options) {
+		o.Token = token
+	}
+}
+
+// LoginURL sets the auth LoginURL
+func LoginURL(url string) Option {
+	return func(o *Options) {
+		o.LoginURL = url
+	}
+}
+
+type GenerateOptions struct {
+	// Metadata associated with the account
+	Metadata map[string]string
+	// Scopes the account has access too
+	Scopes []string
+	// Provider of the account, e.g. oauth
+	Provider string
+	// Type of the account, e.g. user
+	Type string
+	// Secret used to authenticate the account
+	Secret string
+	// Issuer of the account, e.g. micro
+	Issuer string
+}
+
+type GenerateOption func(o *GenerateOptions)
+
+// WithSecret for the generated account
+func WithSecret(s string) GenerateOption {
+	return func(o *GenerateOptions) {
+		o.Secret = s
+	}
+}
+
+// WithType for the generated account
+func WithType(t string) GenerateOption {
+	return func(o *GenerateOptions) {
+		o.Type = t
+	}
+}
+
+// WithMetadata for the generated account
+func WithMetadata(md map[string]string) GenerateOption {
+	return func(o *GenerateOptions) {
+		o.Metadata = md
+	}
+}
+
+// WithProvider for the generated account
+func WithProvider(p string) GenerateOption {
+	return func(o *GenerateOptions) {
+		o.Provider = p
+	}
+}
+
+// WithScopes for the generated account
+func WithScopes(s ...string) GenerateOption {
+	return func(o *GenerateOptions) {
+		o.Scopes = s
+	}
+}
+
+// WithIssuer for the generated account
+func WithIssuer(i string) GenerateOption {
+	return func(o *GenerateOptions) {
+		o.Issuer = i
+	}
+}
+
+// NewGenerateOptions from a slice of options
+func NewGenerateOptions(opts ...GenerateOption) GenerateOptions {
+	var options GenerateOptions
+	for _, o := range opts {
+		o(&options)
+	}
+	return options
+}
+
+type TokenOptions struct {
+	// ID for the account
+	ID string
+	// Secret for the account
+	Secret string
+	// RefreshToken is used to refesh a token
+	RefreshToken string
+	// Expiry is the time the token should live for
+	Expiry time.Duration
+	// Issuer of the account
+	Issuer string
+}
+
+type TokenOption func(o *TokenOptions)
+
+// WithExpiry for the token
+func WithExpiry(ex time.Duration) TokenOption {
+	return func(o *TokenOptions) {
+		o.Expiry = ex
+	}
+}
+
+func WithCredentials(id, secret string) TokenOption {
+	return func(o *TokenOptions) {
+		o.ID = id
+		o.Secret = secret
+	}
+}
+
+func WithToken(rt string) TokenOption {
+	return func(o *TokenOptions) {
+		o.RefreshToken = rt
+	}
+}
+
+func WithTokenIssuer(iss string) TokenOption {
+	return func(o *TokenOptions) {
+		o.Issuer = iss
+	}
+}
+
+// NewTokenOptions from a slice of options
+func NewTokenOptions(opts ...TokenOption) TokenOptions {
+	var options TokenOptions
+	for _, o := range opts {
+		o(&options)
+	}
+
+	// set default expiry of token
+	if options.Expiry == 0 {
+		options.Expiry = time.Minute
+	}
+
+	return options
+}
+
+type VerifyOptions struct {
+	Context   context.Context
+	Namespace string
+}
+
+type VerifyOption func(o *VerifyOptions)
+
+func VerifyContext(ctx context.Context) VerifyOption {
+	return func(o *VerifyOptions) {
+		o.Context = ctx
+	}
+}
+func VerifyNamespace(ns string) VerifyOption {
+	return func(o *VerifyOptions) {
+		o.Namespace = ns
+	}
+}
+
+type RulesOptions struct {
+	Context   context.Context
+	Namespace string
+}
+
+type RulesOption func(o *RulesOptions)
+
+func RulesContext(ctx context.Context) RulesOption {
+	return func(o *RulesOptions) {
+		o.Context = ctx
+	}
+}
+
+func RulesNamespace(ns string) RulesOption {
+	return func(o *RulesOptions) {
+		o.Namespace = ns
+	}
+}

auth/rules.go

@@ -0,0 +1,91 @@
+package auth
+
+import (
+	"fmt"
+	"sort"
+	"strings"
+)
+
+// VerifyAccess an account has access to a resource using the rules provided. If the account does not have
+// access an error will be returned. If there are no rules provided which match the resource, an error
+// will be returned
+func VerifyAccess(rules []*Rule, acc *Account, res *Resource) error {
+	// the rule is only to be applied if the type matches the resource or is catch-all (*)
+	validTypes := []string{"*", res.Type}
+
+	// the rule is only to be applied if the name matches the resource or is catch-all (*)
+	validNames := []string{"*", res.Name}
+
+	// rules can have wildcard excludes on endpoints since this can also be a path for web services,
+	// e.g. /foo/* would include /foo/bar. We also want to check for wildcards and the exact endpoint
+	validEndpoints := []string{"*", res.Endpoint}
+	if comps := strings.Split(res.Endpoint, "/"); len(comps) > 1 {
+		for i := 1; i < len(comps)+1; i++ {
+			wildcard := fmt.Sprintf("%v/*", strings.Join(comps[0:i], "/"))
+			validEndpoints = append(validEndpoints, wildcard)
+		}
+	}
+
+	// filter the rules to the ones which match the criteria above
+	filteredRules := make([]*Rule, 0)
+	for _, rule := range rules {
+		if !include(validTypes, rule.Resource.Type) {
+			continue
+		}
+		if !include(validNames, rule.Resource.Name) {
+			continue
+		}
+		if !include(validEndpoints, rule.Resource.Endpoint) {
+			continue
+		}
+		filteredRules = append(filteredRules, rule)
+	}
+
+	// sort the filtered rules by priority, highest to lowest
+	sort.SliceStable(filteredRules, func(i, j int) bool {
+		return filteredRules[i].Priority > filteredRules[j].Priority
+	})
+
+	// loop through the rules and check for a rule which applies to this account
+	for _, rule := range filteredRules {
+		// a blank scope indicates the rule applies to everyone, even nil accounts
+		if rule.Scope == ScopePublic && rule.Access == AccessDenied {
+			return ErrForbidden
+		} else if rule.Scope == ScopePublic && rule.Access == AccessGranted {
+			return nil
+		}
+
+		// all further checks require an account
+		if acc == nil {
+			continue
+		}
+
+		// this rule applies to any account
+		if rule.Scope == ScopeAccount && rule.Access == AccessDenied {
+			return ErrForbidden
+		} else if rule.Scope == ScopeAccount && rule.Access == AccessGranted {
+			return nil
+		}
+
+		// if the account has the necessary scope
+		if include(acc.Scopes, rule.Scope) && rule.Access == AccessDenied {
+			return ErrForbidden
+		} else if include(acc.Scopes, rule.Scope) && rule.Access == AccessGranted {
+			return nil
+		}
+	}
+
+	// if no rules matched then return forbidden
+	return ErrForbidden
+}
+
+// include is a helper function which checks to see if the slice contains the value. includes is
+// not case sensitive.
+func include(slice []string, val string) bool {
+	for _, s := range slice {
+		if strings.EqualFold(s, val) {
+			return true
+		}
+	}
+	return false
+}

auth/rules_test.go

@@ -0,0 +1,288 @@
+package auth
+
+import (
+	"testing"
+)
+
+func TestVerify(t *testing.T) {
+	srvResource := &Resource{
+		Type:     "service",
+		Name:     "go.micro.service.foo",
+		Endpoint: "Foo.Bar",
+	}
+
+	webResource := &Resource{
+		Type:     "service",
+		Name:     "go.micro.web.foo",
+		Endpoint: "/foo/bar",
+	}
+
+	catchallResource := &Resource{
+		Type:     "*",
+		Name:     "*",
+		Endpoint: "*",
+	}
+
+	tt := []struct {
+		Name     string
+		Rules    []*Rule
+		Account  *Account
+		Resource *Resource
+		Error    error
+	}{
+		{
+			Name:     "NoRules",
+			Rules:    []*Rule{},
+			Account:  nil,
+			Resource: srvResource,
+			Error:    ErrForbidden,
+		},
+		{
+			Name:     "CatchallPublicAccount",
+			Account:  &Account{},
+			Resource: srvResource,
+			Rules: []*Rule{
+				{
+					Scope:    "",
+					Resource: catchallResource,
+				},
+			},
+		},
+		{
+			Name:     "CatchallPublicNoAccount",
+			Resource: srvResource,
+			Rules: []*Rule{
+				{
+					Scope:    "",
+					Resource: catchallResource,
+				},
+			},
+		},
+		{
+			Name:     "CatchallPrivateAccount",
+			Account:  &Account{},
+			Resource: srvResource,
+			Rules: []*Rule{
+				{
+					Scope:    "*",
+					Resource: catchallResource,
+				},
+			},
+		},
+		{
+			Name:     "CatchallPrivateNoAccount",
+			Resource: srvResource,
+			Rules: []*Rule{
+				{
+					Scope:    "*",
+					Resource: catchallResource,
+				},
+			},
+			Error: ErrForbidden,
+		},
+		{
+			Name:     "CatchallServiceRuleMatch",
+			Resource: srvResource,
+			Account:  &Account{},
+			Rules: []*Rule{
+				{
+					Scope: "*",
+					Resource: &Resource{
+						Type:     srvResource.Type,
+						Name:     srvResource.Name,
+						Endpoint: "*",
+					},
+				},
+			},
+		},
+		{
+			Name:     "CatchallServiceRuleNoMatch",
+			Resource: srvResource,
+			Account:  &Account{},
+			Rules: []*Rule{
+				{
+					Scope: "*",
+					Resource: &Resource{
+						Type:     srvResource.Type,
+						Name:     "wrongname",
+						Endpoint: "*",
+					},
+				},
+			},
+			Error: ErrForbidden,
+		},
+		{
+			Name:     "ExactRuleValidScope",
+			Resource: srvResource,
+			Account: &Account{
+				Scopes: []string{"neededscope"},
+			},
+			Rules: []*Rule{
+				{
+					Scope:    "neededscope",
+					Resource: srvResource,
+				},
+			},
+		},
+		{
+			Name:     "ExactRuleInvalidScope",
+			Resource: srvResource,
+			Account: &Account{
+				Scopes: []string{"neededscope"},
+			},
+			Rules: []*Rule{
+				{
+					Scope:    "invalidscope",
+					Resource: srvResource,
+				},
+			},
+			Error: ErrForbidden,
+		},
+		{
+			Name:     "CatchallDenyWithAccount",
+			Resource: srvResource,
+			Account:  &Account{},
+			Rules: []*Rule{
+				{
+					Scope:    "*",
+					Resource: catchallResource,
+					Access:   AccessDenied,
+				},
+			},
+			Error: ErrForbidden,
+		},
+		{
+			Name:     "CatchallDenyWithNoAccount",
+			Resource: srvResource,
+			Account:  &Account{},
+			Rules: []*Rule{
+				{
+					Scope:    "*",
+					Resource: catchallResource,
+					Access:   AccessDenied,
+				},
+			},
+			Error: ErrForbidden,
+		},
+		{
+			Name:     "RulePriorityGrantFirst",
+			Resource: srvResource,
+			Account:  &Account{},
+			Rules: []*Rule{
+				{
+					Scope:    "*",
+					Resource: catchallResource,
+					Access:   AccessGranted,
+					Priority: 1,
+				},
+				{
+					Scope:    "*",
+					Resource: catchallResource,
+					Access:   AccessDenied,
+					Priority: 0,
+				},
+			},
+		},
+		{
+			Name:     "RulePriorityDenyFirst",
+			Resource: srvResource,
+			Account:  &Account{},
+			Rules: []*Rule{
+				{
+					Scope:    "*",
+					Resource: catchallResource,
+					Access:   AccessGranted,
+					Priority: 0,
+				},
+				{
+					Scope:    "*",
+					Resource: catchallResource,
+					Access:   AccessDenied,
+					Priority: 1,
+				},
+			},
+			Error: ErrForbidden,
+		},
+		{
+			Name:     "WebExactEndpointValid",
+			Resource: webResource,
+			Account:  &Account{},
+			Rules: []*Rule{
+				{
+					Scope:    "*",
+					Resource: webResource,
+				},
+			},
+		},
+		{
+			Name:     "WebExactEndpointInalid",
+			Resource: webResource,
+			Account:  &Account{},
+			Rules: []*Rule{
+				{
+					Scope: "*",
+					Resource: &Resource{
+						Type:     webResource.Type,
+						Name:     webResource.Name,
+						Endpoint: "invalidendpoint",
+					},
+				},
+			},
+			Error: ErrForbidden,
+		},
+		{
+			Name:     "WebWildcardEndpoint",
+			Resource: webResource,
+			Account:  &Account{},
+			Rules: []*Rule{
+				{
+					Scope: "*",
+					Resource: &Resource{
+						Type:     webResource.Type,
+						Name:     webResource.Name,
+						Endpoint: "*",
+					},
+				},
+			},
+		},
+		{
+			Name:     "WebWildcardPathEndpointValid",
+			Resource: webResource,
+			Account:  &Account{},
+			Rules: []*Rule{
+				{
+					Scope: "*",
+					Resource: &Resource{
+						Type:     webResource.Type,
+						Name:     webResource.Name,
+						Endpoint: "/foo/*",
+					},
+				},
+			},
+		},
+		{
+			Name:     "WebWildcardPathEndpointInvalid",
+			Resource: webResource,
+			Account:  &Account{},
+			Rules: []*Rule{
+				{
+					Scope: "*",
+					Resource: &Resource{
+						Type:     webResource.Type,
+						Name:     webResource.Name,
+						Endpoint: "/bar/*",
+					},
+				},
+			},
+			Error: ErrForbidden,
+		},
+	}
+
+	for _, tc := range tt {
+		t.Run(tc.Name, func(t *testing.T) {
+			if err := VerifyAccess(tc.Rules, tc.Account, tc.Resource); err != tc.Error {
+				t.Errorf("Expected %v but got %v", tc.Error, err)
+			}
+		})
+	}
+}

broker/broker.go

@@ -1,80 +1,44 @@
 // Package broker is an interface used for asynchronous messaging
-package broker // import "go.unistack.org/micro/v4/broker"
+package broker
 
-import (
+import "context"
-	"context"
-	"errors"
-	"time"
-
-	"go.unistack.org/micro/v4/metadata"
-	"go.unistack.org/micro/v4/options"
-)
-
-// DefaultBroker default memory broker
-var DefaultBroker Broker = NewBroker()
 
 var (
-	// ErrNotConnected returns when broker used but not connected yet
+	DefaultBroker Broker = NewBroker()
-	ErrNotConnected = errors.New("broker not connected")
-	// ErrDisconnected returns when broker disconnected
-	ErrDisconnected = errors.New("broker disconnected")
-	// ErrInvalidMessage returns when message has nvalid format
-	ErrInvalidMessage = errors.New("broker message has invalid format")
-	// DefaultGracefulTimeout
-	DefaultGracefulTimeout = 5 * time.Second
 )
 
 // Broker is an interface used for asynchronous messaging.
 type Broker interface {
-	// Name returns broker instance name
+	Init(...Option) error
-	Name() string
-	// Init initilize broker
-	Init(opts ...options.Option) error
-	// Options returns broker options
 	Options() Options
-	// Address return configured address
 	Address() string
-	// Connect connects to broker
+	Connect(context.Context) error
-	Connect(ctx context.Context) error
+	Disconnect(context.Context) error
-	// Disconnect disconnect from broker
+	Publish(context.Context, string, *Message, ...PublishOption) error
-	Disconnect(ctx context.Context) error
+	Subscribe(context.Context, string, Handler, ...SubscribeOption) (Subscriber, error)
-	// Publish message, msg can be single broker.Message or []broker.Message
-	Publish(ctx context.Context, msg interface{}, opts ...options.Option) error
-	// Subscribe subscribes to topic message via handler
-	Subscribe(ctx context.Context, topic string, handler interface{}, opts ...options.Option) (Subscriber, error)
-	// String type of broker
 	String() string
 }
 
-// Message is given to a subscription handler for processing
+// Handler is used to process messages via a subscription of a topic.
-type Message interface {
+type Handler func(Event) error
-	// Context for the message
+
-	Context() context.Context
+// Event is given to a subscription handler for processing
-	// Topic
+type Event interface {
 	Topic() string
-	// Header returns message headers
+	Message() *Message
-	Header() metadata.Metadata
-	// Body returns broker message may be []byte slice or some go struct
-	Body() interface{}
-	// Ack acknowledge message
 	Ack() error
-	// Error returns message error (like decoding errors or some other)
-	// In this case Body contains raw []byte from broker
 	Error() error
 }
 
+// Message is used to transfer data
+type Message struct {
+	Header map[string]string // contains message metadata
+	Body   []byte            // contains message body
+}
+
 // Subscriber is a convenience return type for the Subscribe method
 type Subscriber interface {
-	// Options returns subscriber options
 	Options() SubscribeOptions
-	// Topic returns topic for subscription
 	Topic() string
-	// Unsubscribe from topic
+	Unsubscribe(context.Context) error
-	Unsubscribe(ctx context.Context) error
 }
-
-// MessageHandler func signature for single message processing
-type MessageHandler func(Message) error
-
-// MessagesHandler func signature for batch message processing
-type MessagesHandler func([]Message) error

broker/context.go

@@ -6,19 +6,41 @@ import (
 
 type brokerKey struct{}
 
-// FromContext returns broker from passed context
 func FromContext(ctx context.Context) (Broker, bool) {
-	if ctx == nil {
-		return nil, false
-	}
 	c, ok := ctx.Value(brokerKey{}).(Broker)
 	return c, ok
 }
 
-// NewContext savess broker in context
 func NewContext(ctx context.Context, s Broker) context.Context {
-	if ctx == nil {
-		ctx = context.Background()
-	}
 	return context.WithValue(ctx, brokerKey{}, s)
 }
+
+// SetSubscribeOption returns a function to setup a context with given value
+func SetSubscribeOption(k, v interface{}) SubscribeOption {
+	return func(o *SubscribeOptions) {
+		if o.Context == nil {
+			o.Context = context.Background()
+		}
+		o.Context = context.WithValue(o.Context, k, v)
+	}
+}
+
+// SetOption returns a function to setup a context with given value
+func SetOption(k, v interface{}) Option {
+	return func(o *Options) {
+		if o.Context == nil {
+			o.Context = context.Background()
+		}
+		o.Context = context.WithValue(o.Context, k, v)
+	}
+}
+
+// SetPublishOption returns a function to setup a context with given value
+func SetPublishOption(k, v interface{}) PublishOption {
+	return func(o *PublishOptions) {
+		if o.Context == nil {
+			o.Context = context.Background()
+		}
+		o.Context = context.WithValue(o.Context, k, v)
+	}
+}

broker/context_test.go

@@ -1,39 +0,0 @@
-package broker
-
-import (
-	"context"
-	"testing"
-)
-
-func TestFromContext(t *testing.T) {
-	ctx := context.WithValue(context.TODO(), brokerKey{}, NewBroker())
-	c, ok := FromContext(ctx)
-	if c == nil || !ok {
-		t.Fatal("FromContext not works")
-	}
-}
-
-func TestFromNilContext(t *testing.T) {
-	// nolint: staticcheck
-	c, ok := FromContext(nil)
-	if ok || c != nil {
-		t.Fatal("FromContext not works")
-	}
-}
-
-func TestNewContext(t *testing.T) {
-	ctx := NewContext(context.TODO(), NewBroker())
-	c, ok := FromContext(ctx)
-	if c == nil || !ok {
-		t.Fatal("NewContext not works")
-	}
-}
-
-func TestNewNilContext(t *testing.T) {
-	// nolint: staticcheck
-	ctx := NewContext(nil, NewBroker())
-	c, ok := FromContext(ctx)
-	if c == nil || !ok {
-		t.Fatal("NewContext not works")
-	}
-}

broker/memory.go

@@ -1,334 +0,0 @@
-package broker
-
-import (
-	"context"
-	"fmt"
-	"sync"
-	"time"
-
-	"go.unistack.org/micro/v4/codec"
-	"go.unistack.org/micro/v4/logger"
-	"go.unistack.org/micro/v4/metadata"
-	"go.unistack.org/micro/v4/options"
-	"go.unistack.org/micro/v4/semconv"
-	maddr "go.unistack.org/micro/v4/util/addr"
-	"go.unistack.org/micro/v4/util/id"
-	mnet "go.unistack.org/micro/v4/util/net"
-	"go.unistack.org/micro/v4/util/rand"
-)
-
-type MemoryBroker struct {
-	subscribers map[string][]*memorySubscriber
-	addr        string
-	opts        Options
-	sync.RWMutex
-	connected bool
-}
-
-func (m *MemoryBroker) Options() Options {
-	return m.opts
-}
-
-func (m *MemoryBroker) Address() string {
-	return m.addr
-}
-
-func (m *MemoryBroker) Connect(ctx context.Context) error {
-	m.Lock()
-	defer m.Unlock()
-
-	if m.connected {
-		return nil
-	}
-
-	// use 127.0.0.1 to avoid scan of all network interfaces
-	addr, err := maddr.Extract("127.0.0.1")
-	if err != nil {
-		return err
-	}
-	var rng rand.Rand
-	i := rng.Intn(20000)
-	// set addr with port
-	addr = mnet.HostPort(addr, 10000+i)
-
-	m.addr = addr
-	m.connected = true
-
-	return nil
-}
-
-func (m *MemoryBroker) Disconnect(ctx context.Context) error {
-	m.Lock()
-	defer m.Unlock()
-
-	select {
-	case <-ctx.Done():
-		return ctx.Err()
-	default:
-		if m.connected {
-			m.connected = false
-		}
-	}
-
-	return nil
-}
-
-func (m *MemoryBroker) Init(opts ...options.Option) error {
-	var err error
-	for _, o := range opts {
-		if err = o(&m.opts); err != nil {
-			return err
-		}
-	}
-	return nil
-}
-
-func (m *MemoryBroker) Publish(ctx context.Context, message interface{}, opts ...options.Option) error {
-	m.RLock()
-	if !m.connected {
-		m.RUnlock()
-		return ErrNotConnected
-	}
-	m.RUnlock()
-
-	var err error
-
-	select {
-	case <-ctx.Done():
-		return ctx.Err()
-	default:
-		options := NewPublishOptions(opts...)
-		var msgs []Message
-		switch v := message.(type) {
-		case []Message:
-			msgs = v
-		case Message:
-			msgs = append(msgs, v)
-		default:
-			return ErrInvalidMessage
-		}
-		msgTopicMap := make(map[string][]*memoryMessage)
-		for _, msg := range msgs {
-			p := &memoryMessage{opts: options}
-			p.topic, _ = msg.Header().Get(metadata.HeaderTopic)
-			if v, ok := msg.Body().(*codec.Frame); ok {
-				p.body = msg.Body()
-			} else if len(m.opts.Codecs) == 0 {
-				p.body = msg.Body()
-			} else {
-				cf, ok := m.opts.Codecs[options.ContentType]
-				if !ok {
-					return fmt.Errorf("%s: %s", codec.ErrUnknownContentType, options.ContentType)
-				}
-				p.body, err = cf.Marshal(v)
-				if err != nil {
-					return err
-				}
-			}
-			msgTopicMap[p.topic] = append(msgTopicMap[p.topic], p)
-		}
-
-		eh := m.opts.ErrorHandler
-
-		for t, ms := range msgTopicMap {
-			ts := time.Now()
-
-			m.opts.Meter.Counter(semconv.PublishMessageInflight, "endpoint", t).Add(len(ms))
-			m.opts.Meter.Counter(semconv.SubscribeMessageInflight, "endpoint", t).Add(len(ms))
-
-			m.RLock()
-			subs, ok := m.subscribers[t]
-			m.RUnlock()
-			if !ok {
-				m.opts.Meter.Counter(semconv.PublishMessageTotal, "endpoint", t, "status", "failure").Add(len(ms))
-				m.opts.Meter.Counter(semconv.PublishMessageInflight, "endpoint", t).Add(-len(ms))
-				m.opts.Meter.Counter(semconv.SubscribeMessageInflight, "endpoint", t).Add(-len(ms))
-				continue
-			}
-
-			m.opts.Meter.Counter(semconv.PublishMessageTotal, "endpoint", t, "status", "success").Add(len(ms))
-			for _, sub := range subs {
-				if sub.opts.ErrorHandler != nil {
-					eh = sub.opts.ErrorHandler
-				}
-
-				switch mh := sub.handler.(type) {
-				case MessagesHandler:
-					mhs := make([]Message, 0, len(ms))
-					for _, m := range ms {
-						mhs = append(mhs, m)
-					}
-					if err = mh(mhs); err != nil {
-						m.opts.Meter.Counter(semconv.SubscribeMessageTotal, "endpoint", t, "status", "failure").Add(len(ms))
-						if eh != nil {
-							switch meh := eh.(type) {
-							case MessagesHandler:
-								_ = meh(mhs)
-							case MessageHandler:
-								for _, me := range mhs {
-									_ = meh(me)
-								}
-							}
-						} else if m.opts.Logger.V(logger.ErrorLevel) {
-							m.opts.Logger.Error(m.opts.Context, err.Error())
-						}
-					}
-				case MessageHandler:
-					for _, p := range ms {
-						if err = mh(p); err != nil {
-							m.opts.Meter.Counter(semconv.SubscribeMessageTotal, "endpoint", t, "status", "failure").Inc()
-							if eh != nil {
-								switch meh := eh.(type) {
-								case MessageHandler:
-									_ = meh(p)
-								case MessagesHandler:
-									_ = meh([]Message{p})
-								}
-							} else if m.opts.Logger.V(logger.ErrorLevel) {
-								m.opts.Logger.Error(m.opts.Context, err.Error())
-							}
-						} else {
-							if sub.opts.AutoAck {
-								if err = p.Ack(); err != nil {
-									m.opts.Logger.Error(m.opts.Context, "ack failed: "+err.Error())
-									m.opts.Meter.Counter(semconv.SubscribeMessageTotal, "endpoint", t, "status", "failure").Inc()
-								} else {
-									m.opts.Meter.Counter(semconv.SubscribeMessageTotal, "endpoint", t, "status", "success").Inc()
-								}
-							} else {
-								m.opts.Meter.Counter(semconv.SubscribeMessageTotal, "endpoint", t, "status", "success").Inc()
-							}
-						}
-						m.opts.Meter.Counter(semconv.PublishMessageInflight, "endpoint", t).Add(-1)
-						m.opts.Meter.Counter(semconv.SubscribeMessageInflight, "endpoint", t).Add(-1)
-					}
-				}
-			}
-
-			te := time.Since(ts)
-			m.opts.Meter.Summary(semconv.PublishMessageLatencyMicroseconds, "endpoint", t).Update(te.Seconds())
-			m.opts.Meter.Histogram(semconv.PublishMessageDurationSeconds, "endpoint", t).Update(te.Seconds())
-			m.opts.Meter.Summary(semconv.SubscribeMessageLatencyMicroseconds, "endpoint", t).Update(te.Seconds())
-			m.opts.Meter.Histogram(semconv.SubscribeMessageDurationSeconds, "endpoint", t).Update(te.Seconds())
-		}
-
-	}
-
-	return nil
-}
-
-func (m *MemoryBroker) Subscribe(ctx context.Context, topic string, handler interface{}, opts ...options.Option) (Subscriber, error) {
-	m.RLock()
-	if !m.connected {
-		m.RUnlock()
-		return nil, ErrNotConnected
-	}
-	m.RUnlock()
-
-	sid, err := id.New()
-	if err != nil {
-		return nil, err
-	}
-
-	options := NewSubscribeOptions(opts...)
-
-	sub := &memorySubscriber{
-		exit:    make(chan bool, 1),
-		id:      sid,
-		topic:   topic,
-		handler: handler,
-		opts:    options,
-		ctx:     ctx,
-	}
-
-	m.Lock()
-	m.subscribers[topic] = append(m.subscribers[topic], sub)
-	m.Unlock()
-
-	go func() {
-		<-sub.exit
-		m.Lock()
-		newSubscribers := make([]*memorySubscriber, 0, len(m.subscribers)-1)
-		for _, sb := range m.subscribers[topic] {
-			if sb.id == sub.id {
-				continue
-			}
-			newSubscribers = append(newSubscribers, sb)
-		}
-		m.subscribers[topic] = newSubscribers
-		m.Unlock()
-	}()
-
-	return sub, nil
-}
-
-func (m *MemoryBroker) String() string {
-	return "memory"
-}
-
-func (m *MemoryBroker) Name() string {
-	return m.opts.Name
-}
-
-type memoryMessage struct {
-	err    error
-	body   interface{}
-	topic  string
-	header metadata.Metadata
-	opts   PublishOptions
-	ctx    context.Context
-}
-
-func (m *memoryMessage) Topic() string {
-	return m.topic
-}
-
-func (m *memoryMessage) Header() metadata.Metadata {
-	return m.header
-}
-
-func (m *memoryMessage) Body() interface{} {
-	return m.body
-}
-
-func (m *memoryMessage) Ack() error {
-	return nil
-}
-
-func (m *memoryMessage) Error() error {
-	return m.err
-}
-
-func (m *memoryMessage) Context() context.Context {
-	return m.ctx
-}
-
-type memorySubscriber struct {
-	ctx     context.Context
-	exit    chan bool
-	handler interface{}
-	id      string
-	topic   string
-	opts    SubscribeOptions
-}
-
-func (m *memorySubscriber) Options() SubscribeOptions {
-	return m.opts
-}
-
-func (m *memorySubscriber) Topic() string {
-	return m.topic
-}
-
-func (m *memorySubscriber) Unsubscribe(ctx context.Context) error {
-	m.exit <- true
-	return nil
-}
-
-// NewBroker return new memory broker
-func NewBroker(opts ...options.Option) *MemoryBroker {
-	return &MemoryBroker{
-		opts:        NewOptions(opts...),
-		subscribers: make(map[string][]*memorySubscriber),
-	}
-}

broker/memory_test.go

@@ -1,107 +0,0 @@
-package broker
-
-import (
-	"context"
-	"fmt"
-	"testing"
-
-	"go.unistack.org/micro/v4/metadata"
-)
-
-func TestMemoryBatchBroker(t *testing.T) {
-	b := NewBroker()
-	ctx := context.Background()
-
-	if err := b.Connect(ctx); err != nil {
-		t.Fatalf("Unexpected connect error %v", err)
-	}
-
-	topic := "test"
-	count := 10
-
-	fn := func(evts []Message) error {
-		var err error
-		for _, evt := range evts {
-			if err = evt.Ack(); err != nil {
-				return err
-			}
-		}
-		return nil
-	}
-
-	sub, err := b.Subscribe(ctx, topic, fn)
-	if err != nil {
-		t.Fatalf("Unexpected error subscribing %v", err)
-	}
-
-	msgs := make([]Message, 0, count)
-	for i := 0; i < count; i++ {
-		message := &memoryMessage{
-			header: metadata.Metadata{
-				metadata.HeaderTopic: []string{topic},
-				"foo":                []string{"bar"},
-				"id":                 []string{fmt.Sprintf("%d", i)},
-			},
-			body: []byte(`"hello world"`),
-		}
-		msgs = append(msgs, message)
-	}
-
-	if err := b.Publish(ctx, msgs); err != nil {
-		t.Fatalf("Unexpected error publishing %v", err)
-	}
-
-	if err := sub.Unsubscribe(ctx); err != nil {
-		t.Fatalf("Unexpected error unsubscribing from %s: %v", topic, err)
-	}
-
-	if err := b.Disconnect(ctx); err != nil {
-		t.Fatalf("Unexpected connect error %v", err)
-	}
-}
-
-func TestMemoryBroker(t *testing.T) {
-	b := NewBroker()
-	ctx := context.Background()
-
-	if err := b.Connect(ctx); err != nil {
-		t.Fatalf("Unexpected connect error %v", err)
-	}
-
-	topic := "test"
-	count := 10
-
-	fn := func(p Message) error {
-		return p.Ack()
-	}
-
-	sub, err := b.Subscribe(ctx, topic, fn)
-	if err != nil {
-		t.Fatalf("Unexpected error subscribing %v", err)
-	}
-
-	msgs := make([]Message, 0, count)
-	for i := 0; i < count; i++ {
-		message := &memoryMessage{
-			header: metadata.Metadata{
-				metadata.HeaderTopic: []string{topic},
-				"foo":                []string{"bar"},
-				"id":                 []string{fmt.Sprintf("%d", i)},
-			},
-			body: []byte(`"hello world"`),
-		}
-		msgs = append(msgs, message)
-	}
-
-	if err := b.Publish(ctx, msgs); err != nil {
-		t.Fatalf("Unexpected error publishing %v", err)
-	}
-
-	if err := sub.Unsubscribe(ctx); err != nil {
-		t.Fatalf("Unexpected error unsubscribing from %s: %v", topic, err)
-	}
-
-	if err := b.Disconnect(ctx); err != nil {
-		t.Fatalf("Unexpected connect error %v", err)
-	}
-}

broker/noop.go

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

broker/options.go

@@ -3,165 +3,210 @@ package broker
 import (
 	"context"
 	"crypto/tls"
-	"time"
 
-	"go.unistack.org/micro/v4/codec"
+	"github.com/unistack-org/micro/v3/codec"
-	"go.unistack.org/micro/v4/logger"
+	"github.com/unistack-org/micro/v3/logger"
-	"go.unistack.org/micro/v4/metadata"
+	"github.com/unistack-org/micro/v3/registry"
-	"go.unistack.org/micro/v4/meter"
-	"go.unistack.org/micro/v4/options"
-	"go.unistack.org/micro/v4/register"
-	"go.unistack.org/micro/v4/sync"
-	"go.unistack.org/micro/v4/tracer"
 )
 
 // Options struct
 type Options struct {
-	// Tracer used for tracing
+	Addrs  []string
-	Tracer tracer.Tracer
+	Secure bool
-	// Register can be used for clustering
+	Codec  codec.Marshaler
-	Register register.Register
+
-	// Codecs holds the codec for marshal/unmarshal
+	// Logger
-	Codecs map[string]codec.Codec
-	// Logger used for logging
 	Logger logger.Logger
-	// Meter used for metrics
+	// Handler executed when errors occur processing messages
-	Meter meter.Meter
+	ErrorHandler Handler
-	// Context holds external options
+
-	Context context.Context
-	// TLSConfig holds tls.TLSConfig options
 	TLSConfig *tls.Config
-	// ErrorHandler used when broker have error while processing message
+	// Registry used for clustering
-	ErrorHandler interface{}
+	Registry registry.Registry
-	// Name holds the broker name
+	// Other options for implementations of the interface
-	Name string
+	// can be stored in a context
-	// Address holds the broker address
+	Context context.Context
-	Address []string
-
-	Wait *sync.WaitGroup
-
-	GracefulTimeout time.Duration
 }
 
 // NewOptions create new Options
-func NewOptions(opts ...options.Option) Options {
+func NewOptions(opts ...Option) Options {
-	newOpts := Options{
+	options := Options{
-		Register:        register.DefaultRegister,
+		Registry: registry.DefaultRegistry,
-		Logger:          logger.DefaultLogger,
+		Logger:   logger.DefaultLogger,
-		Context:         context.Background(),
+		Context:  context.Background(),
-		Meter:           meter.DefaultMeter,
-		Codecs:          make(map[string]codec.Codec),
-		Tracer:          tracer.DefaultTracer,
-		GracefulTimeout: DefaultGracefulTimeout,
 	}
 	for _, o := range opts {
-		o(&newOpts)
+		o(&options)
+	}
+	return options
+}
+
+// Context sets the context option
+func Context(ctx context.Context) Option {
+	return func(o *Options) {
+		o.Context = ctx
 	}
-	return newOpts
 }
 
 // PublishOptions struct
 type PublishOptions struct {
-	// Context holds external options
+	// Other options for implementations of the interface
+	// can be stored in a context
 	Context context.Context
-	// Message metadata usually passed as message headers
-	Metadata metadata.Metadata
-	// Content-Type of message for marshal
-	ContentType string
-	// Topic destination
-	Topic string
-	// BodyOnly flag says the message contains raw body bytes
-	BodyOnly bool
 }
 
 // NewPublishOptions creates PublishOptions struct
-func NewPublishOptions(opts ...options.Option) PublishOptions {
+func NewPublishOptions(opts ...PublishOption) PublishOptions {
 	options := PublishOptions{
 		Context: context.Background(),
 	}
+
 	for _, o := range opts {
 		o(&options)
 	}
-	return options
-}
 
-// PublishTopic pass topic for messages
+	return options
-func PublishTopic(t string) options.Option {
-	return func(src interface{}) error {
-		return options.Set(src, t, ".Topic")
-	}
 }
 
 // SubscribeOptions struct
 type SubscribeOptions struct {
-	// Context holds external options
+	// AutoAck ack messages if handler returns nil err
-	Context context.Context
-	// ErrorHandler used when broker have error while processing message
-	ErrorHandler interface{}
-	// QueueGroup holds consumer group
-	QueueGroup string
-	// AutoAck flag specifies auto ack of incoming message when no error happens
 	AutoAck bool
-	// BodyOnly flag specifies that message contains only body bytes without header
+
-	BodyOnly bool
+	// Handler executed when errors occur processing messages
-	// BatchSize flag specifies max batch size
+	ErrorHandler Handler
-	BatchSize int
+
-	// BatchWait flag specifies max wait time for batch filling
+	// Subscribers with the same group name
-	BatchWait time.Duration
+	// will create a shared subscription where each
+	// receives a subset of messages.
+	Group string
+
+	// Other options for implementations of the interface
+	// can be stored in a context
+	Context context.Context
 }
 
-// ErrorHandler will catch all broker errors that cant be handled
+// Option func
-// in normal way, for example Codec errors
+type Option func(*Options)
-func ErrorHandler(h interface{}) options.Option {
+
-	return func(src interface{}) error {
+// PublishOption func
-		return options.Set(src, h, ".ErrorHandler")
+type PublishOption func(*PublishOptions)
+
+// PublishContext sets the context
+func PublishContext(ctx context.Context) PublishOption {
+	return func(o *PublishOptions) {
+		o.Context = ctx
 	}
 }
 
+// SubscribeOption func
+type SubscribeOption func(*SubscribeOptions)
+
 // NewSubscribeOptions creates new SubscribeOptions
-func NewSubscribeOptions(opts ...options.Option) SubscribeOptions {
+func NewSubscribeOptions(opts ...SubscribeOption) SubscribeOptions {
 	options := SubscribeOptions{
 		AutoAck: true,
 		Context: context.Background(),
 	}
+
 	for _, o := range opts {
 		o(&options)
 	}
+
 	return options
 }
 
-// SubscribeAutoAck contol auto acking of messages
+// Addrs sets the host addresses to be used by the broker
+func Addrs(addrs ...string) Option {
+	return func(o *Options) {
+		o.Addrs = addrs
+	}
+}
+
+// Codec sets the codec used for encoding/decoding used where
+// a broker does not support headers
+func Codec(c codec.Marshaler) Option {
+	return func(o *Options) {
+		o.Codec = c
+	}
+}
+
+// DisableAutoAck disables auto ack
+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) options.Option {
+func SubscribeAutoAck(b bool) SubscribeOption {
-	return func(src interface{}) error {
+	return func(o *SubscribeOptions) {
-		return options.Set(src, b, ".AutoAck")
+		o.AutoAck = b
 	}
 }
 
-// BodyOnly transfer only body without
+// ErrorHandler will catch all broker errors that cant be handled
-func BodyOnly(b bool) options.Option {
+// in normal way, for example Codec errors
-	return func(src interface{}) error {
+func ErrorHandler(h Handler) Option {
-		return options.Set(src, b, ".BodyOnly")
+	return func(o *Options) {
+		o.ErrorHandler = h
 	}
 }
 
-// SubscribeBatchSize specifies max batch size
+// SubscribeErrorHandler will catch all broker errors that cant be handled
-func SubscribeBatchSize(n int) options.Option {
+// in normal way, for example Codec errors
-	return func(src interface{}) error {
+func SubscribeErrorHandler(h Handler) SubscribeOption {
-		return options.Set(src, n, ".BatchSize")
+	return func(o *SubscribeOptions) {
+		o.ErrorHandler = h
 	}
 }
 
-// SubscribeBatchWait specifies max batch wait time
+// Queue sets the subscribers sueue
-func SubscribeBatchWait(td time.Duration) options.Option {
+func Queue(name string) SubscribeOption {
-	return func(src interface{}) error {
+	return func(o *SubscribeOptions) {
-		return options.Set(src, td, ".BatchWait")
+		o.Group = name
 	}
 }
 
-// SubscribeQueueGroup sets the shared queue name distributed messages across subscribers
+// SubscribeGroup sets the name of the queue to share messages on
-func SubscribeQueueGroup(n string) options.Option {
+func SubscribeGroup(name string) SubscribeOption {
-	return func(src interface{}) error {
+	return func(o *SubscribeOptions) {
-		return options.Set(src, n, ".QueueGroup")
+		o.Group = name
+	}
+}
+
+// Registry sets registry option
+func Registry(r registry.Registry) Option {
+	return func(o *Options) {
+		o.Registry = r
+	}
+}
+
+// Secure communication with the broker
+func Secure(b bool) Option {
+	return func(o *Options) {
+		o.Secure = b
+	}
+}
+
+// TLSConfig sets the TLS Config
+func TLSConfig(t *tls.Config) Option {
+	return func(o *Options) {
+		o.TLSConfig = t
+	}
+}
+
+// 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) {
+		o.Context = ctx
 	}
 }

broker/subscriber.go

@@ -1,98 +0,0 @@
-package broker
-
-import (
-	"fmt"
-	"reflect"
-	"strings"
-	"unicode"
-	"unicode/utf8"
-)
-
-const (
-	subSig      = "func(context.Context, interface{}) error"
-	batchSubSig = "func([]context.Context, []interface{}) error"
-)
-
-// Precompute the reflect type for error. Can't use error directly
-// because Typeof takes an empty interface value. This is annoying.
-var typeOfError = reflect.TypeOf((*error)(nil)).Elem()
-
-// Is this an exported - upper case - name?
-func isExported(name string) bool {
-	r, _ := utf8.DecodeRuneInString(name)
-	return unicode.IsUpper(r)
-}
-
-// Is this type exported or a builtin?
-func isExportedOrBuiltinType(t reflect.Type) bool {
-	for t.Kind() == reflect.Ptr {
-		t = t.Elem()
-	}
-	// PkgPath will be non-empty even for an exported type,
-	// so we need to check the type name as well.
-	return isExported(t.Name()) || t.PkgPath() == ""
-}
-
-// ValidateSubscriber func signature
-func ValidateSubscriber(sub interface{}) error {
-	typ := reflect.TypeOf(sub)
-	var argType reflect.Type
-	switch typ.Kind() {
-	case reflect.Func:
-		name := "Func"
-		switch typ.NumIn() {
-		case 1: // func(Message) error
-
-		case 2: // func(context.Context, Message) error or func(context.Context, []Message) error
-			argType = typ.In(2)
-			// if sub.Options().Batch {
-			if argType.Kind() != reflect.Slice {
-				return fmt.Errorf("subscriber %v dont have required signature %s", name, batchSubSig)
-			}
-			if strings.Compare(fmt.Sprintf("%v", argType), "[]interface{}") == 0 {
-				return fmt.Errorf("subscriber %v dont have required signaure %s", name, batchSubSig)
-			}
-		//	}
-		default:
-			return fmt.Errorf("subscriber %v takes wrong number of args: %v required signature %s or %s", name, typ.NumIn(), subSig, batchSubSig)
-		}
-		if !isExportedOrBuiltinType(argType) {
-			return fmt.Errorf("subscriber %v argument type not exported: %v", name, argType)
-		}
-		if typ.NumOut() != 1 {
-			return fmt.Errorf("subscriber %v has wrong number of return values: %v require signature %s or %s",
-				name, typ.NumOut(), subSig, batchSubSig)
-		}
-		if returnType := typ.Out(0); returnType != typeOfError {
-			return fmt.Errorf("subscriber %v returns %v not error", name, returnType.String())
-		}
-	default:
-		hdlr := reflect.ValueOf(sub)
-		name := reflect.Indirect(hdlr).Type().Name()
-
-		for m := 0; m < typ.NumMethod(); m++ {
-			method := typ.Method(m)
-			switch method.Type.NumIn() {
-			case 3:
-				argType = method.Type.In(2)
-			default:
-				return fmt.Errorf("subscriber %v.%v takes wrong number of args: %v required signature %s or %s",
-					name, method.Name, method.Type.NumIn(), subSig, batchSubSig)
-			}
-
-			if !isExportedOrBuiltinType(argType) {
-				return fmt.Errorf("%v argument type not exported: %v", name, argType)
-			}
-			if method.Type.NumOut() != 1 {
-				return fmt.Errorf(
-					"subscriber %v.%v has wrong number of return values: %v require signature %s or %s",
-					name, method.Name, method.Type.NumOut(), subSig, batchSubSig)
-			}
-			if returnType := method.Type.Out(0); returnType != typeOfError {
-				return fmt.Errorf("subscriber %v.%v returns %v not error", name, method.Name, returnType.String())
-			}
-		}
-	}
-
-	return nil
-}

build/build.go

@@ -0,0 +1,32 @@
+// Package build is for building source into a package
+package build
+
+// Build is an interface for building packages
+type Build interface {
+	// Package builds a package
+	Package(name string, src *Source) (*Package, error)
+	// Remove removes the package
+	Remove(*Package) error
+}
+
+// Source is the source of a build
+type Source struct {
+	// Path to the source if local
+	Path string
+	// Language is the language of code
+	Language string
+	// Location of the source
+	Repository string
+}
+
+// Package is packaged format for source
+type Package struct {
+	// Name of the package
+	Name string
+	// Location of the package
+	Path string
+	// Type of package e.g tarball, binary, docker
+	Type string
+	// Source of the package
+	Source *Source
+}

build/options.go

@@ -0,0 +1,17 @@
+package build
+
+// Options struct
+type Options struct {
+	// local path to download source
+	Path string
+}
+
+// Option func
+type Option func(o *Options)
+
+// Path is the Local path for repository
+func Path(p string) Option {
+	return func(o *Options) {
+		o.Path = p
+	}
+}

client/backoff.go

@@ -2,29 +2,14 @@ package client
 
 import (
 	"context"
-	"math"
 	"time"
 
-	"go.unistack.org/micro/v4/util/backoff"
+	"github.com/unistack-org/micro/v3/util/backoff"
 )
 
 // BackoffFunc is the backoff call func
 type BackoffFunc func(ctx context.Context, req Request, attempts int) (time.Duration, error)
 
-// BackoffExp using exponential backoff func
+func exponentialBackoff(ctx context.Context, req Request, attempts int) (time.Duration, error) {
-func BackoffExp(_ context.Context, _ Request, attempts int) (time.Duration, error) {
 	return backoff.Do(attempts), nil
 }
-
-// BackoffInterval specifies randomization interval for backoff func
-func BackoffInterval(min time.Duration, max time.Duration) BackoffFunc {
-	return func(_ context.Context, _ Request, attempts int) (time.Duration, error) {
-		td := time.Duration(math.Pow(float64(attempts), math.E)) * time.Millisecond * 100
-		if td < min {
-			return min, nil
-		} else if td > max {
-			return max, nil
-		}
-		return td, nil
-	}
-}

client/backoff_test.go

@@ -6,7 +6,7 @@ import (
 	"time"
 )
 
-func TestBackoffExp(t *testing.T) {
+func TestBackoff(t *testing.T) {
 	results := []time.Duration{
 		0 * time.Second,
 		100 * time.Millisecond,
@@ -22,7 +22,7 @@ func TestBackoffExp(t *testing.T) {
 	}
 
 	for i := 0; i < 5; i++ {
-		d, err := BackoffExp(context.TODO(), r, i)
+		d, err := exponentialBackoff(context.TODO(), r, i)
 		if err != nil {
 			t.Fatal(err)
 		}
@@ -32,25 +32,3 @@ func TestBackoffExp(t *testing.T) {
 		}
 	}
 }
-
-func TestBackoffInterval(t *testing.T) {
-	min := 100 * time.Millisecond
-	max := 300 * time.Millisecond
-
-	r := &testRequest{
-		service: "test",
-		method:  "test",
-	}
-
-	fn := BackoffInterval(min, max)
-	for i := 0; i < 5; i++ {
-		d, err := fn(context.TODO(), r, i)
-		if err != nil {
-			t.Fatal(err)
-		}
-
-		if d < min || d > max {
-			t.Fatalf("Expected %v < %v < %v", min, d, max)
-		}
-	}
-}

client/client.go

@@ -1,48 +1,39 @@
 // Package client is an interface for an RPC client
-package client // import "go.unistack.org/micro/v4/client"
+package client
 
 import (
 	"context"
 	"time"
 
-	"go.unistack.org/micro/v4/codec"
+	"github.com/unistack-org/micro/v3/codec"
-	"go.unistack.org/micro/v4/options"
 )
 
 var (
 	// DefaultClient is the global default client
-	DefaultClient = NewClient()
+	DefaultClient Client = NewClient()
-	// DefaultContentType is the default content-type if not specified
-	DefaultContentType = ""
-	// DefaultBackoff is the default backoff function for retries (minimum 10 millisecond and maximum 5 second)
-	DefaultBackoff = BackoffInterval(10*time.Millisecond, 5*time.Second)
-	// DefaultRetry is the default check-for-retry function for retries
-	DefaultRetry = RetryNever
-	// DefaultRetries is the default number of times a request is tried
-	DefaultRetries = 0
-	// DefaultRequestTimeout is the default request timeout
-	DefaultRequestTimeout = time.Second * 5
-	// DefaultDialTimeout the default dial timeout
-	DefaultDialTimeout = time.Second * 5
-	// DefaultPoolSize sets the connection pool size
-	DefaultPoolSize = 100
-	// DefaultPoolTTL sets the connection pool ttl
-	DefaultPoolTTL = time.Minute
 )
 
 // Client is the interface used to make requests to services.
 // It supports Request/Response via Transport and Publishing via the Broker.
 // It also supports bidirectional streaming of requests.
 type Client interface {
-	Name() string
+	Init(...Option) error
-	Init(opts ...options.Option) error
 	Options() Options
-	NewRequest(service string, endpoint string, req interface{}, opts ...options.Option) Request
+	NewMessage(topic string, msg interface{}, opts ...MessageOption) Message
-	Call(ctx context.Context, req Request, rsp interface{}, opts ...options.Option) error
+	NewRequest(service, endpoint string, req interface{}, reqOpts ...RequestOption) Request
-	Stream(ctx context.Context, req Request, opts ...options.Option) (Stream, error)
+	Call(ctx context.Context, req Request, rsp interface{}, opts ...CallOption) error
+	Stream(ctx context.Context, req Request, opts ...CallOption) (Stream, error)
+	Publish(ctx context.Context, msg Message, opts ...PublishOption) error
 	String() string
 }
 
+// Message is the interface for publishing asynchronously
+type Message interface {
+	Topic() string
+	Payload() interface{}
+	ContentType() string
+}
+
 // Request is the interface for a synchronous request used by Call or Stream
 type Request interface {
 	// The service to call
@@ -56,25 +47,19 @@ type Request interface {
 	// The unencoded request body
 	Body() interface{}
 	// Write to the encoded request writer. This is nil before a call is made
-	Codec() codec.Codec
+	Codec() codec.Writer
 	// indicates whether the request will be a streaming one rather than unary
 	Stream() bool
-	// Header data
-	// Header() metadata.Metadata
 }
 
 // Response is the response received from a service
 type Response interface {
 	// Read the response
-	Codec() codec.Codec
+	Codec() codec.Reader
-	// The content type
+	// read the header
-	// ContentType() string
+	Header() map[string]string
-	// Header data
-	// Header() metadata.Metadata
 	// Read the undecoded response
 	Read() ([]byte, error)
-	// The unencoded request body
-	// Body() interface{}
 }
 
 // Stream is the interface for a bidirectional synchronous stream
@@ -86,17 +71,41 @@ type Stream interface {
 	// The response read
 	Response() Response
 	// Send will encode and send a request
-	Send(msg interface{}) error
+	Send(interface{}) error
 	// Recv will decode and read a response
-	Recv(msg interface{}) error
+	Recv(interface{}) error
-	// SendMsg will encode and send a request
-	SendMsg(msg interface{}) error
-	// RecvMsg will decode and read a response
-	RecvMsg(msg interface{}) error
 	// Error returns the stream error
 	Error() error
 	// Close closes the stream
 	Close() error
-	// CloseSend closes the send direction of the stream
-	CloseSend() error
 }
+
+// Option used by the Client
+type Option func(*Options)
+
+// CallOption used by Call or Stream
+type CallOption func(*CallOptions)
+
+// PublishOption used by Publish
+type PublishOption func(*PublishOptions)
+
+// MessageOption used by NewMessage
+type MessageOption func(*MessageOptions)
+
+// RequestOption used by NewRequest
+type RequestOption func(*RequestOptions)
+
+var (
+	// DefaultBackoff is the default backoff function for retries
+	DefaultBackoff = exponentialBackoff
+	// DefaultRetry is the default check-for-retry function for retries
+	DefaultRetry = RetryOnError
+	// DefaultRetries is the default number of times a request is tried
+	DefaultRetries = 1
+	// DefaultRequestTimeout is the default request timeout
+	DefaultRequestTimeout = time.Second * 5
+	// DefaultPoolSize sets the connection pool size
+	DefaultPoolSize = 100
+	// DefaultPoolTTL sets the connection pool ttl
+	DefaultPoolTTL = time.Minute
+)

client/client_call_options.go

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

client/client_call_options_test.go

@@ -1,28 +0,0 @@
-package client
-
-import (
-	"context"
-	"testing"
-	"time"
-
-	"go.unistack.org/micro/v4/options"
-)
-
-func TestNewClientCallOptions(t *testing.T) {
-	var flag bool
-	w := func(fn CallFunc) CallFunc {
-		flag = true
-		return fn
-	}
-	c := NewClientCallOptions(NewClient(),
-		options.Address("127.0.0.1"),
-		WithCallWrapper(w),
-		RequestTimeout(1*time.Millisecond),
-		Retries(0),
-		Backoff(BackoffInterval(10*time.Millisecond, 100*time.Millisecond)),
-	)
-	_ = c.Call(context.TODO(), c.NewRequest("service", "endpoint", nil), nil)
-	if !flag {
-		t.Fatalf("NewClientCallOptions not works")
-	}
-}

client/context.go

@@ -6,19 +6,21 @@ import (
 
 type clientKey struct{}
 
-// FromContext get client from context
 func FromContext(ctx context.Context) (Client, bool) {
-	if ctx == nil {
-		return nil, false
-	}
 	c, ok := ctx.Value(clientKey{}).(Client)
 	return c, ok
 }
 
-// NewContext put client in context
 func NewContext(ctx context.Context, c Client) context.Context {
-	if ctx == nil {
-		ctx = context.Background()
-	}
 	return context.WithValue(ctx, clientKey{}, c)
 }
+
+// SetPublishOption returns a function to setup a context with given value
+func SetPublishOption(k, v interface{}) PublishOption {
+	return func(o *PublishOptions) {
+		if o.Context == nil {
+			o.Context = context.Background()
+		}
+		o.Context = context.WithValue(o.Context, k, v)
+	}
+}

client/context_test.go

@@ -1,40 +0,0 @@
-package client
-
-import (
-	"context"
-	"testing"
-)
-
-func TestFromContext(t *testing.T) {
-	ctx := context.WithValue(context.TODO(), clientKey{}, NewClient())
-
-	c, ok := FromContext(ctx)
-	if c == nil || !ok {
-		t.Fatal("FromContext not works")
-	}
-}
-
-func TestFromNilContext(t *testing.T) {
-	// nolint: staticcheck
-	c, ok := FromContext(nil)
-	if ok || c != nil {
-		t.Fatal("FromContext not works")
-	}
-}
-
-func TestNewContext(t *testing.T) {
-	ctx := NewContext(context.TODO(), NewClient())
-	c, ok := FromContext(ctx)
-	if c == nil || !ok {
-		t.Fatal("NewContext not works")
-	}
-}
-
-func TestNewNilContext(t *testing.T) {
-	// nolint: staticcheck
-	ctx := NewContext(nil, NewClient())
-	c, ok := FromContext(ctx)
-	if c == nil || !ok {
-		t.Fatal("NewContext not works")
-	}
-}

client/lookup.go

@@ -4,24 +4,20 @@ import (
 	"context"
 	"sort"
 
-	"go.unistack.org/micro/v4/errors"
+	"github.com/unistack-org/micro/v3/errors"
-	"go.unistack.org/micro/v4/router"
+	"github.com/unistack-org/micro/v3/router"
 )
 
 // LookupFunc is used to lookup routes for a service
 type LookupFunc func(context.Context, Request, CallOptions) ([]string, error)
 
 // LookupRoute for a request using the router and then choose one using the selector
-func LookupRoute(_ context.Context, req Request, opts CallOptions) ([]string, error) {
+func LookupRoute(ctx context.Context, req Request, opts CallOptions) ([]string, error) {
 	// check to see if an address was provided as a call option
 	if len(opts.Address) > 0 {
 		return opts.Address, nil
 	}
 
-	if opts.Router == nil {
-		return nil, router.ErrRouteNotFound
-	}
-
 	// construct the router query
 	query := []router.QueryOption{router.QueryService(req.Service())}
 

client/noop.go

@@ -2,48 +2,38 @@ package client
 
 import (
 	"context"
-	"fmt"
-	"time"
 
-	"go.unistack.org/micro/v4/codec"
+	raw "github.com/unistack-org/micro-codec-bytes"
-	"go.unistack.org/micro/v4/errors"
+	json "github.com/unistack-org/micro-codec-json"
-	"go.unistack.org/micro/v4/metadata"
+	"github.com/unistack-org/micro/v3/broker"
-	"go.unistack.org/micro/v4/options"
+	"github.com/unistack-org/micro/v3/codec"
-	"go.unistack.org/micro/v4/selector"
+	"github.com/unistack-org/micro/v3/errors"
-	"go.unistack.org/micro/v4/semconv"
+	"github.com/unistack-org/micro/v3/metadata"
 )
 
-// DefaultCodecs will be used to encode/decode data
-var DefaultCodecs = map[string]codec.Codec{
-	"application/octet-stream": codec.NewCodec(),
-}
-
 type noopClient struct {
 	opts Options
 }
 
+type noopMessage struct {
+	topic   string
+	payload interface{}
+	opts    MessageOptions
+}
+
 type noopRequest struct {
-	body        interface{}
-	codec       codec.Codec
 	service     string
 	method      string
 	endpoint    string
 	contentType string
+	body        interface{}
+	codec       codec.Writer
 	stream      bool
 }
 
 // NewClient returns new noop client
-func NewClient(opts ...options.Option) Client {
+func NewClient(opts ...Option) Client {
-	nc := &noopClient{opts: NewOptions(opts...)}
+	return &noopClient{opts: NewOptions(opts...)}
-	// wrap in reverse
-
-	c := Client(nc)
-
-	return c
-}
-
-func (n *noopClient) Name() string {
-	return n.opts.Name
 }
 
 func (n *noopRequest) Service() string {
@@ -66,7 +56,7 @@ func (n *noopRequest) Body() interface{} {
 	return n.body
 }
 
-func (n *noopRequest) Codec() codec.Codec {
+func (n *noopRequest) Codec() codec.Writer {
 	return n.codec
 }
 
@@ -75,15 +65,15 @@ func (n *noopRequest) Stream() bool {
 }
 
 type noopResponse struct {
-	codec  codec.Codec
+	codec  codec.Reader
-	header metadata.Metadata
+	header map[string]string
 }
 
-func (n *noopResponse) Codec() codec.Codec {
+func (n *noopResponse) Codec() codec.Reader {
 	return n.codec
 }
 
-func (n *noopResponse) Header() metadata.Metadata {
+func (n *noopResponse) Header() map[string]string {
 	return n.header
 }
 
@@ -113,14 +103,6 @@ func (n *noopStream) Recv(interface{}) error {
 	return nil
 }
 
-func (n *noopStream) SendMsg(interface{}) error {
-	return nil
-}
-
-func (n *noopStream) RecvMsg(interface{}) error {
-	return nil
-}
-
 func (n *noopStream) Error() error {
 	return nil
 }
@@ -129,21 +111,19 @@ func (n *noopStream) Close() error {
 	return nil
 }
 
-func (n *noopStream) CloseSend() error {
+func (n *noopMessage) Topic() string {
-	return nil
+	return n.topic
 }
 
-func (n *noopClient) newCodec(contentType string) (codec.Codec, error) {
+func (n *noopMessage) Payload() interface{} {
-	if cf, ok := n.opts.Codecs[contentType]; ok {
+	return n.payload
-		return cf, nil
-	}
-	if cf, ok := DefaultCodecs[contentType]; ok {
-		return cf, nil
-	}
-	return nil, codec.ErrUnknownContentType
 }
 
-func (n *noopClient) Init(opts ...options.Option) error {
+func (n *noopMessage) ContentType() string {
+	return n.opts.ContentType
+}
+
+func (n *noopClient) Init(opts ...Option) error {
 	for _, o := range opts {
 		o(&n.opts)
 	}
@@ -158,307 +138,68 @@ func (n *noopClient) String() string {
 	return "noop"
 }
 
-func (n *noopClient) Call(ctx context.Context, req Request, rsp interface{}, opts ...options.Option) error {
+func (n *noopClient) Call(ctx context.Context, req Request, rsp interface{}, opts ...CallOption) error {
-	// make a copy of call opts
-	callOpts := n.opts.CallOptions
-	for _, opt := range opts {
-		opt(&callOpts)
-	}
-
-	// check if we already have a deadline
-	d, ok := ctx.Deadline()
-	if !ok {
-		var cancel context.CancelFunc
-		// no deadline so we create a new one
-		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 := RequestTimeout(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
-	hcall := n.call
-
-	// wrap the call in reverse
-	for i := len(callOpts.CallWrappers); i > 0; i-- {
-		hcall = callOpts.CallWrappers[i-1](hcall)
-	}
-
-	// use the router passed as a call option, or fallback to the rpc clients router
-	if callOpts.Router == nil {
-		callOpts.Router = n.opts.Router
-	}
-
-	if callOpts.Selector == nil {
-		callOpts.Selector = n.opts.Selector
-	}
-
-	// inject proxy address
-	// TODO: don't even bother using Lookup/Select in this case
-	if len(n.opts.Proxy) > 0 {
-		callOpts.Address = []string{n.opts.Proxy}
-	}
-
-	var next selector.Next
-
-	// 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)
-		}
-
-		if next == nil {
-			var routes []string
-			// lookup the route to send the reques to
-			// TODO apply any filtering here
-			routes, err = n.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
-			}
-		}
-
-		node := next()
-
-		// make the call
-		err = hcall(ctx, node, req, rsp, callOpts)
-		// record the result of the call to inform future routing decisions
-		if verr := n.opts.Selector.Record(node, err); verr != nil {
-			return verr
-		}
-
-		// 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)
-	var gerr error
-
-	ts := time.Now()
-	endpoint := fmt.Sprintf("%s.%s", req.Service(), req.Endpoint())
-	n.opts.Meter.Counter(semconv.ClientRequestInflight, "endpoint", endpoint).Inc()
-	for i := 0; i <= callOpts.Retries; i++ {
-		go func() {
-			ch <- call(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
-		}
-	}
-
-	if gerr != nil {
-		n.opts.Meter.Counter(semconv.ClientRequestTotal, "endpoint", endpoint, "status", "failure").Inc()
-	} else {
-		n.opts.Meter.Counter(semconv.ClientRequestTotal, "endpoint", endpoint, "status", "success").Inc()
-	}
-	n.opts.Meter.Counter(semconv.ClientRequestInflight, "endpoint", endpoint).Dec()
-	te := time.Since(ts)
-	n.opts.Meter.Summary(semconv.ClientRequestLatencyMicroseconds, "endpoint", endpoint).Update(te.Seconds())
-	n.opts.Meter.Histogram(semconv.ClientRequestDurationSeconds, "endpoint", endpoint).Update(te.Seconds())
-
-	return gerr
-}
-
-func (n *noopClient) call(ctx context.Context, addr string, req Request, rsp interface{}, opts CallOptions) error {
 	return nil
 }
 
-func (n *noopClient) NewRequest(service, endpoint string, req interface{}, opts ...options.Option) Request {
+func (n *noopClient) NewRequest(service, endpoint string, req interface{}, opts ...RequestOption) Request {
-	return &noopRequest{service: service, endpoint: endpoint}
+	return &noopRequest{}
 }
 
-func (n *noopClient) Stream(ctx context.Context, req Request, opts ...options.Option) (Stream, error) {
+func (n *noopClient) NewMessage(topic string, msg interface{}, opts ...MessageOption) Message {
-	var err error
+	options := NewMessageOptions(opts...)
-
+	return &noopMessage{topic: topic, payload: msg, opts: options}
-	// make a copy of call opts
-	callOpts := n.opts.CallOptions
-	for _, o := range opts {
-		o(&callOpts)
-	}
-
-	// check if we already have a deadline
-	d, ok := ctx.Deadline()
-	if !ok && callOpts.StreamTimeout > time.Duration(0) {
-		var cancel context.CancelFunc
-		// no deadline so we create a new one
-		ctx, cancel = context.WithTimeout(ctx, callOpts.StreamTimeout)
-		defer cancel()
-	} else {
-		// got a deadline so no need to setup context
-		// but we need to set the timeout we pass along
-		o := StreamTimeout(time.Until(d))
-		o(&callOpts)
-	}
-
-	// should we noop right here?
-	select {
-	case <-ctx.Done():
-		return nil, errors.New("go.micro.client", fmt.Sprintf("%v", ctx.Err()), 408)
-	default:
-	}
-
-	/*
-		// make copy of call method
-		hstream := h.stream
-		// wrap the call in reverse
-		for i := len(callOpts.CallWrappers); i > 0; i-- {
-			hstream = callOpts.CallWrappers[i-1](hstream)
-		}
-	*/
-
-	// use the router passed as a call option, or fallback to the rpc clients router
-	if callOpts.Router == nil {
-		callOpts.Router = n.opts.Router
-	}
-
-	if callOpts.Selector == nil {
-		callOpts.Selector = n.opts.Selector
-	}
-
-	// inject proxy address
-	// TODO: don't even bother using Lookup/Select in this case
-	if len(n.opts.Proxy) > 0 {
-		callOpts.Address = []string{n.opts.Proxy}
-	}
-
-	var next selector.Next
-
-	call := func(i int) (Stream, error) {
-		// call backoff first. Someone may want an initial start delay
-		t, cerr := callOpts.Backoff(ctx, req, i)
-		if cerr != nil {
-			return nil, errors.InternalServerError("go.micro.client", cerr.Error())
-		}
-
-		// only sleep if greater than 0
-		if t.Seconds() > 0 {
-			time.Sleep(t)
-		}
-
-		if next == nil {
-			var routes []string
-			// lookup the route to send the reques to
-			// TODO apply any filtering here
-			routes, err = n.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
-			}
-		}
-
-		node := next()
-
-		// ts := time.Now()
-		endpoint := fmt.Sprintf("%s.%s", req.Service(), req.Endpoint())
-		n.opts.Meter.Counter(semconv.ClientRequestInflight, "endpoint", endpoint).Inc()
-		stream, cerr := n.stream(ctx, node, req, callOpts)
-		if cerr != nil {
-			n.opts.Meter.Counter(semconv.ClientRequestTotal, "endpoint", endpoint, "status", "failure").Inc()
-		} else {
-			n.opts.Meter.Counter(semconv.ClientRequestTotal, "endpoint", endpoint, "status", "success").Inc()
-		}
-
-		// record the result of the call to inform future routing decisions
-		if verr := n.opts.Selector.Record(node, cerr); verr != nil {
-			return nil, verr
-		}
-
-		// try and transform the error to a go-micro error
-		if verr, ok := cerr.(*errors.Error); ok {
-			return nil, verr
-		}
-
-		return stream, cerr
-	}
-
-	type response struct {
-		stream Stream
-		err    error
-	}
-
-	ch := make(chan response, callOpts.Retries)
-	var grr error
-
-	for i := 0; i <= callOpts.Retries; i++ {
-		go func() {
-			s, cerr := call(i)
-			ch <- response{s, cerr}
-		}()
-
-		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, err)
-			if rerr != nil {
-				return nil, rerr
-			}
-
-			if !retry {
-				return nil, rsp.err
-			}
-
-			grr = rsp.err
-		}
-	}
-
-	return nil, grr
 }
 
-func (n *noopClient) stream(ctx context.Context, addr string, req Request, opts CallOptions) (*noopStream, error) {
+func (n *noopClient) Stream(ctx context.Context, req Request, opts ...CallOption) (Stream, error) {
 	return &noopStream{}, nil
 }
+
+func (n *noopClient) Publish(ctx context.Context, p Message, opts ...PublishOption) error {
+	var body []byte
+
+	options := NewPublishOptions(opts...)
+
+	md, ok := metadata.FromContext(ctx)
+	if !ok {
+		md = metadata.New(0)
+	}
+	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 {
+		cf := n.opts.Broker.Options().Codec
+		if cf == nil {
+			cf = json.Marshaler{}
+		}
+
+		/*
+			// use codec for payload
+			cf, err := n.opts.Codecs[p.ContentType()]
+			if err != nil {
+				return errors.InternalServerError("go.micro.client", err.Error())
+			}
+		*/
+		// set the body
+		b, err := cf.Marshal(p.Payload())
+		if err != nil {
+			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 n.opts.Broker.Publish(ctx, topic, &broker.Message{
+		Header: md,
+		Body:   body,
+	}, broker.PublishContext(options.Context))
+}

client/options.go

@@ -2,61 +2,50 @@ package client
 
 import (
 	"context"
-	"crypto/tls"
-	"net"
 	"time"
 
-	"go.unistack.org/micro/v4/codec"
+	"github.com/unistack-org/micro/v3/broker"
-	"go.unistack.org/micro/v4/logger"
+	"github.com/unistack-org/micro/v3/codec"
-	"go.unistack.org/micro/v4/metadata"
+	"github.com/unistack-org/micro/v3/logger"
-	"go.unistack.org/micro/v4/meter"
+	"github.com/unistack-org/micro/v3/network/transport"
-	"go.unistack.org/micro/v4/options"
+	"github.com/unistack-org/micro/v3/registry"
-	"go.unistack.org/micro/v4/router"
+	"github.com/unistack-org/micro/v3/router"
-	"go.unistack.org/micro/v4/selector"
+	"github.com/unistack-org/micro/v3/selector"
-	"go.unistack.org/micro/v4/selector/random"
+	"github.com/unistack-org/micro/v3/selector/random"
-	"go.unistack.org/micro/v4/tracer"
 )
 
-// Options holds client options
 type Options struct {
-	// Selector used to select needed address
+	// Used to select codec
-	Selector selector.Selector
-	// Logger used to log messages
-	Logger logger.Logger
-	// Tracer used for tracing
-	Tracer tracer.Tracer
-	// Meter used for metrics
-	Meter meter.Meter
-	// Context is used for external options
-	Context context.Context
-	// Router used to get route
-	Router router.Router
-	// TLSConfig specifies tls.Config for secure connection
-	TLSConfig *tls.Config
-	// Codecs map
-	Codecs map[string]codec.Codec
-	// Lookup func used to get destination addr
-	Lookup LookupFunc
-	// Proxy is used for proxy requests
-	Proxy string
-	// ContentType is used to select codec
 	ContentType string
-	// Name is the client name
+	// Proxy address to send requests via
-	Name string
+	Proxy string
-	// CallOptions contains default CallOptions
+
-	CallOptions CallOptions
+	// Plugged interfaces
-	// PoolSize connection pool size
+	Broker    broker.Broker
+	Codecs    map[string]codec.NewCodec
+	Router    router.Router
+	Selector  selector.Selector
+	Transport transport.Transport
+	Logger    logger.Logger
+	// Lookup used for looking up routes
+	Lookup LookupFunc
+
+	// Connection Pool
 	PoolSize int
-	// PoolTTL connection pool ttl
+	PoolTTL  time.Duration
-	PoolTTL time.Duration
+
-	// ContextDialer used to connect
+	// Middleware for client
-	ContextDialer func(context.Context, string) (net.Conn, error)
+	Wrappers []Wrapper
-	// Hooks may contains Client func wrapper
+
-	Hooks options.Hooks
+	// Default Call Options
+	CallOptions CallOptions
+
+	// Other options for implementations of the interface
+	// can be stored in a context
+	Context context.Context
 }
 
-// NewCallOptions creates new call options struct
+func NewCallOptions(opts ...CallOption) CallOptions {
-func NewCallOptions(opts ...options.Option) CallOptions {
 	options := CallOptions{}
 	for _, o := range opts {
 		o(&options)
@@ -64,55 +53,75 @@ func NewCallOptions(opts ...options.Option) CallOptions {
 	return options
 }
 
-// CallOptions holds client call options
 type CallOptions struct {
-	// Selector selects addr
+	// Address of remote hosts
-	Selector selector.Selector
-	// Context used for deadline
-	Context context.Context
-	// Router used for route
-	Router router.Router
-	// Retry func used for retries
-	Retry RetryFunc
-	// Backoff func used for backoff when retry
-	Backoff BackoffFunc
-	// Network name
-	Network string
-	// Content-Type
-	ContentType string
-	// AuthToken string
-	AuthToken string
-	// Address specifies static addr list
 	Address []string
-	// SelectOptions selector options
+	// Backoff func
-	SelectOptions []selector.SelectOption
+	Backoff BackoffFunc
-	// CallWrappers call wrappers
+	// Transport Dial Timeout
-	CallWrappers []CallWrapper
-	// StreamTimeout stream timeout
-	StreamTimeout time.Duration
-	// RequestTimeout request timeout
-	RequestTimeout time.Duration
-	// RequestMetadata holds additional metadata for call
-	RequestMetadata metadata.Metadata
-	// ResponseMetadata holds additional metadata from call
-	ResponseMetadata *metadata.Metadata
-	// DialTimeout dial timeout
 	DialTimeout time.Duration
-	// Retries specifies retries num
+	// Number of Call attempts
 	Retries int
-	// ContextDialer used to connect
+	// Check if retriable func
-	ContextDialer func(context.Context, string) (net.Conn, error)
+	Retry RetryFunc
+	// Request/Response timeout
+	RequestTimeout time.Duration
+	// Router to use for this call
+	Router router.Router
+	// Selector to use for the call
+	Selector selector.Selector
+	// SelectOptions to use when selecting a route
+	SelectOptions []selector.SelectOption
+	// Stream timeout for the stream
+	StreamTimeout time.Duration
+	// Use the auth token as the authorization header
+	AuthToken bool
+	// Network to lookup the route within
+	Network string
+
+	// Middleware for low level call func
+	CallWrappers []CallWrapper
+
+	// Other options for implementations of the interface
+	// can be stored in a context
+	Context context.Context
 }
 
-// ContextDialer pass ContextDialer to client
+func Context(ctx context.Context) Option {
-func ContextDialer(fn func(context.Context, string) (net.Conn, error)) options.Option {
+	return func(o *Options) {
-	return func(src interface{}) error {
+		o.Context = ctx
-		return options.Set(src, fn, ".ContextDialer")
 	}
 }
 
-// NewRequestOptions creates new RequestOptions struct
+func NewPublishOptions(opts ...PublishOption) PublishOptions {
-func NewRequestOptions(opts ...options.Option) RequestOptions {
+	options := PublishOptions{}
+	for _, o := range opts {
+		o(&options)
+	}
+	return options
+}
+
+type PublishOptions struct {
+	// Exchange is the routing exchange for the message
+	Exchange string
+	// Other options for implementations of the interface
+	// can be stored in a context
+	Context context.Context
+}
+
+func NewMessageOptions(opts ...MessageOption) MessageOptions {
+	options := MessageOptions{}
+	for _, o := range opts {
+		o(&options)
+	}
+	return options
+}
+
+type MessageOptions struct {
+	ContentType string
+}
+
+func NewRequestOptions(opts ...RequestOption) RequestOptions {
 	options := RequestOptions{}
 	for _, o := range opts {
 		o(&options)
@@ -120,38 +129,33 @@ func NewRequestOptions(opts ...options.Option) RequestOptions {
 	return options
 }
 
-// RequestOptions holds client request options
 type RequestOptions struct {
-	// Context used for external options
-	Context context.Context
-	// ContentType specify content-type of message
 	ContentType string
-	// Stream flag
+	Stream      bool
-	Stream bool
+
+	// Other options for implementations of the interface
+	// can be stored in a context
+	Context context.Context
 }
 
-// NewOptions creates new options struct
+func NewOptions(opts ...Option) Options {
-func NewOptions(opts ...options.Option) Options {
 	options := Options{
 		Context:     context.Background(),
-		ContentType: DefaultContentType,
+		ContentType: "application/protobuf",
-		Codecs:      make(map[string]codec.Codec),
+		Codecs:      make(map[string]codec.NewCodec),
 		CallOptions: CallOptions{
-			Context:        context.Background(),
 			Backoff:        DefaultBackoff,
 			Retry:          DefaultRetry,
 			Retries:        DefaultRetries,
 			RequestTimeout: DefaultRequestTimeout,
-			DialTimeout:    DefaultDialTimeout,
+			DialTimeout:    transport.DefaultDialTimeout,
 		},
 		Lookup:   LookupRoute,
 		PoolSize: DefaultPoolSize,
 		PoolTTL:  DefaultPoolTTL,
 		Selector: random.NewSelector(),
 		Logger:   logger.DefaultLogger,
-		Meter:    meter.DefaultMeter,
+		Broker:   broker.DefaultBroker,
-		Tracer:   tracer.DefaultTracer,
-		Router:   router.DefaultRouter,
 	}
 
 	for _, o := range opts {
@@ -161,131 +165,279 @@ func NewOptions(opts ...options.Option) Options {
 	return options
 }
 
+// Broker to be used for pub/sub
+func Broker(b broker.Broker) Option {
+	return func(o *Options) {
+		o.Broker = b
+	}
+}
+
+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) {
+		o.Codecs[contentType] = c
+	}
+}
+
+// Default content type of the client
+func ContentType(ct string) Option {
+	return func(o *Options) {
+		o.ContentType = ct
+	}
+}
+
 // Proxy sets the proxy address
-func Proxy(addr string) options.Option {
+func Proxy(addr string) Option {
-	return func(src interface{}) error {
+	return func(o *Options) {
-		return options.Set(src, addr, ".Proxy")
+		o.Proxy = addr
 	}
 }
 
 // PoolSize sets the connection pool size
-func PoolSize(d int) options.Option {
+func PoolSize(d int) Option {
-	return func(src interface{}) error {
+	return func(o *Options) {
-		return options.Set(src, d, ".PoolSize")
+		o.PoolSize = d
 	}
 }
 
 // PoolTTL sets the connection pool ttl
-func PoolTTL(td time.Duration) options.Option {
+func PoolTTL(d time.Duration) Option {
-	return func(src interface{}) error {
+	return func(o *Options) {
-		return options.Set(src, td, ".PoolTTL")
+		o.PoolTTL = d
+	}
+}
+
+// Transport to use for communication e.g http, rabbitmq, etc
+func Transport(t transport.Transport) Option {
+	return func(o *Options) {
+		o.Transport = t
+	}
+}
+
+// Registry sets the routers registry
+func Registry(r registry.Registry) Option {
+	return func(o *Options) {
+		if o.Router != nil {
+			o.Router.Init(router.Registry(r))
+		}
+	}
+}
+
+// Router is used to lookup routes for a service
+func Router(r router.Router) Option {
+	return func(o *Options) {
+		o.Router = r
 	}
 }
 
 // Selector is used to select a route
-func Selector(s selector.Selector) options.Option {
+func Selector(s selector.Selector) Option {
-	return func(src interface{}) error {
+	return func(o *Options) {
-		return options.Set(src, s, ".Selector")
+		o.Selector = s
 	}
 }
 
-// Backoff is used to set the backoff function used when retrying Calls
+// Adds a Wrapper to a list of options passed into the client
-func Backoff(fn BackoffFunc) options.Option {
+func Wrap(w Wrapper) Option {
-	return func(src interface{}) error {
+	return func(o *Options) {
-		return options.Set(src, fn, ".Backoff")
+		o.Wrappers = append(o.Wrappers, w)
+	}
+}
+
+// Adds a Wrapper to the list of CallFunc wrappers
+func WrapCall(cw ...CallWrapper) Option {
+	return func(o *Options) {
+		o.CallOptions.CallWrappers = append(o.CallOptions.CallWrappers, cw...)
+	}
+}
+
+// Backoff is used to set the backoff function used
+// when retrying Calls
+func Backoff(fn BackoffFunc) Option {
+	return func(o *Options) {
+		o.CallOptions.Backoff = fn
 	}
 }
 
 // Lookup sets the lookup function to use for resolving service names
-func Lookup(fn LookupFunc) options.Option {
+func Lookup(l LookupFunc) Option {
-	return func(src interface{}) error {
+	return func(o *Options) {
-		return options.Set(src, fn, ".Lookup")
+		o.Lookup = l
 	}
 }
 
-// WithCallWrapper sets the retry function to be used when re-trying.
+// Number of retries when making the request.
-func WithCallWrapper(fn CallWrapper) options.Option {
+// Should this be a Call Option?
-	return func(src interface{}) error {
+func Retries(i int) Option {
-		return options.Set(src, fn, ".CallWrappers")
+	return func(o *Options) {
-	}
+		o.CallOptions.Retries = i
-}
-
-// Retries sets the retry count when making the request.
-func Retries(n int) options.Option {
-	return func(src interface{}) error {
-		return options.Set(src, n, ".Retries")
 	}
 }
 
 // Retry sets the retry function to be used when re-trying.
-func Retry(fn RetryFunc) options.Option {
+func Retry(fn RetryFunc) Option {
-	return func(src interface{}) error {
+	return func(o *Options) {
-		return options.Set(src, fn, ".Retry")
+		o.CallOptions.Retry = fn
 	}
 }
 
-// RequestTimeout is the request timeout.
+// The request timeout.
-func RequestTimeout(td time.Duration) options.Option {
+// Should this be a Call Option?
-	return func(src interface{}) error {
+func RequestTimeout(d time.Duration) Option {
-		return options.Set(src, td, ".RequestTimeout")
+	return func(o *Options) {
+		o.CallOptions.RequestTimeout = d
 	}
 }
 
 // StreamTimeout sets the stream timeout
-func StreamTimeout(td time.Duration) options.Option {
+func StreamTimeout(d time.Duration) Option {
-	return func(src interface{}) error {
+	return func(o *Options) {
-		return options.Set(src, td, ".StreamTimeout")
+		o.CallOptions.StreamTimeout = d
 	}
 }
 
-// DialTimeout sets the dial timeout
+// Transport dial timeout
-func DialTimeout(td time.Duration) options.Option {
+func DialTimeout(d time.Duration) Option {
-	return func(src interface{}) error {
+	return func(o *Options) {
-		return options.Set(src, td, ".DialTimeout")
+		o.CallOptions.DialTimeout = d
 	}
 }
 
-// WithResponseMetadata is a CallOption which adds metadata.Metadata to Options.CallOptions
+// Call Options
-func ResponseMetadata(md *metadata.Metadata) options.Option {
+
-	return func(src interface{}) error {
+// WithExchange sets the exchange to route a message through
-		return options.Set(src, md, ".ResponseMetadata")
+func WithExchange(e string) PublishOption {
+	return func(o *PublishOptions) {
+		o.Exchange = e
 	}
 }
 
-// WithRequestMetadata is a CallOption which adds metadata.Metadata to Options.CallOptions
+// PublishContext sets the context in publish options
-func RequestMetadata(md metadata.Metadata) options.Option {
+func PublishContext(ctx context.Context) PublishOption {
-	return func(src interface{}) error {
+	return func(o *PublishOptions) {
-		return options.Set(src, metadata.Copy(md), ".RequestMetadata")
+		o.Context = ctx
 	}
 }
 
-// AuthToken is a CallOption which overrides the
+// WithAddress sets the remote addresses to use rather than using service discovery
+func WithAddress(a ...string) CallOption {
+	return func(o *CallOptions) {
+		o.Address = a
+	}
+}
+
+// WithCallWrapper is a CallOption which adds to the existing CallFunc wrappers
+func WithCallWrapper(cw ...CallWrapper) CallOption {
+	return func(o *CallOptions) {
+		o.CallWrappers = append(o.CallWrappers, cw...)
+	}
+}
+
+// WithBackoff is a CallOption which overrides that which
+// set in Options.CallOptions
+func WithBackoff(fn BackoffFunc) CallOption {
+	return func(o *CallOptions) {
+		o.Backoff = fn
+	}
+}
+
+// WithRetry is a CallOption which overrides that which
+// set in Options.CallOptions
+func WithRetry(fn RetryFunc) CallOption {
+	return func(o *CallOptions) {
+		o.Retry = fn
+	}
+}
+
+// WithRetries is a CallOption which overrides that which
+// set in Options.CallOptions
+func WithRetries(i int) CallOption {
+	return func(o *CallOptions) {
+		o.Retries = i
+	}
+}
+
+// WithRequestTimeout is a CallOption which overrides that which
+// set in Options.CallOptions
+func WithRequestTimeout(d time.Duration) CallOption {
+	return func(o *CallOptions) {
+		o.RequestTimeout = d
+	}
+}
+
+// WithStreamTimeout sets the stream timeout
+func WithStreamTimeout(d time.Duration) CallOption {
+	return func(o *CallOptions) {
+		o.StreamTimeout = d
+	}
+}
+
+// WithDialTimeout is a CallOption which overrides that which
+// set in Options.CallOptions
+func WithDialTimeout(d time.Duration) CallOption {
+	return func(o *CallOptions) {
+		o.DialTimeout = d
+	}
+}
+
+// WithAuthToken is a CallOption which overrides the
 // authorization header with the services own auth token
-func AuthToken(t string) options.Option {
+func WithAuthToken() CallOption {
-	return func(src interface{}) error {
+	return func(o *CallOptions) {
-		return options.Set(src, t, ".AuthToken")
+		o.AuthToken = true
 	}
 }
 
-// Network is a CallOption which sets the network attribute
+// WithNetwork is a CallOption which sets the network attribute
-func Network(n string) options.Option {
+func WithNetwork(n string) CallOption {
-	return func(src interface{}) error {
+	return func(o *CallOptions) {
-		return options.Set(src, n, ".Network")
+		o.Network = n
+	}
+}
+
+// WithRouter sets the router to use for this call
+func WithRouter(r router.Router) CallOption {
+	return func(o *CallOptions) {
+		o.Router = r
+	}
+}
+
+// WithSelector sets the selector to use for this call
+func WithSelector(s selector.Selector) CallOption {
+	return func(o *CallOptions) {
+		o.Selector = s
 	}
 }
 
-/*
 // WithSelectOptions sets the options to pass to the selector for this call
-func WithSelectOptions(sops ...selector.SelectOption) options.Option {
+func WithSelectOptions(sops ...selector.SelectOption) CallOption {
 	return func(o *CallOptions) {
 		o.SelectOptions = sops
 	}
 }
-*/
 
-// StreamingRequest specifies that request is streaming
+func WithMessageContentType(ct string) MessageOption {
-func StreamingRequest(b bool) options.Option {
+	return func(o *MessageOptions) {
-	return func(src interface{}) error {
+		o.ContentType = ct
-		return options.Set(src, b, ".Stream")
+	}
+}
+
+// Request Options
+
+func WithContentType(ct string) RequestOption {
+	return func(o *RequestOptions) {
+		o.ContentType = ct
+	}
+}
+
+func StreamingRequest() RequestOption {
+	return func(o *RequestOptions) {
+		o.Stream = true
 	}
 }

client/retry.go

@@ -3,7 +3,7 @@ package client
 import (
 	"context"
 
-	"go.unistack.org/micro/v4/errors"
+	"github.com/unistack-org/micro/v3/errors"
 )
 
 // RetryFunc that returning either false or a non-nil error will result in the call not being retried
@@ -14,37 +14,22 @@ func RetryAlways(ctx context.Context, req Request, retryCount int, err error) (b
 	return true, nil
 }
 
-// RetryNever never retry on error
+// RetryOnError retries a request on a 500 or timeout error
-func RetryNever(ctx context.Context, req Request, retryCount int, err error) (bool, error) {
+func RetryOnError(ctx context.Context, req Request, retryCount int, err error) (bool, error) {
-	return false, nil
-}
-
-// RetryOnError retries a request on a 500 or 408 (timeout) error
-func RetryOnError(_ context.Context, _ Request, _ int, err error) (bool, error) {
 	if err == nil {
 		return false, nil
 	}
-	me := errors.FromError(err)
+
-	switch me.Code {
+	e := errors.Parse(err.Error())
+	if e == nil {
+		return false, nil
+	}
+
+	switch e.Code {
 	// retry on timeout or internal server error
 	case 408, 500:
 		return true, nil
-	}
+	default:
-	return false, nil
-}
-
-// RetryOnErrors retries a request on specified error codes
-func RetryOnErrors(codes ...int32) RetryFunc {
-	return func(_ context.Context, _ Request, _ int, err error) (bool, error) {
-		if err == nil {
-			return false, nil
-		}
-		me := errors.FromError(err)
-		for _, code := range codes {
-			if me.Code == code {
-				return true, nil
-			}
-		}
 		return false, nil
 	}
 }

client/retry_test.go

@@ -1,70 +0,0 @@
-package client
-
-import (
-	"context"
-	"fmt"
-	"testing"
-
-	"go.unistack.org/micro/v4/errors"
-)
-
-func TestRetryAlways(t *testing.T) {
-	tests := []error{
-		nil,
-		errors.InternalServerError("test", "%s", "test"),
-		fmt.Errorf("test"),
-	}
-
-	for _, e := range tests {
-		ok, er := RetryAlways(context.TODO(), nil, 1, e)
-		if !ok || er != nil {
-			t.Fatal("RetryAlways not works properly")
-		}
-	}
-}
-
-func TestRetryNever(t *testing.T) {
-	tests := []error{
-		nil,
-		errors.InternalServerError("test", "%s", "test"),
-		fmt.Errorf("test"),
-	}
-
-	for _, e := range tests {
-		ok, er := RetryNever(context.TODO(), nil, 1, e)
-		if ok || er != nil {
-			t.Fatal("RetryNever not works properly")
-		}
-	}
-}
-
-func TestRetryOnError(t *testing.T) {
-	tests := []error{
-		fmt.Errorf("test"),
-		errors.NotFound("test", "%s", "test"),
-		errors.Timeout("test", "%s", "test"),
-	}
-
-	for i, e := range tests {
-		ok, er := RetryOnError(context.TODO(), nil, 1, e)
-		if i == 2 && (!ok || er != nil) {
-			t.Fatal("RetryOnError not works properly")
-		}
-	}
-}
-
-func TestRetryOnErrors(t *testing.T) {
-	tests := []error{
-		fmt.Errorf("test"),
-		errors.NotFound("test", "%s", "test"),
-		errors.Timeout("test", "%s", "test"),
-	}
-
-	fn := RetryOnErrors(404)
-	for i, e := range tests {
-		ok, er := fn(context.TODO(), nil, 1, e)
-		if i == 1 && (!ok || er != nil) {
-			t.Fatal("RetryOnErrors not works properly")
-		}
-	}
-}

client/test_request.go

@@ -1,16 +1,16 @@
 package client
 
 import (
-	"go.unistack.org/micro/v4/codec"
+	"github.com/unistack-org/micro/v3/codec"
 )
 
 type testRequest struct {
-	codec       codec.Codec
-	body        interface{}
 	service     string
 	method      string
 	endpoint    string
 	contentType string
+	codec       codec.Codec
+	body        interface{}
 	opts        RequestOptions
 }
 
@@ -34,7 +34,7 @@ func (r *testRequest) Body() interface{} {
 	return r.body
 }
 
-func (r *testRequest) Codec() codec.Codec {
+func (r *testRequest) Codec() codec.Writer {
 	return r.codec
 }
 

codec/codec.go

@@ -1,14 +1,11 @@
 // Package codec is an interface for encoding messages
-package codec // import "go.unistack.org/micro/v4/codec"
+package codec
 
 import (
 	"errors"
 	"io"
-
-	"go.unistack.org/micro/v4/metadata"
 )
 
-// Message types
 const (
 	Error MessageType = iota
 	Request
@@ -19,33 +16,42 @@ const (
 var (
 	// ErrInvalidMessage returned when invalid messge passed to codec
 	ErrInvalidMessage = errors.New("invalid message")
-	// ErrUnknownContentType returned when content-type is unknown
-	ErrUnknownContentType = errors.New("unknown content-type")
 )
 
-var (
+// MessageType
-	// DefaultMaxMsgSize specifies how much data codec can handle
-	DefaultMaxMsgSize = 1024 * 1024 * 4 // 4Mb
-	// DefaultCodec is the global default codec
-	DefaultCodec = NewCodec()
-	// DefaultTagName specifies struct tag name to control codec Marshal/Unmarshal
-	DefaultTagName = "codec"
-)
-
-// MessageType specifies message type for codec
 type MessageType int
 
-// Codec encodes/decodes various types of messages used within micro.
+// NewCodec takes in a connection/buffer and returns a new Codec
+type NewCodec func(io.ReadWriteCloser) Codec
+
+// Codec encodes/decodes various types of messages used within go-micro.
 // ReadHeader and ReadBody are called in pairs to read requests/responses
 // from the connection. Close is called when finished with the
 // connection. ReadBody may be called with a nil argument to force the
 // body to be read and discarded.
 type Codec interface {
-	ReadHeader(r io.Reader, m *Message, mt MessageType) error
+	Reader
-	ReadBody(r io.Reader, v interface{}) error
+	Writer
-	Write(w io.Writer, m *Message, v interface{}) error
+	Close() error
-	Marshal(v interface{}, opts ...Option) ([]byte, error)
+	String() string
-	Unmarshal(b []byte, v interface{}, opts ...Option) error
+}
+
+// Reader interface
+type Reader interface {
+	ReadHeader(*Message, MessageType) error
+	ReadBody(interface{}) error
+}
+
+// Writer interface
+type Writer interface {
+	Write(*Message, interface{}) error
+}
+
+// Marshaler is a simple encoding interface used for the broker/transport
+// where headers are not supported by the underlying implementation.
+type Marshaler interface {
+	Marshal(interface{}) ([]byte, error)
+	Unmarshal([]byte, interface{}) error
 	String() string
 }
 
@@ -53,55 +59,14 @@ type Codec interface {
 // the communication, likely followed by the body.
 // In the case of an error, body may be nil.
 type Message struct {
-	Header   metadata.Metadata
+	Id       string
+	Type     MessageType
 	Target   string
 	Method   string
 	Endpoint string
 	Error    string
-	ID       string
+
-	Body     []byte
+	// The values read from the socket
-	Type     MessageType
+	Header map[string]string
-}
+	Body   []byte
-
-// NewMessage creates new codec message
-func NewMessage(t MessageType) *Message {
-	return &Message{Type: t, Header: metadata.New(0)}
-}
-
-// MarshalAppend calls codec.Marshal(v) and returns the data appended to buf.
-// If codec implements MarshalAppend, that is called instead.
-func MarshalAppend(buf []byte, c Codec, v interface{}, opts ...Option) ([]byte, error) {
-	if nc, ok := c.(interface {
-		MarshalAppend([]byte, interface{}, ...Option) ([]byte, error)
-	}); ok {
-		return nc.MarshalAppend(buf, v, opts...)
-	}
-
-	mbuf, err := c.Marshal(v, opts...)
-	if err != nil {
-		return nil, err
-	}
-
-	return append(buf, mbuf...), nil
-}
-
-// RawMessage is a raw encoded JSON value.
-// It implements Marshaler and Unmarshaler and can be used to delay decoding or precompute a encoding.
-type RawMessage []byte
-
-// MarshalJSON returns m as the JSON encoding of m.
-func (m *RawMessage) MarshalJSON() ([]byte, error) {
-	if m == nil {
-		return []byte("null"), nil
-	}
-	return *m, nil
-}
-
-// UnmarshalJSON sets *m to a copy of data.
-func (m *RawMessage) UnmarshalJSON(data []byte) error {
-	if m == nil {
-		return errors.New("RawMessage UnmarshalJSON on nil pointer")
-	}
-	*m = append((*m)[0:0], data...)
-	return nil
 }

codec/context.go

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

codec/context_test.go

@@ -1,35 +0,0 @@
-package codec
-
-import (
-	"context"
-	"testing"
-)
-
-func TestFromContext(t *testing.T) {
-	ctx := context.WithValue(context.TODO(), codecKey{}, NewCodec())
-
-	c, ok := FromContext(ctx)
-	if c == nil || !ok {
-		t.Fatal("FromContext not works")
-	}
-}
-
-func TestNewContext(t *testing.T) {
-	ctx := NewContext(context.TODO(), NewCodec())
-
-	c, ok := FromContext(ctx)
-	if c == nil || !ok {
-		t.Fatal("NewContext not works")
-	}
-}
-
-func TestSetOption(t *testing.T) {
-	type key struct{}
-	o := SetOption(key{}, "test")
-	opts := &Options{}
-	o(opts)
-
-	if v, ok := opts.Context.Value(key{}).(string); !ok || v == "" {
-		t.Fatal("SetOption not works")
-	}
-}

codec/frame.go

@@ -1,45 +0,0 @@
-package codec
-
-// Frame gives us the ability to define raw data to send over the pipes
-type Frame struct {
-	Data []byte
-}
-
-// NewFrame returns new frame with data
-func NewFrame(data []byte) *Frame {
-	return &Frame{Data: data}
-}
-
-// MarshalJSON returns frame data
-func (m *Frame) MarshalJSON() ([]byte, error) {
-	return m.Marshal()
-}
-
-// UnmarshalJSON set frame data
-func (m *Frame) UnmarshalJSON(data []byte) error {
-	return m.Unmarshal(data)
-}
-
-// ProtoMessage noop func
-func (m *Frame) ProtoMessage() {}
-
-// Reset resets frame
-func (m *Frame) Reset() {
-	*m = Frame{}
-}
-
-// String returns frame as string
-func (m *Frame) String() string {
-	return string(m.Data)
-}
-
-// Marshal returns frame data
-func (m *Frame) Marshal() ([]byte, error) {
-	return m.Data, nil
-}
-
-// Unmarshal set frame data
-func (m *Frame) Unmarshal(data []byte) error {
-	m.Data = data
-	return nil
-}