util/buffer: add new seeker implementation

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/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**

.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/ISSUE_TEMPLATE/bug_report.md

@@ -0,0 +1,24 @@
+---
+name: Bug report
+about: For reporting bugs in go-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.
+
+**Environment:**
+Go Version: please paste `go version` output here
+```
+please paste `go env` output here
+```

.github.old/ISSUE_TEMPLATE/feature-request---enhancement.md

@@ -0,0 +1,17 @@
+---
+name: Feature request / Enhancement
+about: If you have a need not served by go-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.

.github.old/ISSUE_TEMPLATE/question.md

@@ -0,0 +1,14 @@
+---
+name: Question
+about: Ask a question about go-micro
+title: ''
+labels: ''
+assignees: ''
+
+---
+
+Before asking, please check if your question has already been answered: 
+
+1. Check the documentation - https://micro.mu/docs/
+2. Check the examples and plugins - https://github.com/micro/examples & https://github.com/micro/go-plugins
+3. Search existing issues

.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

@@ -0,0 +1,47 @@
+name: build
+on:
+ push:
+    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:
+          # Required: the version of golangci-lint is required and must be specified without patch version: we always use the latest patch version.
+          version: v1.30
+          # Optional: working directory, useful for monorepos
+          # working-directory: somedir
+          # Optional: golangci-lint command line arguments.
+          # args: --issues-exit-code=0
+          # Optional: show only new issues if it's a pull request. The default value is `false`.
+          # only-new-issues: true

.github.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

.gitignore

@@ -0,0 +1,39 @@
+# Develop tools
+/.vscode/
+/.idea/
+.idea
+.vscode
+
+# Binaries for programs and plugins
+*.exe
+*.exe~
+*.dll
+*.so
+*.dylib
+
+# Folders
+_obj
+_test
+_build
+.DS_Store
+
+# Architecture specific extensions/prefixes
+*.[568vq]
+[568vq].out
+
+*.cgo1.go
+*.cgo2.c
+_cgo_defun.c
+_cgo_gotypes.go
+_cgo_export.*
+
+# Test binary, build with `go test -c`
+*.test
+
+# Output of the go coverage tool, specifically when used with LiteIDE
+*.out
+
+# vim temp files
+*~
+*.swp
+*.swo

.golangci.yml

@@ -0,0 +1,5 @@
+run:
+  concurrency: 8
+  deadline: 5m
+  issues-exit-code: 1
+  tests: true

.travis.yml

@@ -1,7 +0,0 @@
-language: go
-go:
-- 1.10.x
-- 1.11.x
-notifications:
-  slack:
-    secure: aEvhLbhujaGaKSrOokiG3//PaVHTIrc3fBpoRbCRqfZpyq6WREoapJJhF+tIpWWOwaC9GmChbD6aHo/jMUgwKXVyPSaNjiEL87YzUUpL8B2zslNp1rgfTg/LrzthOx3Q1TYwpaAl3to0fuHUVFX4yMeC2vuThq7WSXgMMxFCtbc=

LICENSE

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

README.md

