fixed metadata hooks

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

.gitea/ISSUE_TEMPLATE/bug_report.md

@@ -0,0 +1,18 @@
+---
+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

@@ -0,0 +1,17 @@
+---
+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

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

.gitea/autoapprove.yml

@@ -0,0 +1,28 @@
+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/workflows/job_coverage.yml

@@ -0,0 +1,51 @@
+name: coverage
+
+on:
+  push:
+    branches: [ main, v3, v4 ]
+  pull_request:
+    branches: [ main, v3, v4 ]
+  # Allows you to run this workflow manually from the Actions tab
+  workflow_dispatch:
+
+jobs:
+
+  build:
+    runs-on: ubuntu-latest
+    steps:
+    - name: checkout code
+      uses: actions/checkout@v4
+      with:
+        filter: 'blob:none'
+
+    - name: setup go
+      uses: actions/setup-go@v5
+      with:
+        cache-dependency-path: "**/*.sum"
+        go-version: 'stable' 
+
+    - name: test coverage
+      run: |
+        go test -v -cover ./... -covermode=count -coverprofile coverage.out -coverpkg ./...
+        go tool cover -func coverage.out -o coverage.out
+
+    - name: coverage badge
+      uses: tj-actions/coverage-badge-go@v2
+      with:
+        green: 80
+        filename: coverage.out
+
+    - uses: stefanzweifel/git-auto-commit-action@v4
+      name: autocommit
+      with:
+        commit_message: Apply Code Coverage Badge
+        skip_fetch: true
+        skip_checkout: true
+        file_pattern: ./README.md
+
+    - name: push
+      if: steps.auto-commit-action.outputs.changes_detected == 'true'
+      uses: ad-m/github-push-action@master
+      with:
+        github_token: ${{ github.token }}
+        branch: ${{ github.ref }}

.gitea/workflows/job_lint.yml

@@ -0,0 +1,29 @@
+name: lint
+
+on:
+  pull_request:
+    types: [opened, reopened, synchronize]
+    branches:
+    - master
+    - v3
+    - v4
+
+jobs:
+  lint:
+    runs-on: ubuntu-latest
+    steps:
+    - name: checkout code
+      uses: actions/checkout@v4
+      with:
+        filter: 'blob:none'
+    - name: setup go
+      uses: actions/setup-go@v5
+      with:
+        cache-dependency-path: "**/*.sum"
+        go-version: 'stable' 
+    - name: setup deps
+      run: go get -v ./...
+    - name: run lint
+      uses: https://github.com/golangci/golangci-lint-action@v6
+      with:
+        version: 'latest'

.gitea/workflows/job_test.yml

@@ -0,0 +1,34 @@
+name: test
+
+on:
+  pull_request:
+    types: [opened, reopened, synchronize]
+    branches:
+    - master
+    - v3
+    - v4
+  push:
+    branches:
+    - master
+    - v3
+    - v4
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    steps:
+    - name: checkout code
+      uses: actions/checkout@v4
+      with:
+        filter: 'blob:none'
+    - name: setup go
+      uses: actions/setup-go@v5
+      with:
+        cache-dependency-path: "**/*.sum"
+        go-version: 'stable'
+    - name: setup deps
+      run: go get -v ./...
+    - name: run test
+      env:
+        INTEGRATION_TESTS: yes
+      run: go test -mod readonly -v ./...

.gitea/workflows/job_tests.yml

@@ -0,0 +1,53 @@
+name: test
+
+on:
+  pull_request:
+    types: [opened, reopened, synchronize]
+    branches:
+    - master
+    - v3
+    - v4
+  push:
+    branches:
+    - master
+    - v3
+    - v4
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    steps:
+    - name: checkout code
+      uses: actions/checkout@v4
+      with:
+        filter: 'blob:none'
+    - name: checkout tests
+      uses: actions/checkout@v4
+      with:
+        ref: master
+        filter: 'blob:none'
+        repository: unistack-org/micro-tests
+        path: micro-tests
+    - name: setup go
+      uses: actions/setup-go@v5
+      with:
+        cache-dependency-path: "**/*.sum"
+        go-version: 'stable'
+    - name: setup go work
+      env:
+        GOWORK: /workspace/${{ github.repository_owner }}/go.work
+      run: |
+        go work init
+        go work use .
+        go work use micro-tests
+    - name: setup deps
+      env:
+        GOWORK: /workspace/${{ github.repository_owner }}/go.work
+      run: go get -v ./...
+    - name: run tests
+      env:
+        INTEGRATION_TESTS: yes
+        GOWORK: /workspace/${{ github.repository_owner }}/go.work
+      run: |
+        cd micro-tests
+        go test -mod readonly -v ./... || true

.github.old/PULL_REQUEST_TEMPLATE.md

@@ -0,0 +1,9 @@
+## 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

@@ -0,0 +1,26 @@
+# 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

@@ -0,0 +1,24 @@
+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

@@ -0,0 +1,21 @@
+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/build.yml

@@ -3,53 +3,38 @@ on:
  push:
     branches:
     - master
+    - v3
 jobs:
   test:
     name: test
     runs-on: ubuntu-latest
     steps:
     - name: setup
-      uses: actions/setup-go@v1
+      uses: actions/setup-go@v3
       with:
-        go-version: 1.15
+        go-version: 1.17
+    - name: checkout
+      uses: actions/checkout@v3
     - name: cache
-      uses: actions/cache@v2
+      uses: actions/cache@v3
       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
+    - name: deps
       run: go get -v -t -d ./...
-    - name: sdk test
+    - name: 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
+        uses: actions/checkout@v3
       - name: lint
-        uses: golangci/golangci-lint-action@v1
+        uses: golangci/golangci-lint-action@v3.4.0
         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.old/workflows/codecov.yml

@@ -0,0 +1,39 @@
+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

@@ -0,0 +1,78 @@
+# 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

@@ -0,0 +1,27 @@
+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

@@ -0,0 +1,40 @@
+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

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

.github/stale.sh

@@ -1,13 +0,0 @@
-#!/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/pr.yml

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

.golangci.yml

@@ -1,40 +1,5 @@
 run:
+  concurrency: 8
   deadline: 5m
-  modules-download-mode: readonly
-  skip-dirs:
-    - util/mdns.new
-  skip-files:
-    - ".*\\.pb\\.go$"
-    - ".*\\.pb\\.micro\\.go$"
-linters:
-  disable-all: false
-  enable-all: false
-  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
+  issues-exit-code: 1
+  tests: true

README.md

@@ -1,4 +1,9 @@
-# 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
+![Coverage](https://img.shields.io/badge/Coverage-44.3%25-yellow)
+[![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://git.unistack.org/unistack-org/micro/actions/workflows/job_tests.yml/badge.svg?branch=v4)](https://git.unistack.org/unistack-org/micro/actions?query=workflow%3Abuild+branch%3Av4+event%3Apush)
+[![Lint](https://goreportcard.com/badge/go.unistack.org/micro/v4)](https://goreportcard.com/report/go.unistack.org/micro/v4)
 
 Micro is a standard library for microservices.
 
@@ -10,30 +15,20 @@ Micro provides the core requirements for distributed systems development includi
 
 Micro abstracts away the details of distributed systems. Here are the main features.
 
-- **Authentication** - Auth is built in as a first class citizen. Authentication and authorization enable secure 
-zero trust networking by providing every service an identity and certificates. This additionally includes rule 
-based access control.
-
 - **Dynamic Config** - Load and hot reload dynamic config from anywhere. The config interface provides a way to load application 
-level config from any source such as env vars, file, etcd. You can merge the sources and even define fallbacks.
+level config from any source such as env vars, cmdline, file, consul, vault... You can merge the sources and even define fallbacks.
 
 - **Data Storage** - A simple data store interface to read, write and delete records. It includes support for memory, file and 
-CockroachDB by default. State and persistence becomes a core requirement beyond prototyping and Micro looks to build that into the framework.
+s3. State and persistence becomes a core requirement beyond prototyping and Micro looks to build that into the framework.
 
 - **Service Discovery** - Automatic service registration and name resolution. Service discovery is at the core of micro service 
 development. When service A needs to speak to service B it needs the location of that service.
 
-- **Load Balancing** - Client side load balancing built on service discovery. Once we have the addresses of any number of instances 
-of a service we now need a way to decide which node to route to. We use random hashed load balancing to provide even distribution 
-across the services and retry a different node if there's a problem. 
-
 - **Message Encoding** - Dynamic message encoding based on content-type. The client and server will use codecs along with content-type 
 to seamlessly encode and decode Go types for you. Any variety of messages could be encoded and sent from different clients. The client 
 and server handle this by default.
 
-- **Transport** - gRPC or http based request/response with support for bidirectional streaming. We provide an abstraction for synchronous communication. A request made to a service will be automatically resolved, load balanced, dialled and streamed.
-
-- **Async Messaging** - PubSub is built in as a first class citizen for asynchronous communication and event driven architectures.
+- **Async Messaging** - Pub/Sub is built in as a first class citizen for asynchronous communication and event driven architectures.
 Event notifications are a core pattern in micro service development.
 
 - **Synchronization** - Distributed systems are often built in an eventually consistent manner. Support for distributed locking and 
@@ -42,10 +37,6 @@ leadership are built in as a Sync interface. When using an eventually consistent
 - **Pluggable Interfaces** - Micro makes use of Go interfaces for each system abstraction. Because of this these interfaces 
 are pluggable and allows Micro to be runtime agnostic.
 
-## Getting Started
-
-To be created.
-
 ## License
 
 Micro is Apache 2.0 licensed.

SECURITY.md

@@ -0,0 +1,15 @@
+# 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

@@ -1,192 +0,0 @@
-package api
-
-import (
-	"errors"
-	"regexp"
-	"strings"
-
-	"github.com/unistack-org/micro/v3/metadata"
-	"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 metadata.Metadata) *Endpoint {
-	if e == nil {
-		return nil
-	}
-
-	ep := &Endpoint{}
-	ep.Name, _ = e.Get("endpoint")
-	ep.Description, _ = e.Get("description")
-	epmethod, _ := e.Get("method")
-	ep.Method = []string{epmethod}
-	eppath, _ := e.Get("path")
-	ep.Path = []string{eppath}
-	ephost, _ := e.Get("host")
-	ep.Host = []string{ephost}
-	ep.Handler, _ = e.Get("handler")
-
-	return ep
-}
-
-// 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

@@ -1,152 +0,0 @@
-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

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

api/handler/api/util.go

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

api/handler/api/util_test.go

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

api/handler/event/event.go

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

api/handler/handler.go

@@ -1,14 +0,0 @@
-// 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

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

api/handler/http/http_test.go

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

api/handler/options.go

@@ -1,65 +0,0 @@
-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/web/web.go

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

api/internal/proto/message.pb.go

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

api/proto/api.pb.go

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

api/proto/api.pb.micro.go

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

api/proto/api.proto

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

api/resolver/grpc/grpc.go

@@ -1,47 +0,0 @@
-// 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

@@ -1,33 +0,0 @@
-// 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

@@ -1,67 +0,0 @@
-package resolver
-
-import (
-	"context"
-
-	"github.com/unistack-org/micro/v3/registry"
-)
-
-// Options struct
-type Options struct {
-	Handler       string
-	ServicePrefix string
-	Context       context.Context
-}
-
-// 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{
-		Context: context.Background(),
-	}
-	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

@@ -1,40 +0,0 @@
-// 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

@@ -1,34 +0,0 @@
-// 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

@@ -1,87 +0,0 @@
-// 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(r.opts.Context, "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

@@ -1,71 +0,0 @@
-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

@@ -1,75 +0,0 @@
-// 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

@@ -1,67 +0,0 @@
-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/logger"
-	"github.com/unistack-org/micro/v3/registry"
-)
-
-type Options struct {
-	Handler  string
-	Registry registry.Registry
-	Resolver resolver.Resolver
-	Logger   logger.Logger
-	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

@@ -1,28 +0,0 @@
-// 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
-	// Init initialize router
-	Init(...Option) error
-	// Stop the router
-	Close() error
-	// Endpoint returns an api.Service endpoint or an error if it does not exist
-	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)
-	// String represenation of router
-	String() string
-}

api/server/acme/acme.go

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

api/server/acme/autocert/autocert.go

@@ -1,53 +0,0 @@
-// Package autocert is the ACME provider from golang.org/x/crypto/acme/autocert
-// This provider does not take any config.
-package autocert
-
-import (
-	"crypto/tls"
-	"net"
-	"os"
-
-	"github.com/unistack-org/micro/v3/api/server"
-	"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 {
-	opts server.Options
-}
-
-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(a.opts.Context, "warning: autocert not using a cache: %v", err)
-		}
-	} else {
-		m.Cache = autocert.DirCache(dir)
-	}
-	return m.TLSConfig(), nil
-}
-
-// New returns an autocert acme.Provider
-func NewProvider() acme.Provider {
-	return &autocertProvider{}
-}