@@ -1,54 +1,43 @@
-# Go Micro [![License](https://img.shields.io/:license-apache-blue.svg)](https://opensource.org/licenses/Apache-2.0) [![GoDoc](https://godoc.org/github.com/micro/go-micro?status.svg)](https://godoc.org/github.com/micro/go-micro) [![Travis CI](https://api.travis-ci.org/micro/go-micro.svg?branch=master)](https://travis-ci.org/micro/go-micro) [![Go Report Card](https://goreportcard.com/badge/micro/go-micro)](https://goreportcard.com/report/github.com/micro/go-micro)
+# Micro
+![Coverage](https://img.shields.io/badge/Coverage-44.6%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/v3?tab=overview)
+[![Status](https://git.unistack.org/unistack-org/micro/actions/workflows/job_tests.yml/badge.svg?branch=v3)](https://git.unistack.org/unistack-org/micro/actions?query=workflow%3Abuild+branch%3Av3+event%3Apush)
+[![Lint](https://goreportcard.com/badge/go.unistack.org/micro/v3)](https://goreportcard.com/report/go.unistack.org/micro/v3)
 
-Go Micro is a framework for micro service development.
+Micro is a standard library for microservices.
 
 ## Overview
 
-Go Micro provides the core requirements for distributed systems development including RPC and Event driven communication. 
-The **micro** philosophy is sane defaults with a pluggable architecture. We provide defaults to get you started quickly 
-but everything can be easily swapped out. 
-
-<img src="https://micro.mu/docs/images/go-micro.svg" />
-
-Plugins are available at [github.com/micro/go-plugins](https://github.com/micro/go-plugins).
-
-Follow us on [Twitter](https://twitter.com/microhq) or join the [Slack](http://slack.micro.mu/) community.
+Micro provides the core requirements for distributed systems development including RPC and Event driven communication. 
 
 ## Features
 
-Go Micro abstracts away the details of distributed systems. Here are the main features.
+Micro abstracts away the details of distributed systems. Here are the main features.
+
+- **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, 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 
+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. The default discovery mechanism is 
-multicast DNS (mdns), a zeroconf system. You can optionally set gossip using the SWIM protocol for p2p networks or consul for a
-resilient cloud-native setup.
-
-- **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. 
+development. When service A needs to speak to service B it needs the location of that service.
 
 - **Message Encoding** - Dynamic message encoding based on content-type. The client and server will use codecs along with content-type 
 to seamlessly encode and decode Go types for you. Any variety of messages could be encoded and sent from different clients. The client 
-and server handle this by default. This includes protobuf and json by default.
+and server handle this by default.
 
-- **Request/Response** - RPC 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. The default 
-transport is http/1.1 or http2 when tls is enabled.
+- **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.
 
-- **Async Messaging** - PubSub is built in as a first class citizen for asynchronous communication and event driven architectures. 
-Event notifications are a core pattern in micro service development. The default messaging is point-to-point http/1.1 or http2 when tls 
-is enabled.
+- **Synchronization** - Distributed systems are often built in an eventually consistent manner. Support for distributed locking and 
+leadership are built in as a Sync interface. When using an eventually consistent database or scheduling use the Sync interface.
 
-- **Pluggable Interfaces** - Go Micro makes use of Go interfaces for each distributed system abstraction. Because of this these interfaces 
-are pluggable and allows Go Micro to be runtime agnostic. You can plugin any underlying technology. Find plugins in 
-[github.com/micro/go-plugins](https://github.com/micro/go-plugins).
+- **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
+## License
 
-See the [docs](https://micro.mu/docs/go-micro.html) for detailed information on the architecture, installation and use of go-micro.
+Micro is Apache 2.0 licensed.
 
-## Sponsors
-
-Sixt is an Enterprise Sponsor of Micro
-
-<a href="https://micro.mu/blog/2016/04/25/announcing-sixt-sponsorship.html"><img src="https://micro.mu/sixt_logo.png" width=150px height="auto" /></a>

README.zh-cn.md

@@ -1,41 +0,0 @@
-# Go Micro [![License](https://img.shields.io/:license-apache-blue.svg)](https://opensource.org/licenses/Apache-2.0) [![GoDoc](https://godoc.org/github.com/micro/go-micro?status.svg)](https://godoc.org/github.com/micro/go-micro) [![Travis CI](https://api.travis-ci.org/micro/go-micro.svg?branch=master)](https://travis-ci.org/micro/go-micro) [![Go Report Card](https://goreportcard.com/badge/micro/go-micro)](https://goreportcard.com/report/github.com/micro/go-micro)
-
-Go Micro是基于Golang的微服务开发框架。
-
-## 概览
-
-Go Micro提供分布式系统开发的核心库，包含RPC与事件驱动的通信机制。
-
-**micro**的设计哲学是可插拔的架构理念，她提供可快速构建系统的组件，并且可以根据自身的需求剥离默认实现并自行定制。
-
-<img src="https://micro.mu/docs/images/go-micro.svg" />
-
-所有插件可在仓库[github.com/micro/go-plugins](https://github.com/micro/go-plugins)中找到。
-
-可以订阅我们的[Twitter](https://twitter.com/microhq)或者加入[Slack](http://slack.micro.mu/)论坛。
-
-## 特性
-
-Go Micro把分布式系统的各种细节抽象出来。下面是它的主要特性。
-
-- **服务发现（Service Discovery）** - 自动服务注册与名称解析。服务发现是微服务开发中的核心。当服务A要与服务B协作时，它得知道B在哪里。默认的服务发现系统是Consul，而multicast DNS (mdns，组播)机制作为本地解决方案，或者零依赖的P2P网络中的SWIM协议（gossip）。 
-
-- **负载均衡（Load Balancing）** - 在服务发现之上构建了负载均衡机制。当我们得到一个服务的任意多个的实例节点时，我们要一个机制去决定要路由到哪一个节点。我们使用随机处理过的哈希负载均衡机制来保证对服务请求颁发的均匀分布，并且在发生问题时进行重试。
-
-- **消息编码（Message Encoding）** - 支持基于内容类型（content-type）动态编码消息。客户端和服务端会一起使用content-type的格式来对Go进行无缝编/解码。各种各样的消息被编码会发送到不同的客户端，客户端服服务端默认会处理这些消息。content-type默认包含proto-rpc和json-rpc。
-
-- **Request/Response** - RPC通信基于支持双向流的请求/响应方式，我们提供有抽象的同步通信机制。请求发送到服务时，会自动解析、负载均衡、拨号、转成字节流。默认的传输协议是http/1.1，而tls下使用http2协议。
-
-- **异步消息（Async Messaging）** - 发布订阅（PubSub）头等功能内置在异步通信与事件驱动架构中。事件通知在微服务开发中处于核心位置。默认的消息传送使用点到点http/1.1，激活tls时则使用http2。
-
-- **可插拔接口（Pluggable Interfaces）** - Go Micro为每个分布式系统抽象出接口。因此，Go Micro的接口都是可插拔的，允许其在运行时不可知的情况下仍可支持。所以只要实现接口，可以在内部使用任何的技术。更多插件请参考：[github.com/micro/go-plugins](https://github.com/micro/go-plugins)。
-
-## 快速上手
-
-更多关于架构、安装的资料可以查看[文档](https://micro.mu/docs/go-micro_cn.html)。
-
-## 赞助商
-
-Sixt是我们的赞助商。
-
-<a href="https://micro.mu/blog/2016/04/25/announcing-sixt-sponsorship.html"><img src="https://micro.mu/sixt_logo.png" width=150px height="auto" /></a>

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

broker/broker.go

@@ -1,70 +1,134 @@
 // Package broker is an interface used for asynchronous messaging
 package broker
 
+import (
+	"context"
+	"errors"
+	"time"
+
+	"go.unistack.org/micro/v3/codec"
+	"go.unistack.org/micro/v3/metadata"
+)
+
+// DefaultBroker default memory broker
+var DefaultBroker Broker = NewBroker()
+
+var (
+	// 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")
+	// DefaultGracefulTimeout
+	DefaultGracefulTimeout = 5 * time.Second
+)
+
 // Broker is an interface used for asynchronous messaging.
 type Broker interface {
+	// 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() error
-	Disconnect() error
-	Init(...Option) error
-	Publish(string, *Message, ...PublishOption) error
-	Subscribe(string, Handler, ...SubscribeOption) (Subscriber, error)
+	// Connect connects to broker
+	Connect(ctx context.Context) error
+	// Disconnect disconnect from broker
+	Disconnect(ctx context.Context) error
+	// Publish message to broker topic
+	Publish(ctx context.Context, topic string, msg *Message, opts ...PublishOption) error
+	// Subscribe subscribes to topic message via handler
+	Subscribe(ctx context.Context, topic string, h Handler, opts ...SubscribeOption) (Subscriber, error)
+	// BatchPublish messages to broker with multiple topics
+	BatchPublish(ctx context.Context, msgs []*Message, opts ...PublishOption) error
+	// BatchSubscribe subscribes to topic messages via handler
+	BatchSubscribe(ctx context.Context, topic string, h BatchHandler, 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
 }
 
+type (
+	FuncPublish        func(ctx context.Context, topic string, msg *Message, opts ...PublishOption) error
+	HookPublish        func(next FuncPublish) FuncPublish
+	FuncBatchPublish   func(ctx context.Context, msgs []*Message, opts ...PublishOption) error
+	HookBatchPublish   func(next FuncBatchPublish) FuncBatchPublish
+	FuncSubscribe      func(ctx context.Context, topic string, h Handler, opts ...SubscribeOption) (Subscriber, error)
+	HookSubscribe      func(next FuncSubscribe) FuncSubscribe
+	FuncBatchSubscribe func(ctx context.Context, topic string, h BatchHandler, opts ...SubscribeOption) (Subscriber, error)
+	HookBatchSubscribe func(next FuncBatchSubscribe) FuncBatchSubscribe
+)
+
 // Handler is used to process messages via a subscription of a topic.
-// The handler is passed a publication interface which contains the
-// message and optional Ack method to acknowledge receipt of the message.
-type Handler func(Publication) error
+type Handler func(Event) error
 
-type Message struct {
-	Header map[string]string
-	Body   []byte
+// Events contains multiple events
+type Events []Event
+
+// Ack try to ack all events and return
+func (evs Events) Ack() error {
+	var err error
+	for _, ev := range evs {
+		if err = ev.Ack(); err != nil {
+			return err
+		}
+	}
+	return nil
 }
 
-// Publication is given to a subscription handler for processing
-type Publication interface {
+// SetError sets error on event
+func (evs Events) SetError(err error) {
+	for _, ev := range evs {
+		ev.SetError(err)
+	}
+}
+
+// BatchHandler is used to process messages in batches via a subscription of a topic.
+type BatchHandler func(Events) error
+
+// Event is given to a subscription handler for processing
+type Event interface {
+	// Context return context.Context for event
+	Context() context.Context
+	// Topic returns event topic
 	Topic() string
+	// Message returns broker message
 	Message() *Message
+	// Ack acknowledge message
 	Ack() error
+	// Error returns message error (like decoding errors or some other)
+	Error() error
+	// SetError set event processing error
+	SetError(err error)
+}
+
+// Message is used to transfer data
+type Message struct {
+	// Header contains message metadata
+	Header metadata.Metadata
+	// Body contains message body
+	Body codec.RawMessage
+}
+
+// NewMessage create broker message with topic filled
+func NewMessage(topic string) *Message {
+	m := &Message{Header: metadata.New(2)}
+	m.Header.Set(metadata.HeaderTopic, topic)
+	return m
 }
 
 // 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() error
-}
-
-var (
-	DefaultBroker Broker = newHttpBroker()
-)
-
-func NewBroker(opts ...Option) Broker {
-	return newHttpBroker(opts...)
-}
-
-func Init(opts ...Option) error {
-	return DefaultBroker.Init(opts...)
-}
-
-func Connect() error {
-	return DefaultBroker.Connect()
-}
-
-func Disconnect() error {
-	return DefaultBroker.Disconnect()
-}
-
-func Publish(topic string, msg *Message, opts ...PublishOption) error {
-	return DefaultBroker.Publish(topic, msg, opts...)
-}
-
-func Subscribe(topic string, handler Handler, opts ...SubscribeOption) (Subscriber, error) {
-	return DefaultBroker.Subscribe(topic, handler, opts...)
-}
-
-func String() string {
-	return DefaultBroker.String()
+	// Unsubscribe from topic
+	Unsubscribe(ctx context.Context) error
 }

broker/context.go

@@ -0,0 +1,63 @@
+package broker
+
+import (
+	"context"
+)
+
+type brokerKey struct{}
+
+// FromContext returns broker from passed context
+func FromContext(ctx context.Context) (Broker, bool) {
+	if ctx == nil {
+		return nil, false
+	}
+	c, ok := ctx.Value(brokerKey{}).(Broker)
+	return c, ok
+}
+
+// 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 {
+		ctx = context.Background()
+	}
+	return context.WithValue(ctx, brokerKey{}, s)
+}
+
+// SetSubscribeOption returns a function to setup a context with given value
+func SetSubscribeOption(k, v interface{}) SubscribeOption {
+	return func(o *SubscribeOptions) {
+		if o.Context == nil {
+			o.Context = context.Background()
+		}
+		o.Context = context.WithValue(o.Context, k, v)
+	}
+}
+
+// SetOption returns a function to setup a context with given value
+func SetOption(k, v interface{}) Option {
+	return func(o *Options) {
+		if o.Context == nil {
+			o.Context = context.Background()
+		}
+		o.Context = context.WithValue(o.Context, k, v)
+	}
+}
+
+// SetPublishOption returns a function to setup a context with given value
+func SetPublishOption(k, v interface{}) PublishOption {
+	return func(o *PublishOptions) {
+		if o.Context == nil {
+			o.Context = context.Background()
+		}
+		o.Context = context.WithValue(o.Context, k, v)
+	}
+}

broker/context_test.go

@@ -0,0 +1,72 @@
+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 TestSetPublishOption(t *testing.T) {
+	type key struct{}
+	o := SetPublishOption(key{}, "test")
+	opts := &PublishOptions{}
+	o(opts)
+
+	if v, ok := opts.Context.Value(key{}).(string); !ok || v == "" {
+		t.Fatal("SetPublishOption 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/http/http.go

@@ -1,11 +0,0 @@
-// Package http provides a http based message broker
-package http
-
-import (
-	"github.com/micro/go-micro/broker"
-)
-
-// NewBroker returns a new http broker
-func NewBroker(opts ...broker.Option) broker.Broker {
-	return broker.NewBroker(opts...)
-}

broker/http/options.go

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

broker/http_broker.go

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

broker/http_broker_test.go

@@ -1,351 +0,0 @@
-package broker
-
-import (
-	"sync"
-	"testing"
-	"time"
-
-	glog "github.com/go-log/log"
-	"github.com/google/uuid"
-	"github.com/micro/go-log"
-	"github.com/micro/go-micro/registry/memory"
-)
-
-func newTestRegistry() *memory.Registry {
-	r := memory.NewRegistry()
-	m := r.(*memory.Registry)
-	m.Setup()
-	return m
-}
-
-func sub(be *testing.B, c int) {
-	// set no op logger
-	log.SetLogger(glog.DefaultLogger)
-
-	be.StopTimer()
-	m := newTestRegistry()
-
-	b := NewBroker(Registry(m))
-	topic := uuid.New().String()
-
-	if err := b.Init(); err != nil {
-		be.Fatalf("Unexpected init error: %v", err)
-	}
-
-	if err := b.Connect(); err != nil {
-		be.Fatalf("Unexpected connect error: %v", err)
-	}
-
-	msg := &Message{
-		Header: map[string]string{
-			"Content-Type": "application/json",
-		},
-		Body: []byte(`{"message": "Hello World"}`),
-	}
-
-	var subs []Subscriber
-	done := make(chan bool, c)
-
-	for i := 0; i < c; i++ {
-		sub, err := b.Subscribe(topic, func(p Publication) error {
-			done <- true
-			m := p.Message()
-
-			if string(m.Body) != string(msg.Body) {
-				be.Fatalf("Unexpected msg %s, expected %s", string(m.Body), string(msg.Body))
-			}
-
-			return nil
-		}, Queue("shared"))
-		if err != nil {
-			be.Fatalf("Unexpected subscribe error: %v", err)
-		}
-		subs = append(subs, sub)
-	}
-
-	for i := 0; i < be.N; i++ {
-		be.StartTimer()
-		if err := b.Publish(topic, msg); err != nil {
-			be.Fatalf("Unexpected publish error: %v", err)
-		}
-		<-done
-		be.StopTimer()
-	}
-
-	for _, sub := range subs {
-		sub.Unsubscribe()
-	}
-
-	if err := b.Disconnect(); err != nil {
-		be.Fatalf("Unexpected disconnect error: %v", err)
-	}
-}
-
-func pub(be *testing.B, c int) {
-	// set no op logger
-	log.SetLogger(glog.DefaultLogger)
-
-	be.StopTimer()
-	m := newTestRegistry()
-	b := NewBroker(Registry(m))
-	topic := uuid.New().String()
-
-	if err := b.Init(); err != nil {
-		be.Fatalf("Unexpected init error: %v", err)
-	}
-
-	if err := b.Connect(); err != nil {
-		be.Fatalf("Unexpected connect error: %v", err)
-	}
-
-	msg := &Message{
-		Header: map[string]string{
-			"Content-Type": "application/json",
-		},
-		Body: []byte(`{"message": "Hello World"}`),
-	}
-
-	done := make(chan bool, c*4)
-
-	sub, err := b.Subscribe(topic, func(p Publication) error {
-		done <- true
-		m := p.Message()
-		if string(m.Body) != string(msg.Body) {
-			be.Fatalf("Unexpected msg %s, expected %s", string(m.Body), string(msg.Body))
-		}
-		return nil
-	}, Queue("shared"))
-	if err != nil {
-		be.Fatalf("Unexpected subscribe error: %v", err)
-	}
-
-	var wg sync.WaitGroup
-	ch := make(chan int, c*4)
-	be.StartTimer()
-
-	for i := 0; i < c; i++ {
-		go func() {
-			for _ = range ch {
-				if err := b.Publish(topic, msg); err != nil {
-					be.Fatalf("Unexpected publish error: %v", err)
-				}
-				select {
-				case <-done:
-				case <-time.After(time.Second):
-				}
-				wg.Done()
-			}
-		}()
-	}
-
-	for i := 0; i < be.N; i++ {
-		wg.Add(1)
-		ch <- i
-	}
-
-	wg.Wait()
-	be.StopTimer()
-	sub.Unsubscribe()
-	close(ch)
-	close(done)
-
-	if err := b.Disconnect(); err != nil {
-		be.Fatalf("Unexpected disconnect error: %v", err)
-	}
-}
-
-func TestBroker(t *testing.T) {
-	m := newTestRegistry()
-	b := NewBroker(Registry(m))
-
-	if err := b.Init(); err != nil {
-		t.Fatalf("Unexpected init error: %v", err)
-	}
-
-	if err := b.Connect(); err != nil {
-		t.Fatalf("Unexpected connect error: %v", err)
-	}
-
-	msg := &Message{
-		Header: map[string]string{
-			"Content-Type": "application/json",
-		},
-		Body: []byte(`{"message": "Hello World"}`),
-	}
-
-	done := make(chan bool)
-
-	sub, err := b.Subscribe("test", func(p Publication) error {
-		m := p.Message()
-
-		if string(m.Body) != string(msg.Body) {
-			t.Fatalf("Unexpected msg %s, expected %s", string(m.Body), string(msg.Body))
-		}
-
-		close(done)
-		return nil
-	})
-	if err != nil {
-		t.Fatalf("Unexpected subscribe error: %v", err)
-	}
-
-	if err := b.Publish("test", msg); err != nil {
-		t.Fatalf("Unexpected publish error: %v", err)
-	}
-
-	<-done
-	sub.Unsubscribe()
-
-	if err := b.Disconnect(); err != nil {
-		t.Fatalf("Unexpected disconnect error: %v", err)
-	}
-}
-
-func TestConcurrentSubBroker(t *testing.T) {
-	m := newTestRegistry()
-	b := NewBroker(Registry(m))
-
-	if err := b.Init(); err != nil {
-		t.Fatalf("Unexpected init error: %v", err)
-	}
-
-	if err := b.Connect(); err != nil {
-		t.Fatalf("Unexpected connect error: %v", err)
-	}
-
-	msg := &Message{
-		Header: map[string]string{
-			"Content-Type": "application/json",
-		},
-		Body: []byte(`{"message": "Hello World"}`),
-	}
-
-	var subs []Subscriber
-	var wg sync.WaitGroup
-
-	for i := 0; i < 10; i++ {
-		sub, err := b.Subscribe("test", func(p Publication) error {
-			defer wg.Done()
-
-			m := p.Message()
-
-			if string(m.Body) != string(msg.Body) {
-				t.Fatalf("Unexpected msg %s, expected %s", string(m.Body), string(msg.Body))
-			}
-
-			return nil
-		})
-		if err != nil {
-			t.Fatalf("Unexpected subscribe error: %v", err)
-		}
-
-		wg.Add(1)
-		subs = append(subs, sub)
-	}
-
-	if err := b.Publish("test", msg); err != nil {
-		t.Fatalf("Unexpected publish error: %v", err)
-	}
-
-	wg.Wait()
-
-	for _, sub := range subs {
-		sub.Unsubscribe()
-	}
-
-	if err := b.Disconnect(); err != nil {
-		t.Fatalf("Unexpected disconnect error: %v", err)
-	}
-}
-
-func TestConcurrentPubBroker(t *testing.T) {
-	m := newTestRegistry()
-	b := NewBroker(Registry(m))
-
-	if err := b.Init(); err != nil {
-		t.Fatalf("Unexpected init error: %v", err)
-	}
-
-	if err := b.Connect(); err != nil {
-		t.Fatalf("Unexpected connect error: %v", err)
-	}
-
-	msg := &Message{
-		Header: map[string]string{
-			"Content-Type": "application/json",
-		},
-		Body: []byte(`{"message": "Hello World"}`),
-	}
-
-	var wg sync.WaitGroup
-
-	sub, err := b.Subscribe("test", func(p Publication) error {
-		defer wg.Done()
-
-		m := p.Message()
-
-		if string(m.Body) != string(msg.Body) {
-			t.Fatalf("Unexpected msg %s, expected %s", string(m.Body), string(msg.Body))
-		}
-
-		return nil
-	})
-	if err != nil {
-		t.Fatalf("Unexpected subscribe error: %v", err)
-	}
-
-	for i := 0; i < 10; i++ {
-		wg.Add(1)
-
-		if err := b.Publish("test", msg); err != nil {
-			t.Fatalf("Unexpected publish error: %v", err)
-		}
-	}
-
-	wg.Wait()
-
-	sub.Unsubscribe()
-
-	if err := b.Disconnect(); err != nil {
-		t.Fatalf("Unexpected disconnect error: %v", err)
-	}
-}
-
-func BenchmarkSub1(b *testing.B) {
-	sub(b, 1)
-}
-func BenchmarkSub8(b *testing.B) {
-	sub(b, 8)
-}
-
-func BenchmarkSub32(b *testing.B) {
-	sub(b, 32)
-}
-
-func BenchmarkSub64(b *testing.B) {
-	sub(b, 64)
-}
-
-func BenchmarkSub128(b *testing.B) {
-	sub(b, 128)
-}
-
-func BenchmarkPub1(b *testing.B) {
-	pub(b, 1)
-}
-
-func BenchmarkPub8(b *testing.B) {
-	pub(b, 8)
-}
-
-func BenchmarkPub32(b *testing.B) {
-	pub(b, 32)
-}
-
-func BenchmarkPub64(b *testing.B) {
-	pub(b, 64)
-}
-
-func BenchmarkPub128(b *testing.B) {
-	pub(b, 128)
-}

broker/memory/memory.go

@@ -1,33 +1,46 @@
-// Package memory provides a memory broker
-package memory
+package broker
 
 import (
-	"errors"
+	"context"
 	"sync"
 
-	"github.com/google/uuid"
-	"github.com/micro/go-micro/broker"
+	"go.unistack.org/micro/v3/broker"
+	"go.unistack.org/micro/v3/logger"
+	"go.unistack.org/micro/v3/metadata"
+	"go.unistack.org/micro/v3/options"
+	maddr "go.unistack.org/micro/v3/util/addr"
+	"go.unistack.org/micro/v3/util/id"
+	mnet "go.unistack.org/micro/v3/util/net"
+	"go.unistack.org/micro/v3/util/rand"
 )
 
 type memoryBroker struct {
-	opts broker.Options
-
+	funcPublish        broker.FuncPublish
+	funcBatchPublish   broker.FuncBatchPublish
+	funcSubscribe      broker.FuncSubscribe
+	funcBatchSubscribe broker.FuncBatchSubscribe
+	subscribers        map[string][]*memorySubscriber
+	addr               string
+	opts               broker.Options
 	sync.RWMutex
-	connected   bool
-	Subscribers map[string][]*memorySubscriber
+	connected bool
 }
 
-type memoryPublication struct {
+type memoryEvent struct {
+	err     error
+	message interface{}
 	topic   string
-	message *broker.Message
+	opts    broker.Options
 }
 
 type memorySubscriber struct {
-	id      string
-	topic   string
-	exit    chan bool
-	handler broker.Handler
-	opts    broker.SubscribeOptions
+	ctx          context.Context
+	exit         chan bool
+	handler      broker.Handler
+	batchhandler broker.BatchHandler
+	id           string
+	topic        string
+	opts         broker.SubscribeOptions
 }
 
 func (m *memoryBroker) Options() broker.Options {
@@ -35,10 +48,16 @@ func (m *memoryBroker) Options() broker.Options {
 }
 
 func (m *memoryBroker) Address() string {
-	return ""
+	return m.addr
 }
 
-func (m *memoryBroker) Connect() error {
+func (m *memoryBroker) Connect(ctx context.Context) error {
+	select {
+	case <-ctx.Done():
+		return ctx.Err()
+	default:
+	}
+
 	m.Lock()
 	defer m.Unlock()
 
@@ -46,12 +65,29 @@ func (m *memoryBroker) Connect() error {
 		return nil
 	}
 
+	// use 127.0.0.1 to avoid scan of all network interfaces
+	addr, err := maddr.Extract("127.0.0.1")
+	if err != nil {
+		return err
+	}
+	var rng rand.Rand
+	i := rng.Intn(20000)
+	// set addr with port
+	addr = mnet.HostPort(addr, 10000+i)
+
+	m.addr = addr
 	m.connected = true
 
 	return nil
 }
 
-func (m *memoryBroker) Disconnect() error {
+func (m *memoryBroker) Disconnect(ctx context.Context) error {
+	select {
+	case <-ctx.Done():
+		return ctx.Err()
+	default:
+	}
+
 	m.Lock()
 	defer m.Unlock()
 
@@ -60,7 +96,6 @@ func (m *memoryBroker) Disconnect() error {
 	}
 
 	m.connected = false
-
 	return nil
 }
 
@@ -68,70 +103,228 @@ func (m *memoryBroker) Init(opts ...broker.Option) error {
 	for _, o := range opts {
 		o(&m.opts)
 	}
+
+	m.funcPublish = m.fnPublish
+	m.funcBatchPublish = m.fnBatchPublish
+	m.funcSubscribe = m.fnSubscribe
+	m.funcBatchSubscribe = m.fnBatchSubscribe
+
+	m.opts.Hooks.EachPrev(func(hook options.Hook) {
+		switch h := hook.(type) {
+		case broker.HookPublish:
+			m.funcPublish = h(m.funcPublish)
+		case broker.HookBatchPublish:
+			m.funcBatchPublish = h(m.funcBatchPublish)
+		case broker.HookSubscribe:
+			m.funcSubscribe = h(m.funcSubscribe)
+		case broker.HookBatchSubscribe:
+			m.funcBatchSubscribe = h(m.funcBatchSubscribe)
+		}
+	})
+
 	return nil
 }
 
-func (m *memoryBroker) Publish(topic string, message *broker.Message, opts ...broker.PublishOption) error {
-	m.Lock()
-	defer m.Unlock()
+func (m *memoryBroker) Publish(ctx context.Context, topic string, msg *broker.Message, opts ...broker.PublishOption) error {
+	return m.funcPublish(ctx, topic, msg, opts...)
+}
 
+func (m *memoryBroker) fnPublish(ctx context.Context, topic string, msg *broker.Message, opts ...broker.PublishOption) error {
+	msg.Header.Set(metadata.HeaderTopic, topic)
+	return m.publish(ctx, []*broker.Message{msg}, opts...)
+}
+
+func (m *memoryBroker) BatchPublish(ctx context.Context, msgs []*broker.Message, opts ...broker.PublishOption) error {
+	return m.funcBatchPublish(ctx, msgs, opts...)
+}
+
+func (m *memoryBroker) fnBatchPublish(ctx context.Context, msgs []*broker.Message, opts ...broker.PublishOption) error {
+	return m.publish(ctx, msgs, opts...)
+}
+
+func (m *memoryBroker) publish(ctx context.Context, msgs []*broker.Message, opts ...broker.PublishOption) error {
+	m.RLock()
 	if !m.connected {
-		return errors.New("not connected")
+		m.RUnlock()
+		return broker.ErrNotConnected
 	}
+	m.RUnlock()
 
-	subs, ok := m.Subscribers[topic]
-	if !ok {
-		return nil
-	}
+	var err error
 
-	p := &memoryPublication{
-		topic:   topic,
-		message: message,
-	}
+	select {
+	case <-ctx.Done():
+		return ctx.Err()
+	default:
+		options := broker.NewPublishOptions(opts...)
 
-	for _, sub := range subs {
-		if err := sub.handler(p); err != nil {
-			return err
+		msgTopicMap := make(map[string]broker.Events)
+		for _, v := range msgs {
+			p := &memoryEvent{opts: m.opts}
+
+			if m.opts.Codec == nil || options.BodyOnly {
+				p.topic, _ = v.Header.Get(metadata.HeaderTopic)
+				p.message = v.Body
+			} else {
+				p.topic, _ = v.Header.Get(metadata.HeaderTopic)
+				p.message, err = m.opts.Codec.Marshal(v)
+				if err != nil {
+					return err
+				}
+			}
+			msgTopicMap[p.topic] = append(msgTopicMap[p.topic], p)
+		}
+
+		beh := m.opts.BatchErrorHandler
+		eh := m.opts.ErrorHandler
+
+		for t, ms := range msgTopicMap {
+			m.RLock()
+			subs, ok := m.subscribers[t]
+			m.RUnlock()
+			if !ok {
+				continue
+			}
+
+			for _, sub := range subs {
+				if sub.opts.BatchErrorHandler != nil {
+					beh = sub.opts.BatchErrorHandler
+				}
+				if sub.opts.ErrorHandler != nil {
+					eh = sub.opts.ErrorHandler
+				}
+
+				switch {
+				// batch processing
+				case sub.batchhandler != nil:
+					if err = sub.batchhandler(ms); err != nil {
+						ms.SetError(err)
+						if beh != nil {
+							_ = beh(ms)
+						} else if m.opts.Logger.V(logger.ErrorLevel) {
+							m.opts.Logger.Error(m.opts.Context, err.Error())
+						}
+					} else if sub.opts.AutoAck {
+						if err = ms.Ack(); err != nil {
+							m.opts.Logger.Error(m.opts.Context, "broker ack error", err)
+						}
+					}
+					// single processing
+				case sub.handler != nil:
+					for _, p := range ms {
+						if err = sub.handler(p); err != nil {
+							p.SetError(err)
+							if eh != nil {
+								_ = eh(p)
+							} else if m.opts.Logger.V(logger.ErrorLevel) {
+								m.opts.Logger.Error(m.opts.Context, "broker handler error", err)
+							}
+						} else if sub.opts.AutoAck {
+							if err = p.Ack(); err != nil {
+								m.opts.Logger.Error(m.opts.Context, "broker ack error", err)
+							}
+						}
+					}
+				}
+			}
 		}
 	}
 
 	return nil
 }
 
-func (m *memoryBroker) Subscribe(topic string, handler broker.Handler, opts ...broker.SubscribeOption) (broker.Subscriber, error) {
-	m.Lock()
-	defer m.Unlock()
+func (m *memoryBroker) BatchSubscribe(ctx context.Context, topic string, handler broker.BatchHandler, opts ...broker.SubscribeOption) (broker.Subscriber, error) {
+	return m.funcBatchSubscribe(ctx, topic, handler, opts...)
+}
 
+func (m *memoryBroker) fnBatchSubscribe(ctx context.Context, topic string, handler broker.BatchHandler, opts ...broker.SubscribeOption) (broker.Subscriber, error) {
+	m.RLock()
 	if !m.connected {
-		return nil, errors.New("not connected")
+		m.RUnlock()
+		return nil, broker.ErrNotConnected
+	}
+	m.RUnlock()
+
+	sid, err := id.New()
+	if err != nil {
+		return nil, err
 	}
 
-	var options broker.SubscribeOptions
-	for _, o := range opts {
-		o(&options)
-	}
+	options := broker.NewSubscribeOptions(opts...)
 
 	sub := &memorySubscriber{
-		exit:    make(chan bool, 1),
-		id:      uuid.New().String(),
-		topic:   topic,
-		handler: handler,
-		opts:    options,
+		exit:         make(chan bool, 1),
+		id:           sid,
+		topic:        topic,
+		batchhandler: handler,
+		opts:         options,
+		ctx:          ctx,
 	}
 
-	m.Subscribers[topic] = append(m.Subscribers[topic], sub)
+	m.Lock()
+	m.subscribers[topic] = append(m.subscribers[topic], sub)
+	m.Unlock()
 
 	go func() {
 		<-sub.exit
 		m.Lock()
-		var newSubscribers []*memorySubscriber
-		for _, sb := range m.Subscribers[topic] {
+		newSubscribers := make([]*memorySubscriber, 0, len(m.subscribers)-1)
+		for _, sb := range m.subscribers[topic] {
 			if sb.id == sub.id {
 				continue
 			}
 			newSubscribers = append(newSubscribers, sb)
 		}
-		m.Subscribers[topic] = newSubscribers
+		m.subscribers[topic] = newSubscribers
+		m.Unlock()
+	}()
+
+	return sub, nil
+}
+
+func (m *memoryBroker) Subscribe(ctx context.Context, topic string, handler broker.Handler, opts ...broker.SubscribeOption) (broker.Subscriber, error) {
+	return m.funcSubscribe(ctx, topic, handler, opts...)
+}
+
+func (m *memoryBroker) fnSubscribe(ctx context.Context, topic string, handler broker.Handler, opts ...broker.SubscribeOption) (broker.Subscriber, error) {
+	m.RLock()
+	if !m.connected {
+		m.RUnlock()
+		return nil, broker.ErrNotConnected
+	}
+	m.RUnlock()
+
+	sid, err := id.New()
+	if err != nil {
+		return nil, err
+	}
+
+	options := broker.NewSubscribeOptions(opts...)
+
+	sub := &memorySubscriber{
+		exit:    make(chan bool, 1),
+		id:      sid,
+		topic:   topic,
+		handler: handler,
+		opts:    options,
+		ctx:     ctx,
+	}
+
+	m.Lock()
+	m.subscribers[topic] = append(m.subscribers[topic], sub)
+	m.Unlock()
+
+	go func() {
+		<-sub.exit
+		m.Lock()
+		newSubscribers := make([]*memorySubscriber, 0, len(m.subscribers)-1)
+		for _, sb := range m.subscribers[topic] {
+			if sb.id == sub.id {
+				continue
+			}
+			newSubscribers = append(newSubscribers, sb)
+		}
+		m.subscribers[topic] = newSubscribers
 		m.Unlock()
 	}()
 
@@ -142,18 +335,60 @@ func (m *memoryBroker) String() string {
 	return "memory"
 }
 
-func (m *memoryPublication) Topic() string {
+func (m *memoryBroker) Name() string {
+	return m.opts.Name
+}
+
+func (m *memoryBroker) Live() bool {
+	return true
+}
+
+func (m *memoryBroker) Ready() bool {
+	return true
+}
+
+func (m *memoryBroker) Health() bool {
+	return true
+}
+
+func (m *memoryEvent) Topic() string {
 	return m.topic
 }
 
-func (m *memoryPublication) Message() *broker.Message {
-	return m.message
+func (m *memoryEvent) Message() *broker.Message {
+	switch v := m.message.(type) {
+	case *broker.Message:
+		return v
+	case []byte:
+		msg := &broker.Message{}
+		if err := m.opts.Codec.Unmarshal(v, msg); err != nil {
+			if m.opts.Logger.V(logger.ErrorLevel) {
+				m.opts.Logger.Error(m.opts.Context, "[memory]: failed to unmarshal: %v", err)
+			}
+			return nil
+		}
+		return msg
+	}
+
+	return nil
 }
 
-func (m *memoryPublication) Ack() error {
+func (m *memoryEvent) Ack() error {
 	return nil
 }
 
+func (m *memoryEvent) Error() error {
+	return m.err
+}
+
+func (m *memoryEvent) SetError(err error) {
+	m.err = err
+}
+
+func (m *memoryEvent) Context() context.Context {
+	return m.opts.Context
+}
+
 func (m *memorySubscriber) Options() broker.SubscribeOptions {
 	return m.opts
 }
@@ -162,19 +397,15 @@ func (m *memorySubscriber) Topic() string {
 	return m.topic
 }
 
-func (m *memorySubscriber) Unsubscribe() error {
+func (m *memorySubscriber) Unsubscribe(ctx context.Context) error {
 	m.exit <- true
 	return nil
 }
 
+// NewBroker return new memory broker
 func NewBroker(opts ...broker.Option) broker.Broker {
-	var options broker.Options
-	for _, o := range opts {
-		o(&options)
-	}
-
 	return &memoryBroker{
-		opts:        options,
-		Subscribers: make(map[string][]*memorySubscriber),
+		opts:        broker.NewOptions(opts...),
+		subscribers: make(map[string][]*memorySubscriber),
 	}
 }

broker/memory/memory_test.go

@@ -1,50 +1,114 @@
-package memory
+package broker
 
 import (
+	"context"
 	"fmt"
 	"testing"
 
-	"github.com/micro/go-micro/broker"
+	"go.unistack.org/micro/v3/broker"
+	"go.unistack.org/micro/v3/metadata"
 )
 
-func TestMemoryBroker(t *testing.T) {
+func TestMemoryBatchBroker(t *testing.T) {
 	b := NewBroker()
+	ctx := context.Background()
 
-	if err := b.Connect(); err != nil {
+	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 := 10
 
-	fn := func(p broker.Publication) error {
-		return nil
+	fn := func(evts broker.Events) error {
+		return evts.Ack()
 	}
 
-	sub, err := b.Subscribe(topic, fn)
+	sub, err := b.BatchSubscribe(ctx, topic, fn)
 	if err != nil {
 		t.Fatalf("Unexpected error subscribing %v", err)
 	}
 
+	msgs := make([]*broker.Message, 0, count)
 	for i := 0; i < count; i++ {
 		message := &broker.Message{
 			Header: map[string]string{
-				"foo": "bar",
-				"id":  fmt.Sprintf("%d", i),
+				metadata.HeaderTopic: topic,
+				"foo":                "bar",
+				"id":                 fmt.Sprintf("%d", i),
 			},
-			Body: []byte(`hello world`),
-		}
-
-		if err := b.Publish(topic, message); err != nil {
-			t.Fatalf("Unexpected error publishing %d", i)
+			Body: []byte(`"hello world"`),
 		}
+		msgs = append(msgs, message)
 	}
 
-	if err := sub.Unsubscribe(); err != nil {
+	if err := b.BatchPublish(ctx, msgs); err != nil {
+		t.Fatalf("Unexpected error publishing %v", err)
+	}
+
+	if err := sub.Unsubscribe(ctx); err != nil {
 		t.Fatalf("Unexpected error unsubscribing from %s: %v", topic, err)
 	}
 
-	if err := b.Disconnect(); err != nil {
+	if err := b.Disconnect(ctx); err != nil {
+		t.Fatalf("Unexpected connect error %v", err)
+	}
+}
+
+func TestMemoryBroker(t *testing.T) {
+	b := NewBroker()
+	ctx := context.Background()
+
+	if err := b.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 := 10
+
+	fn := func(_ broker.Event) error {
+		return nil
+	}
+
+	sub, err := b.Subscribe(ctx, topic, fn)
+	if err != nil {
+		t.Fatalf("Unexpected error subscribing %v", err)
+	}
+
+	msgs := make([]*broker.Message, 0, count)
+	for i := 0; i < count; i++ {
+		message := &broker.Message{
+			Header: map[string]string{
+				metadata.HeaderTopic: topic,
+				"foo":                "bar",
+				"id":                 fmt.Sprintf("%d", i),
+			},
+			Body: []byte(`"hello world"`),
+		}
+		msgs = append(msgs, message)
+
+		if err := b.Publish(ctx, topic, message); err != nil {
+			t.Fatalf("Unexpected error publishing %d err: %v", i, err)
+		}
+	}
+
+	if err := b.BatchPublish(ctx, msgs); err != nil {
+		t.Fatalf("Unexpected error publishing %v", err)
+	}
+
+	if err := sub.Unsubscribe(ctx); err != nil {
+		t.Fatalf("Unexpected error unsubscribing from %s: %v", topic, err)
+	}
+
+	if err := b.Disconnect(ctx); err != nil {
 		t.Fatalf("Unexpected connect error %v", err)
 	}
 }

broker/noop.go

@@ -0,0 +1,140 @@
+package broker
+
+import (
+	"context"
+	"strings"
+
+	"go.unistack.org/micro/v3/options"
+)
+
+type NoopBroker struct {
+	funcPublish        FuncPublish
+	funcBatchPublish   FuncBatchPublish
+	funcSubscribe      FuncSubscribe
+	funcBatchSubscribe FuncBatchSubscribe
+	opts               Options
+}
+
+func NewBroker(opts ...Option) *NoopBroker {
+	b := &NoopBroker{opts: NewOptions(opts...)}
+	b.funcPublish = b.fnPublish
+	b.funcBatchPublish = b.fnBatchPublish
+	b.funcSubscribe = b.fnSubscribe
+	b.funcBatchSubscribe = b.fnBatchSubscribe
+
+	return b
+}
+
+func (b *NoopBroker) Health() bool {
+	return true
+}
+
+func (b *NoopBroker) Live() bool {
+	return true
+}
+
+func (b *NoopBroker) Ready() bool {
+	return true
+}
+
+func (b *NoopBroker) Name() string {
+	return b.opts.Name
+}
+
+func (b *NoopBroker) String() string {
+	return "noop"
+}
+
+func (b *NoopBroker) Options() Options {
+	return b.opts
+}
+
+func (b *NoopBroker) Init(opts ...Option) error {
+	for _, opt := range opts {
+		opt(&b.opts)
+	}
+
+	b.funcPublish = b.fnPublish
+	b.funcBatchPublish = b.fnBatchPublish
+	b.funcSubscribe = b.fnSubscribe
+	b.funcBatchSubscribe = b.fnBatchSubscribe
+
+	b.opts.Hooks.EachPrev(func(hook options.Hook) {
+		switch h := hook.(type) {
+		case HookPublish:
+			b.funcPublish = h(b.funcPublish)
+		case HookBatchPublish:
+			b.funcBatchPublish = h(b.funcBatchPublish)
+		case HookSubscribe:
+			b.funcSubscribe = h(b.funcSubscribe)
+		case HookBatchSubscribe:
+			b.funcBatchSubscribe = h(b.funcBatchSubscribe)
+		}
+	})
+
+	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, ",")
+}
+
+func (b *NoopBroker) fnBatchPublish(_ context.Context, _ []*Message, _ ...PublishOption) error {
+	return nil
+}
+
+func (b *NoopBroker) BatchPublish(ctx context.Context, msgs []*Message, opts ...PublishOption) error {
+	return b.funcBatchPublish(ctx, msgs, opts...)
+}
+
+func (b *NoopBroker) fnPublish(_ context.Context, _ string, _ *Message, _ ...PublishOption) error {
+	return nil
+}
+
+func (b *NoopBroker) Publish(ctx context.Context, topic string, msg *Message, opts ...PublishOption) error {
+	return b.funcPublish(ctx, topic, msg, opts...)
+}
+
+type NoopSubscriber struct {
+	ctx          context.Context
+	topic        string
+	handler      Handler
+	batchHandler BatchHandler
+	opts         SubscribeOptions
+}
+
+func (b *NoopBroker) fnBatchSubscribe(ctx context.Context, topic string, handler BatchHandler, opts ...SubscribeOption) (Subscriber, error) {
+	return &NoopSubscriber{ctx: ctx, topic: topic, opts: NewSubscribeOptions(opts...), batchHandler: handler}, nil
+}
+
+func (b *NoopBroker) BatchSubscribe(ctx context.Context, topic string, handler BatchHandler, opts ...SubscribeOption) (Subscriber, error) {
+	return b.funcBatchSubscribe(ctx, topic, handler, opts...)
+}
+
+func (b *NoopBroker) fnSubscribe(ctx context.Context, topic string, handler Handler, 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 Handler, 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, msg *Message, opts ...PublishOption) error {
+		t.f = true
+		return fn(ctx, topic, msg, opts...)
+	}
+}
+
+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,63 +3,136 @@ package broker
 import (
 	"context"
 	"crypto/tls"
+	"time"
 
-	"github.com/micro/go-micro/codec"
-	"github.com/micro/go-micro/registry"
+	"go.unistack.org/micro/v3/codec"
+	"go.unistack.org/micro/v3/logger"
+	"go.unistack.org/micro/v3/meter"
+	"go.unistack.org/micro/v3/options"
+	"go.unistack.org/micro/v3/register"
+	"go.unistack.org/micro/v3/sync"
+	"go.unistack.org/micro/v3/tracer"
 )
 
+// Options struct
 type Options struct {
-	Addrs     []string
-	Secure    bool
-	Codec     codec.Marshaler
+	// Name holds the broker name
+	Name string
+
+	// Tracer used for tracing
+	Tracer tracer.Tracer
+	// Register can be used for clustering
+	Register register.Register
+	// Codec holds the codec for marshal/unmarshal
+	Codec codec.Codec
+	// Logger used for logging
+	Logger logger.Logger
+	// 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
-	// Other options for implementations of the interface
-	// can be stored in a context
-	Context context.Context
+
+	// ErrorHandler used when broker can't unmarshal incoming message
+	ErrorHandler Handler
+	// BatchErrorHandler used when broker can't unmashal incoming messages
+	BatchErrorHandler BatchHandler
+
+	// 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{
+		Register:        register.DefaultRegister,
+		Logger:          logger.DefaultLogger,
+		Context:         context.Background(),
+		Meter:           meter.DefaultMeter,
+		Codec:           codec.DefaultCodec,
+		Tracer:          tracer.DefaultTracer,
+		GracefulTimeout: DefaultGracefulTimeout,
+	}
+	for _, o := range opts {
+		o(&options)
+	}
+	return options
+}
+
+// Context sets the context option
+func Context(ctx context.Context) Option {
+	return func(o *Options) {
+		o.Context = ctx
+	}
+}
+
+// PublishOptions struct
 type PublishOptions struct {
-	// Other options for implementations of the interface
-	// can be stored in a context
+	// Context holds external options
 	Context context.Context
+	// BodyOnly flag says the message contains raw body bytes
+	BodyOnly bool
 }
 
+// NewPublishOptions creates PublishOptions struct
+func NewPublishOptions(opts ...PublishOption) PublishOptions {
+	options := PublishOptions{
+		Context: context.Background(),
+	}
+	for _, o := range opts {
+		o(&options)
+	}
+	return options
+}
+
+// SubscribeOptions struct
 type SubscribeOptions struct {
-	// AutoAck defaults to true. When a handler returns
-	// with a nil error the message is acked.
-	AutoAck bool
-	// Subscribers with the same queue name
-	// will create a shared subscription where each
-	// receives a subset of messages.
-	Queue string
-
-	// Other options for implementations of the interface
-	// can be stored in a context
+	// Context holds external options
 	Context context.Context
+	// ErrorHandler used when broker can't unmarshal incoming message
+	ErrorHandler Handler
+	// BatchErrorHandler used when broker can't unmashal incoming messages
+	BatchErrorHandler BatchHandler
+	// 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
 type Option func(*Options)
 
+// PublishOption func
 type PublishOption func(*PublishOptions)
 
-type SubscribeOption func(*SubscribeOptions)
-
-type contextKeyT string
-
-var (
-	registryKey = contextKeyT("github.com/micro/go-micro/registry")
-)
-
-func NewSubscribeOptions(opts ...SubscribeOption) SubscribeOptions {
-	opt := SubscribeOptions{
-		AutoAck: true,
+// PublishBodyOnly publish only body of the message
+func PublishBodyOnly(b bool) PublishOption {
+	return func(o *PublishOptions) {
+		o.BodyOnly = b
 	}
+}
 
-	for _, o := range opts {
-		o(&opt)
+// PublishContext sets the context
+func PublishContext(ctx context.Context) PublishOption {
+	return func(o *PublishOptions) {
+		o.Context = ctx
 	}
-
-	return opt
 }
 
 // Addrs sets the host addresses to be used by the broker
@@ -71,50 +144,163 @@ func Addrs(addrs ...string) Option {
 
 // Codec sets the codec used for encoding/decoding used where
 // a broker does not support headers
-func Codec(c codec.Marshaler) Option {
+func Codec(c codec.Codec) Option {
 	return func(o *Options) {
 		o.Codec = c
 	}
 }
 
-// DisableAutoAck will disable auto acking of messages
-// after they have been handled.
-func DisableAutoAck() SubscribeOption {
-	return func(o *SubscribeOptions) {
-		o.AutoAck = false
+// 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
 	}
 }
 
-// Queue sets the name of the queue to share messages on
+// BatchErrorHandler will catch all broker errors that cant be handled
+// in normal way, for example Codec errors
+func BatchErrorHandler(h BatchHandler) Option {
+	return func(o *Options) {
+		o.BatchErrorHandler = 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
+	}
+}
+
+// SubscribeBatchErrorHandler will catch all broker errors that cant be handled
+// in normal way, for example Codec errors
+func SubscribeBatchErrorHandler(h BatchHandler) SubscribeOption {
+	return func(o *SubscribeOptions) {
+		o.BatchErrorHandler = h
+	}
+}
+
+// Queue sets the subscribers queue
+// Deprecated
 func Queue(name string) SubscribeOption {
 	return func(o *SubscribeOptions) {
-		o.Queue = name
+		o.Group = name
 	}
 }
 
-func Registry(r registry.Registry) Option {
+// SubscribeGroup sets the name of the queue to share messages on
+func SubscribeGroup(name string) SubscribeOption {
+	return func(o *SubscribeOptions) {
+		o.Group = name
+	}
+}
+
+// Register sets register option
+func Register(r register.Register) Option {
 	return func(o *Options) {
-		o.Context = context.WithValue(o.Context, registryKey, r)
+		o.Register = r
 	}
 }
 
-// Secure communication with the broker
-func Secure(b bool) Option {
-	return func(o *Options) {
-		o.Secure = b
-	}
-}
-
-// Specify TLS Config
+// TLSConfig sets the TLS Config
 func TLSConfig(t *tls.Config) Option {
 	return func(o *Options) {
 		o.TLSConfig = t
 	}
 }
 
+// Logger sets the logger
+func Logger(l logger.Logger) Option {
+	return func(o *Options) {
+		o.Logger = l
+	}
+}
+
+// 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
 	}
 }
+
+// DisableAutoAck disables auto ack
+// Deprecated
+func DisableAutoAck() SubscribeOption {
+	return func(o *SubscribeOptions) {
+		o.AutoAck = false
+	}
+}
+
+// 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
+}

client/backoff.go

@@ -4,14 +4,27 @@ import (
 	"context"
 	"math"
 	"time"
+
+	"go.unistack.org/micro/v3/util/backoff"
 )
 
+// BackoffFunc is the backoff call func
 type BackoffFunc func(ctx context.Context, req Request, attempts int) (time.Duration, error)
 
-// exponential backoff
-func exponentialBackoff(ctx context.Context, req Request, attempts int) (time.Duration, error) {
-	if attempts == 0 {
-		return time.Duration(0), nil
-	}
-	return time.Duration(math.Pow(10, float64(attempts))) * time.Millisecond, nil
+// 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

@@ -2,26 +2,55 @@ package client
 
 import (
 	"context"
-	"math"
 	"testing"
 	"time"
 )
 
-func TestBackoff(t *testing.T) {
-	delta := time.Duration(0)
+func TestBackoffExp(t *testing.T) {
+	results := []time.Duration{
+		0 * time.Second,
+		100 * time.Millisecond,
+		600 * time.Millisecond,
+		1900 * time.Millisecond,
+		4300 * time.Millisecond,
+		7900 * time.Millisecond,
+	}
 
-	c := NewClient()
+	r := &testRequest{
+		service: "test",
+		method:  "test",
+	}
 
 	for i := 0; i < 5; i++ {
-		d, err := exponentialBackoff(context.TODO(), c.NewRequest("test", "test", nil), i)
+		d, err := BackoffExp(context.TODO(), r, i)
 		if err != nil {
 			t.Fatal(err)
 		}
 
-		if d < delta {
-			t.Fatalf("Expected greater than %v, got %v", delta, d)
+		if d != results[i] {
+			t.Fatalf("Expected equal than %v, got %v", results[i], d)
+		}
+	}
+}
+
+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)
 		}
-
-		delta = time.Millisecond * time.Duration(math.Pow(10, float64(i+1)))
 	}
 }

client/buffer.go

@@ -1,14 +0,0 @@
-package client
-
-import (
-	"bytes"
-)
-
-type buffer struct {
-	*bytes.Buffer
-}
-
-func (b *buffer) Close() error {
-	b.Buffer.Reset()
-	return nil
-}

client/client.go

@@ -5,33 +5,62 @@ import (
 	"context"
 	"time"
 
-	"github.com/micro/go-micro/codec"
+	"go.unistack.org/micro/v3/codec"
+	"go.unistack.org/micro/v3/metadata"
+)
+
+var (
+	// DefaultClient is the global default client
+	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 bidiectional streaming of requests.
+// 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
+	BatchPublish(ctx context.Context, msg []Message, opts ...PublishOption) error
 	String() string
 }
 
-// Router manages request routing
-type Router interface {
-	SendRequest(context.Context, Request) (Response, error)
-}
+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
+	FuncPublish      func(ctx context.Context, msg Message, opts ...PublishOption) error
+	HookPublish      func(next FuncPublish) FuncPublish
+	FuncBatchPublish func(ctx context.Context, msg []Message, opts ...PublishOption) error
+	HookBatchPublish func(next FuncBatchPublish) FuncBatchPublish
+)
 
 // Message is the interface for publishing asynchronously
 type Message interface {
 	Topic() string
 	Payload() interface{}
 	ContentType() string
+	Metadata() metadata.Metadata
 }
 
 // Request is the interface for a synchronous request used by Call or Stream
@@ -47,7 +76,7 @@ type Request interface {
 	// The unencoded request body
 	Body() interface{}
 	// Write to the encoded request writer. This is nil before a call is made
-	Codec() codec.Writer
+	Codec() codec.Codec
 	// indicates whether the request will be a streaming one rather than unary
 	Stream() bool
 }
@@ -55,14 +84,14 @@ type Request interface {
 // Response is the response received from a service
 type Response interface {
 	// Read the response
-	Codec() codec.Reader
-	// read the header
-	Header() map[string]string
+	Codec() codec.Codec
+	// Header data
+	Header() metadata.Metadata
 	// Read the undecoded response
 	Read() ([]byte, error)
 }
 
-// Stream is the inteface for a bidirectional synchronous stream
+// Stream is the interface for a bidirectional synchronous stream
 type Stream interface {
 	// Context for the stream
 	Context() context.Context
@@ -71,13 +100,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
@@ -94,57 +129,3 @@ type MessageOption func(*MessageOptions)
 
 // RequestOption used by NewRequest
 type RequestOption func(*RequestOptions)
-
-var (
-	// DefaultClient is a default client to use out of the box
-	DefaultClient Client = newRpcClient()
-	// DefaultBackoff is the default backoff function for retries
-	DefaultBackoff = exponentialBackoff
-	// DefaultRetry is the default check-for-retry function for retries
-	DefaultRetry = RetryOnError
-	// DefaultRetries is the default number of times a request is tried
-	DefaultRetries = 1
-	// DefaultRequestTimeout is the default request timeout
-	DefaultRequestTimeout = time.Second * 5
-	// DefaultPoolSize sets the connection pool size
-	DefaultPoolSize = 100
-	// DefaultPoolTTL sets the connection pool ttl
-	DefaultPoolTTL = time.Minute
-)
-
-// Makes a synchronous call to a service using the default client
-func Call(ctx context.Context, request Request, response interface{}, opts ...CallOption) error {
-	return DefaultClient.Call(ctx, request, response, opts...)
-}
-
-// Publishes a publication using the default client. Using the underlying broker
-// set within the options.
-func Publish(ctx context.Context, msg Message, opts ...PublishOption) error {
-	return DefaultClient.Publish(ctx, msg, opts...)
-}
-
-// Creates a new message using the default client
-func NewMessage(topic string, payload interface{}, opts ...MessageOption) Message {
-	return DefaultClient.NewMessage(topic, payload, opts...)
-}
-
-// Creates a new client with the options passed in
-func NewClient(opt ...Option) Client {
-	return newRpcClient(opt...)
-}
-
-// Creates a new request using the default client. Content Type will
-// be set to the default within options and use the appropriate codec
-func NewRequest(service, endpoint string, request interface{}, reqOpts ...RequestOption) Request {
-	return DefaultClient.NewRequest(service, endpoint, request, reqOpts...)
-}
-
-// Creates a streaming connection with a service and returns responses on the
-// channel passed in. It's up to the user to close the streamer.
-func NewStream(ctx context.Context, request Request, opts ...CallOption) (Stream, error) {
-	return DefaultClient.Stream(ctx, request, opts...)
-}
-
-func String() string {
-	return DefaultClient.String()
-}

client/client_call_options.go

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

client/context.go

@@ -6,11 +6,58 @@ import (
 
 type clientKey struct{}
 
+// FromContext get client from context
 func FromContext(ctx context.Context) (Client, bool) {
+	if ctx == nil {
+		return nil, false
+	}
 	c, ok := ctx.Value(clientKey{}).(Client)
 	return c, ok
 }
 
+// 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 {
+		ctx = context.Background()
+	}
 	return context.WithValue(ctx, clientKey{}, c)
 }
+
+// SetPublishOption returns a function to setup a context with given value
+func SetPublishOption(k, v interface{}) PublishOption {
+	return func(o *PublishOptions) {
+		if o.Context == nil {
+			o.Context = context.Background()
+		}
+		o.Context = context.WithValue(o.Context, k, v)
+	}
+}
+
+// SetCallOption returns a function to setup a context with given value
+func SetCallOption(k, v interface{}) CallOption {
+	return func(o *CallOptions) {
+		if o.Context == nil {
+			o.Context = context.Background()
+		}
+		o.Context = context.WithValue(o.Context, k, v)
+	}
+}
+
+// SetOption returns a function to setup a context with given value
+func SetOption(k, v interface{}) Option {
+	return func(o *Options) {
+		if o.Context == nil {
+			o.Context = context.Background()
+		}
+		o.Context = context.WithValue(o.Context, k, v)
+	}
+}

client/context_test.go

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

@@ -0,0 +1,53 @@
+package client
+
+import (
+	"context"
+	"sort"
+
+	"go.unistack.org/micro/v3/errors"
+	"go.unistack.org/micro/v3/router"
+)
+
+// LookupFunc is used to lookup routes for a service
+type LookupFunc func(context.Context, Request, CallOptions) ([]string, error)
+
+// LookupRoute for a request using the router and then choose one using the selector
+func LookupRoute(_ context.Context, req Request, opts CallOptions) ([]string, error) {
+	// check to see if an address was provided as a call option
+	if len(opts.Address) > 0 {
+		return opts.Address, nil
+	}
+
+	if opts.Router == nil {
+		return nil, router.ErrRouteNotFound
+	}
+
+	// construct the router query
+	query := []router.QueryOption{router.QueryService(req.Service())}
+
+	// if a custom network was requested, pass this to the router. By default the router will use it's
+	// own network, which is set during initialisation.
+	if len(opts.Network) > 0 {
+		query = append(query, router.QueryNetwork(opts.Network))
+	}
+
+	// lookup the routes which can be used to execute the request
+	routes, err := opts.Router.Lookup(query...)
+	if err == router.ErrRouteNotFound {
+		return nil, errors.InternalServerError("go.micro.client", "service %s: %s", req.Service(), err.Error())
+	} else if err != nil {
+		return nil, errors.InternalServerError("go.micro.client", "error getting next %s node: %s", req.Service(), err.Error())
+	}
+
+	// sort by lowest metric first
+	sort.Slice(routes, func(i, j int) bool {
+		return routes[i].Metric < routes[j].Metric
+	})
+
+	addrs := make([]string, 0, len(routes))
+	for _, route := range routes {
+		addrs = append(addrs, route.Address)
+	}
+
+	return addrs, nil
+}

client/mock/context.go

@@ -1,16 +0,0 @@
-package mock
-
-import (
-	"context"
-)
-
-type responseKey struct{}
-
-func fromContext(ctx context.Context) (map[string][]MockResponse, bool) {
-	r, ok := ctx.Value(responseKey{}).(map[string][]MockResponse)
-	return r, ok
-}
-
-func newContext(ctx context.Context, r map[string][]MockResponse) context.Context {
-	return context.WithValue(ctx, responseKey{}, r)
-}

client/mock/mock.go

@@ -1,132 +0,0 @@
-// Package mock provides a mock client for testing
-package mock
-
-import (
-	"context"
-	"fmt"
-	"reflect"
-	"sync"
-
-	"github.com/micro/go-micro/client"
-	"github.com/micro/go-micro/errors"
-)
-
-var (
-	_ client.Client = NewClient()
-)
-
-type MockResponse struct {
-	Endpoint string
-	Response interface{}
-	Error    error
-}
-
-type MockClient struct {
-	Client client.Client
-	Opts   client.Options
-
-	sync.Mutex
-	Response map[string][]MockResponse
-}
-
-func (m *MockClient) Init(opts ...client.Option) error {
-	m.Lock()
-	defer m.Unlock()
-
-	for _, opt := range opts {
-		opt(&m.Opts)
-	}
-
-	r, ok := fromContext(m.Opts.Context)
-	if !ok {
-		r = make(map[string][]MockResponse)
-	}
-	m.Response = r
-
-	return nil
-}
-
-func (m *MockClient) Options() client.Options {
-	return m.Opts
-}
-
-func (m *MockClient) NewMessage(topic string, msg interface{}, opts ...client.MessageOption) client.Message {
-	return m.Client.NewMessage(topic, msg, opts...)
-}
-
-func (m *MockClient) NewRequest(service, endpoint string, req interface{}, reqOpts ...client.RequestOption) client.Request {
-	return m.Client.NewRequest(service, endpoint, req, reqOpts...)
-}
-
-func (m *MockClient) Call(ctx context.Context, req client.Request, rsp interface{}, opts ...client.CallOption) error {
-	m.Lock()
-	defer m.Unlock()
-
-	response, ok := m.Response[req.Service()]
-	if !ok {
-		return errors.NotFound("go.micro.client.mock", "service not found")
-	}
-
-	for _, r := range response {
-		if r.Endpoint != req.Endpoint() {
-			continue
-		}
-
-		if r.Error != nil {
-			return r.Error
-		}
-
-		v := reflect.ValueOf(rsp)
-
-		if t := reflect.TypeOf(rsp); t.Kind() == reflect.Ptr {
-			v = reflect.Indirect(v)
-		}
-		response := r.Response
-		if t := reflect.TypeOf(r.Response); t.Kind() == reflect.Func {
-			response = reflect.ValueOf(r.Response).Call([]reflect.Value{})[0].Interface()
-		}
-
-		v.Set(reflect.ValueOf(response))
-
-		return nil
-	}
-
-	return fmt.Errorf("rpc: can't find service %s", req.Endpoint())
-}
-
-func (m *MockClient) Stream(ctx context.Context, req client.Request, opts ...client.CallOption) (client.Stream, error) {
-	m.Lock()
-	defer m.Unlock()
-
-	// TODO: mock stream
-	return nil, nil
-}
-
-func (m *MockClient) Publish(ctx context.Context, p client.Message, opts ...client.PublishOption) error {
-	return nil
-}
-
-func (m *MockClient) String() string {
-	return "mock"
-}
-
-func NewClient(opts ...client.Option) *MockClient {
-	options := client.Options{
-		Context: context.TODO(),
-	}
-
-	for _, opt := range opts {
-		opt(&options)
-	}
-
-	r, ok := fromContext(options.Context)
-	if !ok {
-		r = make(map[string][]MockResponse)
-	}
-
-	return &MockClient{
-		Client:   client.DefaultClient,
-		Opts:     options,
-		Response: r,
-	}
-}

client/mock/mock_test.go

@@ -1,38 +0,0 @@
-package mock
-
-import (
-	"context"
-	"testing"
-
-	"github.com/micro/go-micro/errors"
-)
-
-func TestClient(t *testing.T) {
-	type TestResponse struct {
-		Param string
-	}
-
-	response := []MockResponse{
-		{Endpoint: "Foo.Bar", Response: map[string]interface{}{"foo": "bar"}},
-		{Endpoint: "Foo.Struct", Response: &TestResponse{Param: "aparam"}},
-		{Endpoint: "Foo.Fail", Error: errors.InternalServerError("go.mock", "failed")},
-		{Endpoint: "Foo.Func", Response: func() string { return "string" }},
-		{Endpoint: "Foo.FuncStruct", Response: func() *TestResponse { return &TestResponse{Param: "aparam"} }},
-	}
-
-	c := NewClient(Response("go.mock", response))
-
-	for _, r := range response {
-		req := c.NewRequest("go.mock", r.Endpoint, map[string]interface{}{"foo": "bar"})
-		var rsp interface{}
-
-		err := c.Call(context.TODO(), req, &rsp)
-
-		if err != r.Error {
-			t.Fatalf("Expecter error %v got %v", r.Error, err)
-		}
-
-		t.Log(rsp)
-	}
-
-}

client/mock/options.go

@@ -1,17 +0,0 @@
-package mock
-
-import (
-	"github.com/micro/go-micro/client"
-)
-
-// Response sets the response methods for a service
-func Response(service string, response []MockResponse) client.Option {
-	return func(o *client.Options) {
-		r, ok := fromContext(o.Context)
-		if !ok {
-			r = make(map[string][]MockResponse)
-		}
-		r[service] = response
-		o.Context = newContext(o.Context, r)
-	}
-}

client/noop.go

@@ -0,0 +1,638 @@
+package client
+
+import (
+	"context"
+	"fmt"
+	"os"
+	"strconv"
+	"time"
+
+	"go.unistack.org/micro/v3/broker"
+	"go.unistack.org/micro/v3/codec"
+	"go.unistack.org/micro/v3/errors"
+	"go.unistack.org/micro/v3/metadata"
+	"go.unistack.org/micro/v3/options"
+	"go.unistack.org/micro/v3/selector"
+	"go.unistack.org/micro/v3/semconv"
+	"go.unistack.org/micro/v3/tracer"
+)
+
+// DefaultCodecs will be used to encode/decode data
+var DefaultCodecs = map[string]codec.Codec{
+	"application/octet-stream": codec.NewCodec(),
+}
+
+type noopClient struct {
+	funcPublish      FuncPublish
+	funcBatchPublish FuncBatchPublish
+	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
+	stream      bool
+}
+
+// NewClient returns new noop client
+func NewClient(opts ...Option) Client {
+	n := &noopClient{opts: NewOptions(opts...)}
+
+	n.funcCall = n.fnCall
+	n.funcStream = n.fnStream
+	n.funcPublish = n.fnPublish
+	n.funcBatchPublish = n.fnBatchPublish
+
+	return n
+}
+
+func (n *noopClient) Name() string {
+	return n.opts.Name
+}
+
+func (n *noopRequest) Service() string {
+	return n.service
+}
+
+func (n *noopRequest) Method() string {
+	return n.method
+}
+
+func (n *noopRequest) Endpoint() string {
+	return n.endpoint
+}
+
+func (n *noopRequest) ContentType() string {
+	return n.contentType
+}
+
+func (n *noopRequest) Body() interface{} {
+	return n.body
+}
+
+func (n *noopRequest) Codec() codec.Codec {
+	return n.codec
+}
+
+func (n *noopRequest) Stream() bool {
+	return n.stream
+}
+
+type noopResponse struct {
+	codec  codec.Codec
+	header metadata.Metadata
+}
+
+func (n *noopResponse) Codec() codec.Codec {
+	return n.codec
+}
+
+func (n *noopResponse) Header() metadata.Metadata {
+	return n.header
+}
+
+func (n *noopResponse) Read() ([]byte, error) {
+	return nil, nil
+}
+
+type noopStream struct {
+	err error
+	ctx context.Context
+}
+
+func (n *noopStream) Context() context.Context {
+	return n.ctx
+}
+
+func (n *noopStream) Request() Request {
+	return &noopRequest{}
+}
+
+func (n *noopStream) Response() Response {
+	return &noopResponse{}
+}
+
+func (n *noopStream) Send(interface{}) error {
+	return nil
+}
+
+func (n *noopStream) Recv(interface{}) error {
+	return nil
+}
+
+func (n *noopStream) SendMsg(interface{}) error {
+	return nil
+}
+
+func (n *noopStream) RecvMsg(interface{}) error {
+	return nil
+}
+
+func (n *noopStream) Error() error {
+	return n.err
+}
+
+func (n *noopStream) Close() error {
+	if sp, ok := tracer.SpanFromContext(n.ctx); ok && sp != nil {
+		if n.err != nil {
+			sp.SetStatus(tracer.SpanStatusError, n.err.Error())
+		}
+		sp.Finish()
+	}
+	return n.err
+}
+
+func (n *noopStream) CloseSend() error {
+	return n.err
+}
+
+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 *noopMessage) Metadata() metadata.Metadata {
+	return n.opts.Metadata
+}
+
+func (n *noopClient) newCodec(contentType string) (codec.Codec, error) {
+	if cf, ok := n.opts.Codecs[contentType]; ok {
+		return cf, nil
+	}
+	if cf, ok := DefaultCodecs[contentType]; ok {
+		return cf, nil
+	}
+	return nil, codec.ErrUnknownContentType
+}
+
+func (n *noopClient) Init(opts ...Option) error {
+	for _, o := range opts {
+		o(&n.opts)
+	}
+
+	n.funcCall = n.fnCall
+	n.funcStream = n.fnStream
+	n.funcPublish = n.fnPublish
+	n.funcBatchPublish = n.fnBatchPublish
+
+	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)
+		case HookPublish:
+			n.funcPublish = h(n.funcPublish)
+		case HookBatchPublish:
+			n.funcBatchPublish = h(n.funcBatchPublish)
+		}
+	})
+
+	return nil
+}
+
+func (n *noopClient) Options() Options {
+	return n.opts
+}
+
+func (n *noopClient) String() string {
+	return "noop"
+}
+
+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, _ interface{}, _ ...RequestOption) Request {
+	return &noopRequest{service: service, endpoint: endpoint}
+}
+
+func (n *noopClient) NewMessage(topic string, msg interface{}, opts ...MessageOption) Message {
+	options := NewMessageOptions(append([]MessageOption{MessageContentType(n.opts.ContentType)}, opts...)...)
+	return &noopMessage{topic: topic, payload: msg, opts: options}
+}
+
+func (n *noopClient) Stream(ctx context.Context, req Request, opts ...CallOption) (Stream, 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()),
+	)
+	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())
+
+	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 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
+}
+
+func (n *noopClient) BatchPublish(ctx context.Context, ps []Message, opts ...PublishOption) error {
+	return n.funcBatchPublish(ctx, ps, opts...)
+}
+
+func (n *noopClient) fnBatchPublish(ctx context.Context, ps []Message, opts ...PublishOption) error {
+	return n.publish(ctx, ps, opts...)
+}
+
+func (n *noopClient) Publish(ctx context.Context, p Message, opts ...PublishOption) error {
+	return n.funcPublish(ctx, p, opts...)
+}
+
+func (n *noopClient) fnPublish(ctx context.Context, p Message, opts ...PublishOption) error {
+	return n.publish(ctx, []Message{p}, opts...)
+}
+
+func (n *noopClient) publish(ctx context.Context, ps []Message, opts ...PublishOption) error {
+	options := NewPublishOptions(opts...)
+
+	msgs := make([]*broker.Message, 0, len(ps))
+
+	// get proxy
+	exchange := ""
+	if v, ok := os.LookupEnv("MICRO_PROXY"); ok {
+		exchange = v
+	}
+	// get the exchange
+	if len(options.Exchange) > 0 {
+		exchange = options.Exchange
+	}
+
+	omd, ok := metadata.FromOutgoingContext(ctx)
+	if !ok {
+		omd = metadata.New(0)
+	}
+
+	for _, p := range ps {
+		md := metadata.Copy(omd)
+		topic := p.Topic()
+		if len(exchange) > 0 {
+			topic = exchange
+		}
+		md[metadata.HeaderTopic] = topic
+		iter := p.Metadata().Iterator()
+		var k, v string
+		for iter.Next(&k, &v) {
+			md.Set(k, v)
+		}
+
+		md[metadata.HeaderContentType] = p.ContentType()
+
+		var body []byte
+
+		// passed in raw data
+		if d, ok := p.Payload().(*codec.Frame); ok {
+			body = d.Data
+		} else {
+			// use codec for payload
+			cf, err := n.newCodec(p.ContentType())
+			if err != nil {
+				return errors.InternalServerError("go.micro.client", "%s", err)
+			}
+
+			// set the body
+			b, err := cf.Marshal(p.Payload())
+			if err != nil {
+				return errors.InternalServerError("go.micro.client", "%s", err)
+			}
+			body = b
+		}
+
+		msgs = append(msgs, &broker.Message{Header: md, Body: body})
+	}
+
+	if len(msgs) == 1 {
+		return n.opts.Broker.Publish(ctx, msgs[0].Header[metadata.HeaderTopic], msgs[0],
+			broker.PublishContext(options.Context),
+			broker.PublishBodyOnly(options.BodyOnly),
+		)
+	}
+
+	return n.opts.Broker.BatchPublish(ctx, msgs,
+		broker.PublishContext(options.Context),
+		broker.PublishBodyOnly(options.BodyOnly),
+	)
+}

client/noop_test.go

@@ -0,0 +1,35 @@
+package client
+
+import (
+	"context"
+	"testing"
+)
+
+type testHook struct {
+	f bool
+}
+
+func (t *testHook) Publish(fn FuncPublish) FuncPublish {
+	return func(ctx context.Context, msg Message, opts ...PublishOption) error {
+		t.f = true
+		return fn(ctx, msg, opts...)
+	}
+}
+
+func TestNoopHook(t *testing.T) {
+	h := &testHook{}
+
+	c := NewClient(Hooks(HookPublish(h.Publish)))
+
+	if err := c.Init(); err != nil {
+		t.Fatal(err)
+	}
+
+	if err := c.Publish(context.TODO(), c.NewMessage("", nil, MessageContentType("application/octet-stream"))); err != nil {
+		t.Fatal(err)
+	}
+
+	if !h.f {
+		t.Fatal("hook not works")
+	}
+}

client/options.go

@@ -2,130 +2,226 @@ package client
 
 import (
 	"context"
+	"crypto/tls"
+	"net"
 	"time"
 
-	"github.com/micro/go-micro/broker"
-	"github.com/micro/go-micro/codec"
-	"github.com/micro/go-micro/registry"
-	"github.com/micro/go-micro/selector"
-	"github.com/micro/go-micro/transport"
+	"go.unistack.org/micro/v3/broker"
+	"go.unistack.org/micro/v3/codec"
+	"go.unistack.org/micro/v3/logger"
+	"go.unistack.org/micro/v3/metadata"
+	"go.unistack.org/micro/v3/meter"
+	"go.unistack.org/micro/v3/options"
+	"go.unistack.org/micro/v3/register"
+	"go.unistack.org/micro/v3/router"
+	"go.unistack.org/micro/v3/selector"
+	"go.unistack.org/micro/v3/selector/random"
+	"go.unistack.org/micro/v3/tracer"
 )
 
+// Options holds client options
 type Options struct {
-	// Used to select codec
+	// Codecs map
+	Codecs map[string]codec.Codec
+
+	// Proxy is used for proxy requests
+	Proxy string
+	// ContentType is used to select codec
 	ContentType string
+	// Name is the client name
+	Name string
 
-	// Plugged interfaces
-	Broker    broker.Broker
-	Codecs    map[string]codec.NewCodec
-	Registry  registry.Registry
-	Selector  selector.Selector
-	Transport transport.Transport
+	// Selector used to select needed address
+	Selector selector.Selector
+	// Logger used to log messages
+	Logger logger.Logger
+	// 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
 
-	// Router sets the router
-	Router Router
+	// TLSConfig specifies tls.Config for secure connection
+	TLSConfig *tls.Config
 
-	// Connection Pool
-	PoolSize int
-	PoolTTL  time.Duration
+	// Lookup func used to get destination addr
+	Lookup LookupFunc
+	// ContextDialer used to connect
+	ContextDialer func(context.Context, string) (net.Conn, error)
 
-	// 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
+func NewCallOptions(opts ...CallOption) CallOptions {
+	options := CallOptions{}
+	for _, o := range opts {
+		o(&options)
+	}
+	return options
+}
+
+// CallOptions holds client call options
 type CallOptions struct {
+	// RequestMetadata holds additional metadata for call
+	RequestMetadata metadata.Metadata
+
+	// Network name
+	Network string
+	// Content-Type
+	ContentType string
+	// AuthToken string
+	AuthToken string
+
+	// 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
 
-	// Address of remote host
-	Address string
-	// Backoff func
-	Backoff BackoffFunc
-	// Check if retriable func
-	Retry RetryFunc
-	// Transport Dial Timeout
-	DialTimeout time.Duration
-	// Number of Call attempts
-	Retries int
-	// Request/Response timeout
+	// StreamTimeout stream timeout
+	StreamTimeout time.Duration
+	// RequestTimeout request timeout
 	RequestTimeout time.Duration
 
-	// Middleware for low level call func
-	CallWrappers []CallWrapper
-
-	// Other options for implementations of the interface
-	// can be stored in a context
-	Context context.Context
+	// 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
+func Context(ctx context.Context) Option {
+	return func(o *Options) {
+		o.Context = ctx
+	}
+}
+
+// NewPublishOptions create new PublishOptions struct from option
+func NewPublishOptions(opts ...PublishOption) PublishOptions {
+	options := PublishOptions{}
+	for _, o := range opts {
+		o(&options)
+	}
+	return options
+}
+
+// PublishOptions holds publish options
 type PublishOptions struct {
-	// Exchange is the routing exchange for the message
+	// Context used for external options
+	Context context.Context
+	// Exchange topic exchange name
 	Exchange string
-	// Other options for implementations of the interface
-	// can be stored in a context
-	Context context.Context
+	// BodyOnly will publish only message body
+	BodyOnly bool
 }
 
+// NewMessageOptions creates message options struct
+func NewMessageOptions(opts ...MessageOption) MessageOptions {
+	options := MessageOptions{Metadata: metadata.New(1)}
+	for _, o := range opts {
+		o(&options)
+	}
+	return options
+}
+
+// MessageOptions holds client message options
 type MessageOptions struct {
+	// Metadata additional metadata
+	Metadata metadata.Metadata
+	// ContentType specify content-type of message
+	// deprecated
 	ContentType string
 }
 
+// NewRequestOptions creates new RequestOptions struct
+func NewRequestOptions(opts ...RequestOption) RequestOptions {
+	options := RequestOptions{}
+	for _, o := range opts {
+		o(&options)
+	}
+	return options
+}
+
+// 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
 }
 
-func newOptions(options ...Option) Options {
-	opts := Options{
-		Codecs: make(map[string]codec.NewCodec),
+// NewOptions creates new options struct
+func NewOptions(opts ...Option) Options {
+	options := Options{
+		Context:     context.Background(),
+		ContentType: DefaultContentType,
+		Codecs:      DefaultCodecs,
 		CallOptions: CallOptions{
+			Context:        context.Background(),
 			Backoff:        DefaultBackoff,
 			Retry:          DefaultRetry,
 			Retries:        DefaultRetries,
 			RequestTimeout: DefaultRequestTimeout,
-			DialTimeout:    transport.DefaultDialTimeout,
 		},
+		Lookup:   LookupRoute,
 		PoolSize: DefaultPoolSize,
 		PoolTTL:  DefaultPoolTTL,
+		Selector: random.NewSelector(),
+		Logger:   logger.DefaultLogger,
+		Broker:   broker.DefaultBroker,
+		Meter:    meter.DefaultMeter,
+		Tracer:   tracer.DefaultTracer,
+		Router:   router.DefaultRouter,
 	}
 
-	for _, o := range options {
-		o(&opts)
+	for _, o := range opts {
+		o(&options)
 	}
 
-	if len(opts.ContentType) == 0 {
-		opts.ContentType = DefaultContentType
-	}
-
-	if opts.Broker == nil {
-		opts.Broker = broker.DefaultBroker
-	}
-
-	if opts.Registry == nil {
-		opts.Registry = registry.DefaultRegistry
-	}
-
-	if opts.Selector == nil {
-		opts.Selector = selector.NewSelector(
-			selector.Registry(opts.Registry),
-		)
-	}
-
-	if opts.Transport == nil {
-		opts.Transport = transport.DefaultTransport
-	}
-
-	return opts
+	return options
 }
 
 // Broker to be used for pub/sub
@@ -135,20 +231,48 @@ func Broker(b broker.Broker) Option {
 	}
 }
 
+// Tracer to be used for tracing
+func Tracer(t tracer.Tracer) Option {
+	return func(o *Options) {
+		o.Tracer = t
+	}
+}
+
+// Logger to be used for log mesages
+func Logger(l logger.Logger) Option {
+	return func(o *Options) {
+		o.Logger = l
+	}
+}
+
+// Meter to be used for metrics
+func Meter(m meter.Meter) Option {
+	return func(o *Options) {
+		o.Meter = m
+	}
+}
+
 // Codec to be used to encode/decode requests for a given content type
-func Codec(contentType string, c codec.NewCodec) Option {
+func Codec(contentType string, c codec.Codec) Option {
 	return func(o *Options) {
 		o.Codecs[contentType] = c
 	}
 }
 
-// Default content type of the client
+// ContentType used by default if not specified
 func ContentType(ct string) Option {
 	return func(o *Options) {
 		o.ContentType = ct
 	}
 }
 
+// Proxy sets the proxy address
+func Proxy(addr string) Option {
+	return func(o *Options) {
+		o.Proxy = addr
+	}
+}
+
 // PoolSize sets the connection pool size
 func PoolSize(d int) Option {
 	return func(o *Options) {
@@ -156,58 +280,66 @@ func PoolSize(d int) Option {
 	}
 }
 
-// PoolSize sets the connection pool size
+// PoolTTL sets the connection pool ttl
 func PoolTTL(d time.Duration) Option {
 	return func(o *Options) {
 		o.PoolTTL = d
 	}
 }
 
-// Registry to find nodes for a given service
-func Registry(r registry.Registry) Option {
+// Register sets the routers register
+func Register(r register.Register) Option {
 	return func(o *Options) {
-		o.Registry = r
+		if o.Router != nil {
+			_ = o.Router.Init(router.Register(r))
+		}
 	}
 }
 
-// Transport to use for communication e.g http, rabbitmq, etc
-func Transport(t transport.Transport) Option {
+// Router is used to lookup routes for a service
+func Router(r router.Router) Option {
 	return func(o *Options) {
-		o.Transport = t
+		o.Router = r
 	}
 }
 
-// Select is used to select a node to route a request to
+// Selector is used to select a route
 func Selector(s selector.Selector) Option {
 	return func(o *Options) {
 		o.Selector = s
 	}
 }
 
-// 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
 	}
 }
 
-// Number of retries when making the request.
-// Should this be a Call Option?
+// 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) {
+		o.Lookup = l
+	}
+}
+
+// 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.
 func Retries(i int) Option {
 	return func(o *Options) {
 		o.CallOptions.Retries = i
@@ -221,50 +353,85 @@ func Retry(fn RetryFunc) Option {
 	}
 }
 
-// The request timeout.
-// Should this be a Call Option?
+// RequestTimeout is the request timeout.
 func RequestTimeout(d time.Duration) Option {
 	return func(o *Options) {
 		o.CallOptions.RequestTimeout = d
 	}
 }
 
-// Transport dial timeout
+// StreamTimeout sets the stream timeout
+func StreamTimeout(d time.Duration) Option {
+	return func(o *Options) {
+		o.CallOptions.StreamTimeout = d
+	}
+}
+
+// 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
+// Deprecated
 func WithExchange(e string) PublishOption {
 	return func(o *PublishOptions) {
 		o.Exchange = e
 	}
 }
 
-// WithAddress sets the remote address to use rather than using service discovery
-func WithAddress(a string) CallOption {
+// PublishExchange sets the exchange to route a message through
+func PublishExchange(e string) PublishOption {
+	return func(o *PublishOptions) {
+		o.Exchange = e
+	}
+}
+
+// WithBodyOnly publish only message body
+// DERECATED
+func WithBodyOnly(b bool) PublishOption {
+	return func(o *PublishOptions) {
+		o.BodyOnly = b
+	}
+}
+
+// PublishBodyOnly publish only message body
+func PublishBodyOnly(b bool) PublishOption {
+	return func(o *PublishOptions) {
+		o.BodyOnly = b
+	}
+}
+
+// PublishContext sets the context in publish options
+func PublishContext(ctx context.Context) PublishOption {
+	return func(o *PublishOptions) {
+		o.Context = ctx
+	}
+}
+
+// WithContextDialer pass ContextDialer to client call
+func WithContextDialer(fn func(context.Context, string) (net.Conn, error)) CallOption {
+	return func(o *CallOptions) {
+		o.ContextDialer = fn
+	}
+}
+
+// WithContentType specifies call content type
+func WithContentType(ct string) CallOption {
+	return func(o *CallOptions) {
+		o.ContentType = ct
+	}
+}
+
+// WithAddress sets the remote addresses to use rather than using service discovery
+func WithAddress(a ...string) CallOption {
 	return func(o *CallOptions) {
 		o.Address = a
 	}
 }
 
-func WithSelectOption(so ...selector.SelectOption) CallOption {
-	return func(o *CallOptions) {
-		o.SelectOptions = append(o.SelectOptions, so...)
-	}
-}
-
-// 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 {
@@ -289,6 +456,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 {
@@ -297,6 +478,13 @@ func WithRequestTimeout(d time.Duration) CallOption {
 	}
 }
 
+// WithStreamTimeout sets the stream timeout
+func WithStreamTimeout(d time.Duration) CallOption {
+	return func(o *CallOptions) {
+		o.StreamTimeout = d
+	}
+}
+
 // WithDialTimeout is a CallOption which overrides that which
 // set in Options.CallOptions
 func WithDialTimeout(d time.Duration) CallOption {
@@ -305,23 +493,76 @@ func WithDialTimeout(d time.Duration) CallOption {
 	}
 }
 
-// Request Options
+// WithAuthToken is a CallOption which overrides the
+// authorization header with the services own auth token
+func WithAuthToken(t string) CallOption {
+	return func(o *CallOptions) {
+		o.AuthToken = t
+	}
+}
 
-func WithContentType(ct string) RequestOption {
+// WithRouter sets the router to use for this call
+func WithRouter(r router.Router) CallOption {
+	return func(o *CallOptions) {
+		o.Router = r
+	}
+}
+
+// WithSelector sets the selector to use for this call
+func WithSelector(s selector.Selector) CallOption {
+	return func(o *CallOptions) {
+		o.Selector = s
+	}
+}
+
+// WithSelectOptions sets the options to pass to the selector for this call
+func WithSelectOptions(sops ...selector.SelectOption) CallOption {
+	return func(o *CallOptions) {
+		o.SelectOptions = sops
+	}
+}
+
+// WithMessageContentType sets the message content type
+// Deprecated
+func WithMessageContentType(ct string) MessageOption {
+	return func(o *MessageOptions) {
+		o.Metadata.Set(metadata.HeaderContentType, ct)
+		o.ContentType = ct
+	}
+}
+
+// MessageContentType sets the message content type
+func MessageContentType(ct string) MessageOption {
+	return func(o *MessageOptions) {
+		o.Metadata.Set(metadata.HeaderContentType, ct)
+		o.ContentType = ct
+	}
+}
+
+// MessageMetadata sets the message metadata
+func MessageMetadata(k, v string) MessageOption {
+	return func(o *MessageOptions) {
+		o.Metadata.Set(k, v)
+	}
+}
+
+// StreamingRequest specifies that request is streaming
+func StreamingRequest(b bool) RequestOption {
+	return func(o *RequestOptions) {
+		o.Stream = b
+	}
+}
+
+// RequestContentType specifies request content type
+func RequestContentType(ct string) RequestOption {
 	return func(o *RequestOptions) {
 		o.ContentType = ct
 	}
 }
 
-func StreamingRequest() RequestOption {
-	return func(o *RequestOptions) {
-		o.Stream = true
-	}
-}
-
-// WithRouter sets the client router
-func WithRouter(r Router) Option {
+// Hooks sets hook runs before action
+func Hooks(h ...options.Hook) Option {
 	return func(o *Options) {
-		o.Router = r
+		o.Hooks = append(o.Hooks, h...)
 	}
 }

client/options_test.go

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

client/retry.go

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

client/retry_test.go

@@ -0,0 +1,70 @@
+package client
+
+import (
+	"context"
+	"fmt"
+	"testing"
+
+	"go.unistack.org/micro/v3/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/rpc/rpc.go

@@ -1,11 +0,0 @@
-// Package rpc provides an rpc client
-package rpc
-
-import (
-	"github.com/micro/go-micro/client"
-)
-
-// NewClient returns a new micro client interface
-func NewClient(opts ...client.Option) client.Client {
-	return client.NewClient(opts...)
-}

client/rpc_client.go

@@ -1,567 +0,0 @@
-package client
-
-import (
-	"bytes"
-	"context"
-	"fmt"
-	"net"
-	"os"
-	"strconv"
-	"sync"
-	"sync/atomic"
-	"time"
-
-	"github.com/google/uuid"
-	"github.com/micro/go-micro/broker"
-	"github.com/micro/go-micro/codec"
-	"github.com/micro/go-micro/errors"
-	"github.com/micro/go-micro/metadata"
-	"github.com/micro/go-micro/registry"
-	"github.com/micro/go-micro/selector"
-	"github.com/micro/go-micro/transport"
-)
-
-type rpcClient struct {
-	once sync.Once
-	opts Options
-	pool *pool
-	seq  uint64
-}
-
-func newRpcClient(opt ...Option) Client {
-	opts := newOptions(opt...)
-
-	rc := &rpcClient{
-		once: sync.Once{},
-		opts: opts,
-		pool: newPool(opts.PoolSize, opts.PoolTTL),
-		seq:  0,
-	}
-
-	c := Client(rc)
-
-	// wrap in reverse
-	for i := len(opts.Wrappers); i > 0; i-- {
-		c = opts.Wrappers[i-1](c)
-	}
-
-	return c
-}
-
-func (r *rpcClient) newCodec(contentType string) (codec.NewCodec, error) {
-	if c, ok := r.opts.Codecs[contentType]; ok {
-		return c, nil
-	}
-	if cf, ok := DefaultCodecs[contentType]; ok {
-		return cf, nil
-	}
-	return nil, fmt.Errorf("Unsupported Content-Type: %s", contentType)
-}
-
-func (r *rpcClient) call(ctx context.Context, node *registry.Node, req Request, resp interface{}, opts CallOptions) error {
-	address := node.Address
-	if node.Port > 0 {
-		address = fmt.Sprintf("%s:%d", address, node.Port)
-	}
-
-	msg := &transport.Message{
-		Header: make(map[string]string),
-	}
-
-	md, ok := metadata.FromContext(ctx)
-	if ok {
-		for k, v := range md {
-			msg.Header[k] = v
-		}
-	}
-
-	// set timeout in nanoseconds
-	msg.Header["Timeout"] = fmt.Sprintf("%d", opts.RequestTimeout)
-	// set the content type for the request
-	msg.Header["Content-Type"] = req.ContentType()
-	// set the accept header
-	msg.Header["Accept"] = req.ContentType()
-
-	// setup old protocol
-	cf := setupProtocol(msg, node)
-
-	// no codec specified
-	if cf == nil {
-		var err error
-		cf, err = r.newCodec(req.ContentType())
-		if err != nil {
-			return errors.InternalServerError("go.micro.client", err.Error())
-		}
-	}
-
-	var grr error
-	c, err := r.pool.getConn(address, r.opts.Transport, transport.WithTimeout(opts.DialTimeout))
-	if err != nil {
-		return errors.InternalServerError("go.micro.client", "connection error: %v", err)
-	}
-	defer func() {
-		// defer execution of release
-		r.pool.release(address, c, grr)
-	}()
-
-	seq := atomic.LoadUint64(&r.seq)
-	atomic.AddUint64(&r.seq, 1)
-	codec := newRpcCodec(msg, c, cf)
-
-	rsp := &rpcResponse{
-		socket: c,
-		codec:  codec,
-	}
-
-	stream := &rpcStream{
-		context:  ctx,
-		request:  req,
-		response: rsp,
-		codec:    codec,
-		closed:   make(chan bool),
-		id:       fmt.Sprintf("%v", seq),
-	}
-	defer stream.Close()
-
-	ch := make(chan error, 1)
-
-	go func() {
-		defer func() {
-			if r := recover(); r != nil {
-				ch <- errors.InternalServerError("go.micro.client", "panic recovered: %v", r)
-			}
-		}()
-
-		// send request
-		if err := stream.Send(req.Body()); err != nil {
-			ch <- err
-			return
-		}
-
-		// recv request
-		if err := stream.Recv(resp); err != nil {
-			ch <- err
-			return
-		}
-
-		// success
-		ch <- nil
-	}()
-
-	select {
-	case err := <-ch:
-		grr = err
-		return err
-	case <-ctx.Done():
-		grr = ctx.Err()
-		return errors.Timeout("go.micro.client", fmt.Sprintf("%v", ctx.Err()))
-	}
-}
-
-func (r *rpcClient) stream(ctx context.Context, node *registry.Node, req Request, opts CallOptions) (Stream, error) {
-	address := node.Address
-	if node.Port > 0 {
-		address = fmt.Sprintf("%s:%d", address, node.Port)
-	}
-
-	msg := &transport.Message{
-		Header: make(map[string]string),
-	}
-
-	md, ok := metadata.FromContext(ctx)
-	if ok {
-		for k, v := range md {
-			msg.Header[k] = v
-		}
-	}
-
-	// set timeout in nanoseconds
-	msg.Header["Timeout"] = fmt.Sprintf("%d", opts.RequestTimeout)
-	// set the content type for the request
-	msg.Header["Content-Type"] = req.ContentType()
-	// set the accept header
-	msg.Header["Accept"] = req.ContentType()
-
-	// set old codecs
-	cf := setupProtocol(msg, node)
-
-	// no codec specified
-	if cf == nil {
-		var err error
-		cf, err = r.newCodec(req.ContentType())
-		if err != nil {
-			return nil, errors.InternalServerError("go.micro.client", err.Error())
-		}
-	}
-
-	dOpts := []transport.DialOption{
-		transport.WithStream(),
-	}
-
-	if opts.DialTimeout >= 0 {
-		dOpts = append(dOpts, transport.WithTimeout(opts.DialTimeout))
-	}
-
-	c, err := r.opts.Transport.Dial(address, dOpts...)
-	if err != nil {
-		return nil, errors.InternalServerError("go.micro.client", "connection error: %v", err)
-	}
-
-	codec := newRpcCodec(msg, c, cf)
-
-	rsp := &rpcResponse{
-		socket: c,
-		codec:  codec,
-	}
-
-	// set request codec
-	if r, ok := req.(*rpcRequest); ok {
-		r.codec = codec
-	}
-
-	stream := &rpcStream{
-		context:  ctx,
-		request:  req,
-		response: rsp,
-		closed:   make(chan bool),
-		codec:    codec,
-	}
-
-	ch := make(chan error, 1)
-
-	go func() {
-		ch <- stream.Send(req.Body())
-	}()
-
-	var grr error
-
-	select {
-	case err := <-ch:
-		grr = err
-	case <-ctx.Done():
-		grr = errors.Timeout("go.micro.client", fmt.Sprintf("%v", ctx.Err()))
-	}
-
-	if grr != nil {
-		stream.Close()
-		return nil, grr
-	}
-
-	return stream, nil
-}
-
-func (r *rpcClient) Init(opts ...Option) error {
-	size := r.opts.PoolSize
-	ttl := r.opts.PoolTTL
-
-	for _, o := range opts {
-		o(&r.opts)
-	}
-
-	// update pool configuration if the options changed
-	if size != r.opts.PoolSize || ttl != r.opts.PoolTTL {
-		r.pool.Lock()
-		r.pool.size = r.opts.PoolSize
-		r.pool.ttl = int64(r.opts.PoolTTL.Seconds())
-		r.pool.Unlock()
-	}
-
-	return nil
-}
-
-func (r *rpcClient) Options() Options {
-	return r.opts
-}
-
-func (r *rpcClient) next(request Request, opts CallOptions) (selector.Next, error) {
-	service := request.Service()
-
-	// get proxy
-	if prx := os.Getenv("MICRO_PROXY"); len(prx) > 0 {
-		service = prx
-	}
-
-	// get proxy address
-	if prx := os.Getenv("MICRO_PROXY_ADDRESS"); len(prx) > 0 {
-		opts.Address = prx
-	}
-
-	// return remote address
-	if len(opts.Address) > 0 {
-		address := opts.Address
-		port := 0
-
-		host, sport, err := net.SplitHostPort(opts.Address)
-		if err == nil {
-			address = host
-			port, _ = strconv.Atoi(sport)
-		}
-
-		return func() (*registry.Node, error) {
-			return &registry.Node{
-				Address: address,
-				Port:    port,
-			}, nil
-		}, nil
-	}
-
-	// get next nodes from the selector
-	next, err := r.opts.Selector.Select(service, opts.SelectOptions...)
-	if err != nil && err == selector.ErrNotFound {
-		return nil, errors.NotFound("go.micro.client", "service %s: %v", service, err.Error())
-	} else if err != nil {
-		return nil, errors.InternalServerError("go.micro.client", "error selecting %s node: %v", service, err.Error())
-	}
-
-	return next, nil
-}
-
-func (r *rpcClient) Call(ctx context.Context, request Request, response interface{}, opts ...CallOption) error {
-	// make a copy of call opts
-	callOpts := r.opts.CallOptions
-	for _, opt := range opts {
-		opt(&callOpts)
-	}
-
-	next, err := r.next(request, callOpts)
-	if err != nil {
-		return err
-	}
-
-	// check if we already have a deadline
-	d, ok := ctx.Deadline()
-	if !ok {
-		// no deadline so we create a new one
-		ctx, _ = context.WithTimeout(ctx, callOpts.RequestTimeout)
-	} else {
-		// got a deadline so no need to setup context
-		// but we need to set the timeout we pass along
-		opt := WithRequestTimeout(d.Sub(time.Now()))
-		opt(&callOpts)
-	}
-
-	// should we noop right here?
-	select {
-	case <-ctx.Done():
-		return errors.Timeout("go.micro.client", fmt.Sprintf("%v", ctx.Err()))
-	default:
-	}
-
-	// make copy of call method
-	rcall := r.call
-
-	// wrap the call in reverse
-	for i := len(callOpts.CallWrappers); i > 0; i-- {
-		rcall = callOpts.CallWrappers[i-1](rcall)
-	}
-
-	// return errors.New("go.micro.client", "request timeout", 408)
-	call := func(i int) error {
-		// call backoff first. Someone may want an initial start delay
-		t, err := callOpts.Backoff(ctx, request, i)
-		if err != nil {
-			return errors.InternalServerError("go.micro.client", "backoff error: %v", err.Error())
-		}
-
-		// only sleep if greater than 0
-		if t.Seconds() > 0 {
-			time.Sleep(t)
-		}
-
-		// select next node
-		node, err := next()
-		if err != nil && err == selector.ErrNotFound {
-			return errors.NotFound("go.micro.client", "service %s: %v", request.Service(), err.Error())
-		} else if err != nil {
-			return errors.InternalServerError("go.micro.client", "error getting next %s node: %v", request.Service(), err.Error())
-		}
-
-		// make the call
-		err = rcall(ctx, node, request, response, callOpts)
-		r.opts.Selector.Mark(request.Service(), node, err)
-		return err
-	}
-
-	ch := make(chan error, callOpts.Retries)
-	var gerr error
-
-	for i := 0; i <= callOpts.Retries; i++ {
-		go func(i int) {
-			ch <- call(i)
-		}(i)
-
-		select {
-		case <-ctx.Done():
-			return errors.Timeout("go.micro.client", fmt.Sprintf("call timeout: %v", ctx.Err()))
-		case err := <-ch:
-			// if the call succeeded lets bail early
-			if err == nil {
-				return nil
-			}
-
-			retry, rerr := callOpts.Retry(ctx, request, i, err)
-			if rerr != nil {
-				return rerr
-			}
-
-			if !retry {
-				return err
-			}
-
-			gerr = err
-		}
-	}
-
-	return gerr
-}
-
-func (r *rpcClient) Stream(ctx context.Context, request Request, opts ...CallOption) (Stream, error) {
-	// make a copy of call opts
-	callOpts := r.opts.CallOptions
-	for _, opt := range opts {
-		opt(&callOpts)
-	}
-
-	next, err := r.next(request, callOpts)
-	if err != nil {
-		return nil, err
-	}
-
-	// should we noop right here?
-	select {
-	case <-ctx.Done():
-		return nil, errors.Timeout("go.micro.client", fmt.Sprintf("%v", ctx.Err()))
-	default:
-	}
-
-	call := func(i int) (Stream, error) {
-		// call backoff first. Someone may want an initial start delay
-		t, err := callOpts.Backoff(ctx, request, i)
-		if err != nil {
-			return nil, errors.InternalServerError("go.micro.client", "backoff error: %v", err.Error())
-		}
-
-		// only sleep if greater than 0
-		if t.Seconds() > 0 {
-			time.Sleep(t)
-		}
-
-		node, err := next()
-		if err != nil && err == selector.ErrNotFound {
-			return nil, errors.NotFound("go.micro.client", "service %s: %v", request.Service(), err.Error())
-		} else if err != nil {
-			return nil, errors.InternalServerError("go.micro.client", "error getting next %s node: %v", request.Service(), err.Error())
-		}
-
-		stream, err := r.stream(ctx, node, request, callOpts)
-		r.opts.Selector.Mark(request.Service(), node, err)
-		return stream, err
-	}
-
-	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, err := call(i)
-			ch <- response{s, err}
-		}()
-
-		select {
-		case <-ctx.Done():
-			return nil, errors.Timeout("go.micro.client", fmt.Sprintf("call timeout: %v", ctx.Err()))
-		case rsp := <-ch:
-			// if the call succeeded lets bail early
-			if rsp.err == nil {
-				return rsp.stream, nil
-			}
-
-			retry, rerr := callOpts.Retry(ctx, request, i, rsp.err)
-			if rerr != nil {
-				return nil, rerr
-			}
-
-			if !retry {
-				return nil, rsp.err
-			}
-
-			grr = rsp.err
-		}
-	}
-
-	return nil, grr
-}
-
-func (r *rpcClient) Publish(ctx context.Context, msg Message, opts ...PublishOption) error {
-	options := PublishOptions{
-		Context: context.Background(),
-	}
-	for _, o := range opts {
-		o(&options)
-	}
-
-	md, ok := metadata.FromContext(ctx)
-	if !ok {
-		md = make(map[string]string)
-	}
-
-	id := uuid.New().String()
-	md["Content-Type"] = msg.ContentType()
-	md["Micro-Topic"] = msg.Topic()
-	md["Micro-Id"] = id
-
-	// set the topic
-	topic := msg.Topic()
-
-	// get proxy
-	if prx := os.Getenv("MICRO_PROXY"); len(prx) > 0 {
-		options.Exchange = prx
-	}
-
-	// get the exchange
-	if len(options.Exchange) > 0 {
-		topic = options.Exchange
-	}
-
-	// encode message body
-	cf, err := r.newCodec(msg.ContentType())
-	if err != nil {
-		return errors.InternalServerError("go.micro.client", err.Error())
-	}
-	b := &buffer{bytes.NewBuffer(nil)}
-	if err := cf(b).Write(&codec.Message{
-		Target: topic,
-		Type:   codec.Publication,
-		Header: map[string]string{
-			"Micro-Id":    id,
-			"Micro-Topic": msg.Topic(),
-		},
-	}, msg.Payload()); err != nil {
-		return errors.InternalServerError("go.micro.client", err.Error())
-	}
-	r.once.Do(func() {
-		r.opts.Broker.Connect()
-	})
-
-	return r.opts.Broker.Publish(topic, &broker.Message{
-		Header: md,
-		Body:   b.Bytes(),
-	})
-}
-
-func (r *rpcClient) NewMessage(topic string, message interface{}, opts ...MessageOption) Message {
-	return newMessage(topic, message, r.opts.ContentType, opts...)
-}
-
-func (r *rpcClient) NewRequest(service, method string, request interface{}, reqOpts ...RequestOption) Request {
-	return newRequest(service, method, request, r.opts.ContentType, reqOpts...)
-}
-
-func (r *rpcClient) String() string {
-	return "rpc"
-}

client/rpc_client_test.go

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

client/rpc_codec.go

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

client/rpc_message.go

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

client/rpc_pool.go

@@ -1,87 +0,0 @@
-package client
-
-import (
-	"sync"
-	"time"
-
-	"github.com/micro/go-micro/transport"
-)
-
-type pool struct {
-	size int
-	ttl  int64
-
-	sync.Mutex
-	conns map[string][]*poolConn
-}
-
-type poolConn struct {
-	transport.Client
-	created int64
-}
-
-func newPool(size int, ttl time.Duration) *pool {
-	return &pool{
-		size:  size,
-		ttl:   int64(ttl.Seconds()),
-		conns: make(map[string][]*poolConn),
-	}
-}
-
-// NoOp the Close since we manage it
-func (p *poolConn) Close() error {
-	return nil
-}
-
-func (p *pool) getConn(addr string, tr transport.Transport, opts ...transport.DialOption) (*poolConn, error) {
-	p.Lock()
-	conns := p.conns[addr]
-	now := time.Now().Unix()
-
-	// while we have conns check age and then return one
-	// otherwise we'll create a new conn
-	for len(conns) > 0 {
-		conn := conns[len(conns)-1]
-		conns = conns[:len(conns)-1]
-		p.conns[addr] = conns
-
-		// if conn is old kill it and move on
-		if d := now - conn.created; d > p.ttl {
-			conn.Client.Close()
-			continue
-		}
-
-		// we got a good conn, lets unlock and return it
-		p.Unlock()
-
-		return conn, nil
-	}
-
-	p.Unlock()
-
-	// create new conn
-	c, err := tr.Dial(addr, opts...)
-	if err != nil {
-		return nil, err
-	}
-	return &poolConn{c, time.Now().Unix()}, nil
-}
-
-func (p *pool) release(addr string, conn *poolConn, err error) {
-	// don't store the conn if it has errored
-	if err != nil {
-		conn.Client.Close()
-		return
-	}
-
-	// otherwise put it back for reuse
-	p.Lock()
-	conns := p.conns[addr]
-	if len(conns) >= p.size {
-		p.Unlock()
-		conn.Client.Close()
-		return
-	}
-	p.conns[addr] = append(conns, conn)
-	p.Unlock()
-}

client/rpc_pool_test.go

@@ -1,84 +0,0 @@
-package client
-
-import (
-	"testing"
-	"time"
-
-	"github.com/micro/go-micro/transport"
-	"github.com/micro/go-micro/transport/memory"
-)
-
-func testPool(t *testing.T, size int, ttl time.Duration) {
-	// zero pool
-	p := newPool(size, ttl)
-
-	// mock transport
-	tr := memory.NewTransport()
-
-	// listen
-	l, err := tr.Listen(":0")
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer l.Close()
-
-	// accept loop
-	go func() {
-		for {
-			if err := l.Accept(func(s transport.Socket) {
-				for {
-					var msg transport.Message
-					if err := s.Recv(&msg); err != nil {
-						return
-					}
-					if err := s.Send(&msg); err != nil {
-						return
-					}
-				}
-			}); err != nil {
-				return
-			}
-		}
-	}()
-
-	for i := 0; i < 10; i++ {
-		// get a conn
-		c, err := p.getConn(l.Addr(), tr)
-		if err != nil {
-			t.Fatal(err)
-		}
-
-		msg := &transport.Message{
-			Body: []byte(`hello world`),
-		}
-
-		if err := c.Send(msg); err != nil {
-			t.Fatal(err)
-		}
-
-		var rcv transport.Message
-
-		if err := c.Recv(&rcv); err != nil {
-			t.Fatal(err)
-		}
-
-		if string(rcv.Body) != string(msg.Body) {
-			t.Fatalf("got %v, expected %v", rcv.Body, msg.Body)
-		}
-
-		// release the conn
-		p.release(l.Addr(), c, nil)
-
-		p.Lock()
-		if i := len(p.conns[l.Addr()]); i > size {
-			p.Unlock()
-			t.Fatalf("pool size %d is greater than expected %d", i, size)
-		}
-		p.Unlock()
-	}
-}
-
-func TestRPCPool(t *testing.T) {
-	testPool(t, 0, time.Minute)
-	testPool(t, 2, time.Minute)
-}

client/rpc_request.go

@@ -1,65 +0,0 @@
-package client
-
-import (
-	"github.com/micro/go-micro/codec"
-)
-
-type rpcRequest struct {
-	service     string
-	method      string
-	endpoint    string
-	contentType string
-	codec       codec.Codec
-	body        interface{}
-	opts        RequestOptions
-}
-
-func newRequest(service, endpoint string, request interface{}, contentType string, reqOpts ...RequestOption) Request {
-	var opts RequestOptions
-
-	for _, o := range reqOpts {
-		o(&opts)
-	}
-
-	// set the content-type specified
-	if len(opts.ContentType) > 0 {
-		contentType = opts.ContentType
-	}
-
-	return &rpcRequest{
-		service:     service,
-		method:      endpoint,
-		endpoint:    endpoint,
-		body:        request,
-		contentType: contentType,
-		opts:        opts,
-	}
-}
-
-func (r *rpcRequest) ContentType() string {
-	return r.contentType
-}
-
-func (r *rpcRequest) Service() string {
-	return r.service
-}
-
-func (r *rpcRequest) Method() string {
-	return r.method
-}
-
-func (r *rpcRequest) Endpoint() string {
-	return r.endpoint
-}
-
-func (r *rpcRequest) Body() interface{} {
-	return r.body
-}
-
-func (r *rpcRequest) Codec() codec.Writer {
-	return r.codec
-}
-
-func (r *rpcRequest) Stream() bool {
-	return r.opts.Stream
-}

client/rpc_request_test.go

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

client/rpc_response.go

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

client/rpc_stream.go

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

client/test_request.go

@@ -0,0 +1,43 @@
+package client
+
+import (
+	"go.unistack.org/micro/v3/codec"
+)
+
+type testRequest struct {
+	codec       codec.Codec
+	body        interface{}
+	service     string
+	method      string
+	endpoint    string
+	contentType string
+	opts        RequestOptions
+}
+
+func (r *testRequest) ContentType() string {
+	return r.contentType
+}
+
+func (r *testRequest) Service() string {
+	return r.service
+}
+
+func (r *testRequest) Method() string {
+	return r.method
+}
+
+func (r *testRequest) Endpoint() string {
+	return r.endpoint
+}
+
+func (r *testRequest) Body() interface{} {
+	return r.body
+}
+
+func (r *testRequest) Codec() codec.Codec {
+	return r.codec
+}
+
+func (r *testRequest) Stream() bool {
+	return r.opts.Stream
+}

client/wrapper.go

@@ -2,12 +2,10 @@ package client
 
 import (
 	"context"
-
-	"github.com/micro/go-micro/registry"
 )
 
 // CallFunc represents the individual call func
-type CallFunc func(ctx context.Context, node *registry.Node, req Request, rsp interface{}, opts CallOptions) error
+type CallFunc func(ctx context.Context, addr string, req Request, rsp interface{}, opts CallOptions) error
 
 // CallWrapper is a low level wrapper for the CallFunc
 type CallWrapper func(CallFunc) CallFunc

cluster/cluster.go

@@ -0,0 +1,47 @@
+package cluster
+
+import (
+	"context"
+
+	"go.unistack.org/micro/v3/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
+}

cmd/cmd.go

@@ -1,480 +0,0 @@
-// Package cmd is an interface for parsing the command line
-package cmd
-
-import (
-	"fmt"
-	"io"
-	"math/rand"
-	"os"
-	"strings"
-	"time"
-
-	"github.com/micro/cli"
-	"github.com/micro/go-log"
-	"github.com/micro/go-micro/client"
-	"github.com/micro/go-micro/server"
-
-	// brokers
-	"github.com/micro/go-micro/broker"
-	"github.com/micro/go-micro/broker/http"
-	"github.com/micro/go-micro/broker/memory"
-
-	// registries
-	"github.com/micro/go-micro/registry"
-	"github.com/micro/go-micro/registry/consul"
-	"github.com/micro/go-micro/registry/gossip"
-	"github.com/micro/go-micro/registry/mdns"
-	rmem "github.com/micro/go-micro/registry/memory"
-
-	// selectors
-	"github.com/micro/go-micro/selector"
-	"github.com/micro/go-micro/selector/dns"
-	"github.com/micro/go-micro/selector/static"
-
-	// transports
-	"github.com/micro/go-micro/transport"
-	thttp "github.com/micro/go-micro/transport/http"
-	tmem "github.com/micro/go-micro/transport/memory"
-)
-
-type Cmd interface {
-	// The cli app within this cmd
-	App() *cli.App
-	// Adds options, parses flags and initialise
-	// exits on error
-	Init(opts ...Option) error
-	// Options set within this command
-	Options() Options
-}
-
-type cmd struct {
-	opts Options
-	app  *cli.App
-}
-
-type Option func(o *Options)
-
-var (
-	DefaultCmd = newCmd()
-
-	DefaultFlags = []cli.Flag{
-		cli.StringFlag{
-			Name:   "client",
-			EnvVar: "MICRO_CLIENT",
-			Usage:  "Client for go-micro; rpc",
-		},
-		cli.StringFlag{
-			Name:   "client_request_timeout",
-			EnvVar: "MICRO_CLIENT_REQUEST_TIMEOUT",
-			Usage:  "Sets the client request timeout. e.g 500ms, 5s, 1m. Default: 5s",
-		},
-		cli.IntFlag{
-			Name:   "client_retries",
-			EnvVar: "MICRO_CLIENT_RETRIES",
-			Usage:  "Sets the client retries. Default: 1",
-		},
-		cli.IntFlag{
-			Name:   "client_pool_size",
-			EnvVar: "MICRO_CLIENT_POOL_SIZE",
-			Usage:  "Sets the client connection pool size. Default: 1",
-		},
-		cli.StringFlag{
-			Name:   "client_pool_ttl",
-			EnvVar: "MICRO_CLIENT_POOL_TTL",
-			Usage:  "Sets the client connection pool ttl. e.g 500ms, 5s, 1m. Default: 1m",
-		},
-		cli.IntFlag{
-			Name:   "register_ttl",
-			EnvVar: "MICRO_REGISTER_TTL",
-			Usage:  "Register TTL in seconds",
-		},
-		cli.IntFlag{
-			Name:   "register_interval",
-			EnvVar: "MICRO_REGISTER_INTERVAL",
-			Usage:  "Register interval in seconds",
-		},
-		cli.StringFlag{
-			Name:   "server",
-			EnvVar: "MICRO_SERVER",
-			Usage:  "Server for go-micro; rpc",
-		},
-		cli.StringFlag{
-			Name:   "server_name",
-			EnvVar: "MICRO_SERVER_NAME",
-			Usage:  "Name of the server. go.micro.srv.example",
-		},
-		cli.StringFlag{
-			Name:   "server_version",
-			EnvVar: "MICRO_SERVER_VERSION",
-			Usage:  "Version of the server. 1.1.0",
-		},
-		cli.StringFlag{
-			Name:   "server_id",
-			EnvVar: "MICRO_SERVER_ID",
-			Usage:  "Id of the server. Auto-generated if not specified",
-		},
-		cli.StringFlag{
-			Name:   "server_address",
-			EnvVar: "MICRO_SERVER_ADDRESS",
-			Usage:  "Bind address for the server. 127.0.0.1:8080",
-		},
-		cli.StringFlag{
-			Name:   "server_advertise",
-			EnvVar: "MICRO_SERVER_ADVERTISE",
-			Usage:  "Used instead of the server_address when registering with discovery. 127.0.0.1:8080",
-		},
-		cli.StringSliceFlag{
-			Name:   "server_metadata",
-			EnvVar: "MICRO_SERVER_METADATA",
-			Value:  &cli.StringSlice{},
-			Usage:  "A list of key-value pairs defining metadata. version=1.0.0",
-		},
-		cli.StringFlag{
-			Name:   "broker",
-			EnvVar: "MICRO_BROKER",
-			Usage:  "Broker for pub/sub. http, nats, rabbitmq",
-		},
-		cli.StringFlag{
-			Name:   "broker_address",
-			EnvVar: "MICRO_BROKER_ADDRESS",
-			Usage:  "Comma-separated list of broker addresses",
-		},
-		cli.StringFlag{
-			Name:   "registry",
-			EnvVar: "MICRO_REGISTRY",
-			Usage:  "Registry for discovery. consul, mdns",
-		},
-		cli.StringFlag{
-			Name:   "registry_address",
-			EnvVar: "MICRO_REGISTRY_ADDRESS",
-			Usage:  "Comma-separated list of registry addresses",
-		},
-		cli.StringFlag{
-			Name:   "selector",
-			EnvVar: "MICRO_SELECTOR",
-			Usage:  "Selector used to pick nodes for querying",
-		},
-		cli.StringFlag{
-			Name:   "transport",
-			EnvVar: "MICRO_TRANSPORT",
-			Usage:  "Transport mechanism used; http",
-		},
-		cli.StringFlag{
-			Name:   "transport_address",
-			EnvVar: "MICRO_TRANSPORT_ADDRESS",
-			Usage:  "Comma-separated list of transport addresses",
-		},
-	}
-
-	DefaultBrokers = map[string]func(...broker.Option) broker.Broker{
-		"http":   http.NewBroker,
-		"memory": memory.NewBroker,
-	}
-
-	DefaultClients = map[string]func(...client.Option) client.Client{
-		"rpc": client.NewClient,
-	}
-
-	DefaultRegistries = map[string]func(...registry.Option) registry.Registry{
-		"consul": consul.NewRegistry,
-		"gossip": gossip.NewRegistry,
-		"mdns":   mdns.NewRegistry,
-		"memory": rmem.NewRegistry,
-	}
-
-	DefaultSelectors = map[string]func(...selector.Option) selector.Selector{
-		"default": selector.NewSelector,
-		"dns":     dns.NewSelector,
-		"cache":   selector.NewSelector,
-		"static":  static.NewSelector,
-	}
-
-	DefaultServers = map[string]func(...server.Option) server.Server{
-		"rpc": server.NewServer,
-	}
-
-	DefaultTransports = map[string]func(...transport.Option) transport.Transport{
-		"memory": tmem.NewTransport,
-		"http":   thttp.NewTransport,
-	}
-
-	// used for default selection as the fall back
-	defaultClient    = "rpc"
-	defaultServer    = "rpc"
-	defaultBroker    = "http"
-	defaultRegistry  = "mdns"
-	defaultSelector  = "registry"
-	defaultTransport = "http"
-)
-
-func init() {
-	rand.Seed(time.Now().Unix())
-	help := cli.HelpPrinter
-	cli.HelpPrinter = func(writer io.Writer, templ string, data interface{}) {
-		help(writer, templ, data)
-		os.Exit(0)
-	}
-}
-
-func newCmd(opts ...Option) Cmd {
-	options := Options{
-		Broker:    &broker.DefaultBroker,
-		Client:    &client.DefaultClient,
-		Registry:  &registry.DefaultRegistry,
-		Server:    &server.DefaultServer,
-		Selector:  &selector.DefaultSelector,
-		Transport: &transport.DefaultTransport,
-
-		Brokers:    DefaultBrokers,
-		Clients:    DefaultClients,
-		Registries: DefaultRegistries,
-		Selectors:  DefaultSelectors,
-		Servers:    DefaultServers,
-		Transports: DefaultTransports,
-	}
-
-	for _, o := range opts {
-		o(&options)
-	}
-
-	if len(options.Description) == 0 {
-		options.Description = "a go-micro service"
-	}
-
-	cmd := new(cmd)
-	cmd.opts = options
-	cmd.app = cli.NewApp()
-	cmd.app.Name = cmd.opts.Name
-	cmd.app.Version = cmd.opts.Version
-	cmd.app.Usage = cmd.opts.Description
-	cmd.app.Before = cmd.Before
-	cmd.app.Flags = DefaultFlags
-	cmd.app.Action = func(c *cli.Context) {}
-
-	if len(options.Version) == 0 {
-		cmd.app.HideVersion = true
-	}
-
-	return cmd
-}
-
-func (c *cmd) App() *cli.App {
-	return c.app
-}
-
-func (c *cmd) Options() Options {
-	return c.opts
-}
-
-func (c *cmd) Before(ctx *cli.Context) error {
-	// If flags are set then use them otherwise do nothing
-	var serverOpts []server.Option
-	var clientOpts []client.Option
-
-	// Set the client
-	if name := ctx.String("client"); len(name) > 0 {
-		// only change if we have the client and type differs
-		if cl, ok := c.opts.Clients[name]; ok && (*c.opts.Client).String() != name {
-			*c.opts.Client = cl()
-		}
-	}
-
-	// Set the server
-	if name := ctx.String("server"); len(name) > 0 {
-		// only change if we have the server and type differs
-		if s, ok := c.opts.Servers[name]; ok && (*c.opts.Server).String() != name {
-			*c.opts.Server = s()
-		}
-	}
-
-	// Set the broker
-	if name := ctx.String("broker"); len(name) > 0 && (*c.opts.Broker).String() != name {
-		b, ok := c.opts.Brokers[name]
-		if !ok {
-			return fmt.Errorf("Broker %s not found", name)
-		}
-
-		*c.opts.Broker = b()
-		serverOpts = append(serverOpts, server.Broker(*c.opts.Broker))
-		clientOpts = append(clientOpts, client.Broker(*c.opts.Broker))
-	}
-
-	// Set the registry
-	if name := ctx.String("registry"); len(name) > 0 && (*c.opts.Registry).String() != name {
-		r, ok := c.opts.Registries[name]
-		if !ok {
-			return fmt.Errorf("Registry %s not found", name)
-		}
-
-		*c.opts.Registry = r()
-		serverOpts = append(serverOpts, server.Registry(*c.opts.Registry))
-		clientOpts = append(clientOpts, client.Registry(*c.opts.Registry))
-
-		if err := (*c.opts.Selector).Init(selector.Registry(*c.opts.Registry)); err != nil {
-			log.Fatalf("Error configuring registry: %v", err)
-		}
-
-		clientOpts = append(clientOpts, client.Selector(*c.opts.Selector))
-
-		if err := (*c.opts.Broker).Init(broker.Registry(*c.opts.Registry)); err != nil {
-			log.Fatalf("Error configuring broker: %v", err)
-		}
-	}
-
-	// Set the selector
-	if name := ctx.String("selector"); len(name) > 0 && (*c.opts.Selector).String() != name {
-		s, ok := c.opts.Selectors[name]
-		if !ok {
-			return fmt.Errorf("Selector %s not found", name)
-		}
-
-		*c.opts.Selector = s(selector.Registry(*c.opts.Registry))
-
-		// No server option here. Should there be?
-		clientOpts = append(clientOpts, client.Selector(*c.opts.Selector))
-	}
-
-	// Set the transport
-	if name := ctx.String("transport"); len(name) > 0 && (*c.opts.Transport).String() != name {
-		t, ok := c.opts.Transports[name]
-		if !ok {
-			return fmt.Errorf("Transport %s not found", name)
-		}
-
-		*c.opts.Transport = t()
-		serverOpts = append(serverOpts, server.Transport(*c.opts.Transport))
-		clientOpts = append(clientOpts, client.Transport(*c.opts.Transport))
-	}
-
-	// Parse the server options
-	metadata := make(map[string]string)
-	for _, d := range ctx.StringSlice("server_metadata") {
-		var key, val string
-		parts := strings.Split(d, "=")
-		key = parts[0]
-		if len(parts) > 1 {
-			val = strings.Join(parts[1:], "=")
-		}
-		metadata[key] = val
-	}
-
-	if len(metadata) > 0 {
-		serverOpts = append(serverOpts, server.Metadata(metadata))
-	}
-
-	if len(ctx.String("broker_address")) > 0 {
-		if err := (*c.opts.Broker).Init(broker.Addrs(strings.Split(ctx.String("broker_address"), ",")...)); err != nil {
-			log.Fatalf("Error configuring broker: %v", err)
-		}
-	}
-
-	if len(ctx.String("registry_address")) > 0 {
-		if err := (*c.opts.Registry).Init(registry.Addrs(strings.Split(ctx.String("registry_address"), ",")...)); err != nil {
-			log.Fatalf("Error configuring registry: %v", err)
-		}
-	}
-
-	if len(ctx.String("transport_address")) > 0 {
-		if err := (*c.opts.Transport).Init(transport.Addrs(strings.Split(ctx.String("transport_address"), ",")...)); err != nil {
-			log.Fatalf("Error configuring transport: %v", err)
-		}
-	}
-
-	if len(ctx.String("server_name")) > 0 {
-		serverOpts = append(serverOpts, server.Name(ctx.String("server_name")))
-	}
-
-	if len(ctx.String("server_version")) > 0 {
-		serverOpts = append(serverOpts, server.Version(ctx.String("server_version")))
-	}
-
-	if len(ctx.String("server_id")) > 0 {
-		serverOpts = append(serverOpts, server.Id(ctx.String("server_id")))
-	}
-
-	if len(ctx.String("server_address")) > 0 {
-		serverOpts = append(serverOpts, server.Address(ctx.String("server_address")))
-	}
-
-	if len(ctx.String("server_advertise")) > 0 {
-		serverOpts = append(serverOpts, server.Advertise(ctx.String("server_advertise")))
-	}
-
-	if ttl := time.Duration(ctx.GlobalInt("register_ttl")); ttl > 0 {
-		serverOpts = append(serverOpts, server.RegisterTTL(ttl*time.Second))
-	}
-
-	if val := time.Duration(ctx.GlobalInt("register_interval")); val > 0 {
-		serverOpts = append(serverOpts, server.RegisterInterval(val*time.Second))
-	}
-
-	// client opts
-	if r := ctx.Int("client_retries"); r >= 0 {
-		clientOpts = append(clientOpts, client.Retries(r))
-	}
-
-	if t := ctx.String("client_request_timeout"); len(t) > 0 {
-		d, err := time.ParseDuration(t)
-		if err != nil {
-			return fmt.Errorf("failed to parse client_request_timeout: %v", t)
-		}
-		clientOpts = append(clientOpts, client.RequestTimeout(d))
-	}
-
-	if r := ctx.Int("client_pool_size"); r > 0 {
-		clientOpts = append(clientOpts, client.PoolSize(r))
-	}
-
-	if t := ctx.String("client_pool_ttl"); len(t) > 0 {
-		d, err := time.ParseDuration(t)
-		if err != nil {
-			return fmt.Errorf("failed to parse client_pool_ttl: %v", t)
-		}
-		clientOpts = append(clientOpts, client.PoolTTL(d))
-	}
-
-	// We have some command line opts for the server.
-	// Lets set it up
-	if len(serverOpts) > 0 {
-		if err := (*c.opts.Server).Init(serverOpts...); err != nil {
-			log.Fatalf("Error configuring server: %v", err)
-		}
-	}
-
-	// Use an init option?
-	if len(clientOpts) > 0 {
-		if err := (*c.opts.Client).Init(clientOpts...); err != nil {
-			log.Fatalf("Error configuring client: %v", err)
-		}
-	}
-
-	return nil
-}
-
-func (c *cmd) Init(opts ...Option) error {
-	for _, o := range opts {
-		o(&c.opts)
-	}
-	c.app.Name = c.opts.Name
-	c.app.Version = c.opts.Version
-	c.app.HideVersion = len(c.opts.Version) == 0
-	c.app.Usage = c.opts.Description
-	c.app.RunAndExitOnError()
-	return nil
-}
-
-func DefaultOptions() Options {
-	return DefaultCmd.Options()
-}
-
-func App() *cli.App {
-	return DefaultCmd.App()
-}
-
-func Init(opts ...Option) error {
-	return DefaultCmd.Init(opts...)
-}
-
-func NewCmd(opts ...Option) Cmd {
-	return newCmd(opts...)
-}

cmd/options.go

@@ -1,137 +0,0 @@
-package cmd
-
-import (
-	"context"
-
-	"github.com/micro/go-micro/broker"
-	"github.com/micro/go-micro/client"
-	"github.com/micro/go-micro/registry"
-	"github.com/micro/go-micro/selector"
-	"github.com/micro/go-micro/server"
-	"github.com/micro/go-micro/transport"
-)
-
-type Options struct {
-	// For the Command Line itself
-	Name        string
-	Description string
-	Version     string
-
-	// We need pointers to things so we can swap them out if needed.
-	Broker    *broker.Broker
-	Registry  *registry.Registry
-	Selector  *selector.Selector
-	Transport *transport.Transport
-	Client    *client.Client
-	Server    *server.Server
-
-	Brokers    map[string]func(...broker.Option) broker.Broker
-	Clients    map[string]func(...client.Option) client.Client
-	Registries map[string]func(...registry.Option) registry.Registry
-	Selectors  map[string]func(...selector.Option) selector.Selector
-	Servers    map[string]func(...server.Option) server.Server
-	Transports map[string]func(...transport.Option) transport.Transport
-
-	// Other options for implementations of the interface
-	// can be stored in a context
-	Context context.Context
-}
-
-// Command line Name
-func Name(n string) Option {
-	return func(o *Options) {
-		o.Name = n
-	}
-}
-
-// Command line Description
-func Description(d string) Option {
-	return func(o *Options) {
-		o.Description = d
-	}
-}
-
-// Command line Version
-func Version(v string) Option {
-	return func(o *Options) {
-		o.Version = v
-	}
-}
-
-func Broker(b *broker.Broker) Option {
-	return func(o *Options) {
-		o.Broker = b
-	}
-}
-
-func Selector(s *selector.Selector) Option {
-	return func(o *Options) {
-		o.Selector = s
-	}
-}
-
-func Registry(r *registry.Registry) Option {
-	return func(o *Options) {
-		o.Registry = r
-	}
-}
-
-func Transport(t *transport.Transport) Option {
-	return func(o *Options) {
-		o.Transport = t
-	}
-}
-
-func Client(c *client.Client) Option {
-	return func(o *Options) {
-		o.Client = c
-	}
-}
-
-func Server(s *server.Server) Option {
-	return func(o *Options) {
-		o.Server = s
-	}
-}
-
-// New broker func
-func NewBroker(name string, b func(...broker.Option) broker.Broker) Option {
-	return func(o *Options) {
-		o.Brokers[name] = b
-	}
-}
-
-// New client func
-func NewClient(name string, b func(...client.Option) client.Client) Option {
-	return func(o *Options) {
-		o.Clients[name] = b
-	}
-}
-
-// New registry func
-func NewRegistry(name string, r func(...registry.Option) registry.Registry) Option {
-	return func(o *Options) {
-		o.Registries[name] = r
-	}
-}
-
-// New selector func
-func NewSelector(name string, s func(...selector.Option) selector.Selector) Option {
-	return func(o *Options) {
-		o.Selectors[name] = s
-	}
-}
-
-// New server func
-func NewServer(name string, s func(...server.Option) server.Server) Option {
-	return func(o *Options) {
-		o.Servers[name] = s
-	}
-}
-
-// New transport func
-func NewTransport(name string, t func(...transport.Option) transport.Transport) Option {
-	return func(o *Options) {
-		o.Transports[name] = t
-	}
-}

codec/bytes/bytes.go

@@ -1,75 +0,0 @@
-// Package bytes provides a bytes codec which does not encode or decode anything
-package bytes
-
-import (
-	"fmt"
-	"io"
-	"io/ioutil"
-
-	"github.com/micro/go-micro/codec"
-)
-
-type Codec struct {
-	Conn io.ReadWriteCloser
-}
-
-// Frame gives us the ability to define raw data to send over the pipes
-type Frame struct {
-	Data []byte
-}
-
-func (c *Codec) ReadHeader(m *codec.Message, t codec.MessageType) error {
-	return nil
-}
-
-func (c *Codec) ReadBody(b interface{}) error {
-	// read bytes
-	buf, err := ioutil.ReadAll(c.Conn)
-	if err != nil {
-		return err
-	}
-
-	switch b.(type) {
-	case *[]byte:
-		v := b.(*[]byte)
-		*v = buf
-	case *Frame:
-		v := b.(*Frame)
-		v.Data = buf
-	default:
-		return fmt.Errorf("failed to read body: %v is not type of *[]byte", b)
-	}
-
-	return nil
-}
-
-func (c *Codec) Write(m *codec.Message, b interface{}) error {
-	var v []byte
-	switch b.(type) {
-	case *Frame:
-		v = b.(*Frame).Data
-	case *[]byte:
-		ve := b.(*[]byte)
-		v = *ve
-	case []byte:
-		v = b.([]byte)
-	default:
-		return fmt.Errorf("failed to write: %v is not type of *[]byte or []byte", b)
-	}
-	_, err := c.Conn.Write(v)
-	return err
-}
-
-func (c *Codec) Close() error {
-	return c.Conn.Close()
-}
-
-func (c *Codec) String() string {
-	return "bytes"
-}
-
-func NewCodec(c io.ReadWriteCloser) codec.Codec {
-	return &Codec{
-		Conn: c,
-	}
-}

codec/bytes/marshaler.go

@@ -1,41 +0,0 @@
-package bytes
-
-import (
-	"errors"
-)
-
-type Marshaler struct{}
-
-type Message struct {
-	Header map[string]string
-	Body   []byte
-}
-
-func (n Marshaler) Marshal(v interface{}) ([]byte, error) {
-	switch v.(type) {
-	case *[]byte:
-		ve := v.(*[]byte)
-		return *ve, nil
-	case []byte:
-		return v.([]byte), nil
-	case *Message:
-		return v.(*Message).Body, nil
-	}
-	return nil, errors.New("invalid message")
-}
-
-func (n Marshaler) Unmarshal(d []byte, v interface{}) error {
-	switch v.(type) {
-	case *[]byte:
-		ve := v.(*[]byte)
-		*ve = d
-	case *Message:
-		ve := v.(*Message)
-		ve.Body = d
-	}
-	return errors.New("invalid message")
-}
-
-func (n Marshaler) String() string {
-	return "bytes"
-}

codec/codec.go

@@ -2,62 +2,76 @@
 package codec
 
 import (
-	"io"
+	"errors"
+
+	"gopkg.in/yaml.v3"
 )
 
-const (
-	Error MessageType = iota
-	Request
-	Response
-	Publication
+var (
+	// ErrInvalidMessage returned when invalid messge passed to codec
+	ErrInvalidMessage = errors.New("invalid message")
+	// ErrUnknownContentType returned when content-type is unknown
+	ErrUnknownContentType = errors.New("unknown content-type")
 )
 
-type MessageType int
+var (
+	// DefaultCodec is the global default codec
+	DefaultCodec = NewCodec()
+	// DefaultTagName specifies struct tag name to control codec Marshal/Unmarshal
+	DefaultTagName = "codec"
+)
 
-// Takes in a connection/buffer and returns a new Codec
-type NewCodec func(io.ReadWriteCloser) Codec
-
-// Codec encodes/decodes various types of messages used within go-micro.
-// ReadHeader and ReadBody are called in pairs to read requests/responses
-// from the connection. Close is called when finished with the
-// connection. ReadBody may be called with a nil argument to force the
-// body to be read and discarded.
+// Codec encodes/decodes various types of messages.
 type Codec interface {
-	Reader
-	Writer
-	Close() error
+	Marshal(v interface{}, opts ...Option) ([]byte, error)
+	Unmarshal(b []byte, v interface{}, opts ...Option) error
 	String() string
 }
 
-type Reader interface {
-	ReadHeader(*Message, MessageType) error
-	ReadBody(interface{}) error
-}
-
-type Writer interface {
-	Write(*Message, interface{}) error
-}
-
-// Marshaler is a simple encoding interface used for the broker/transport
-// where headers are not supported by the underlying implementation.
-type Marshaler interface {
-	Marshal(interface{}) ([]byte, error)
-	Unmarshal([]byte, interface{}) error
+type CodecV2 interface {
+	Marshal(buf []byte, v interface{}, opts ...Option) ([]byte, error)
+	Unmarshal(buf []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
+// 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
 
-	// The values read from the socket
-	Header map[string]string
-	Body   []byte
+// 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
+}
+
+// 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/v3/codec;codec";
+option java_multiple_files = true;
+option java_outer_classname = "MicroCodec";
+option java_package = "micro.codec";
+option objc_class_prefix = "MCODEC";
+
+message Frame {
+  bytes data = 1;
+}

codec/grpc/grpc.go

@@ -1,132 +0,0 @@
-// Package grpc provides a grpc codec
-package grpc
-
-import (
-	"encoding/json"
-	"errors"
-	"fmt"
-	"io"
-	"strings"
-
-	"github.com/golang/protobuf/proto"
-	"github.com/micro/go-micro/codec"
-)
-
-type Codec struct {
-	Conn        io.ReadWriteCloser
-	ContentType string
-}
-
-func (c *Codec) ReadHeader(m *codec.Message, t codec.MessageType) error {
-	if ct := m.Header["Content-Type"]; len(ct) > 0 {
-		c.ContentType = ct
-	}
-
-	if ct := m.Header["content-type"]; len(ct) > 0 {
-		c.ContentType = ct
-	}
-
-	// service method
-	path := m.Header[":path"]
-	if len(path) == 0 || path[0] != '/' {
-		m.Target = m.Header["Micro-Service"]
-		m.Endpoint = m.Header["Micro-Endpoint"]
-	} else {
-		// [ , a.package.Foo, Bar]
-		parts := strings.Split(path, "/")
-		if len(parts) != 3 {
-			return errors.New("Unknown request path")
-		}
-		service := strings.Split(parts[1], ".")
-		m.Endpoint = strings.Join([]string{service[len(service)-1], parts[2]}, ".")
-		m.Target = strings.Join(service[:len(service)-1], ".")
-	}
-
-	return nil
-}
-
-func (c *Codec) ReadBody(b interface{}) error {
-	// no body
-	if b == nil {
-		return nil
-	}
-
-	_, buf, err := decode(c.Conn)
-	if err != nil {
-		return err
-	}
-
-	switch c.ContentType {
-	case "application/grpc+json":
-		return json.Unmarshal(buf, b)
-	case "application/grpc+proto", "application/grpc":
-		return proto.Unmarshal(buf, b.(proto.Message))
-	}
-
-	return errors.New("Unsupported Content-Type")
-}
-
-func (c *Codec) Write(m *codec.Message, b interface{}) error {
-	var buf []byte
-	var err error
-
-	if ct := m.Header["Content-Type"]; len(ct) > 0 {
-		c.ContentType = ct
-	}
-
-	if ct := m.Header["content-type"]; len(ct) > 0 {
-		c.ContentType = ct
-	}
-
-	switch m.Type {
-	case codec.Request:
-		parts := strings.Split(m.Endpoint, ".")
-		m.Header[":method"] = "POST"
-		m.Header[":path"] = fmt.Sprintf("/%s.%s/%s", m.Target, parts[0], parts[1])
-		m.Header[":proto"] = "HTTP/2.0"
-		m.Header["te"] = "trailers"
-		m.Header["user-agent"] = "grpc-go/1.0.0"
-		m.Header[":authority"] = m.Target
-		m.Header["content-type"] = c.ContentType
-	case codec.Response:
-		m.Header["Trailer"] = "grpc-status, grpc-message"
-		m.Header["grpc-status"] = "0"
-		m.Header["grpc-message"] = ""
-	}
-
-	// marshal content
-	switch c.ContentType {
-	case "application/grpc+json":
-		buf, err = json.Marshal(b)
-	case "application/grpc+proto", "application/grpc":
-		pb, ok := b.(proto.Message)
-		if ok {
-			buf, err = proto.Marshal(pb)
-		}
-	default:
-		err = errors.New("Unsupported Content-Type")
-	}
-	// check error
-	if err != nil {
-		m.Header["grpc-status"] = "8"
-		m.Header["grpc-message"] = err.Error()
-		return err
-	}
-
-	return encode(0, buf, c.Conn)
-}
-
-func (c *Codec) Close() error {
-	return c.Conn.Close()
-}
-
-func (c *Codec) String() string {
-	return "grpc"
-}
-
-func NewCodec(c io.ReadWriteCloser) codec.Codec {
-	return &Codec{
-		Conn:        c,
-		ContentType: "application/grpc",
-	}
-}

codec/grpc/util.go

@@ -1,70 +0,0 @@
-package grpc
-
-import (
-	"encoding/binary"
-	"fmt"
-	"io"
-)
-
-var (
-	maxMessageSize = 1024 * 1024 * 4
-	maxInt         = int(^uint(0) >> 1)
-)
-
-func decode(r io.Reader) (uint8, []byte, error) {
-	header := make([]byte, 5)
-
-	// read the header
-	if _, err := r.Read(header[:]); err != nil {
-		return uint8(0), nil, err
-	}
-
-	// get encoding format e.g compressed
-	cf := uint8(header[0])
-
-	// get message length
-	length := binary.BigEndian.Uint32(header[1:])
-
-	// no encoding format
-	if length == 0 {
-		return cf, nil, nil
-	}
-
-	//
-	if int64(length) > int64(maxInt) {
-		return cf, nil, fmt.Errorf("grpc: received message larger than max length allowed on current machine (%d vs. %d)", length, maxInt)
-	}
-	if int(length) > maxMessageSize {
-		return cf, nil, fmt.Errorf("grpc: received message larger than max (%d vs. %d)", length, maxMessageSize)
-	}
-
-	msg := make([]byte, int(length))
-
-	if _, err := r.Read(msg); err != nil {
-		if err == io.EOF {
-			err = io.ErrUnexpectedEOF
-		}
-		return cf, nil, err
-	}
-
-	return cf, msg, nil
-}
-
-func encode(cf uint8, buf []byte, w io.Writer) error {
-	header := make([]byte, 5)
-
-	// set compression
-	header[0] = byte(cf)
-
-	// write length as header
-	binary.BigEndian.PutUint32(header[1:], uint32(len(buf)))
-
-	// read the header
-	if _, err := w.Write(header[:]); err != nil {
-		return err
-	}
-
-	// write the buffer
-	_, err := w.Write(buf)
-	return err
-}

codec/json/json.go

@@ -1,49 +0,0 @@
-// Package json provides a json codec
-package json
-
-import (
-	"encoding/json"
-	"io"
-
-	"github.com/micro/go-micro/codec"
-)
-
-type Codec struct {
-	Conn    io.ReadWriteCloser
-	Encoder *json.Encoder
-	Decoder *json.Decoder
-}
-
-func (c *Codec) ReadHeader(m *codec.Message, t codec.MessageType) error {
-	return nil
-}
-
-func (c *Codec) ReadBody(b interface{}) error {
-	if b == nil {
-		return nil
-	}
-	return c.Decoder.Decode(b)
-}
-
-func (c *Codec) Write(m *codec.Message, b interface{}) error {
-	if b == nil {
-		return nil
-	}
-	return c.Encoder.Encode(b)
-}
-
-func (c *Codec) Close() error {
-	return c.Conn.Close()
-}
-
-func (c *Codec) String() string {
-	return "json"
-}
-
-func NewCodec(c io.ReadWriteCloser) codec.Codec {
-	return &Codec{
-		Conn:    c,
-		Decoder: json.NewDecoder(c),
-		Encoder: json.NewEncoder(c),
-	}
-}

codec/json/marshaler.go

@@ -1,19 +0,0 @@
-package json
-
-import (
-	"encoding/json"
-)
-
-type Marshaler struct{}
-
-func (j Marshaler) Marshal(v interface{}) ([]byte, error) {
-	return json.Marshal(v)
-}
-
-func (j Marshaler) Unmarshal(d []byte, v interface{}) error {
-	return json.Unmarshal(d, v)
-}
-
-func (j Marshaler) String() string {
-	return "json"
-}

codec/jsonrpc/client.go

@@ -1,97 +0,0 @@
-package jsonrpc
-
-import (
-	"encoding/json"
-	"fmt"
-	"io"
-	"sync"
-
-	"github.com/micro/go-micro/codec"
-)
-
-type clientCodec struct {
-	dec *json.Decoder // for reading JSON values
-	enc *json.Encoder // for writing JSON values
-	c   io.Closer
-
-	// temporary work space
-	req  clientRequest
-	resp clientResponse
-
-	sync.Mutex
-	pending map[interface{}]string
-}
-
-type clientRequest struct {
-	Method string         `json:"method"`
-	Params [1]interface{} `json:"params"`
-	ID     interface{}    `json:"id"`
-}
-
-type clientResponse struct {
-	ID     interface{}      `json:"id"`
-	Result *json.RawMessage `json:"result"`
-	Error  interface{}      `json:"error"`
-}
-
-func newClientCodec(conn io.ReadWriteCloser) *clientCodec {
-	return &clientCodec{
-		dec:     json.NewDecoder(conn),
-		enc:     json.NewEncoder(conn),
-		c:       conn,
-		pending: make(map[interface{}]string),
-	}
-}
-
-func (c *clientCodec) Write(m *codec.Message, b interface{}) error {
-	c.Lock()
-	c.pending[m.Id] = m.Method
-	c.Unlock()
-	c.req.Method = m.Method
-	c.req.Params[0] = b
-	c.req.ID = m.Id
-	return c.enc.Encode(&c.req)
-}
-
-func (r *clientResponse) reset() {
-	r.ID = 0
-	r.Result = nil
-	r.Error = nil
-}
-
-func (c *clientCodec) ReadHeader(m *codec.Message) error {
-	c.resp.reset()
-	if err := c.dec.Decode(&c.resp); err != nil {
-		return err
-	}
-
-	c.Lock()
-	m.Method = c.pending[c.resp.ID]
-	delete(c.pending, c.resp.ID)
-	c.Unlock()
-
-	m.Error = ""
-	m.Id = fmt.Sprintf("%v", c.resp.ID)
-	if c.resp.Error != nil {
-		x, ok := c.resp.Error.(string)
-		if !ok {
-			return fmt.Errorf("invalid error %v", c.resp.Error)
-		}
-		if x == "" {
-			x = "unspecified error"
-		}
-		m.Error = x
-	}
-	return nil
-}
-
-func (c *clientCodec) ReadBody(x interface{}) error {
-	if x == nil || c.resp.Result == nil {
-		return nil
-	}
-	return json.Unmarshal(*c.resp.Result, x)
-}
-
-func (c *clientCodec) Close() error {
-	return c.c.Close()
-}

codec/jsonrpc/jsonrpc.go

@@ -1,89 +0,0 @@
-// Package jsonrpc provides a json-rpc 1.0 codec
-package jsonrpc
-
-import (
-	"bytes"
-	"encoding/json"
-	"fmt"
-	"io"
-
-	"github.com/micro/go-micro/codec"
-)
-
-type jsonCodec struct {
-	buf *bytes.Buffer
-	mt  codec.MessageType
-	rwc io.ReadWriteCloser
-	c   *clientCodec
-	s   *serverCodec
-}
-
-func (j *jsonCodec) Close() error {
-	j.buf.Reset()
-	return j.rwc.Close()
-}
-
-func (j *jsonCodec) String() string {
-	return "json-rpc"
-}
-
-func (j *jsonCodec) Write(m *codec.Message, b interface{}) error {
-	switch m.Type {
-	case codec.Request:
-		return j.c.Write(m, b)
-	case codec.Response, codec.Error:
-		return j.s.Write(m, b)
-	case codec.Publication:
-		data, err := json.Marshal(b)
-		if err != nil {
-			return err
-		}
-		_, err = j.rwc.Write(data)
-		return err
-	default:
-		return fmt.Errorf("Unrecognised message type: %v", m.Type)
-	}
-}
-
-func (j *jsonCodec) ReadHeader(m *codec.Message, mt codec.MessageType) error {
-	j.buf.Reset()
-	j.mt = mt
-
-	switch mt {
-	case codec.Request:
-		return j.s.ReadHeader(m)
-	case codec.Response:
-		return j.c.ReadHeader(m)
-	case codec.Publication:
-		_, err := io.Copy(j.buf, j.rwc)
-		return err
-	default:
-		return fmt.Errorf("Unrecognised message type: %v", mt)
-	}
-	return nil
-}
-
-func (j *jsonCodec) ReadBody(b interface{}) error {
-	switch j.mt {
-	case codec.Request:
-		return j.s.ReadBody(b)
-	case codec.Response:
-		return j.c.ReadBody(b)
-	case codec.Publication:
-		if b != nil {
-			return json.Unmarshal(j.buf.Bytes(), b)
-		}
-	default:
-		return fmt.Errorf("Unrecognised message type: %v", j.mt)
-	}
-	return nil
-}
-
-func NewCodec(rwc io.ReadWriteCloser) codec.Codec {
-	return &jsonCodec{
-		buf: bytes.NewBuffer(nil),
-		rwc: rwc,
-		c:   newClientCodec(rwc),
-		s:   newServerCodec(rwc),
-	}
-}

codec/jsonrpc/server.go

@@ -1,87 +0,0 @@
-package jsonrpc
-
-import (
-	"encoding/json"
-	"fmt"
-	"io"
-
-	"github.com/micro/go-micro/codec"
-)
-
-type serverCodec struct {
-	dec *json.Decoder // for reading JSON values
-	enc *json.Encoder // for writing JSON values
-	c   io.Closer
-
-	// temporary work space
-	req  serverRequest
-	resp serverResponse
-}
-
-type serverRequest struct {
-	Method string           `json:"method"`
-	Params *json.RawMessage `json:"params"`
-	ID     interface{}      `json:"id"`
-}
-
-type serverResponse struct {
-	ID     interface{} `json:"id"`
-	Result interface{} `json:"result"`
-	Error  interface{} `json:"error"`
-}
-
-func newServerCodec(conn io.ReadWriteCloser) *serverCodec {
-	return &serverCodec{
-		dec: json.NewDecoder(conn),
-		enc: json.NewEncoder(conn),
-		c:   conn,
-	}
-}
-
-func (r *serverRequest) reset() {
-	r.Method = ""
-	if r.Params != nil {
-		*r.Params = (*r.Params)[0:0]
-	}
-	if r.ID != nil {
-		r.ID = nil
-	}
-}
-
-func (c *serverCodec) ReadHeader(m *codec.Message) error {
-	c.req.reset()
-	if err := c.dec.Decode(&c.req); err != nil {
-		return err
-	}
-	m.Method = c.req.Method
-	m.Id = fmt.Sprintf("%v", c.req.ID)
-	c.req.ID = nil
-	return nil
-}
-
-func (c *serverCodec) ReadBody(x interface{}) error {
-	if x == nil {
-		return nil
-	}
-	var params [1]interface{}
-	params[0] = x
-	return json.Unmarshal(*c.req.Params, &params)
-}
-
-var null = json.RawMessage([]byte("null"))
-
-func (c *serverCodec) Write(m *codec.Message, x interface{}) error {
-	var resp serverResponse
-	resp.ID = m.Id
-	resp.Result = x
-	if m.Error == "" {
-		resp.Error = nil
-	} else {
-		resp.Error = m.Error
-	}
-	return c.enc.Encode(resp)
-}
-
-func (c *serverCodec) Close() error {
-	return c.c.Close()
-}

codec/noop.go

@@ -0,0 +1,68 @@
+package codec
+
+import (
+	"encoding/json"
+
+	codecpb "go.unistack.org/micro-proto/v3/codec"
+)
+
+type noopCodec struct {
+	opts Options
+}
+
+func (c *noopCodec) String() string {
+	return "noop"
+}
+
+// NewCodec returns new noop codec
+func NewCodec(opts ...Option) Codec {
+	return &noopCodec{opts: NewOptions(opts...)}
+}
+
+func (c *noopCodec) Marshal(v interface{}, opts ...Option) ([]byte, error) {
+	if v == nil {
+		return nil, nil
+	}
+
+	switch ve := v.(type) {
+	case string:
+		return []byte(ve), nil
+	case *string:
+		return []byte(*ve), nil
+	case *[]byte:
+		return *ve, nil
+	case []byte:
+		return ve, nil
+	case *Frame:
+		return ve.Data, nil
+	case *codecpb.Frame:
+		return ve.Data, nil
+	}
+
+	return json.Marshal(v)
+}
+
+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)
+		return nil
+	case []byte:
+		copy(ve, d)
+		return nil
+	case *[]byte:
+		*ve = d
+		return nil
+	case *Frame:
+		ve.Data = d
+		return nil
+	case *codecpb.Frame:
+		ve.Data = d
+		return nil
+	}
+
+	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)
+	}
+}

codec/options.go

@@ -0,0 +1,81 @@
+package codec
+
+import (
+	"context"
+
+	"go.unistack.org/micro/v3/logger"
+	"go.unistack.org/micro/v3/meter"
+	"go.unistack.org/micro/v3/tracer"
+)
+
+// Option func
+type Option func(*Options)
+
+// Options contains codec options
+type Options struct {
+	// Meter used for metrics
+	Meter meter.Meter
+	// Logger used for logging
+	Logger logger.Logger
+	// Tracer used for tracing
+	Tracer tracer.Tracer
+	// Context stores additional codec options
+	Context context.Context
+	// TagName specifies tag name in struct to control codec
+	TagName string
+	// Flatten specifies that struct must be analyzed for flatten tag
+	Flatten bool
+}
+
+// TagName sets the codec tag name in struct
+func TagName(n string) Option {
+	return func(o *Options) {
+		o.TagName = n
+	}
+}
+
+// Flatten enables checking for flatten tag name
+func Flatten(b bool) Option {
+	return func(o *Options) {
+		o.Flatten = b
+	}
+}
+
+// Logger sets the logger
+func Logger(l logger.Logger) Option {
+	return func(o *Options) {
+		o.Logger = l
+	}
+}
+
+// Tracer to be used for tracing
+func Tracer(t tracer.Tracer) Option {
+	return func(o *Options) {
+		o.Tracer = t
+	}
+}
+
+// Meter sets the meter
+func Meter(m meter.Meter) Option {
+	return func(o *Options) {
+		o.Meter = m
+	}
+}
+
+// NewOptions returns new options
+func NewOptions(opts ...Option) Options {
+	options := Options{
+		Context: context.Background(),
+		Logger:  logger.DefaultLogger,
+		Meter:   meter.DefaultMeter,
+		Tracer:  tracer.DefaultTracer,
+		TagName: DefaultTagName,
+		Flatten: false,
+	}
+
+	for _, o := range opts {
+		o(&options)
+	}
+
+	return options
+}

codec/proto/marshaler.go

@@ -1,19 +0,0 @@
-package proto
-
-import (
-	"github.com/golang/protobuf/proto"
-)
-
-type Marshaler struct{}
-
-func (Marshaler) Marshal(v interface{}) ([]byte, error) {
-	return proto.Marshal(v.(proto.Message))
-}
-
-func (Marshaler) Unmarshal(data []byte, v interface{}) error {
-	return proto.Unmarshal(data, v.(proto.Message))
-}
-
-func (Marshaler) Name() string {
-	return "proto"
-}

codec/proto/proto.go

@@ -1,56 +0,0 @@
-// Package proto provides a proto codec
-package proto
-
-import (
-	"io"
-	"io/ioutil"
-
-	"github.com/golang/protobuf/proto"
-	"github.com/micro/go-micro/codec"
-)
-
-type Codec struct {
-	Conn io.ReadWriteCloser
-}
-
-func (c *Codec) ReadHeader(m *codec.Message, t codec.MessageType) error {
-	return nil
-}
-
-func (c *Codec) ReadBody(b interface{}) error {
-	if b == nil {
-		return nil
-	}
-	buf, err := ioutil.ReadAll(c.Conn)
-	if err != nil {
-		return err
-	}
-	return proto.Unmarshal(buf, b.(proto.Message))
-}
-
-func (c *Codec) Write(m *codec.Message, b interface{}) error {
-	p, ok := b.(proto.Message)
-	if !ok {
-		return nil
-	}
-	buf, err := proto.Marshal(p)
-	if err != nil {
-		return err
-	}
-	_, err = c.Conn.Write(buf)
-	return err
-}
-
-func (c *Codec) Close() error {
-	return c.Conn.Close()
-}
-
-func (c *Codec) String() string {
-	return "proto"
-}
-
-func NewCodec(c io.ReadWriteCloser) codec.Codec {
-	return &Codec{
-		Conn: c,
-	}
-}

codec/protorpc/envelope.pb.go

@@ -1,83 +0,0 @@
-// Code generated by protoc-gen-go.
-// source: envelope.proto
-// DO NOT EDIT!
-
-/*
-Package proto is a generated protocol buffer package.
-
-It is generated from these files:
-	envelope.proto
-
-It has these top-level messages:
-	Request
-	Response
-*/
-package protorpc
-
-import proto "github.com/golang/protobuf/proto"
-import json "encoding/json"
-import math "math"
-
-// Reference proto, json, and math imports to suppress error if they are not otherwise used.
-var _ = proto.Marshal
-var _ = &json.SyntaxError{}
-var _ = math.Inf
-
-type Request struct {
-	ServiceMethod    *string `protobuf:"bytes,1,opt,name=service_method" json:"service_method,omitempty"`
-	Seq              *uint64 `protobuf:"fixed64,2,opt,name=seq" json:"seq,omitempty"`
-	XXX_unrecognized []byte  `json:"-"`
-}
-
-func (m *Request) Reset()         { *m = Request{} }
-func (m *Request) String() string { return proto.CompactTextString(m) }
-func (*Request) ProtoMessage()    {}
-
-func (m *Request) GetServiceMethod() string {
-	if m != nil && m.ServiceMethod != nil {
-		return *m.ServiceMethod
-	}
-	return ""
-}
-
-func (m *Request) GetSeq() uint64 {
-	if m != nil && m.Seq != nil {
-		return *m.Seq
-	}
-	return 0
-}
-
-type Response struct {
-	ServiceMethod    *string `protobuf:"bytes,1,opt,name=service_method" json:"service_method,omitempty"`
-	Seq              *uint64 `protobuf:"fixed64,2,opt,name=seq" json:"seq,omitempty"`
-	Error            *string `protobuf:"bytes,3,opt,name=error" json:"error,omitempty"`
-	XXX_unrecognized []byte  `json:"-"`
-}
-
-func (m *Response) Reset()         { *m = Response{} }
-func (m *Response) String() string { return proto.CompactTextString(m) }
-func (*Response) ProtoMessage()    {}
-
-func (m *Response) GetServiceMethod() string {
-	if m != nil && m.ServiceMethod != nil {
-		return *m.ServiceMethod
-	}
-	return ""
-}
-
-func (m *Response) GetSeq() uint64 {
-	if m != nil && m.Seq != nil {
-		return *m.Seq
-	}
-	return 0
-}
-
-func (m *Response) GetError() string {
-	if m != nil && m.Error != nil {
-		return *m.Error
-	}
-	return ""
-}
-
-func init() {
-}

codec/protorpc/envelope.proto

@@ -1,12 +0,0 @@
-package protorpc;
-
-message Request {
-	optional string service_method = 1;
-	optional fixed64 seq = 2;
-}
-
-message Response {
-	optional string service_method = 1;
-	optional fixed64 seq = 2;
-	optional string error = 3;
-}

codec/protorpc/netstring.go

@@ -1,36 +0,0 @@
-package protorpc
-
-import (
-	"encoding/binary"
-	"io"
-)
-
-// WriteNetString writes data to a big-endian netstring on a Writer.
-// Size is always a 32-bit unsigned int.
-func WriteNetString(w io.Writer, data []byte) (written int, err error) {
-	size := make([]byte, 4)
-	binary.BigEndian.PutUint32(size, uint32(len(data)))
-	if written, err = w.Write(size); err != nil {
-		return
-	}
-	return w.Write(data)
-}
-
-// ReadNetString reads data from a big-endian netstring.
-func ReadNetString(r io.Reader) (data []byte, err error) {
-	sizeBuf := make([]byte, 4)
-	_, err = r.Read(sizeBuf)
-	if err != nil {
-		return nil, err
-	}
-	size := binary.BigEndian.Uint32(sizeBuf)
-	if size == 0 {
-		return nil, nil
-	}
-	data = make([]byte, size)
-	_, err = r.Read(data)
-	if err != nil {
-		return nil, err
-	}
-	return
-}

codec/protorpc/protorpc.go

@@ -1,178 +0,0 @@
-// Protorpc provides a net/rpc proto-rpc codec. See envelope.proto for the format.
-package protorpc
-
-import (
-	"bytes"
-	"fmt"
-	"io"
-	"strconv"
-	"sync"
-
-	"github.com/golang/protobuf/proto"
-	"github.com/micro/go-micro/codec"
-)
-
-type flusher interface {
-	Flush() error
-}
-
-type protoCodec struct {
-	sync.Mutex
-	rwc io.ReadWriteCloser
-	mt  codec.MessageType
-	buf *bytes.Buffer
-}
-
-func (c *protoCodec) Close() error {
-	c.buf.Reset()
-	return c.rwc.Close()
-}
-
-func (c *protoCodec) String() string {
-	return "proto-rpc"
-}
-
-func id(id string) *uint64 {
-	p, err := strconv.ParseInt(id, 10, 64)
-	if err != nil {
-		p = 0
-	}
-	i := uint64(p)
-	return &i
-}
-
-func (c *protoCodec) Write(m *codec.Message, b interface{}) error {
-	switch m.Type {
-	case codec.Request:
-		c.Lock()
-		defer c.Unlock()
-		// This is protobuf, of course we copy it.
-		pbr := &Request{ServiceMethod: &m.Method, Seq: id(m.Id)}
-		data, err := proto.Marshal(pbr)
-		if err != nil {
-			return err
-		}
-		_, err = WriteNetString(c.rwc, data)
-		if err != nil {
-			return err
-		}
-		// Of course this is a protobuf! Trust me or detonate the program.
-		data, err = proto.Marshal(b.(proto.Message))
-		if err != nil {
-			return err
-		}
-		_, err = WriteNetString(c.rwc, data)
-		if err != nil {
-			return err
-		}
-		if flusher, ok := c.rwc.(flusher); ok {
-			if err = flusher.Flush(); err != nil {
-				return err
-			}
-		}
-	case codec.Response, codec.Error:
-		c.Lock()
-		defer c.Unlock()
-		rtmp := &Response{ServiceMethod: &m.Method, Seq: id(m.Id), Error: &m.Error}
-		data, err := proto.Marshal(rtmp)
-		if err != nil {
-			return err
-		}
-		_, err = WriteNetString(c.rwc, data)
-		if err != nil {
-			return err
-		}
-		if pb, ok := b.(proto.Message); ok {
-			data, err = proto.Marshal(pb)
-			if err != nil {
-				return err
-			}
-		} else {
-			data = nil
-		}
-		_, err = WriteNetString(c.rwc, data)
-		if err != nil {
-			return err
-		}
-		if flusher, ok := c.rwc.(flusher); ok {
-			if err = flusher.Flush(); err != nil {
-				return err
-			}
-		}
-	case codec.Publication:
-		data, err := proto.Marshal(b.(proto.Message))
-		if err != nil {
-			return err
-		}
-		c.rwc.Write(data)
-	default:
-		return fmt.Errorf("Unrecognised message type: %v", m.Type)
-	}
-	return nil
-}
-
-func (c *protoCodec) ReadHeader(m *codec.Message, mt codec.MessageType) error {
-	c.buf.Reset()
-	c.mt = mt
-
-	switch mt {
-	case codec.Request:
-		data, err := ReadNetString(c.rwc)
-		if err != nil {
-			return err
-		}
-		rtmp := new(Request)
-		err = proto.Unmarshal(data, rtmp)
-		if err != nil {
-			return err
-		}
-		m.Method = rtmp.GetServiceMethod()
-		m.Id = fmt.Sprintf("%d", rtmp.GetSeq())
-	case codec.Response:
-		data, err := ReadNetString(c.rwc)
-		if err != nil {
-			return err
-		}
-		rtmp := new(Response)
-		err = proto.Unmarshal(data, rtmp)
-		if err != nil {
-			return err
-		}
-		m.Method = rtmp.GetServiceMethod()
-		m.Id = fmt.Sprintf("%d", rtmp.GetSeq())
-		m.Error = rtmp.GetError()
-	case codec.Publication:
-		_, err := io.Copy(c.buf, c.rwc)
-		return err
-	default:
-		return fmt.Errorf("Unrecognised message type: %v", mt)
-	}
-	return nil
-}
-
-func (c *protoCodec) ReadBody(b interface{}) error {
-	var data []byte
-	switch c.mt {
-	case codec.Request, codec.Response:
-		var err error
-		data, err = ReadNetString(c.rwc)
-		if err != nil {
-			return err
-		}
-	case codec.Publication:
-		data = c.buf.Bytes()
-	default:
-		return fmt.Errorf("Unrecognised message type: %v", c.mt)
-	}
-	if b != nil {
-		return proto.Unmarshal(data, b.(proto.Message))
-	}
-	return nil
-}
-
-func NewCodec(rwc io.ReadWriteCloser) codec.Codec {
-	return &protoCodec{
-		buf: bytes.NewBuffer(nil),
-		rwc: rwc,
-	}
-}

config/config.go

@@ -0,0 +1,224 @@
+// Package config is an interface for dynamic configuration.
+package config
+
+import (
+	"context"
+	"errors"
+	"reflect"
+	"time"
+)
+
+type Validator interface {
+	Validate() error
+}
+
+// DefaultConfig default config
+var DefaultConfig = NewConfig()
+
+// DefaultWatcherMinInterval default min interval for poll changes
+var DefaultWatcherMinInterval = 5 * time.Second
+
+// DefaultWatcherMaxInterval default max interval for poll changes
+var DefaultWatcherMaxInterval = 9 * time.Second
+
+var (
+	// ErrCodecMissing is returned when codec needed and not specified
+	ErrCodecMissing = errors.New("codec missing")
+	// ErrInvalidStruct is returned when the target struct is invalid
+	ErrInvalidStruct = errors.New("invalid struct specified")
+	// ErrWatcherStopped is returned when source watcher has been stopped
+	ErrWatcherStopped = errors.New("watcher stopped")
+	// ErrWatcherNotImplemented returned when config does not implement watch
+	ErrWatcherNotImplemented = errors.New("watcher not implemented")
+)
+
+// Config is an interface abstraction for dynamic configuration
+type Config interface {
+	// Name returns name of config
+	Name() string
+	// Init the config
+	Init(opts ...Option) error
+	// Options in the config
+	Options() Options
+	// Load config from sources
+	Load(context.Context, ...LoadOption) error
+	// Save config to sources
+	Save(context.Context, ...SaveOption) error
+	// Watch a config for changes
+	Watch(context.Context, ...WatchOption) (Watcher, error)
+	// String returns config type name
+	String() string
+}
+
+type (
+	FuncLoad func(ctx context.Context, opts ...LoadOption) error
+	HookLoad func(next FuncLoad) FuncLoad
+	FuncSave func(ctx context.Context, opts ...SaveOption) error
+	HookSave func(next FuncSave) FuncSave
+)
+
+// Watcher is the config watcher
+type Watcher interface {
+	// Next blocks until update happens or error returned
+	Next() (map[string]interface{}, error)
+	// Stop stops watcher
+	Stop() error
+}
+
+// Load loads config from config sources
+func Load(ctx context.Context, cs []Config, opts ...LoadOption) error {
+	var err error
+	for _, c := range cs {
+		if err = c.Init(); err != nil {
+			return err
+		}
+		if err = c.Load(ctx, opts...); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+// Validate runs Validate() error func for each struct field
+func Validate(ctx context.Context, cfg interface{}) error {
+	if cfg == nil {
+		return nil
+	}
+
+	if v, ok := cfg.(Validator); ok {
+		if err := v.Validate(); err != nil {
+			return err
+		}
+	}
+
+	sv := reflect.ValueOf(cfg)
+	if sv.Kind() == reflect.Ptr {
+		sv = sv.Elem()
+	}
+	if sv.Kind() != reflect.Struct {
+		return nil
+	}
+
+	typ := sv.Type()
+	for idx := 0; idx < typ.NumField(); idx++ {
+		fld := typ.Field(idx)
+		val := sv.Field(idx)
+		if !val.IsValid() || len(fld.PkgPath) != 0 {
+			continue
+		}
+
+		if v, ok := val.Interface().(Validator); ok {
+			if err := v.Validate(); err != nil {
+				return err
+			}
+		}
+
+		switch val.Kind() {
+		case reflect.Ptr:
+			if reflect.Indirect(val).Kind() == reflect.Struct {
+				if err := Validate(ctx, val.Interface()); err != nil {
+					return err
+				}
+			}
+		case reflect.Struct:
+			if err := Validate(ctx, val.Interface()); err != nil {
+				return err
+			}
+		}
+	}
+
+	return nil
+}
+
+var (
+	// DefaultBeforeLoad default func that runs before config Load
+	DefaultBeforeLoad = func(ctx context.Context, c Config) error {
+		for _, fn := range c.Options().BeforeLoad {
+			if fn == nil {
+				return nil
+			}
+			if err := fn(ctx, c); err != nil {
+				c.Options().Logger.Error(ctx, c.String()+" BeforeLoad error", err)
+				if !c.Options().AllowFail {
+					return err
+				}
+			}
+		}
+		return nil
+	}
+	// DefaultAfterLoad default func that runs after config Load
+	DefaultAfterLoad = func(ctx context.Context, c Config) error {
+		for _, fn := range c.Options().AfterLoad {
+			if fn == nil {
+				return nil
+			}
+			if err := fn(ctx, c); err != nil {
+				c.Options().Logger.Error(ctx, c.String()+" AfterLoad error", err)
+				if !c.Options().AllowFail {
+					return err
+				}
+			}
+		}
+		return nil
+	}
+	// DefaultBeforeSave default func that runs befora config Save
+	DefaultBeforeSave = func(ctx context.Context, c Config) error {
+		for _, fn := range c.Options().BeforeSave {
+			if fn == nil {
+				return nil
+			}
+			if err := fn(ctx, c); err != nil {
+				c.Options().Logger.Error(ctx, c.String()+" BeforeSave error", err)
+				if !c.Options().AllowFail {
+					return err
+				}
+			}
+		}
+		return nil
+	}
+	// DefaultAfterSave default func that runs after config Save
+	DefaultAfterSave = func(ctx context.Context, c Config) error {
+		for _, fn := range c.Options().AfterSave {
+			if fn == nil {
+				return nil
+			}
+			if err := fn(ctx, c); err != nil {
+				c.Options().Logger.Error(ctx, c.String()+" AfterSave error", err)
+				if !c.Options().AllowFail {
+					return err
+				}
+			}
+		}
+		return nil
+	}
+	// DefaultBeforeInit default func that runs befora config Init
+	DefaultBeforeInit = func(ctx context.Context, c Config) error {
+		for _, fn := range c.Options().BeforeInit {
+			if fn == nil {
+				return nil
+			}
+			if err := fn(ctx, c); err != nil {
+				c.Options().Logger.Error(ctx, c.String()+" BeforeInit error", err)
+				if !c.Options().AllowFail {
+					return err
+				}
+			}
+		}
+		return nil
+	}
+	// DefaultAfterInit default func that runs after config Init
+	DefaultAfterInit = func(ctx context.Context, c Config) error {
+		for _, fn := range c.Options().AfterSave {
+			if fn == nil {
+				return nil
+			}
+			if err := fn(ctx, c); err != nil {
+				c.Options().Logger.Error(ctx, c.String()+" AfterInit error", err)
+				if !c.Options().AllowFail {
+					return err
+				}
+			}
+		}
+		return nil
+	}
+)

config/context.go

@@ -0,0 +1,73 @@
+package config
+
+import (
+	"context"
+)
+
+type configKey struct{}
+
+// FromContext returns store from context
+func FromContext(ctx context.Context) (Config, bool) {
+	if ctx == nil {
+		return nil, false
+	}
+	c, ok := ctx.Value(configKey{}).(Config)
+	return c, ok
+}
+
+// MustContext returns store from context
+func MustContext(ctx context.Context) Config {
+	c, ok := FromContext(ctx)
+	if !ok {
+		panic("missing config")
+	}
+	return c
+}
+
+// NewContext put store in context
+func NewContext(ctx context.Context, c Config) context.Context {
+	if ctx == nil {
+		ctx = context.Background()
+	}
+	return context.WithValue(ctx, configKey{}, c)
+}
+
+// SetOption returns a function to setup a context with given value
+func SetOption(k, v interface{}) Option {
+	return func(o *Options) {
+		if o.Context == nil {
+			o.Context = context.Background()
+		}
+		o.Context = context.WithValue(o.Context, k, v)
+	}
+}
+
+// SetSaveOption returns a function to setup a context with given value
+func SetSaveOption(k, v interface{}) SaveOption {
+	return func(o *SaveOptions) {
+		if o.Context == nil {
+			o.Context = context.Background()
+		}
+		o.Context = context.WithValue(o.Context, k, v)
+	}
+}
+
+// SetLoadOption returns a function to setup a context with given value
+func SetLoadOption(k, v interface{}) LoadOption {
+	return func(o *LoadOptions) {
+		if o.Context == nil {
+			o.Context = context.Background()
+		}
+		o.Context = context.WithValue(o.Context, k, v)
+	}
+}
+
+// SetWatchOption returns a function to setup a context with given value
+func SetWatchOption(k, v interface{}) WatchOption {
+	return func(o *WatchOptions) {
+		if o.Context == nil {
+			o.Context = context.Background()
+		}
+		o.Context = context.WithValue(o.Context, k, v)
+	}
+}

config/context_test.go

@@ -0,0 +1,86 @@
+package config
+
+import (
+	"context"
+	"testing"
+)
+
+func TestFromNilContext(t *testing.T) {
+	// nolint: staticcheck
+	c, ok := FromContext(nil)
+	if ok || c != nil {
+		t.Fatal("FromContext not works")
+	}
+}
+
+func TestNewNilContext(t *testing.T) {
+	// nolint: staticcheck
+	ctx := NewContext(nil, NewConfig())
+
+	c, ok := FromContext(ctx)
+	if c == nil || !ok {
+		t.Fatal("NewContext not works")
+	}
+}
+
+func TestFromContext(t *testing.T) {
+	ctx := context.WithValue(context.TODO(), configKey{}, NewConfig())
+
+	c, ok := FromContext(ctx)
+	if c == nil || !ok {
+		t.Fatal("FromContext not works")
+	}
+}
+
+func TestNewContext(t *testing.T) {
+	ctx := NewContext(context.TODO(), NewConfig())
+
+	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")
+	}
+}
+
+func TestSetSaveOption(t *testing.T) {
+	type key struct{}
+	o := SetSaveOption(key{}, "test")
+	opts := &SaveOptions{}
+	o(opts)
+
+	if v, ok := opts.Context.Value(key{}).(string); !ok || v == "" {
+		t.Fatal("SetSaveOption not works")
+	}
+}
+
+func TestSetLoadOption(t *testing.T) {
+	type key struct{}
+	o := SetLoadOption(key{}, "test")
+	opts := &LoadOptions{}
+	o(opts)
+
+	if v, ok := opts.Context.Value(key{}).(string); !ok || v == "" {
+		t.Fatal("SetLoadOption not works")
+	}
+}
+
+func TestSetWatchOption(t *testing.T) {
+	type key struct{}
+	o := SetWatchOption(key{}, "test")
+	opts := &WatchOptions{}
+	o(opts)
+
+	if v, ok := opts.Context.Value(key{}).(string); !ok || v == "" {
+		t.Fatal("SetWatchOption not works")
+	}
+}