api/server/acme/autocert/autocert_test.go

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

api/server/acme/autocert/cache.go

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

api/server/acme/certmagic/certmagic.go

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

api/server/acme/certmagic/storage.go

@@ -1,138 +0,0 @@
-package certmagic
-
-import (
-	"bytes"
-	"encoding/gob"
-	"errors"
-	"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
-	}
-	return s.store.Write(s.store.Options().Context, key, buf.Bytes())
-}
-
-func (s *storage) Load(key string) ([]byte, error) {
-	if !s.Exists(key) {
-		return nil, certmagic.ErrNotExist(errors.New(key + " doesn't exist"))
-	}
-	var val []byte
-	err := s.store.Read(s.store.Options().Context, key, val)
-	if err != nil {
-		return nil, err
-	}
-	b := bytes.NewBuffer(val)
-	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, nil); 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) {
-	var val []byte
-	err := s.store.Read(s.store.Options().Context, key, val)
-	if err != nil {
-		return certmagic.KeyInfo{}, err
-	}
-	b := bytes.NewBuffer(val)
-	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 micro/lock and micro/store
-func NewStorage(lock sync.Sync, store store.Store) certmagic.Storage {
-	return &storage{
-		lock:  lock,
-		store: store,
-	}
-}

api/server/acme/options.go

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

api/server/cors/cors.go

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

api/server/http/http.go

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

api/server/http/http_test.go

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

api/server/options.go

@@ -1,96 +0,0 @@
-package server
-
-import (
-	"context"
-	"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
-	Context      context.Context
-}
-
-// NewOptions returns new Options
-func NewOptions(opts ...Option) Options {
-	options := Options{
-		Logger:  logger.DefaultLogger,
-		Context: context.Background(),
-	}
-	for _, o := range opts {
-		o(&options)
-	}
-	return options
-}
-
-type Wrapper func(h http.Handler) http.Handler
-
-func WrapHandler(w ...Wrapper) Option {
-	return func(o *Options) {
-		o.Wrappers = append(o.Wrappers, w...)
-	}
-}
-
-func EnableCORS(b bool) Option {
-	return func(o *Options) {
-		o.EnableCORS = b
-	}
-}
-
-func EnableACME(b bool) Option {
-	return func(o *Options) {
-		o.EnableACME = b
-	}
-}
-
-func ACMEHosts(hosts ...string) Option {
-	return func(o *Options) {
-		o.ACMEHosts = hosts
-	}
-}
-
-func ACMEProvider(p acme.Provider) Option {
-	return func(o *Options) {
-		o.ACMEProvider = p
-	}
-}
-
-func EnableTLS(b bool) Option {
-	return func(o *Options) {
-		o.EnableTLS = b
-	}
-}
-
-func TLSConfig(t *tls.Config) Option {
-	return func(o *Options) {
-		o.TLSConfig = t
-	}
-}
-
-func Resolver(r resolver.Resolver) Option {
-	return func(o *Options) {
-		o.Resolver = r
-	}
-}
-
-func Logger(l logger.Logger) Option {
-	return func(o *Options) {
-		o.Logger = l
-	}
-}

api/server/server.go

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

auth/auth.go

@@ -1,142 +0,0 @@
-// Package auth provides authentication and authorization capability
-package auth
-
-import (
-	"context"
-	"errors"
-	"time"
-
-	"github.com/unistack-org/micro/v3/metadata"
-)
-
-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 = NewAuth()
-	// ErrInvalidToken is when the token provided is not valid
-	ErrInvalidToken = errors.New("invalid token provided")
-	// ErrForbidden is when a user does not have the necessary scope to access a resource
-	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 metadata.Metadata `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) {
-	if ctx == nil {
-		return nil, false
-	}
-	acc, ok := ctx.Value(accountKey{}).(*Account)
-	return acc, ok
-}
-
-// ContextWithAccount sets the account in the context
-func ContextWithAccount(ctx context.Context, account *Account) context.Context {
-	if ctx == nil {
-		ctx = context.Background()
-	}
-	return context.WithValue(ctx, accountKey{}, account)
-}

auth/noop.go

@@ -1,78 +0,0 @@
-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
-}
-
-// NewAuth returns new noop auth
-func NewAuth(opts ...Option) Auth {
-	return &noopAuth{opts: NewOptions(opts...)}
-}

auth/options.go

@@ -1,290 +0,0 @@
-package auth
-
-import (
-	"context"
-	"time"
-
-	"github.com/unistack-org/micro/v3/logger"
-	"github.com/unistack-org/micro/v3/metadata"
-	"github.com/unistack-org/micro/v3/store"
-)
-
-// NewOptions creates Options struct from slice of options
-func NewOptions(opts ...Option) Options {
-	options := Options{
-		Logger: logger.DefaultLogger,
-	}
-	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
-}
-
-// Option func
-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
-	}
-}
-
-// GenerateOptions struct
-type GenerateOptions struct {
-	// Metadata associated with the account
-	Metadata metadata.Metadata
-	// 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
-}
-
-// GenerateOption func
-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 metadata.Metadata) GenerateOption {
-	return func(o *GenerateOptions) {
-		o.Metadata = metadata.Copy(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
-}
-
-// TokenOptions struct
-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
-}
-
-// TokenOption func
-type TokenOption func(o *TokenOptions)
-
-// WithExpiry for the token
-func WithExpiry(ex time.Duration) TokenOption {
-	return func(o *TokenOptions) {
-		o.Expiry = ex
-	}
-}
-
-// WithCredentials sets tye id and secret
-func WithCredentials(id, secret string) TokenOption {
-	return func(o *TokenOptions) {
-		o.ID = id
-		o.Secret = secret
-	}
-}
-
-// WithToken sets the refresh token
-func WithToken(rt string) TokenOption {
-	return func(o *TokenOptions) {
-		o.RefreshToken = rt
-	}
-}
-
-// WithTokenIssuer sets the token issuer option
-func WithTokenIssuer(iss string) TokenOption {
-	return func(o *TokenOptions) {
-		o.Issuer = iss
-	}
-}
-
-// 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
-}
-
-// VerifyOptions struct
-type VerifyOptions struct {
-	Context   context.Context
-	Namespace string
-}
-
-// VerifyOption func
-type VerifyOption func(o *VerifyOptions)
-
-// VerifyContext pass context to verify
-func VerifyContext(ctx context.Context) VerifyOption {
-	return func(o *VerifyOptions) {
-		o.Context = ctx
-	}
-}
-
-// VerifyNamespace sets thhe namespace for verify
-func VerifyNamespace(ns string) VerifyOption {
-	return func(o *VerifyOptions) {
-		o.Namespace = ns
-	}
-}
-
-// RulesOptions struct
-type RulesOptions struct {
-	Context   context.Context
-	Namespace string
-}
-
-// RulesOption func
-type RulesOption func(o *RulesOptions)
-
-// RulesContext pass rules context
-func RulesContext(ctx context.Context) RulesOption {
-	return func(o *RulesOptions) {
-		o.Context = ctx
-	}
-}
-
-// RulesNamespace sets the rule namespace
-func RulesNamespace(ns string) RulesOption {
-	return func(o *RulesOptions) {
-		o.Namespace = ns
-	}
-}
-
-// Logger sets the logger
-func Logger(l logger.Logger) Option {
-	return func(o *Options) {
-		o.Logger = l
-	}
-}

auth/rules.go

@@ -1,91 +0,0 @@
-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

@@ -1,288 +0,0 @@
-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

@@ -3,47 +3,89 @@ package broker
 
 import (
 	"context"
+	"errors"
+	"time"
 
-	"github.com/unistack-org/micro/v3/metadata"
+	"go.unistack.org/micro/v4/codec"
+	"go.unistack.org/micro/v4/metadata"
 )
 
+// DefaultBroker default memory broker
+var DefaultBroker Broker = NewBroker()
+
 var (
-	// DefaultBroker default broker
-	DefaultBroker Broker = NewBroker()
+	// ErrNotConnected returns when broker used but not connected yet
+	ErrNotConnected = errors.New("broker not connected")
+	// ErrDisconnected returns when broker disconnected
+	ErrDisconnected = errors.New("broker disconnected")
+	// ErrInvalidMessage returns when invalid Message passed
+	ErrInvalidMessage = errors.New("invalid message")
+	// ErrInvalidHandler returns when subscriber passed to Subscribe
+	ErrInvalidHandler = errors.New("invalid handler, ony func(Message) error and func([]Message) error supported")
+	// DefaultGracefulTimeout
+	DefaultGracefulTimeout = 5 * time.Second
 )
 
 // Broker is an interface used for asynchronous messaging.
 type Broker interface {
-	Init(...Option) error
+	// Name returns broker instance name
+	Name() string
+	// Init initilize broker
+	Init(opts ...Option) error
+	// Options returns broker options
 	Options() Options
+	// Address return configured address
 	Address() string
-	Connect(context.Context) error
-	Disconnect(context.Context) error
-	Publish(context.Context, string, *Message, ...PublishOption) error
-	Subscribe(context.Context, string, Handler, ...SubscribeOption) (Subscriber, error)
+	// Connect connects to broker
+	Connect(ctx context.Context) error
+	// Disconnect disconnect from broker
+	Disconnect(ctx context.Context) error
+	// NewMessage create new broker message to publish.
+	NewMessage(ctx context.Context, hdr metadata.Metadata, body interface{}, opts ...PublishOption) (Message, error)
+	// Publish message to broker topic
+	Publish(ctx context.Context, topic string, messages ...Message) error
+	// Subscribe subscribes to topic message via handler
+	Subscribe(ctx context.Context, topic string, handler interface{}, opts ...SubscribeOption) (Subscriber, error)
+	// String type of broker
 	String() string
+	// Live returns broker liveness
+	Live() bool
+	// Ready returns broker readiness
+	Ready() bool
+	// Health returns broker health
+	Health() bool
 }
 
-// Handler is used to process messages via a subscription of a topic.
-type Handler func(Event) error
+type (
+	FuncPublish   func(ctx context.Context, topic string, messages ...Message) error
+	HookPublish   func(next FuncPublish) FuncPublish
+	FuncSubscribe func(ctx context.Context, topic string, handler interface{}, opts ...SubscribeOption) (Subscriber, error)
+	HookSubscribe func(next FuncSubscribe) FuncSubscribe
+)
 
-// Event is given to a subscription handler for processing
-type Event interface {
+// Message is given to a subscription handler for processing
+type Message interface {
+	// Context for the message.
+	Context() context.Context
+	// Topic returns message destination topic.
 	Topic() string
-	Message() *Message
+	// Header returns message headers.
+	Header() metadata.Metadata
+	// Body returns broker message []byte slice
+	Body() []byte
+	// Unmarshal try to decode message body to dst.
+	// This is helper method that uses codec.Unmarshal.
+	Unmarshal(dst interface{}, opts ...codec.Option) error
+	// Ack acknowledge message if supported.
 	Ack() error
-	Error() error
-}
-
-// Message is used to transfer data
-type Message struct {
-	Header metadata.Metadata // 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(context.Context) error
+	// Unsubscribe from topic
+	Unsubscribe(ctx context.Context) error
 }

broker/context.go

@@ -15,6 +15,15 @@ func FromContext(ctx context.Context) (Broker, bool) {
 	return c, ok
 }
 
+// MustContext returns broker from passed context
+func MustContext(ctx context.Context) Broker {
+	b, ok := FromContext(ctx)
+	if !ok {
+		panic("missing broker")
+	}
+	return b
+}
+
 // NewContext savess broker in context
 func NewContext(ctx context.Context, s Broker) context.Context {
 	if ctx == nil {
@@ -33,16 +42,6 @@ func SetSubscribeOption(k, v interface{}) SubscribeOption {
 	}
 }
 
-// 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) {
@@ -52,3 +51,13 @@ func SetPublishOption(k, v interface{}) PublishOption {
 		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)
+	}
+}

broker/context_test.go

@@ -0,0 +1,61 @@
+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")
+	}
+}
+
+func TestSetSubscribeOption(t *testing.T) {
+	type key struct{}
+	o := SetSubscribeOption(key{}, "test")
+	opts := &SubscribeOptions{}
+	o(opts)
+
+	if v, ok := opts.Context.Value(key{}).(string); !ok || v == "" {
+		t.Fatal("SetSubscribeOption 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")
+	}
+}

broker/memory/memory.go

@@ -0,0 +1,338 @@
+package broker
+
+import (
+	"context"
+	"strings"
+	"sync"
+
+	"go.unistack.org/micro/v4/broker"
+	"go.unistack.org/micro/v4/codec"
+	"go.unistack.org/micro/v4/logger"
+	"go.unistack.org/micro/v4/metadata"
+	"go.unistack.org/micro/v4/options"
+	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 Broker struct {
+	funcPublish   broker.FuncPublish
+	funcSubscribe broker.FuncSubscribe
+	subscribers   map[string][]*Subscriber
+	addr          string
+	opts          broker.Options
+	sync.RWMutex
+	connected bool
+}
+
+type memoryMessage struct {
+	c     codec.Codec
+	topic string
+	ctx   context.Context
+	body  []byte
+	hdr   metadata.Metadata
+	opts  broker.PublishOptions
+}
+
+func (m *memoryMessage) Ack() error {
+	return nil
+}
+
+func (m *memoryMessage) Body() []byte {
+	return m.body
+}
+
+func (m *memoryMessage) Header() metadata.Metadata {
+	return m.hdr
+}
+
+func (m *memoryMessage) Context() context.Context {
+	return m.ctx
+}
+
+func (m *memoryMessage) Topic() string {
+	return ""
+}
+
+func (m *memoryMessage) Unmarshal(dst interface{}, opts ...codec.Option) error {
+	return m.c.Unmarshal(m.body, dst)
+}
+
+type Subscriber struct {
+	ctx     context.Context
+	exit    chan bool
+	handler interface{}
+	id      string
+	topic   string
+	opts    broker.SubscribeOptions
+}
+
+func (b *Broker) newCodec(ct string) (codec.Codec, error) {
+	if idx := strings.IndexRune(ct, ';'); idx >= 0 {
+		ct = ct[:idx]
+	}
+	b.RLock()
+	c, ok := b.opts.Codecs[ct]
+	b.RUnlock()
+	if ok {
+		return c, nil
+	}
+	return nil, codec.ErrUnknownContentType
+}
+
+func (b *Broker) Options() broker.Options {
+	return b.opts
+}
+
+func (b *Broker) Address() string {
+	return b.addr
+}
+
+func (b *Broker) Connect(ctx context.Context) error {
+	select {
+	case <-ctx.Done():
+		return ctx.Err()
+	default:
+	}
+
+	b.Lock()
+	defer b.Unlock()
+
+	if b.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)
+
+	b.addr = addr
+	b.connected = true
+
+	return nil
+}
+
+func (b *Broker) Disconnect(ctx context.Context) error {
+	select {
+	case <-ctx.Done():
+		return ctx.Err()
+	default:
+	}
+
+	b.Lock()
+	defer b.Unlock()
+
+	if !b.connected {
+		return nil
+	}
+
+	b.connected = false
+	return nil
+}
+
+func (b *Broker) Init(opts ...broker.Option) error {
+	for _, o := range opts {
+		o(&b.opts)
+	}
+
+	b.funcPublish = b.fnPublish
+	b.funcSubscribe = b.fnSubscribe
+
+	b.opts.Hooks.EachPrev(func(hook options.Hook) {
+		switch h := hook.(type) {
+		case broker.HookPublish:
+			b.funcPublish = h(b.funcPublish)
+		case broker.HookSubscribe:
+			b.funcSubscribe = h(b.funcSubscribe)
+		}
+	})
+
+	return nil
+}
+
+func (b *Broker) NewMessage(ctx context.Context, hdr metadata.Metadata, body interface{}, opts ...broker.PublishOption) (broker.Message, error) {
+	options := broker.NewPublishOptions(opts...)
+	m := &memoryMessage{ctx: ctx, hdr: hdr, opts: options}
+	c, err := b.newCodec(m.opts.ContentType)
+	if err == nil {
+		m.body, err = c.Marshal(body)
+	}
+	if err != nil {
+		return nil, err
+	}
+
+	return m, nil
+}
+
+func (b *Broker) Publish(ctx context.Context, topic string, messages ...broker.Message) error {
+	return b.funcPublish(ctx, topic, messages...)
+}
+
+func (b *Broker) fnPublish(ctx context.Context, topic string, messages ...broker.Message) error {
+	return b.publish(ctx, topic, messages...)
+}
+
+func (b *Broker) publish(ctx context.Context, topic string, messages ...broker.Message) error {
+	b.RLock()
+	if !b.connected {
+		b.RUnlock()
+		return broker.ErrNotConnected
+	}
+	b.RUnlock()
+
+	select {
+	case <-ctx.Done():
+		return ctx.Err()
+	default:
+	}
+
+	b.RLock()
+	subs, ok := b.subscribers[topic]
+	b.RUnlock()
+	if !ok {
+		return nil
+	}
+
+	var err error
+
+	for _, sub := range subs {
+		switch s := sub.handler.(type) {
+		default:
+			if b.opts.Logger.V(logger.ErrorLevel) {
+				b.opts.Logger.Error(ctx, "broker  handler error", broker.ErrInvalidHandler)
+			}
+		case func(broker.Message) error:
+			for _, message := range messages {
+				msg, ok := message.(*memoryMessage)
+				if !ok {
+					if b.opts.Logger.V(logger.ErrorLevel) {
+						b.opts.Logger.Error(ctx, "broker handler error", broker.ErrInvalidMessage)
+					}
+				}
+				msg.topic = topic
+				if err = s(msg); err == nil && sub.opts.AutoAck {
+					err = msg.Ack()
+				}
+				if err != nil {
+					if b.opts.Logger.V(logger.ErrorLevel) {
+						b.opts.Logger.Error(ctx, "broker handler error", err)
+					}
+				}
+			}
+		case func([]broker.Message) error:
+			if err = s(messages); err == nil && sub.opts.AutoAck {
+				for _, message := range messages {
+					err = message.Ack()
+					if err != nil {
+						if b.opts.Logger.V(logger.ErrorLevel) {
+							b.opts.Logger.Error(ctx, "broker handler error", err)
+						}
+					}
+				}
+			}
+		}
+	}
+
+	return nil
+}
+
+func (b *Broker) Subscribe(ctx context.Context, topic string, handler interface{}, opts ...broker.SubscribeOption) (broker.Subscriber, error) {
+	return b.funcSubscribe(ctx, topic, handler, opts...)
+}
+
+func (b *Broker) fnSubscribe(ctx context.Context, topic string, handler interface{}, opts ...broker.SubscribeOption) (broker.Subscriber, error) {
+	if err := broker.IsValidHandler(handler); err != nil {
+		return nil, err
+	}
+
+	b.RLock()
+	if !b.connected {
+		b.RUnlock()
+		return nil, broker.ErrNotConnected
+	}
+	b.RUnlock()
+
+	sid, err := id.New()
+	if err != nil {
+		return nil, err
+	}
+
+	options := broker.NewSubscribeOptions(opts...)
+
+	sub := &Subscriber{
+		exit:    make(chan bool, 1),
+		id:      sid,
+		topic:   topic,
+		handler: handler,
+		opts:    options,
+		ctx:     ctx,
+	}
+
+	b.Lock()
+	b.subscribers[topic] = append(b.subscribers[topic], sub)
+	b.Unlock()
+
+	go func() {
+		<-sub.exit
+		b.Lock()
+		newSubscribers := make([]*Subscriber, 0, len(b.subscribers)-1)
+		for _, sb := range b.subscribers[topic] {
+			if sb.id == sub.id {
+				continue
+			}
+			newSubscribers = append(newSubscribers, sb)
+		}
+		b.subscribers[topic] = newSubscribers
+		b.Unlock()
+	}()
+
+	return sub, nil
+}
+
+func (b *Broker) String() string {
+	return "memory"
+}
+
+func (b *Broker) Name() string {
+	return b.opts.Name
+}
+
+func (b *Broker) Live() bool {
+	return true
+}
+
+func (b *Broker) Ready() bool {
+	return true
+}
+
+func (b *Broker) Health() bool {
+	return true
+}
+
+func (m *Subscriber) Options() broker.SubscribeOptions {
+	return m.opts
+}
+
+func (m *Subscriber) Topic() string {
+	return m.topic
+}
+
+func (m *Subscriber) Unsubscribe(ctx context.Context) error {
+	m.exit <- true
+	return nil
+}
+
+// NewBroker return new memory broker
+func NewBroker(opts ...broker.Option) broker.Broker {
+	return &Broker{
+		opts:        broker.NewOptions(opts...),
+		subscribers: make(map[string][]*Subscriber),
+	}
+}

broker/memory/memory_test.go

@@ -0,0 +1,74 @@
+package broker
+
+import (
+	"context"
+	"fmt"
+	"testing"
+
+	"go.uber.org/atomic"
+	"go.unistack.org/micro/v4/broker"
+	"go.unistack.org/micro/v4/codec"
+	"go.unistack.org/micro/v4/metadata"
+)
+
+type hldr struct {
+	c atomic.Int64
+}
+
+func (h *hldr) Handler(m broker.Message) error {
+	h.c.Add(1)
+	return nil
+}
+
+func TestMemoryBroker(t *testing.T) {
+	b := NewBroker(broker.Codec("application/octet-stream", codec.NewCodec()))
+	ctx := context.Background()
+
+	if err := b.Init(); err != nil {
+		t.Fatalf("Unexpected init error %v", err)
+	}
+
+	if err := b.Connect(ctx); err != nil {
+		t.Fatalf("Unexpected connect error %v", err)
+	}
+
+	topic := "test"
+	count := int64(10)
+
+	h := &hldr{}
+
+	sub, err := b.Subscribe(ctx, topic, h.Handler)
+	if err != nil {
+		t.Fatalf("Unexpected error subscribing %v", err)
+	}
+
+	for i := int64(0); i < count; i++ {
+		message, err := b.NewMessage(ctx,
+			metadata.Pairs(
+				"foo", "bar",
+				"id", fmt.Sprintf("%d", i),
+			),
+			[]byte(`"hello world"`),
+			broker.PublishContentType("application/octet-stream"),
+		)
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		if err := b.Publish(ctx, topic, message); err != nil {
+			t.Fatalf("Unexpected error publishing %d err: %v", i, 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)
+	}
+
+	if h.c.Load() != count {
+		t.Fatal("invalid messages count received")
+	}
+}

broker/noop.go

@@ -1,77 +1,176 @@
 package broker
 
-import "context"
+import (
+	"context"
+	"strings"
+	"sync"
 
-type noopBroker struct {
+	"go.unistack.org/micro/v4/codec"
+	"go.unistack.org/micro/v4/metadata"
+	"go.unistack.org/micro/v4/options"
+)
+
+type NoopBroker struct {
+	funcPublish   FuncPublish
+	funcSubscribe FuncSubscribe
 	opts          Options
+	sync.RWMutex
 }
 
-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)
+func (b *NoopBroker) newCodec(ct string) (codec.Codec, error) {
+	if idx := strings.IndexRune(ct, ';'); idx >= 0 {
+		ct = ct[:idx]
 	}
-
-	return nil
+	b.RLock()
+	c, ok := b.opts.Codecs[ct]
+	b.RUnlock()
+	if ok {
+		return c, nil
+	}
+	return nil, codec.ErrUnknownContentType
 }
 
-// Options returns broker Options
-func (n *noopBroker) Options() Options {
-	return n.opts
+func NewBroker(opts ...Option) *NoopBroker {
+	b := &NoopBroker{opts: NewOptions(opts...)}
+	b.funcPublish = b.fnPublish
+	b.funcSubscribe = b.fnSubscribe
+
+	return b
 }
 
-// Address returns broker address
-func (n *noopBroker) Address() string {
-	return ""
+func (b *NoopBroker) Health() bool {
+	return true
 }
 
-// Connect connects to broker
-func (n *noopBroker) Connect(ctx context.Context) error {
-	return nil
+func (b *NoopBroker) Live() bool {
+	return true
 }
 
-// Disconnect disconnects from broker
-func (n *noopBroker) Disconnect(ctx context.Context) error {
-	return nil
+func (b *NoopBroker) Ready() bool {
+	return true
 }
 
-// Publish publishes message to broker
-func (n *noopBroker) Publish(ctx context.Context, topic string, m *Message, opts ...PublishOption) error {
-	return nil
+func (b *NoopBroker) Name() string {
+	return b.opts.Name
 }
 
-// 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 {
+func (b *NoopBroker) String() string {
 	return "noop"
 }
 
-// Options returns subscriber options
-func (n *noopSubscriber) Options() SubscribeOptions {
-	return n.opts
+func (b *NoopBroker) Options() Options {
+	return b.opts
 }
 
-// TOpic returns subscriber topic
-func (n *noopSubscriber) Topic() string {
-	return n.topic
-}
+func (b *NoopBroker) Init(opts ...Option) error {
+	for _, opt := range opts {
+		opt(&b.opts)
+	}
+
+	b.funcPublish = b.fnPublish
+	b.funcSubscribe = b.fnSubscribe
+
+	b.opts.Hooks.EachPrev(func(hook options.Hook) {
+		switch h := hook.(type) {
+		case HookPublish:
+			b.funcPublish = h(b.funcPublish)
+		case HookSubscribe:
+			b.funcSubscribe = h(b.funcSubscribe)
+		}
+	})
 
-// Unsubscribe unsbscribes from broker topic
-func (n *noopSubscriber) Unsubscribe(ctx context.Context) error {
+	return nil
+}
+
+func (b *NoopBroker) Connect(_ context.Context) error {
+	return nil
+}
+
+func (b *NoopBroker) Disconnect(_ context.Context) error {
+	return nil
+}
+
+func (b *NoopBroker) Address() string {
+	return strings.Join(b.opts.Addrs, ",")
+}
+
+type noopMessage struct {
+	c    codec.Codec
+	ctx  context.Context
+	body []byte
+	hdr  metadata.Metadata
+	opts PublishOptions
+}
+
+func (m *noopMessage) Ack() error {
+	return nil
+}
+
+func (m *noopMessage) Body() []byte {
+	return m.body
+}
+
+func (m *noopMessage) Header() metadata.Metadata {
+	return m.hdr
+}
+
+func (m *noopMessage) Context() context.Context {
+	return m.ctx
+}
+
+func (m *noopMessage) Topic() string {
+	return ""
+}
+
+func (m *noopMessage) Unmarshal(dst interface{}, opts ...codec.Option) error {
+	return m.c.Unmarshal(m.body, dst)
+}
+
+func (b *NoopBroker) NewMessage(ctx context.Context, hdr metadata.Metadata, body interface{}, opts ...PublishOption) (Message, error) {
+	options := NewPublishOptions(opts...)
+	m := &noopMessage{ctx: ctx, hdr: hdr, opts: options}
+	c, err := b.newCodec(m.opts.ContentType)
+	if err == nil {
+		m.body, err = c.Marshal(body)
+	}
+	if err != nil {
+		return nil, err
+	}
+
+	return m, nil
+}
+
+func (b *NoopBroker) fnPublish(_ context.Context, _ string, _ ...Message) error {
+	return nil
+}
+
+func (b *NoopBroker) Publish(ctx context.Context, topic string, msg ...Message) error {
+	return b.funcPublish(ctx, topic, msg...)
+}
+
+type NoopSubscriber struct {
+	ctx     context.Context
+	topic   string
+	handler interface{}
+	opts    SubscribeOptions
+}
+
+func (b *NoopBroker) fnSubscribe(ctx context.Context, topic string, handler interface{}, opts ...SubscribeOption) (Subscriber, error) {
+	return &NoopSubscriber{ctx: ctx, topic: topic, opts: NewSubscribeOptions(opts...), handler: handler}, nil
+}
+
+func (b *NoopBroker) Subscribe(ctx context.Context, topic string, handler interface{}, opts ...SubscribeOption) (Subscriber, error) {
+	return b.funcSubscribe(ctx, topic, handler, opts...)
+}
+
+func (s *NoopSubscriber) Options() SubscribeOptions {
+	return s.opts
+}
+
+func (s *NoopSubscriber) Topic() string {
+	return s.topic
+}
+
+func (s *NoopSubscriber) Unsubscribe(_ context.Context) error {
 	return nil
 }

broker/noop_test.go

@@ -0,0 +1,35 @@
+package broker
+
+import (
+	"context"
+	"testing"
+)
+
+type testHook struct {
+	f bool
+}
+
+func (t *testHook) Publish1(fn FuncPublish) FuncPublish {
+	return func(ctx context.Context, topic string, messages ...Message) error {
+		t.f = true
+		return fn(ctx, topic, messages...)
+	}
+}
+
+func TestNoopHook(t *testing.T) {
+	h := &testHook{}
+
+	b := NewBroker(Hooks(HookPublish(h.Publish1)))
+
+	if err := b.Init(); err != nil {
+		t.Fatal(err)
+	}
+
+	if err := b.Publish(context.TODO(), "", nil); err != nil {
+		t.Fatal(err)
+	}
+
+	if !h.f {
+		t.Fatal("hook not works")
+	}
+}

broker/options.go

@@ -3,40 +3,62 @@ package broker
 import (
 	"context"
 	"crypto/tls"
+	"time"
 
-	"github.com/unistack-org/micro/v3/codec"
-	"github.com/unistack-org/micro/v3/logger"
-	"github.com/unistack-org/micro/v3/registry"
+	"go.unistack.org/micro/v4/codec"
+	"go.unistack.org/micro/v4/logger"
+	"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 {
-	Addrs  []string
-	Secure bool
+	// Name holds the broker name
+	Name string
 
-	// Codec
-	Codec codec.Codec
-
-	// Logger the logger
+	// Tracer used for tracing
+	Tracer tracer.Tracer
+	// Register can be used for clustering
+	Register register.Register
+	// Codecs holds the codecs for marshal/unmarshal based on content-type
+	Codecs map[string]codec.Codec
+	// Logger used for logging
 	Logger logger.Logger
-	// Handler executed when errors occur processing messages
-	ErrorHandler Handler
-
-	TLSConfig *tls.Config
-	// Registry used for clustering
-	Registry registry.Registry
-	// Other options for implementations of the interface
-	// can be stored in a context
+	// Meter used for metrics
+	Meter meter.Meter
+	// Context holds external options
 	Context context.Context
+
+	// Wait waits for a collection of goroutines to finish
+	Wait *sync.WaitGroup
+	// TLSConfig holds tls.TLSConfig options
+	TLSConfig *tls.Config
+
+	// Addrs holds the broker address
+	Addrs []string
+	// Hooks can be run before broker Publish/BatchPublish and
+	// Subscribe/BatchSubscribe methods
+	Hooks options.Hooks
+
+	// GracefulTimeout contains time to wait to finish in flight requests
+	GracefulTimeout time.Duration
 }
 
 // NewOptions create new Options
 func NewOptions(opts ...Option) Options {
 	options := Options{
-		Registry: registry.DefaultRegistry,
+		Register:        register.DefaultRegister,
 		Logger:          logger.DefaultLogger,
 		Context:         context.Background(),
+		Meter:           meter.DefaultMeter,
+		Codecs:          make(map[string]codec.Codec),
+		Tracer:          tracer.DefaultTracer,
+		GracefulTimeout: DefaultGracefulTimeout,
 	}
+
 	for _, o := range opts {
 		o(&options)
 	}
@@ -52,10 +74,12 @@ func Context(ctx context.Context) Option {
 
 // PublishOptions struct
 type PublishOptions struct {
-	// BodyOnly says that only body of the message must be published
+	// ContentType for message body
+	ContentType string
+	// BodyOnly flag says the message contains raw body bytes and don't need
+	// codec Marshal method
 	BodyOnly bool
-	// Other options for implementations of the interface
-	// can be stored in a context
+	// Context holds custom options
 	Context context.Context
 }
 
@@ -64,33 +88,26 @@ func NewPublishOptions(opts ...PublishOption) PublishOptions {
 	options := PublishOptions{
 		Context: context.Background(),
 	}
-
 	for _, o := range opts {
 		o(&options)
 	}
-
 	return options
 }
 
 // SubscribeOptions struct
 type SubscribeOptions struct {
-	// AutoAck ack messages if handler returns nil err
-	AutoAck bool
-
-	// Handler executed when errors occur processing messages
-	ErrorHandler Handler
-
-	// Subscribers with the same group name
-	// will create a shared subscription where each
-	// receives a subset of messages.
-	Group string
-
-	// BodyOnly says that consumed only body of the message
-	BodyOnly bool
-
-	// Other options for implementations of the interface
-	// can be stored in a context
+	// Context holds external options
 	Context context.Context
+	// Group holds consumer group
+	Group string
+	// AutoAck flag specifies auto ack of incoming message when no error happens
+	AutoAck bool
+	// BodyOnly flag specifies that message contains only body bytes without header
+	BodyOnly bool
+	// BatchSize flag specifies max batch size
+	BatchSize int
+	// BatchWait flag specifies max wait time for batch filling
+	BatchWait time.Duration
 }
 
 // Option func
@@ -99,6 +116,13 @@ type Option func(*Options)
 // PublishOption func
 type PublishOption func(*PublishOptions)
 
+// PublishContentType sets message content-type that used to Marshal
+func PublishContentType(ct string) PublishOption {
+	return func(o *PublishOptions) {
+		o.ContentType = ct
+	}
+}
+
 // PublishBodyOnly publish only body of the message
 func PublishBodyOnly(b bool) PublishOption {
 	return func(o *PublishOptions) {
@@ -106,30 +130,6 @@ func PublishBodyOnly(b bool) PublishOption {
 	}
 }
 
-// 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 ...SubscribeOption) SubscribeOptions {
-	options := SubscribeOptions{
-		AutoAck: true,
-		Context: context.Background(),
-	}
-
-	for _, o := range opts {
-		o(&options)
-	}
-
-	return options
-}
-
 // Addrs sets the host addresses to be used by the broker
 func Addrs(addrs ...string) Option {
 	return func(o *Options) {
@@ -137,57 +137,10 @@ func Addrs(addrs ...string) Option {
 	}
 }
 
-// Codec sets the codec used for encoding/decoding used where
-// a broker does not support headers
-func Codec(c codec.Codec) Option {
+// Codec sets the codec used for encoding/decoding messages
+func Codec(ct string, c codec.Codec) 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) SubscribeOption {
-	return func(o *SubscribeOptions) {
-		o.AutoAck = b
-	}
-}
-
-// SubscribeBodyOnly consumes only body of the message
-func SubscribeBodyOnly(b bool) SubscribeOption {
-	return func(o *SubscribeOptions) {
-		o.BodyOnly = b
-	}
-}
-
-// ErrorHandler will catch all broker errors that cant be handled
-// in normal way, for example Codec errors
-func ErrorHandler(h Handler) Option {
-	return func(o *Options) {
-		o.ErrorHandler = h
-	}
-}
-
-// SubscribeErrorHandler will catch all broker errors that cant be handled
-// in normal way, for example Codec errors
-func SubscribeErrorHandler(h Handler) SubscribeOption {
-	return func(o *SubscribeOptions) {
-		o.ErrorHandler = h
-	}
-}
-
-// Queue sets the subscribers queue
-// Deprecated
-func Queue(name string) SubscribeOption {
-	return func(o *SubscribeOptions) {
-		o.Group = name
+		o.Codecs[ct] = c
 	}
 }
 
@@ -198,17 +151,10 @@ func SubscribeGroup(name string) SubscribeOption {
 	}
 }
 
-// Registry sets registry option
-func Registry(r registry.Registry) Option {
+// Register sets register option
+func Register(r register.Register) 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
+		o.Register = r
 	}
 }
 
@@ -226,9 +172,81 @@ func Logger(l logger.Logger) Option {
 	}
 }
 
+// Tracer to be used for tracing
+func Tracer(t tracer.Tracer) Option {
+	return func(o *Options) {
+		o.Tracer = t
+	}
+}
+
+// Meter sets the meter
+func Meter(m meter.Meter) Option {
+	return func(o *Options) {
+		o.Meter = m
+	}
+}
+
+// Name sets the name
+func Name(n string) Option {
+	return func(o *Options) {
+		o.Name = n
+	}
+}
+
+// Hooks sets hook runs before action
+func Hooks(h ...options.Hook) Option {
+	return func(o *Options) {
+		o.Hooks = append(o.Hooks, h...)
+	}
+}
+
 // SubscribeContext set context
 func SubscribeContext(ctx context.Context) SubscribeOption {
 	return func(o *SubscribeOptions) {
 		o.Context = ctx
 	}
 }
+
+// SubscribeAutoAck contol auto acking of messages
+// after they have been handled.
+func SubscribeAutoAck(b bool) SubscribeOption {
+	return func(o *SubscribeOptions) {
+		o.AutoAck = b
+	}
+}
+
+// SubscribeBodyOnly consumes only body of the message
+func SubscribeBodyOnly(b bool) SubscribeOption {
+	return func(o *SubscribeOptions) {
+		o.BodyOnly = b
+	}
+}
+
+// SubscribeBatchSize specifies max batch size
+func SubscribeBatchSize(n int) SubscribeOption {
+	return func(o *SubscribeOptions) {
+		o.BatchSize = n
+	}
+}
+
+// SubscribeBatchWait specifies max batch wait time
+func SubscribeBatchWait(td time.Duration) SubscribeOption {
+	return func(o *SubscribeOptions) {
+		o.BatchWait = td
+	}
+}
+
+// SubscribeOption func
+type SubscribeOption func(*SubscribeOptions)
+
+// NewSubscribeOptions creates new SubscribeOptions
+func NewSubscribeOptions(opts ...SubscribeOption) SubscribeOptions {
+	options := SubscribeOptions{
+		AutoAck: true,
+		Context: context.Background(),
+	}
+	for _, o := range opts {
+		o(&options)
+	}
+	return options
+}

broker/subscriber.go

@@ -0,0 +1,14 @@
+package broker
+
+// IsValidHandler func signature
+func IsValidHandler(sub interface{}) error {
+	switch sub.(type) {
+	default:
+		return ErrInvalidHandler
+	case func(Message) error:
+		break
+	case func([]Message) error:
+		break
+	}
+	return nil
+}

build/build.go

@@ -1,32 +0,0 @@
-// 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

@@ -1,17 +0,0 @@
-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,14 +2,29 @@ package client
 
 import (
 	"context"
+	"math"
 	"time"
 
-	"github.com/unistack-org/micro/v3/util/backoff"
+	"go.unistack.org/micro/v4/util/backoff"
 )
 
 // BackoffFunc is the backoff call func
 type BackoffFunc func(ctx context.Context, req Request, attempts int) (time.Duration, error)
 
-func exponentialBackoff(ctx context.Context, req Request, attempts int) (time.Duration, error) {
+// BackoffExp using exponential backoff func
+func BackoffExp(_ context.Context, _ Request, attempts int) (time.Duration, error) {
 	return backoff.Do(attempts), nil
 }
+
+// BackoffInterval specifies randomization interval for backoff func
+func BackoffInterval(minTime time.Duration, maxTime 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 < minTime {
+			return minTime, nil
+		} else if td > maxTime {
+			return maxTime, nil
+		}
+		return td, nil
+	}
+}

client/backoff_test.go

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

client/client.go

@@ -5,35 +5,47 @@ import (
 	"context"
 	"time"
 
-	"github.com/unistack-org/micro/v3/codec"
-	"github.com/unistack-org/micro/v3/metadata"
+	"go.unistack.org/micro/v4/codec"
+	"go.unistack.org/micro/v4/metadata"
 )
 
 var (
 	// DefaultClient is the global default client
-	DefaultClient Client = NewClient()
+	DefaultClient = 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
+	// DefaultPoolSize sets the connection pool size
+	DefaultPoolSize = 100
+	// DefaultPoolTTL sets the connection pool ttl
+	DefaultPoolTTL = time.Minute
 )
 
 // Client is the interface used to make requests to services.
-// It supports Request/Response via Transport and Publishing via the Broker.
 // It also supports bidirectional streaming of requests.
 type Client interface {
-	Init(...Option) error
+	Name() string
+	Init(opts ...Option) error
 	Options() Options
-	NewMessage(topic string, msg interface{}, opts ...MessageOption) Message
-	NewRequest(service, endpoint string, req interface{}, reqOpts ...RequestOption) Request
+	NewRequest(service string, endpoint string, req interface{}, opts ...RequestOption) Request
 	Call(ctx context.Context, req Request, rsp interface{}, opts ...CallOption) error
 	Stream(ctx context.Context, req Request, opts ...CallOption) (Stream, error)
-	Publish(ctx context.Context, msg Message, opts ...PublishOption) error
 	String() string
 }
 
-// Message is the interface for publishing asynchronously
-type Message interface {
-	Topic() string
-	Payload() interface{}
-	ContentType() string
-}
+type (
+	FuncCall   func(ctx context.Context, req Request, rsp interface{}, opts ...CallOption) error
+	HookCall   func(next FuncCall) FuncCall
+	FuncStream func(ctx context.Context, req Request, opts ...CallOption) (Stream, error)
+	HookStream func(next FuncStream) FuncStream
+)
 
 // Request is the interface for a synchronous request used by Call or Stream
 type Request interface {
@@ -57,7 +69,7 @@ type Request interface {
 type Response interface {
 	// Read the response
 	Codec() codec.Codec
-	// read the header
+	// Header data
 	Header() metadata.Metadata
 	// Read the undecoded response
 	Read() ([]byte, error)
@@ -72,13 +84,19 @@ type Stream interface {
 	// The response read
 	Response() Response
 	// Send will encode and send a request
-	Send(interface{}) error
+	Send(msg interface{}) error
 	// Recv will decode and read a response
-	Recv(interface{}) error
+	Recv(msg interface{}) error
+	// 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
@@ -87,26 +105,5 @@ 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 = RetryNever
-	// DefaultRetries is the default number of times a request is tried
-	DefaultRetries = 0
-	// DefaultRequestTimeout is the default request timeout
-	DefaultRequestTimeout = time.Second * 5
-	// DefaultPoolSize sets the connection pool size
-	DefaultPoolSize = 100
-	// DefaultPoolTTL sets the connection pool ttl
-	DefaultPoolTTL = time.Minute
-)

client/context.go

@@ -15,6 +15,15 @@ func FromContext(ctx context.Context) (Client, bool) {
 	return c, ok
 }
 
+// MustContext get client from context
+func MustContext(ctx context.Context) Client {
+	c, ok := FromContext(ctx)
+	if !ok {
+		panic("missing client")
+	}
+	return c
+}
+
 // NewContext put client in context
 func NewContext(ctx context.Context, c Client) context.Context {
 	if ctx == nil {
@@ -23,16 +32,6 @@ func NewContext(ctx context.Context, c Client) context.Context {
 	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)
-	}
-}
-
 // SetCallOption returns a function to setup a context with given value
 func SetCallOption(k, v interface{}) CallOption {
 	return func(o *CallOptions) {

client/context_test.go

@@ -0,0 +1,62 @@
+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")
+	}
+}
+
+func TestSetCallOption(t *testing.T) {
+	type key struct{}
+	o := SetCallOption(key{}, "test")
+	opts := &CallOptions{}
+	o(opts)
+
+	if v, ok := opts.Context.Value(key{}).(string); !ok || v == "" {
+		t.Fatal("SetCallOption 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")
+	}
+}

client/lookup.go

@@ -4,15 +4,15 @@ import (
 	"context"
 	"sort"
 
-	"github.com/unistack-org/micro/v3/errors"
-	"github.com/unistack-org/micro/v3/router"
+	"go.unistack.org/micro/v4/errors"
+	"go.unistack.org/micro/v4/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(ctx context.Context, req Request, opts CallOptions) ([]string, error) {
+func LookupRoute(_ 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

client/noop.go

@@ -2,51 +2,52 @@ package client
 
 import (
 	"context"
+	"fmt"
+	"strconv"
+	"time"
 
-	"github.com/unistack-org/micro/v3/broker"
-	"github.com/unistack-org/micro/v3/codec"
-	"github.com/unistack-org/micro/v3/errors"
-	"github.com/unistack-org/micro/v3/metadata"
+	"go.unistack.org/micro/v4/codec"
+	"go.unistack.org/micro/v4/errors"
+	"go.unistack.org/micro/v4/metadata"
+	"go.unistack.org/micro/v4/options"
+	"go.unistack.org/micro/v4/selector"
+	"go.unistack.org/micro/v4/semconv"
+	"go.unistack.org/micro/v4/tracer"
 )
 
-var (
-	// DefaultCodecs will be used to encode/decode data
-	DefaultCodecs = map[string]codec.Codec{
-		//"application/json":         cjson.NewCodec,
-		//"application/json-rpc":     cjsonrpc.NewCodec,
-		//"application/protobuf":     cproto.NewCodec,
-		//"application/proto-rpc":    cprotorpc.NewCodec,
+// DefaultCodecs will be used to encode/decode data
+var DefaultCodecs = map[string]codec.Codec{
 	"application/octet-stream": codec.NewCodec(),
-	}
-)
-
-const (
-	defaultContentType = "application/json"
-)
+}
 
 type noopClient struct {
+	funcCall   FuncCall
+	funcStream FuncStream
 	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.Codec
 	stream      bool
 }
 
 // NewClient returns new noop client
 func NewClient(opts ...Option) Client {
-	return &noopClient{opts: NewOptions(opts...)}
+	n := &noopClient{opts: NewOptions(opts...)}
+
+	n.funcCall = n.fnCall
+	n.funcStream = n.fnStream
+
+	return n
+}
+
+func (n *noopClient) Name() string {
+	return n.opts.Name
 }
 
 func (n *noopRequest) Service() string {
@@ -94,10 +95,13 @@ func (n *noopResponse) Read() ([]byte, error) {
 	return nil, nil
 }
 
-type noopStream struct{}
+type noopStream struct {
+	err error
+	ctx context.Context
+}
 
 func (n *noopStream) Context() context.Context {
-	return context.Background()
+	return n.ctx
 }
 
 func (n *noopStream) Request() Request {
@@ -116,40 +120,49 @@ func (n *noopStream) Recv(interface{}) error {
 	return nil
 }
 
-func (n *noopStream) Error() error {
+func (n *noopStream) SendMsg(interface{}) error {
 	return nil
 }
 
+func (n *noopStream) RecvMsg(interface{}) error {
+	return nil
+}
+
+func (n *noopStream) Error() error {
+	return n.err
+}
+
 func (n *noopStream) Close() error {
-	return nil
-}
-
-func (n *noopMessage) Topic() string {
-	return n.topic
-}
-
-func (n *noopMessage) Payload() interface{} {
-	return n.payload
-}
-
-func (n *noopMessage) ContentType() string {
-	return n.opts.ContentType
-}
-
-func (n *noopClient) newCodec(contentType string) (codec.Codec, error) {
-	if cf, ok := n.opts.Codecs[contentType]; ok {
-		return cf, nil
+	if sp, ok := tracer.SpanFromContext(n.ctx); ok && sp != nil {
+		if n.err != nil {
+			sp.SetStatus(tracer.SpanStatusError, n.err.Error())
 		}
-	if cf, ok := DefaultCodecs[contentType]; ok {
-		return cf, nil
+		sp.Finish()
 	}
-	return nil, codec.ErrUnknownContentType
+	return n.err
+}
+
+func (n *noopStream) CloseSend() error {
+	return n.err
 }
 
 func (n *noopClient) Init(opts ...Option) error {
 	for _, o := range opts {
 		o(&n.opts)
 	}
+
+	n.funcCall = n.fnCall
+	n.funcStream = n.fnStream
+
+	n.opts.Hooks.EachPrev(func(hook options.Hook) {
+		switch h := hook.(type) {
+		case HookCall:
+			n.funcCall = h(n.funcCall)
+		case HookStream:
+			n.funcStream = h(n.funcStream)
+		}
+	})
+
 	return nil
 }
 
@@ -162,61 +175,328 @@ func (n *noopClient) String() string {
 }
 
 func (n *noopClient) Call(ctx context.Context, req Request, rsp interface{}, opts ...CallOption) error {
+	ts := time.Now()
+	n.opts.Meter.Counter(semconv.ClientRequestInflight, "endpoint", req.Endpoint()).Inc()
+	var sp tracer.Span
+	ctx, sp = n.opts.Tracer.Start(ctx, "rpc-client",
+		tracer.WithSpanKind(tracer.SpanKindClient),
+		tracer.WithSpanLabels("endpoint", req.Endpoint()),
+	)
+	err := n.funcCall(ctx, req, rsp, opts...)
+	n.opts.Meter.Counter(semconv.ClientRequestInflight, "endpoint", req.Endpoint()).Dec()
+	te := time.Since(ts)
+	n.opts.Meter.Summary(semconv.ClientRequestLatencyMicroseconds, "endpoint", req.Endpoint()).Update(te.Seconds())
+	n.opts.Meter.Histogram(semconv.ClientRequestDurationSeconds, "endpoint", req.Endpoint()).Update(te.Seconds())
+
+	if me := errors.FromError(err); me == nil {
+		sp.Finish()
+		n.opts.Meter.Counter(semconv.ClientRequestTotal, "endpoint", req.Endpoint(), "status", "success", "code", strconv.Itoa(int(200))).Inc()
+	} else {
+		sp.SetStatus(tracer.SpanStatusError, err.Error())
+		n.opts.Meter.Counter(semconv.ClientRequestTotal, "endpoint", req.Endpoint(), "status", "failure", "code", strconv.Itoa(int(me.Code))).Inc()
+	}
+
+	return err
+}
+
+func (n *noopClient) fnCall(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 := WithRequestTimeout(time.Until(d))
+		opt(&callOpts)
+	}
+
+	// should we noop right here?
+	select {
+	case <-ctx.Done():
+		return errors.New("go.micro.client", fmt.Sprintf("%v", ctx.Err()), 408)
+	default:
+	}
+
+	// make copy of call method
+	hcall := func(ctx context.Context, addr string, req Request, rsp interface{}, opts CallOptions) error {
 		return nil
+	}
+
+	// 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", "%s", err)
+		}
+
+		// 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", "%s", err)
+			}
+
+			// 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
+
+	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
+		}
+	}
+
+	return gerr
 }
 
-func (n *noopClient) NewRequest(service, endpoint string, req interface{}, opts ...RequestOption) Request {
-	return &noopRequest{}
-}
-
-func (n *noopClient) NewMessage(topic string, msg interface{}, opts ...MessageOption) Message {
-	options := NewMessageOptions(opts...)
-	return &noopMessage{topic: topic, payload: msg, opts: options}
+func (n *noopClient) NewRequest(service, endpoint string, _ interface{}, _ ...RequestOption) Request {
+	return &noopRequest{service: service, endpoint: endpoint}
 }
 
 func (n *noopClient) Stream(ctx context.Context, req Request, opts ...CallOption) (Stream, error) {
-	return &noopStream{}, nil
-}
+	ts := time.Now()
+	n.opts.Meter.Counter(semconv.ClientRequestInflight, "endpoint", req.Endpoint()).Inc()
+	var sp tracer.Span
+	ctx, sp = n.opts.Tracer.Start(ctx, "rpc-client",
+		tracer.WithSpanKind(tracer.SpanKindClient),
+		tracer.WithSpanLabels("endpoint", req.Endpoint()),
+	)
+	stream, err := n.funcStream(ctx, req, opts...)
+	n.opts.Meter.Counter(semconv.ClientRequestInflight, "endpoint", req.Endpoint()).Dec()
+	te := time.Since(ts)
+	n.opts.Meter.Summary(semconv.ClientRequestLatencyMicroseconds, "endpoint", req.Endpoint()).Update(te.Seconds())
+	n.opts.Meter.Histogram(semconv.ClientRequestDurationSeconds, "endpoint", req.Endpoint()).Update(te.Seconds())
 
-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().(*codec.Frame); ok {
-		body = d.Data
+	if me := errors.FromError(err); me == nil {
+		sp.Finish()
+		n.opts.Meter.Counter(semconv.ClientRequestTotal, "endpoint", req.Endpoint(), "status", "success", "code", strconv.Itoa(int(200))).Inc()
 	} else {
-		// use codec for payload
-		cf, err := n.newCodec(p.ContentType())
-		if err != nil {
-			return errors.InternalServerError("go.micro.client", err.Error())
+		sp.SetStatus(tracer.SpanStatusError, err.Error())
+		n.opts.Meter.Counter(semconv.ClientRequestTotal, "endpoint", req.Endpoint(), "status", "failure", "code", strconv.Itoa(int(me.Code))).Inc()
 	}
 
-		// 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))
+	return stream, err
+}
+
+func (n *noopClient) fnStream(ctx context.Context, req Request, opts ...CallOption) (Stream, error) {
+	var err error
+
+	// 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 := WithStreamTimeout(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", "%s", cerr)
+		}
+
+		// 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", "%s", err)
+			}
+
+			// balance the list of nodes
+			next, err = callOpts.Selector.Select(routes)
+			if err != nil {
+				return nil, err
+			}
+		}
+
+		node := next()
+
+		stream, cerr := n.stream(ctx, node, req, callOpts)
+
+		// 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, _ string, _ Request, _ CallOptions) (Stream, error) {
+	return &noopStream{ctx: ctx}, nil
 }

client/options.go

@@ -2,48 +2,71 @@ package client
 
 import (
 	"context"
+	"crypto/tls"
+	"net"
 	"time"
 
-	"github.com/unistack-org/micro/v3/broker"
-	"github.com/unistack-org/micro/v3/codec"
-	"github.com/unistack-org/micro/v3/logger"
-	"github.com/unistack-org/micro/v3/network/transport"
-	"github.com/unistack-org/micro/v3/registry"
-	"github.com/unistack-org/micro/v3/router"
-	"github.com/unistack-org/micro/v3/selector"
-	"github.com/unistack-org/micro/v3/selector/random"
+	"go.unistack.org/micro/v4/broker"
+	"go.unistack.org/micro/v4/codec"
+	"go.unistack.org/micro/v4/logger"
+	"go.unistack.org/micro/v4/metadata"
+	"go.unistack.org/micro/v4/meter"
+	"go.unistack.org/micro/v4/options"
+	"go.unistack.org/micro/v4/register"
+	"go.unistack.org/micro/v4/router"
+	"go.unistack.org/micro/v4/selector"
+	"go.unistack.org/micro/v4/selector/random"
+	"go.unistack.org/micro/v4/tracer"
 )
 
 // Options holds client options
 type Options struct {
-	// Used to select codec
-	ContentType string
-	// Proxy address to send requests via
-	Proxy string
-
-	// Plugged interfaces
-	Broker    broker.Broker
+	// Codecs map
 	Codecs map[string]codec.Codec
-	Router    router.Router
+
+	// Proxy is used for proxy requests
+	Proxy string
+	// ContentType is used to select codec
+	ContentType string
+	// Name is the client name
+	Name string
+
+	// Selector used to select needed address
 	Selector selector.Selector
-	Transport transport.Transport
+	// Logger used to log messages
 	Logger logger.Logger
-	// Lookup used for looking up routes
+	// Tracer used for tracing
+	Tracer tracer.Tracer
+	// Broker used to publish messages
+	Broker broker.Broker
+	// 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
+
+	// Lookup func used to get destination addr
 	Lookup LookupFunc
+	// ContextDialer used to connect
+	ContextDialer func(context.Context, string) (net.Conn, error)
 
-	// Connection Pool
-	PoolSize int
-	PoolTTL  time.Duration
-
-	// Middleware for client
+	// Wrappers contains wrappers
 	Wrappers []Wrapper
+	// Hooks can be run before broker Publish/BatchPublish and
+	// Subscribe/BatchSubscribe methods
+	Hooks options.Hooks
 
-	// Default Call Options
+	// CallOptions contains default CallOptions
 	CallOptions CallOptions
 
-	// Other options for implementations of the interface
-	// can be stored in a context
-	Context context.Context
+	// PoolSize connection pool size
+	PoolSize int
+	// PoolTTL connection pool ttl
+	PoolTTL time.Duration
 }
 
 // NewCallOptions creates new call options struct
@@ -57,37 +80,54 @@ func NewCallOptions(opts ...CallOption) CallOptions {
 
 // CallOptions holds client call options
 type CallOptions struct {
-	// Address of remote hosts
-	Address []string
-	// Backoff func
-	Backoff BackoffFunc
-	// Transport Dial Timeout
-	DialTimeout time.Duration
-	// Number of Call attempts
-	Retries int
-	// Check if retriable func
-	Retry RetryFunc
-	// Request/Response timeout
-	RequestTimeout time.Duration
-	// Router to use for this call
-	Router router.Router
-	// Selector to use for the call
-	Selector 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
+	// RequestMetadata holds additional metadata for call
+	RequestMetadata metadata.Metadata
+
+	// Network name
 	Network string
+	// Content-Type
+	ContentType string
+	// AuthToken string
+	AuthToken string
 
-	// Middleware for low level call func
-	CallWrappers []CallWrapper
-
-	// Other options for implementations of the interface
-	// can be stored in a context
+	// Selector selects addr
+	Selector selector.Selector
+	// Context used for deadline
 	Context context.Context
+	// Router used for route
+	Router router.Router
+	// Retry func used for retries
+
+	// ResponseMetadata holds additional metadata from call
+	ResponseMetadata *metadata.Metadata
+
+	Retry RetryFunc
+	// Backoff func used for backoff when retry
+	Backoff BackoffFunc
+	// ContextDialer used to connect
+	ContextDialer func(context.Context, string) (net.Conn, error)
+
+	// Address specifies static addr list
+	Address []string
+	// SelectOptions selector options
+	SelectOptions []selector.SelectOption
+
+	// StreamTimeout stream timeout
+	StreamTimeout time.Duration
+	// RequestTimeout request timeout
+	RequestTimeout time.Duration
+
+	// DialTimeout dial timeout
+	DialTimeout time.Duration
+	// Retries specifies retries num
+	Retries int
+}
+
+// ContextDialer pass ContextDialer to client
+func ContextDialer(fn func(context.Context, string) (net.Conn, error)) Option {
+	return func(o *Options) {
+		o.ContextDialer = fn
+	}
 }
 
 // Context pass context to client
@@ -97,38 +137,6 @@ func Context(ctx context.Context) Option {
 	}
 }
 
-// NewPublishOptions create new PublishOptions struct from option
-func NewPublishOptions(opts ...PublishOption) PublishOptions {
-	options := PublishOptions{}
-	for _, o := range opts {
-		o(&options)
-	}
-	return options
-}
-
-// PublishOptions holds publish 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
-}
-
-// NewMessageOptions creates message options struct
-func NewMessageOptions(opts ...MessageOption) MessageOptions {
-	options := MessageOptions{}
-	for _, o := range opts {
-		o(&options)
-	}
-	return options
-}
-
-// MessageOptions holds client message options
-type MessageOptions struct {
-	ContentType string
-}
-
 // NewRequestOptions creates new RequestOptions struct
 func NewRequestOptions(opts ...RequestOption) RequestOptions {
 	options := RequestOptions{}
@@ -140,26 +148,26 @@ func NewRequestOptions(opts ...RequestOption) RequestOptions {
 
 // RequestOptions holds client request options
 type RequestOptions struct {
-	ContentType string
-	Stream      bool
-
-	// Other options for implementations of the interface
-	// can be stored in a context
+	// Context used for external options
 	Context context.Context
+	// ContentType specify content-type of message
+	ContentType string
+	// Stream flag
+	Stream bool
 }
 
 // NewOptions creates new options struct
 func NewOptions(opts ...Option) Options {
 	options := Options{
 		Context:     context.Background(),
-		ContentType: "application/json",
-		Codecs:      make(map[string]codec.Codec),
+		ContentType: DefaultContentType,
+		Codecs:      DefaultCodecs,
 		CallOptions: CallOptions{
+			Context:        context.Background(),
 			Backoff:        DefaultBackoff,
 			Retry:          DefaultRetry,
 			Retries:        DefaultRetries,
 			RequestTimeout: DefaultRequestTimeout,
-			DialTimeout:    transport.DefaultDialTimeout,
 		},
 		Lookup:   LookupRoute,
 		PoolSize: DefaultPoolSize,
@@ -167,6 +175,9 @@ func NewOptions(opts ...Option) Options {
 		Selector: random.NewSelector(),
 		Logger:   logger.DefaultLogger,
 		Broker:   broker.DefaultBroker,
+		Meter:    meter.DefaultMeter,
+		Tracer:   tracer.DefaultTracer,
+		Router:   router.DefaultRouter,
 	}
 
 	for _, o := range opts {
@@ -183,6 +194,13 @@ func Broker(b broker.Broker) Option {
 	}
 }
 
+// Tracer to be used for tracing
+func Tracer(t tracer.Tracer) Option {
+	return func(o *Options) {
+		o.Tracer = t
+	}
+}
+
 // Logger to be used for log mesages
 func Logger(l logger.Logger) Option {
 	return func(o *Options) {
@@ -190,6 +208,13 @@ func Logger(l logger.Logger) Option {
 	}
 }
 
+// Meter to be used for metrics
+func Meter(m meter.Meter) Option {
+	return func(o *Options) {
+		o.Meter = m
+	}
+}
+
 // Codec to be used to encode/decode requests for a given content type
 func Codec(contentType string, c codec.Codec) Option {
 	return func(o *Options) {
@@ -197,7 +222,7 @@ func Codec(contentType string, c codec.Codec) Option {
 	}
 }
 
-// Default content type of the client
+// ContentType used by default if not specified
 func ContentType(ct string) Option {
 	return func(o *Options) {
 		o.ContentType = ct
@@ -225,18 +250,11 @@ func PoolTTL(d time.Duration) Option {
 	}
 }
 
-// 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 {
+// Register sets the routers register
+func Register(r register.Register) Option {
 	return func(o *Options) {
 		if o.Router != nil {
-			o.Router.Init(router.Registry(r))
+			_ = o.Router.Init(router.Register(r))
 		}
 	}
 }
@@ -255,28 +273,20 @@ func Selector(s selector.Selector) Option {
 	}
 }
 
-// Adds a Wrapper to a list of options passed into the client
-func Wrap(w Wrapper) Option {
-	return func(o *Options) {
-		o.Wrappers = append(o.Wrappers, w)
-	}
-}
-
-// Adds a Wrapper to the list of CallFunc wrappers
-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
+// 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
 	}
 }
 
+// Name sets the client name
+func Name(n string) Option {
+	return func(o *Options) {
+		o.Name = n
+	}
+}
+
 // Lookup sets the lookup function to use for resolving service names
 func Lookup(l LookupFunc) Option {
 	return func(o *Options) {
@@ -284,8 +294,15 @@ func Lookup(l LookupFunc) Option {
 	}
 }
 
+// TLSConfig specifies a *tls.Config
+func TLSConfig(t *tls.Config) Option {
+	return func(o *Options) {
+		// set the internal tls
+		o.TLSConfig = t
+	}
+}
+
 // Retries sets the retry count when making the request.
-// Should this be a Call Option?
 func Retries(i int) Option {
 	return func(o *Options) {
 		o.CallOptions.Retries = i
@@ -300,7 +317,6 @@ func Retry(fn RetryFunc) Option {
 }
 
 // RequestTimeout is the request timeout.
-// Should this be a Call Option?
 func RequestTimeout(d time.Duration) Option {
 	return func(o *Options) {
 		o.CallOptions.RequestTimeout = d
@@ -314,26 +330,24 @@ func StreamTimeout(d time.Duration) Option {
 	}
 }
 
-// Transport dial timeout
+// DialTimeout sets the dial timeout
 func DialTimeout(d time.Duration) Option {
 	return func(o *Options) {
 		o.CallOptions.DialTimeout = d
 	}
 }
 
-// Call Options
-
-// WithExchange sets the exchange to route a message through
-func WithExchange(e string) PublishOption {
-	return func(o *PublishOptions) {
-		o.Exchange = e
+// WithContextDialer pass ContextDialer to client call
+func WithContextDialer(fn func(context.Context, string) (net.Conn, error)) CallOption {
+	return func(o *CallOptions) {
+		o.ContextDialer = fn
 	}
 }
 
-// PublishContext sets the context in publish options
-func PublishContext(ctx context.Context) PublishOption {
-	return func(o *PublishOptions) {
-		o.Context = ctx
+// WithContentType specifies call content type
+func WithContentType(ct string) CallOption {
+	return func(o *CallOptions) {
+		o.ContentType = ct
 	}
 }
 
@@ -344,13 +358,6 @@ func WithAddress(a ...string) CallOption {
 	}
 }
 
-// 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 {
@@ -375,6 +382,20 @@ func WithRetries(i int) CallOption {
 	}
 }
 
+// WithResponseMetadata is a CallOption which adds metadata.Metadata to Options.CallOptions
+func WithResponseMetadata(md *metadata.Metadata) CallOption {
+	return func(o *CallOptions) {
+		o.ResponseMetadata = md
+	}
+}
+
+// WithRequestMetadata is a CallOption which adds metadata.Metadata to Options.CallOptions
+func WithRequestMetadata(md metadata.Metadata) CallOption {
+	return func(o *CallOptions) {
+		o.RequestMetadata = md
+	}
+}
+
 // WithRequestTimeout is a CallOption which overrides that which
 // set in Options.CallOptions
 func WithRequestTimeout(d time.Duration) CallOption {
@@ -400,16 +421,9 @@ func WithDialTimeout(d time.Duration) CallOption {
 
 // WithAuthToken is a CallOption which overrides the
 // authorization header with the services own auth token
-func WithAuthToken() CallOption {
+func WithAuthToken(t string) CallOption {
 	return func(o *CallOptions) {
-		o.AuthToken = true
-	}
-}
-
-// WithNetwork is a CallOption which sets the network attribute
-func WithNetwork(n string) CallOption {
-	return func(o *CallOptions) {
-		o.Network = n
+		o.AuthToken = t
 	}
 }
 
@@ -434,25 +448,23 @@ func WithSelectOptions(sops ...selector.SelectOption) CallOption {
 	}
 }
 
-// WithMessageContentType sets the message content type
-func WithMessageContentType(ct string) MessageOption {
-	return func(o *MessageOptions) {
-		o.ContentType = ct
-	}
-}
-
-// Request Options
-
-// WithContentType specifies request content type
-func WithContentType(ct string) RequestOption {
-	return func(o *RequestOptions) {
-		o.ContentType = ct
-	}
-}
-
 // StreamingRequest specifies that request is streaming
-func StreamingRequest() RequestOption {
+func StreamingRequest(b bool) RequestOption {
 	return func(o *RequestOptions) {
-		o.Stream = true
+		o.Stream = b
+	}
+}
+
+// RequestContentType specifies request content type
+func RequestContentType(ct string) RequestOption {
+	return func(o *RequestOptions) {
+		o.ContentType = ct
+	}
+}
+
+// Hooks sets hook runs before action
+func Hooks(h ...options.Hook) Option {
+	return func(o *Options) {
+		o.Hooks = append(o.Hooks, h...)
 	}
 }

client/retry.go

@@ -3,7 +3,7 @@ package client
 import (
 	"context"
 
-	"github.com/unistack-org/micro/v3/errors"
+	"go.unistack.org/micro/v4/errors"
 )
 
 // RetryFunc that returning either false or a non-nil error will result in the call not being retried
@@ -19,18 +19,32 @@ func RetryNever(ctx context.Context, req Request, retryCount int, err error) (bo
 	return false, nil
 }
 
-// RetryOnError retries a request on a 500 or timeout error
-func RetryOnError(ctx context.Context, req Request, retryCount int, err error) (bool, error) {
+// 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 {
 	// retry on timeout or internal server error
 	case 408, 500:
 		return true, nil
 	}
-
 	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

@@ -0,0 +1,70 @@
+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 (
-	"github.com/unistack-org/micro/v3/codec"
+	"go.unistack.org/micro/v4/codec"
 )
 
 type testRequest struct {
+	codec       codec.Codec
+	body        interface{}
 	service     string
 	method      string
 	endpoint    string
 	contentType string
-	codec       codec.Codec
-	body        interface{}
 	opts        RequestOptions
 }
 

cluster/cluster.go

@@ -0,0 +1,47 @@
+package cluster
+
+import (
+	"context"
+
+	"go.unistack.org/micro/v4/metadata"
+)
+
+// Message sent to member in cluster
+type Message interface {
+	// Header returns message headers
+	Header() metadata.Metadata
+	// Body returns broker message may be []byte slice or some go struct or interface
+	Body() interface{}
+}
+
+type Node interface {
+	// Name returns node name
+	Name() string
+	// Address returns node address
+	Address() string
+	// Metadata returns node metadata
+	Metadata() metadata.Metadata
+}
+
+// Cluster interface used for cluster communication across nodes
+type Cluster interface {
+	// Join is used to take an existing members and performing state sync
+	Join(ctx context.Context, addr ...string) error
+	// Leave broadcast a leave message and stop listeners
+	Leave(ctx context.Context) error
+	// Ping is used to probe live status of the node
+	Ping(ctx context.Context, node Node, payload []byte) error
+	// Members returns the cluster members
+	Members() ([]Node, error)
+	// Broadcast send message for all members in cluster, if filter is not nil, nodes may be filtered
+	// by key/value pairs
+	Broadcast(ctx context.Context, msg Message, filter ...string) error
+	// Unicast send message to single member in cluster
+	Unicast(ctx context.Context, node Node, msg Message) error
+	// Live returns cluster liveness
+	Live() bool
+	// Ready returns cluster readiness
+	Ready() bool
+	// Health returns cluster health
+	Health() bool
+}

codec/codec.go

@@ -3,17 +3,8 @@ package codec
 
 import (
 	"errors"
-	"io"
 
-	"github.com/unistack-org/micro/v3/metadata"
-)
-
-const (
-	// Message types
-	Error MessageType = iota
-	Request
-	Response
-	Event
+	"gopkg.in/yaml.v3"
 )
 
 var (
@@ -24,60 +15,63 @@ var (
 )
 
 var (
-	// DefaultMaxMsgSize specifies how much data codec can handle
-	DefaultMaxMsgSize       = 1024 * 1024 * 4 // 4Mb
-	DefaultCodec      Codec = NewCodec()
+	// DefaultCodec is the global default codec
+	DefaultCodec = NewCodec()
+	// DefaultTagName specifies struct tag name to control codec Marshal/Unmarshal
+	DefaultTagName = "codec"
 )
 
-// MessageType
-type MessageType int
-
-// Codec encodes/decodes various types of messages used within 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.
+// Codec encodes/decodes various types of messages.
 type Codec interface {
-	ReadHeader(io.Reader, *Message, MessageType) error
-	ReadBody(io.Reader, interface{}) error
-	Write(io.Writer, *Message, interface{}) error
-	Marshal(interface{}) ([]byte, error)
-	Unmarshal([]byte, interface{}) error
+	Marshal(v interface{}, opts ...Option) ([]byte, error)
+	Unmarshal(b []byte, v interface{}, opts ...Option) error
 	String() string
 }
 
-// Message represents detailed information about
-// the communication, likely followed by the body.
-// In the case of an error, body may be nil.
-type Message struct {
-	Id       string
-	Type     MessageType
-	Target   string
-	Method   string
-	Endpoint string
-	Error    string
-
-	// The values read from the socket
-	Header metadata.Metadata
-	Body   []byte
+type CodecV2 interface {
+	Marshal(buf []byte, v interface{}, opts ...Option) ([]byte, error)
+	Unmarshal(buf []byte, v interface{}, opts ...Option) error
+	String() string
 }
 
-// Option func
-type Option func(*Options)
+// 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
 
-// Options contains codec options
-type Options struct {
-	MaxMsgSize int64
-}
-
-// MaxMsgSize sets the max message size
-func MaxMsgSize(n int64) Option {
-	return func(o *Options) {
-		o.MaxMsgSize = n
+// MarshalJSON returns m as the JSON encoding of m.
+func (m *RawMessage) MarshalJSON() ([]byte, error) {
+	if m == nil {
+		return []byte("null"), nil
+	} else if len(*m) == 0 {
+		return []byte("null"), nil
 	}
+	return *m, nil
 }
 
-// NewMessage creates new codec message
-func NewMessage(t MessageType) *Message {
-	return &Message{Type: t, Header: metadata.New(0)}
+// 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
+}
+
+// MarshalYAML returns m as the JSON encoding of m.
+func (m *RawMessage) MarshalYAML() ([]byte, error) {
+	if m == nil {
+		return []byte("null"), nil
+	} else if len(*m) == 0 {
+		return []byte("null"), nil
+	}
+	return *m, nil
+}
+
+// UnmarshalYAML sets *m to a copy of data.
+func (m *RawMessage) UnmarshalYAML(n *yaml.Node) error {
+	if m == nil {
+		return errors.New("RawMessage UnmarshalYAML on nil pointer")
+	}
+	*m = append((*m)[0:0], []byte(n.Value)...)
+	return nil
 }

codec/context.go

@@ -0,0 +1,43 @@
+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
+}
+
+// MustContext returns codec from context
+func MustContext(ctx context.Context) Codec {
+	c, ok := FromContext(ctx)
+	if !ok {
+		panic("missing codec")
+	}
+	return c
+}
+
+// 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

@@ -0,0 +1,35 @@
+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

@@ -0,0 +1,58 @@
+package codec
+
+import "gopkg.in/yaml.v3"
+
+// 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)
+}
+
+// MarshalYAML returns frame data
+func (m *Frame) MarshalYAML() ([]byte, error) {
+	return m.Marshal()
+}
+
+// UnmarshalYAML set frame data
+func (m *Frame) UnmarshalYAML(n *yaml.Node) error {
+	m.Data = []byte(n.Value)
+	return nil
+}
+
+// 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
+}

codec/frame.proto

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

codec/noop.go

@@ -1,73 +1,13 @@
 package codec
 
 import (
-	"io"
-	"io/ioutil"
+	"encoding/json"
+
+	codecpb "go.unistack.org/micro-proto/v4/codec"
 )
 
 type noopCodec struct {
-}
-
-// Frame gives us the ability to define raw data to send over the pipes
-type Frame struct {
-	Data []byte
-}
-
-func (c *noopCodec) ReadHeader(conn io.Reader, m *Message, t MessageType) error {
-	return nil
-}
-
-func (c *noopCodec) ReadBody(conn io.Reader, b interface{}) error {
-	// read bytes
-	buf, err := ioutil.ReadAll(conn)
-	if err != nil {
-		return err
-	}
-
-	if b == nil {
-		return nil
-	}
-
-	switch v := b.(type) {
-	case string:
-		v = string(buf)
-	case *string:
-		*v = string(buf)
-	case []byte:
-		v = buf
-	case *[]byte:
-		*v = buf
-	case *Frame:
-		v.Data = buf
-	default:
-		return ErrInvalidMessage
-	}
-
-	return nil
-}
-
-func (c *noopCodec) Write(conn io.Writer, m *Message, b interface{}) error {
-	if b == nil {
-		return nil
-	}
-
-	var v []byte
-	switch vb := b.(type) {
-	case *Frame:
-		v = vb.Data
-	case string:
-		v = []byte(vb)
-	case *string:
-		v = []byte(*vb)
-	case *[]byte:
-		v = *vb
-	case []byte:
-		v = vb
-	default:
-		return ErrInvalidMessage
-	}
-	_, err := conn.Write(v)
-	return err
+	opts Options
 }
 
 func (c *noopCodec) String() string {
@@ -75,11 +15,11 @@ func (c *noopCodec) String() string {
 }
 
 // NewCodec returns new noop codec
-func NewCodec() Codec {
-	return &noopCodec{}
+func NewCodec(opts ...Option) Codec {
+	return &noopCodec{opts: NewOptions(opts...)}
 }
 
-func (c *noopCodec) Marshal(v interface{}) ([]byte, error) {
+func (c *noopCodec) Marshal(v interface{}, opts ...Option) ([]byte, error) {
 	if v == nil {
 		return nil, nil
 	}
@@ -95,33 +35,34 @@ func (c *noopCodec) Marshal(v interface{}) ([]byte, error) {
 		return ve, nil
 	case *Frame:
 		return ve.Data, nil
-	case *Message:
-		return ve.Body, nil
+	case *codecpb.Frame:
+		return ve.Data, nil
 	}
-	return nil, ErrInvalidMessage
+
+	return json.Marshal(v)
 }
 
-func (c *noopCodec) Unmarshal(d []byte, v interface{}) error {
-	var err error
+func (c *noopCodec) Unmarshal(d []byte, v interface{}, opts ...Option) error {
 	if v == nil {
 		return nil
 	}
 	switch ve := v.(type) {
-	case string:
-		ve = string(d)
 	case *string:
 		*ve = string(d)
+		return nil
 	case []byte:
-		ve = d
+		copy(ve, d)
+		return nil
 	case *[]byte:
 		*ve = d
+		return nil
 	case *Frame:
 		ve.Data = d
-	case *Message:
-		ve.Body = d
-	default:
-		err = ErrInvalidMessage
+		return nil
+	case *codecpb.Frame:
+		ve.Data = d
+		return nil
 	}
 
-	return err
+	return json.Unmarshal(d, v)
 }

codec/noop_test.go

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