merge stable changes (#61)

.github.old/ISSUE_TEMPLATE/bug_report.md

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

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

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

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

.github.old/workflows/autoapprove.yml

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

.github.old/workflows/automerge.yml

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

.github.old/workflows/codecov.yml

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

.github.old/workflows/pr.yml

@@ -1,40 +0,0 @@
-name: prbuild
-on:
-  pull_request:
-    branches:
-    - master
-    - v3
-jobs:
-  test:
-    name: test
-    runs-on: ubuntu-latest
-    steps:
-    - name: setup
-      uses: actions/setup-go@v3
-      with:
-        go-version: 1.17
-    - name: checkout
-      uses: actions/checkout@v3
-    - name: cache
-      uses: actions/cache@v3
-      with:
-        path: ~/go/pkg/mod
-        key: ${{ runner.os }}-go-${{ hashFiles('**/go.sum') }}
-        restore-keys: ${{ runner.os }}-go-
-    - name: deps
-      run: go get -v -t -d ./...
-    - name: test
-      env:
-        INTEGRATION_TESTS: yes
-      run: go test -mod readonly -v ./...
-  lint:
-    name: lint
-    runs-on: ubuntu-latest
-    steps:
-      - name: checkout
-        uses: actions/checkout@v3
-      - name: lint
-        uses: golangci/golangci-lint-action@v3.4.0
-        continue-on-error: true
-        with:
-          version: v1.30

.github/ISSUE_TEMPLATE/bug_report.md

@@ -1,6 +1,6 @@
 ---
 name: Bug report
-about: For reporting bugs in micro
+about: For reporting bugs in go-micro
 title: "[BUG]"
 labels: ''
 assignees: ''
@@ -16,3 +16,9 @@ assignees: ''
 **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/ISSUE_TEMPLATE/feature-request---enhancement.md

@@ -1,6 +1,6 @@
 ---
 name: Feature request / Enhancement
-about: If you have a need not served by micro
+about: If you have a need not served by go-micro
 title: "[FEATURE]"
 labels: ''
 assignees: ''
@@ -14,4 +14,4 @@ A clear and concise description of what the problem is. Ex. I'm always frustrate
 A clear and concise description of what you want to happen.
 
 **Additional context**
-Add any other context or screenshots about the feature request here.
+Add any other context or screenshots about the feature request here.

.github/ISSUE_TEMPLATE/question.md

@@ -1,8 +1,14 @@
 ---
 name: Question
-about: Ask a question about micro
+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/autoapprove.yml

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

.github/workflows/build.yml

@@ -1,6 +1,6 @@
 name: build
 on:
- push:
+  push:
     branches:
     - master
     - v3
@@ -10,35 +10,51 @@ jobs:
     runs-on: ubuntu-latest
     steps:
     - name: setup
-      uses: actions/setup-go@v3
+      uses: actions/setup-go@v2
       with:
-        go-version: 1.17
+        go-version: 1.16
-    - name: checkout
-      uses: actions/checkout@v3
     - name: cache
-      uses: actions/cache@v3
+      uses: actions/cache@v2
       with:
         path: ~/go/pkg/mod
         key: ${{ runner.os }}-go-${{ hashFiles('**/go.sum') }}
         restore-keys: ${{ runner.os }}-go-
-    - name: deps
+    - name: sdk checkout
+      uses: actions/checkout@v2
+    - name: sdk deps
       run: go get -v -t -d ./...
-    - name: test
+    - name: sdk test
       env:
         INTEGRATION_TESTS: yes
       run: go test -mod readonly -v ./...
+    - name: tests checkout
+      uses: actions/checkout@v2
+      with:
+        repository: unistack-org/micro-tests
+        ref: refs/heads/master
+        path: micro-tests
+        fetch-depth: 1
+    - name: tests deps
+      run: |
+        cd micro-tests
+        go mod edit -replace="github.com/unistack-org/micro/v3=../"
+        go get -v -t -d ./...
+    - name: tests test
+      env:
+        INTEGRATION_TESTS: yes
+      run: cd micro-tests && go test -mod readonly -v ./...
   lint:
     name: lint
     runs-on: ubuntu-latest
     steps:
       - name: checkout
-        uses: actions/checkout@v3
+        uses: actions/checkout@v2
       - name: lint
-        uses: golangci/golangci-lint-action@v3.4.0
+        uses: golangci/golangci-lint-action@v2
         continue-on-error: true
         with:
           # Required: the version of golangci-lint is required and must be specified without patch version: we always use the latest patch version.
-          version: v1.30
+          version: v1.39
           # Optional: working directory, useful for monorepos
           # working-directory: somedir
           # Optional: golangci-lint command line arguments.

.github/workflows/codeql-analysis.yml

@@ -43,14 +43,14 @@ jobs:
 
     steps:
     - name: checkout
-      uses: actions/checkout@v3
+      uses: actions/checkout@v2
     - name: setup
-      uses: actions/setup-go@v3
+      uses: actions/setup-go@v2
       with:
-        go-version: 1.17
+        go-version: 1.16
     # Initializes the CodeQL tools for scanning.
     - name: init
-      uses: github/codeql-action/init@v2
+      uses: github/codeql-action/init@v1
       with:
         languages: ${{ matrix.language }}
         # If you wish to specify custom queries, you can do so here or in a config file.
@@ -61,7 +61,7 @@ jobs:
     # 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
+      uses: github/codeql-action/autobuild@v1
 
     # ℹ️ Command-line programs to run using the OS shell.
     # 📚 https://git.io/JvXDl
@@ -75,4 +75,4 @@ jobs:
     #   make release
 
     - name: analyze
-      uses: github/codeql-action/analyze@v2
+      uses: github/codeql-action/analyze@v1

.github/workflows/dependabot-automerge.yml

@@ -1,4 +1,4 @@
-name: "dependabot-automerge"
+name: "prautomerge"
 
 on:
   pull_request_target:
@@ -9,17 +9,21 @@ permissions:
   contents: write
 
 jobs:
-  automerge:
+  dependabot:
     runs-on: ubuntu-latest
-    if: github.actor == 'dependabot[bot]'
+    if: ${{ github.actor == 'dependabot[bot]' }}
     steps:
       - name: metadata
         id: metadata
-        uses: dependabot/fetch-metadata@v1.3.6
+        uses: dependabot/fetch-metadata@v1.1.1
         with:
           github-token: "${{ secrets.TOKEN }}"
+      - name: approve
+        run: gh pr review --approve "$PR_URL"
+        env:
+          PR_URL: ${{github.event.pull_request.html_url}}
+          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:

.github/workflows/job_coverage.yml

@@ -1,53 +0,0 @@
-name: coverage
-
-on:
-  push:
-    branches: [ main, v3, v4 ]
-    paths-ignore:
-      - '.github/**'
-      - '.gitea/**'
-  pull_request:
-    branches: [ main, v3, v4 ]
-
-jobs:
-
-  build:
-    if: github.server_url != 'https://github.com'
-    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: false
-        skip_checkout: false
-        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 }}

.github/workflows/job_lint.yml

@@ -1,29 +0,0 @@
-name: lint
-
-on:
-  pull_request:
-    types: [opened, reopened, synchronize]
-    branches: [ master, v3, v4 ]
-    paths-ignore:
-      - '.github/**'
-      - '.gitea/**'
-
-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: golangci/golangci-lint-action@v6
-      with:
-        version: 'latest'

.github/workflows/job_sync.yml

@@ -1,94 +0,0 @@
-name: sync
-
-on:
-  schedule:
-    - cron: '*/5 * * * *'
-  # Allows you to run this workflow manually from the Actions tab
-  workflow_dispatch:
-
-jobs:
-  sync:
-    if: github.server_url != 'https://github.com'
-    runs-on: ubuntu-latest
-    steps:
-    - name: init
-      run: |
-        git config --global user.email "vtolstov <vtolstov@users.noreply.github.com>"
-        git config --global user.name "github-actions[bot]"
-        echo "machine git.unistack.org login vtolstov password ${{ secrets.TOKEN_GITEA }}" >> /root/.netrc
-        echo "machine github.com login vtolstov password ${{ secrets.TOKEN_GITHUB }}" >> /root/.netrc
-
-    - name: check master
-      id: check_master
-      run: |
-        src_hash=$(git ls-remote https://github.com/${GITHUB_REPOSITORY} refs/heads/master | cut -f1)
-        dst_hash=$(git ls-remote ${GITHUB_SERVER_URL}/${GITHUB_REPOSITORY} refs/heads/master | cut -f1)
-        echo "src_hash=$src_hash"
-        echo "dst_hash=$dst_hash"
-        if [ "$src_hash" != "$dst_hash" ]; then
-          echo "sync_needed=true" >> $GITHUB_OUTPUT
-        else
-          echo "sync_needed=false" >> $GITHUB_OUTPUT
-        fi
-
-    - name: sync master
-      if: steps.check_master.outputs.sync_needed == 'true'
-      run: |
-        git clone --filter=blob:none --filter=tree:0 --branch master --single-branch ${GITHUB_SERVER_URL}/${GITHUB_REPOSITORY} repo
-        cd repo
-        git remote add --no-tags --fetch --track master upstream https://github.com/${GITHUB_REPOSITORY}
-        git pull --rebase upstream master
-        git push upstream master --progress
-        git push origin master --progress
-        cd ../
-        rm -rf repo
-
-    - name: check v3
-      id: check_v3
-      run: |
-        src_hash=$(git ls-remote https://github.com/${GITHUB_REPOSITORY} refs/heads/v3 | cut -f1)
-        dst_hash=$(git ls-remote ${GITHUB_SERVER_URL}/${GITHUB_REPOSITORY} refs/heads/v3 | cut -f1)
-        echo "src_hash=$src_hash"
-        echo "dst_hash=$dst_hash"
-        if [ "$src_hash" != "$dst_hash" ]; then
-          echo "sync_needed=true" >> $GITHUB_OUTPUT
-        else
-          echo "sync_needed=false" >> $GITHUB_OUTPUT
-        fi
-
-    - name: sync v3
-      if: steps.check_v3.outputs.sync_needed == 'true'
-      run: |
-        git clone --filter=blob:none --filter=tree:0 --branch v3 --single-branch ${GITHUB_SERVER_URL}/${GITHUB_REPOSITORY} repo
-        cd repo
-        git remote add --no-tags --fetch --track v3 upstream https://github.com/${GITHUB_REPOSITORY}
-        git pull --rebase upstream v3
-        git push upstream v3 --progress
-        git push origin v3 --progress
-        cd ../
-        rm -rf repo
-
-    - name: check v4
-      id: check_v4
-      run: |
-        src_hash=$(git ls-remote https://github.com/${GITHUB_REPOSITORY} refs/heads/v4 | cut -f1)
-        dst_hash=$(git ls-remote ${GITHUB_SERVER_URL}/${GITHUB_REPOSITORY} refs/heads/v4 | cut -f1)
-        echo "src_hash=$src_hash"
-        echo "dst_hash=$dst_hash"
-        if [ "$src_hash" != "$dst_hash" ]; then
-          echo "sync_needed=true" >> $GITHUB_OUTPUT
-        else
-          echo "sync_needed=false" >> $GITHUB_OUTPUT
-        fi
-
-    - name: sync v4
-      if: steps.check_v4.outputs.sync_needed == 'true'
-      run: |
-        git clone --filter=blob:none --filter=tree:0 --branch v4 --single-branch ${GITHUB_SERVER_URL}/${GITHUB_REPOSITORY} repo
-        cd repo
-        git remote add --no-tags --fetch --track v4 upstream https://github.com/${GITHUB_REPOSITORY}
-        git pull --rebase upstream v4
-        git push upstream v4 --progress
-        git push origin v4 --progress
-        cd ../
-        rm -rf repo

.github/workflows/job_test.yml

@@ -1,31 +0,0 @@
-name: test
-
-on:
-  pull_request:
-    types: [opened, reopened, synchronize]
-    branches: [ master, v3, v4 ]
-  push:
-    branches: [ master, v3, v4 ]
-    paths-ignore:
-      - '.github/**'
-      - '.gitea/**'
-
-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 ./...

.github/workflows/job_tests.yml

@@ -1,50 +0,0 @@
-name: test
-
-on:
-  pull_request:
-    types: [opened, reopened, synchronize]
-    branches: [ master, v3, v4 ]
-  push:
-    branches: [ master, v3, v4 ]
-    paths-ignore:
-      - '.github/**'
-      - '.gitea/**'
-
-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: ${{ github.workspace }}/go.work
-      run: |
-        go work init
-        go work use .
-        go work use micro-tests
-    - name: setup deps
-      env:
-        GOWORK: ${{ github.workspace }}/go.work
-      run: go get -v ./...
-    - name: run tests
-      env:
-        INTEGRATION_TESTS: yes
-        GOWORK: ${{ github.workspace }}/go.work
-      run: |
-        cd micro-tests
-        go test -mod readonly -v ./... || true

.github/workflows/pr.yml

@@ -0,0 +1,63 @@
+name: prbuild
+on:
+  pull_request:
+    branches:
+    - master
+    - v3
+jobs:
+  test:
+    name: test
+    runs-on: ubuntu-latest
+    steps:
+    - name: setup
+      uses: actions/setup-go@v2
+      with:
+        go-version: 1.16
+    - name: cache
+      uses: actions/cache@v2
+      with:
+        path: ~/go/pkg
+        key: ${{ runner.os }}-go-${{ hashFiles('**/go.sum') }}
+        restore-keys: ${{ runner.os }}-go-
+    - name: sdk checkout
+      uses: actions/checkout@v2
+    - name: sdk deps
+      run: go get -v -t -d ./...
+    - name: sdk test
+      env:
+        INTEGRATION_TESTS: yes
+      run: go test -mod readonly -v ./...
+    - name: tests checkout
+      uses: actions/checkout@v2
+      with:
+        repository: unistack-org/micro-tests
+        ref: refs/heads/master
+        path: micro-tests
+        fetch-depth: 1
+    - name: tests deps
+      run: |
+        cd micro-tests
+        go mod edit -replace="github.com/unistack-org/micro/v3=../"
+        go get -v -t -d ./...
+    - name: tests test
+      env:
+        INTEGRATION_TESTS: yes
+      run: cd micro-tests && go test -mod readonly -v ./...
+  lint:
+    name: lint
+    runs-on: ubuntu-latest
+    steps:
+      - name: checkout
+        uses: actions/checkout@v2
+      - name: lint
+        uses: golangci/golangci-lint-action@v2
+        continue-on-error: true
+        with:
+          # Required: the version of golangci-lint is required and must be specified without patch version: we always use the latest patch version.
+          version: v1.39
+          # Optional: working directory, useful for monorepos
+          # working-directory: somedir
+          # Optional: golangci-lint command line arguments.
+          # args: --issues-exit-code=0
+          # Optional: show only new issues if it's a pull request. The default value is `false`.
+          # only-new-issues: true

.gitignore

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

.golangci.yml

@@ -1,5 +1,44 @@
 run:
-  concurrency: 8
+  concurrency: 4
-  timeout: 5m
+  deadline: 5m
   issues-exit-code: 1
   tests: true
+
+linters-settings:
+  govet:
+    check-shadowing: true
+    enable:
+      - fieldalignment
+
+linters:
+  enable:
+    - govet
+    - deadcode
+    - errcheck
+    - govet
+    - ineffassign
+    - staticcheck
+    - structcheck
+    - typecheck
+    - unused
+    - varcheck
+    - bodyclose
+    - gci
+    - goconst
+    - gocritic
+    - gosimple
+    - gofmt
+    - gofumpt
+    - goimports
+    - revive
+    - gosec
+    - makezero
+    - misspell
+    - nakedret
+    - nestif
+    - nilerr
+    - noctx
+    - prealloc
+    - unconvert
+    - unparam
+  disable-all: false

README.md

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

SECURITY.md

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

api/api.go

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

api/api_test.go

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

api/handler/handler.go

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

api/handler/options.go

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

api/resolver/grpc/grpc.go

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

api/resolver/host/host.go

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

api/resolver/options.go

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

api/resolver/path/path.go

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

api/resolver/resolver.go

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

api/resolver/subdomain/subdomain.go

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

api/resolver/subdomain/subdomain_test.go

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

api/resolver/vpath/vpath.go

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

api/router/options.go

@@ -0,0 +1,75 @@
+package router
+
+import (
+	"context"
+
+	"go.unistack.org/micro/v3/api/resolver"
+	"go.unistack.org/micro/v3/api/resolver/vpath"
+	"go.unistack.org/micro/v3/logger"
+	"go.unistack.org/micro/v3/register"
+)
+
+// Options holds the options for api router
+type Options struct {
+	// Register for service lookup
+	Register register.Register
+	// Resolver to use
+	Resolver resolver.Resolver
+	// Logger micro logger
+	Logger logger.Logger
+	// Context is for external options
+	Context context.Context
+	// Handler name
+	Handler string
+}
+
+// Option func signature
+type Option func(o *Options)
+
+// NewOptions returns options struct filled by opts
+func NewOptions(opts ...Option) Options {
+	options := Options{
+		Context: context.Background(),
+		Handler: "meta",
+	}
+
+	for _, o := range opts {
+		o(&options)
+	}
+
+	if options.Resolver == nil {
+		options.Resolver = vpath.NewResolver(
+			resolver.WithHandler(options.Handler),
+		)
+	}
+
+	return options
+}
+
+// WithContext sets the context
+func WithContext(ctx context.Context) Option {
+	return func(o *Options) {
+		o.Context = ctx
+	}
+}
+
+// WithHandler sets the handler
+func WithHandler(h string) Option {
+	return func(o *Options) {
+		o.Handler = h
+	}
+}
+
+// WithRegister sets the register
+func WithRegister(r register.Register) Option {
+	return func(o *Options) {
+		o.Register = r
+	}
+}
+
+// WithResolver sets the resolver
+func WithResolver(r resolver.Resolver) Option {
+	return func(o *Options) {
+		o.Resolver = r
+	}
+}

api/router/router.go

@@ -0,0 +1,31 @@
+// Package router provides api service routing
+package router // import "go.unistack.org/micro/v3/api/router"
+
+import (
+	"net/http"
+
+	"go.unistack.org/micro/v3/api"
+)
+
+// DefaultRouter contains default router implementation
+var DefaultRouter Router
+
+// Router is used to determine an endpoint for a request
+type Router interface {
+	// Returns options
+	Options() Options
+	// Init initialize router
+	Init(...Option) error
+	// Stop the router
+	Close() error
+	// Endpoint returns an api.Service endpoint or an error if it does not exist
+	Endpoint(r *http.Request) (*api.Service, error)
+	// Register endpoint in router
+	Register(ep *api.Endpoint) error
+	// Deregister endpoint from router
+	Deregister(ep *api.Endpoint) error
+	// Route returns an api.Service route
+	Route(r *http.Request) (*api.Service, error)
+	// String representation of router
+	String() string
+}

auth/auth.go

@@ -0,0 +1,141 @@
+// Package auth provides authentication and authorization capability
+package auth // import "go.unistack.org/micro/v3/auth"
+
+import (
+	"context"
+	"errors"
+	"time"
+
+	"go.unistack.org/micro/v3/metadata"
+)
+
+const (
+	// BearerScheme used for Authorization header
+	BearerScheme = "Bearer "
+	// ScopePublic is the scope applied to a rule to allow access to the public
+	ScopePublic = ""
+	// ScopeAccount is the scope applied to a rule to limit to users with any valid account
+	ScopeAccount = "*"
+)
+
+var (
+	// DefaultAuth holds default auth implementation
+	DefaultAuth Auth = NewAuth()
+	// ErrInvalidToken is when the token provided is not valid
+	ErrInvalidToken = errors.New("invalid token provided")
+	// ErrForbidden is when a user does not have the necessary scope to access a resource
+	ErrForbidden = errors.New("resource forbidden")
+)
+
+// Auth provides authentication and authorization
+type Auth interface {
+	// Init the auth
+	Init(opts ...Option) error
+	// Options set for auth
+	Options() Options
+	// Generate a new account
+	Generate(id string, opts ...GenerateOption) (*Account, error)
+	// Verify an account has access to a resource using the rules
+	Verify(acc *Account, res *Resource, opts ...VerifyOption) error
+	// Inspect a token
+	Inspect(token string) (*Account, error)
+	// Token generated using refresh token or credentials
+	Token(opts ...TokenOption) (*Token, error)
+	// Grant access to a resource
+	Grant(rule *Rule) error
+	// Revoke access to a resource
+	Revoke(rule *Rule) error
+	// Rules returns all the rules used to verify requests
+	Rules(...RulesOption) ([]*Rule, error)
+	// String returns the name of the implementation
+	String() string
+}
+
+// Account provided by an auth provider
+type Account struct {
+	// Metadata any other associated metadata
+	Metadata metadata.Metadata `json:"metadata"`
+	// ID of the account e.g. email or id
+	ID string `json:"id"`
+	// Type of the account, e.g. service
+	Type string `json:"type"`
+	// Issuer of the account
+	Issuer string `json:"issuer"`
+	// Secret for the account, e.g. the password
+	Secret string `json:"secret"`
+	// Scopes the account has access to
+	Scopes []string `json:"scopes"`
+}
+
+// Token can be short or long lived
+type Token struct {
+	// Time of token creation
+	Created time.Time `json:"created"`
+	// Time of token expiry
+	Expiry time.Time `json:"expiry"`
+	// The token to be used for accessing resources
+	AccessToken string `json:"access_token"`
+	// RefreshToken to be used to generate a new token
+	RefreshToken string `json:"refresh_token"`
+}
+
+// Expired returns a boolean indicating if the token needs to be refreshed
+func (t *Token) Expired() bool {
+	return t.Expiry.Unix() < time.Now().Unix()
+}
+
+// Resource is an entity such as a user or
+type Resource struct {
+	// Name of the resource, e.g. go.micro.service.notes
+	Name string `json:"name"`
+	// Type of resource, e.g. service
+	Type string `json:"type"`
+	// Endpoint resource e.g NotesService.Create
+	Endpoint string `json:"endpoint"`
+}
+
+// Access defines the type of access a rule grants
+type Access int
+
+const (
+	// AccessGranted to a resource
+	AccessGranted Access = iota
+	// AccessDenied to a resource
+	AccessDenied
+)
+
+// Rule is used to verify access to a resource
+type Rule struct {
+	// Resource that rule belongs to
+	Resource *Resource
+	// ID of the rule
+	ID string
+	// Scope of the rule
+	Scope string
+	// Access flag allow/deny
+	Access Access
+	// Priority holds the rule priority
+	Priority int32
+}
+
+type accountKey struct{}
+
+// AccountFromContext gets the account from the context, which
+// is set by the auth wrapper at the start of a call. If the account
+// is not set, a nil account will be returned. The error is only returned
+// when there was a problem retrieving an account
+func AccountFromContext(ctx context.Context) (*Account, bool) {
+	if ctx == nil {
+		return nil, false
+	}
+	acc, ok := ctx.Value(accountKey{}).(*Account)
+	return acc, ok
+}
+
+// ContextWithAccount sets the account in the context
+func ContextWithAccount(ctx context.Context, account *Account) context.Context {
+	if ctx == nil {
+		ctx = context.Background()
+	}
+	return context.WithValue(ctx, accountKey{}, account)
+}

auth/noop.go

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

auth/options.go

@@ -0,0 +1,311 @@
+package auth
+
+import (
+	"context"
+	"time"
+
+	"go.unistack.org/micro/v3/logger"
+	"go.unistack.org/micro/v3/metadata"
+	"go.unistack.org/micro/v3/meter"
+	"go.unistack.org/micro/v3/store"
+	"go.unistack.org/micro/v3/tracer"
+)
+
+// NewOptions creates Options struct from slice of options
+func NewOptions(opts ...Option) Options {
+	options := Options{
+		Tracer: tracer.DefaultTracer,
+		Logger: logger.DefaultLogger,
+		Meter:  meter.DefaultMeter,
+	}
+	for _, o := range opts {
+		o(&options)
+	}
+	return options
+}
+
+// Options struct holds auth options
+type Options struct {
+	// Context holds the external options
+	Context context.Context
+	// Meter used for metrics
+	Meter meter.Meter
+	// Logger used for logging
+	Logger logger.Logger
+	// Tracer used for tracing
+	Tracer tracer.Tracer
+	// Store used for stre data
+	Store store.Store
+	// Token is the services token used to authenticate itself
+	Token *Token
+	// LoginURL is the relative url path where a user can login
+	LoginURL string
+	// PrivateKey for encoding JWTs
+	PrivateKey string
+	// PublicKey for decoding JWTs
+	PublicKey string
+	// Secret is used to authenticate the service
+	Secret string
+	// ID is the services auth ID
+	ID string
+	// Issuer of the service's account
+	Issuer string
+	// Name holds the auth name
+	Name string
+	// Addrs sets the addresses of auth
+	Addrs []string
+}
+
+// Option func
+type Option func(o *Options)
+
+// Addrs is the auth addresses to use
+func Addrs(addrs ...string) Option {
+	return func(o *Options) {
+		o.Addrs = addrs
+	}
+}
+
+// Name sets the name
+func Name(n string) Option {
+	return func(o *Options) {
+		o.Name = n
+	}
+}
+
+// Issuer of the services account
+func Issuer(i string) Option {
+	return func(o *Options) {
+		o.Issuer = i
+	}
+}
+
+// Store to back auth
+func Store(s store.Store) Option {
+	return func(o *Options) {
+		o.Store = s
+	}
+}
+
+// PublicKey is the JWT public key
+func PublicKey(key string) Option {
+	return func(o *Options) {
+		o.PublicKey = key
+	}
+}
+
+// PrivateKey is the JWT private key
+func PrivateKey(key string) Option {
+	return func(o *Options) {
+		o.PrivateKey = key
+	}
+}
+
+// Credentials sets the auth credentials
+func Credentials(id, secret string) Option {
+	return func(o *Options) {
+		o.ID = id
+		o.Secret = secret
+	}
+}
+
+// ClientToken sets the auth token to use when making requests
+func ClientToken(token *Token) Option {
+	return func(o *Options) {
+		o.Token = token
+	}
+}
+
+// LoginURL sets the auth LoginURL
+func LoginURL(url string) Option {
+	return func(o *Options) {
+		o.LoginURL = url
+	}
+}
+
+// GenerateOptions struct
+type GenerateOptions struct {
+	Metadata metadata.Metadata
+	Provider string
+	Type     string
+	Secret   string
+	Issuer   string
+	Scopes   []string
+}
+
+// GenerateOption func
+type GenerateOption func(o *GenerateOptions)
+
+// WithSecret for the generated account
+func WithSecret(s string) GenerateOption {
+	return func(o *GenerateOptions) {
+		o.Secret = s
+	}
+}
+
+// WithType for the generated account
+func WithType(t string) GenerateOption {
+	return func(o *GenerateOptions) {
+		o.Type = t
+	}
+}
+
+// WithMetadata for the generated account
+func WithMetadata(md metadata.Metadata) GenerateOption {
+	return func(o *GenerateOptions) {
+		o.Metadata = metadata.Copy(md)
+	}
+}
+
+// WithProvider for the generated account
+func WithProvider(p string) GenerateOption {
+	return func(o *GenerateOptions) {
+		o.Provider = p
+	}
+}
+
+// WithScopes for the generated account
+func WithScopes(s ...string) GenerateOption {
+	return func(o *GenerateOptions) {
+		o.Scopes = s
+	}
+}
+
+// WithIssuer for the generated account
+func WithIssuer(i string) GenerateOption {
+	return func(o *GenerateOptions) {
+		o.Issuer = i
+	}
+}
+
+// NewGenerateOptions from a slice of options
+func NewGenerateOptions(opts ...GenerateOption) GenerateOptions {
+	var options GenerateOptions
+	for _, o := range opts {
+		o(&options)
+	}
+	return options
+}
+
+// TokenOptions struct
+type TokenOptions struct {
+	ID           string
+	Secret       string
+	RefreshToken string
+	Issuer       string
+	Expiry       time.Duration
+}
+
+// TokenOption func
+type TokenOption func(o *TokenOptions)
+
+// WithExpiry for the token
+func WithExpiry(ex time.Duration) TokenOption {
+	return func(o *TokenOptions) {
+		o.Expiry = ex
+	}
+}
+
+// WithCredentials sets tye id and secret
+func WithCredentials(id, secret string) TokenOption {
+	return func(o *TokenOptions) {
+		o.ID = id
+		o.Secret = secret
+	}
+}
+
+// WithToken sets the refresh token
+func WithToken(rt string) TokenOption {
+	return func(o *TokenOptions) {
+		o.RefreshToken = rt
+	}
+}
+
+// WithTokenIssuer sets the token issuer option
+func WithTokenIssuer(iss string) TokenOption {
+	return func(o *TokenOptions) {
+		o.Issuer = iss
+	}
+}
+
+// NewTokenOptions from a slice of options
+func NewTokenOptions(opts ...TokenOption) TokenOptions {
+	var options TokenOptions
+	for _, o := range opts {
+		o(&options)
+	}
+
+	// set default expiry of token
+	if options.Expiry == 0 {
+		options.Expiry = time.Minute
+	}
+
+	return options
+}
+
+// VerifyOptions struct
+type VerifyOptions struct {
+	Context   context.Context
+	Namespace string
+}
+
+// VerifyOption func
+type VerifyOption func(o *VerifyOptions)
+
+// VerifyContext pass context to verify
+func VerifyContext(ctx context.Context) VerifyOption {
+	return func(o *VerifyOptions) {
+		o.Context = ctx
+	}
+}
+
+// VerifyNamespace sets thhe namespace for verify
+func VerifyNamespace(ns string) VerifyOption {
+	return func(o *VerifyOptions) {
+		o.Namespace = ns
+	}
+}
+
+// RulesOptions struct
+type RulesOptions struct {
+	Context   context.Context
+	Namespace string
+}
+
+// RulesOption func
+type RulesOption func(o *RulesOptions)
+
+// RulesContext pass rules context
+func RulesContext(ctx context.Context) RulesOption {
+	return func(o *RulesOptions) {
+		o.Context = ctx
+	}
+}
+
+// RulesNamespace sets the rule namespace
+func RulesNamespace(ns string) RulesOption {
+	return func(o *RulesOptions) {
+		o.Namespace = ns
+	}
+}
+
+// Logger sets the logger
+func Logger(l logger.Logger) Option {
+	return func(o *Options) {
+		o.Logger = l
+	}
+}
+
+// Meter sets the meter
+func Meter(m meter.Meter) Option {
+	return func(o *Options) {
+		o.Meter = m
+	}
+}
+
+// Tracer sets the meter
+func Tracer(t tracer.Tracer) Option {
+	return func(o *Options) {
+		o.Tracer = t
+	}
+}

auth/rules.go

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

auth/rules_test.go

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

broker/broker.go

@@ -1,13 +1,11 @@
 // Package broker is an interface used for asynchronous messaging
-package broker
+package broker // import "go.unistack.org/micro/v3/broker"
 
 import (
 	"context"
 	"errors"
-	"time"
 
-	"go.unistack.org/micro/v4/codec"
+	"go.unistack.org/micro/v3/metadata"
-	"go.unistack.org/micro/v4/metadata"
 )
 
 // DefaultBroker default memory broker
@@ -18,12 +16,6 @@ var (
 	ErrNotConnected = errors.New("broker not connected")
 	// ErrDisconnected returns when broker disconnected
 	ErrDisconnected = errors.New("broker disconnected")
-	// ErrInvalidMessage returns when invalid Message passed
-	ErrInvalidMessage = errors.New("invalid message")
-	// ErrInvalidHandler returns when subscriber passed to Subscribe
-	ErrInvalidHandler = errors.New("invalid handler, ony func(Message) error and func([]Message) error supported")
-	// DefaultGracefulTimeout
-	DefaultGracefulTimeout = 5 * time.Second
 )
 
 // Broker is an interface used for asynchronous messaging.
@@ -40,44 +32,91 @@ type Broker interface {
 	Connect(ctx context.Context) error
 	// Disconnect disconnect from broker
 	Disconnect(ctx context.Context) error
-	// NewMessage create new broker message to publish.
-	NewMessage(ctx context.Context, hdr metadata.Metadata, body interface{}, opts ...MessageOption) (Message, error)
 	// Publish message to broker topic
-	Publish(ctx context.Context, topic string, messages ...Message) error
+	Publish(ctx context.Context, topic string, msg *Message, opts ...PublishOption) error
 	// Subscribe subscribes to topic message via handler
-	Subscribe(ctx context.Context, topic string, handler interface{}, opts ...SubscribeOption) (Subscriber, error)
+	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 (
+// Handler is used to process messages via a subscription of a topic.
-	FuncPublish   func(ctx context.Context, topic string, messages ...Message) error
+type Handler func(Event) error
-	HookPublish   func(next FuncPublish) FuncPublish
-	FuncSubscribe func(ctx context.Context, topic string, handler interface{}, opts ...SubscribeOption) (Subscriber, error)
-	HookSubscribe func(next FuncSubscribe) FuncSubscribe
-)
 
-// Message is given to a subscription handler for processing
+// Events contains multiple events
-type Message interface {
+type Events []Event
-	// Context for the message.
+
-	Context() context.Context
+func (evs Events) Ack() error {
-	// Topic returns message destination topic.
+	var err error
+	for _, ev := range evs {
+		if err = ev.Ack(); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+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 {
+	// Topic returns event topic
 	Topic() string
-	// Header returns message headers.
+	// Message returns broker message
-	Header() metadata.Metadata
+	Message() *Message
-	// Body returns broker message []byte slice
+	// Ack acknowledge message
-	Body() []byte
-	// Unmarshal try to decode message body to dst.
-	// This is helper method that uses codec.Unmarshal.
-	Unmarshal(dst interface{}, opts ...codec.Option) error
-	// Ack acknowledge message if supported.
 	Ack() error
+	// Error returns message error (like decoding errors or some other)
+	Error() error
+	// SetError set event processing error
+	SetError(err error)
+}
+
+// RawMessage is a raw encoded JSON value.
+// It implements Marshaler and Unmarshaler and can be used to delay decoding or precompute a encoding.
+type RawMessage []byte
+
+// MarshalJSON returns m as the JSON encoding of m.
+func (m *RawMessage) MarshalJSON() ([]byte, error) {
+	if m == nil {
+		return []byte("null"), nil
+	}
+	return *m, nil
+}
+
+// UnmarshalJSON sets *m to a copy of data.
+func (m *RawMessage) UnmarshalJSON(data []byte) error {
+	if m == nil {
+		return errors.New("RawMessage UnmarshalJSON on nil pointer")
+	}
+	*m = append((*m)[0:0], data...)
+	return nil
+}
+
+// Message is used to transfer data
+type Message struct {
+	// Header contains message metadata
+	Header metadata.Metadata
+	// Body contains message body
+	Body 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

broker/context.go

@@ -15,15 +15,6 @@ func FromContext(ctx context.Context) (Broker, bool) {
 	return c, ok
 }
 
-// MustContext returns broker from passed context
-func MustContext(ctx context.Context) Broker {
-	b, ok := FromContext(ctx)
-	if !ok {
-		panic("missing broker")
-	}
-	return b
-}
-
 // NewContext savess broker in context
 func NewContext(ctx context.Context, s Broker) context.Context {
 	if ctx == nil {
@@ -42,16 +33,6 @@ func SetSubscribeOption(k, v interface{}) SubscribeOption {
 	}
 }
 
-// SetMessageOption returns a function to setup a context with given value
-func SetMessageOption(k, v interface{}) MessageOption {
-	return func(o *MessageOptions) {
-		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) {
@@ -61,3 +42,13 @@ func SetOption(k, v interface{}) Option {
 		o.Context = context.WithValue(o.Context, k, v)
 	}
 }
+
+// SetPublishOption returns a function to setup a context with given value
+func SetPublishOption(k, v interface{}) PublishOption {
+	return func(o *PublishOptions) {
+		if o.Context == nil {
+			o.Context = context.Background()
+		}
+		o.Context = context.WithValue(o.Context, k, v)
+	}
+}

broker/context_test.go

@@ -1,61 +0,0 @@
-package broker
-
-import (
-	"context"
-	"testing"
-)
-
-func TestFromContext(t *testing.T) {
-	ctx := context.WithValue(context.TODO(), brokerKey{}, NewBroker())
-	c, ok := FromContext(ctx)
-	if c == nil || !ok {
-		t.Fatal("FromContext not works")
-	}
-}
-
-func TestFromNilContext(t *testing.T) {
-	// nolint: staticcheck
-	c, ok := FromContext(nil)
-	if ok || c != nil {
-		t.Fatal("FromContext not works")
-	}
-}
-
-func TestNewContext(t *testing.T) {
-	ctx := NewContext(context.TODO(), NewBroker())
-	c, ok := FromContext(ctx)
-	if c == nil || !ok {
-		t.Fatal("NewContext not works")
-	}
-}
-
-func TestNewNilContext(t *testing.T) {
-	// nolint: staticcheck
-	ctx := NewContext(nil, NewBroker())
-	c, ok := FromContext(ctx)
-	if c == nil || !ok {
-		t.Fatal("NewContext not works")
-	}
-}
-
-func TestSetSubscribeOption(t *testing.T) {
-	type key struct{}
-	o := SetSubscribeOption(key{}, "test")
-	opts := &SubscribeOptions{}
-	o(opts)
-
-	if v, ok := opts.Context.Value(key{}).(string); !ok || v == "" {
-		t.Fatal("SetSubscribeOption not works")
-	}
-}
-
-func TestSetOption(t *testing.T) {
-	type key struct{}
-	o := SetOption(key{}, "test")
-	opts := &Options{}
-	o(opts)
-
-	if v, ok := opts.Context.Value(key{}).(string); !ok || v == "" {
-		t.Fatal("SetOption not works")
-	}
-}

broker/memory.go

@@ -0,0 +1,342 @@
+package broker
+
+import (
+	"context"
+	"sync"
+
+	"go.unistack.org/micro/v3/logger"
+	"go.unistack.org/micro/v3/metadata"
+	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 {
+	subscribers map[string][]*memorySubscriber
+	addr        string
+	opts        Options
+	sync.RWMutex
+	connected bool
+}
+
+type memoryEvent struct {
+	err     error
+	message interface{}
+	topic   string
+	opts    Options
+}
+
+type memorySubscriber struct {
+	ctx          context.Context
+	exit         chan bool
+	handler      Handler
+	batchhandler BatchHandler
+	id           string
+	topic        string
+	opts         SubscribeOptions
+}
+
+func (m *memoryBroker) Options() Options {
+	return m.opts
+}
+
+func (m *memoryBroker) Address() string {
+	return m.addr
+}
+
+func (m *memoryBroker) Connect(ctx context.Context) error {
+	m.Lock()
+	defer m.Unlock()
+
+	if m.connected {
+		return nil
+	}
+
+	// use 127.0.0.1 to avoid scan of all network interfaces
+	addr, err := maddr.Extract("127.0.0.1")
+	if err != nil {
+		return err
+	}
+	var rng rand.Rand
+	i := rng.Intn(20000)
+	// set addr with port
+	addr = mnet.HostPort(addr, 10000+i)
+
+	m.addr = addr
+	m.connected = true
+
+	return nil
+}
+
+func (m *memoryBroker) Disconnect(ctx context.Context) error {
+	m.Lock()
+	defer m.Unlock()
+
+	if !m.connected {
+		return nil
+	}
+
+	m.connected = false
+	return nil
+}
+
+func (m *memoryBroker) Init(opts ...Option) error {
+	for _, o := range opts {
+		o(&m.opts)
+	}
+	return nil
+}
+
+func (m *memoryBroker) Publish(ctx context.Context, topic string, msg *Message, opts ...PublishOption) error {
+	msg.Header.Set(metadata.HeaderTopic, topic)
+	return m.publish(ctx, []*Message{msg}, opts...)
+}
+
+func (m *memoryBroker) BatchPublish(ctx context.Context, msgs []*Message, opts ...PublishOption) error {
+	return m.publish(ctx, msgs, opts...)
+}
+
+func (m *memoryBroker) publish(ctx context.Context, msgs []*Message, opts ...PublishOption) error {
+	m.RLock()
+	if !m.connected {
+		m.RUnlock()
+		return ErrNotConnected
+	}
+	m.RUnlock()
+
+	var err error
+
+	select {
+	case <-ctx.Done():
+		return ctx.Err()
+	default:
+		options := NewPublishOptions(opts...)
+
+		msgTopicMap := make(map[string]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.Errorf(m.opts.Context, "ack failed: %v", 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, err.Error())
+							}
+						} else if sub.opts.AutoAck {
+							if err = p.Ack(); err != nil {
+								m.opts.Logger.Errorf(m.opts.Context, "ack failed: %v", err)
+							}
+						}
+					}
+				}
+			}
+		}
+	}
+
+	return nil
+}
+
+func (m *memoryBroker) BatchSubscribe(ctx context.Context, topic string, handler BatchHandler, opts ...SubscribeOption) (Subscriber, error) {
+	m.RLock()
+	if !m.connected {
+		m.RUnlock()
+		return nil, ErrNotConnected
+	}
+	m.RUnlock()
+
+	sid, err := id.New()
+	if err != nil {
+		return nil, err
+	}
+
+	options := NewSubscribeOptions(opts...)
+
+	sub := &memorySubscriber{
+		exit:         make(chan bool, 1),
+		id:           sid,
+		topic:        topic,
+		batchhandler: handler,
+		opts:         options,
+		ctx:          ctx,
+	}
+
+	m.Lock()
+	m.subscribers[topic] = append(m.subscribers[topic], sub)
+	m.Unlock()
+
+	go func() {
+		<-sub.exit
+		m.Lock()
+		newSubscribers := make([]*memorySubscriber, 0, len(m.subscribers)-1)
+		for _, sb := range m.subscribers[topic] {
+			if sb.id == sub.id {
+				continue
+			}
+			newSubscribers = append(newSubscribers, sb)
+		}
+		m.subscribers[topic] = newSubscribers
+		m.Unlock()
+	}()
+
+	return sub, nil
+}
+
+func (m *memoryBroker) Subscribe(ctx context.Context, topic string, handler Handler, opts ...SubscribeOption) (Subscriber, error) {
+	m.RLock()
+	if !m.connected {
+		m.RUnlock()
+		return nil, ErrNotConnected
+	}
+	m.RUnlock()
+
+	sid, err := id.New()
+	if err != nil {
+		return nil, err
+	}
+
+	options := NewSubscribeOptions(opts...)
+
+	sub := &memorySubscriber{
+		exit:    make(chan bool, 1),
+		id:      sid,
+		topic:   topic,
+		handler: handler,
+		opts:    options,
+		ctx:     ctx,
+	}
+
+	m.Lock()
+	m.subscribers[topic] = append(m.subscribers[topic], sub)
+	m.Unlock()
+
+	go func() {
+		<-sub.exit
+		m.Lock()
+		newSubscribers := make([]*memorySubscriber, 0, len(m.subscribers)-1)
+		for _, sb := range m.subscribers[topic] {
+			if sb.id == sub.id {
+				continue
+			}
+			newSubscribers = append(newSubscribers, sb)
+		}
+		m.subscribers[topic] = newSubscribers
+		m.Unlock()
+	}()
+
+	return sub, nil
+}
+
+func (m *memoryBroker) String() string {
+	return "memory"
+}
+
+func (m *memoryBroker) Name() string {
+	return m.opts.Name
+}
+
+func (m *memoryEvent) Topic() string {
+	return m.topic
+}
+
+func (m *memoryEvent) Message() *Message {
+	switch v := m.message.(type) {
+	case *Message:
+		return v
+	case []byte:
+		msg := &Message{}
+		if err := m.opts.Codec.Unmarshal(v, msg); err != nil {
+			if m.opts.Logger.V(logger.ErrorLevel) {
+				m.opts.Logger.Error(m.opts.Context, "[memory]: failed to unmarshal: %v", err)
+			}
+			return nil
+		}
+		return msg
+	}
+
+	return nil
+}
+
+func (m *memoryEvent) Ack() error {
+	return nil
+}
+
+func (m *memoryEvent) Error() error {
+	return m.err
+}
+
+func (m *memoryEvent) SetError(err error) {
+	m.err = err
+}
+
+func (m *memorySubscriber) Options() SubscribeOptions {
+	return m.opts
+}
+
+func (m *memorySubscriber) Topic() string {
+	return m.topic
+}
+
+func (m *memorySubscriber) Unsubscribe(ctx context.Context) error {
+	m.exit <- true
+	return nil
+}
+
+// NewBroker return new memory broker
+func NewBroker(opts ...Option) Broker {
+	return &memoryBroker{
+		opts:        NewOptions(opts...),
+		subscribers: make(map[string][]*memorySubscriber),
+	}
+}

broker/memory/memory.go

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

broker/memory/memory_test.go

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

broker/memory_test.go

@@ -0,0 +1,105 @@
+package broker
+
+import (
+	"context"
+	"fmt"
+	"testing"
+
+	"go.unistack.org/micro/v3/metadata"
+)
+
+func TestMemoryBatchBroker(t *testing.T) {
+	b := NewBroker()
+	ctx := context.Background()
+
+	if err := b.Connect(ctx); err != nil {
+		t.Fatalf("Unexpected connect error %v", err)
+	}
+
+	topic := "test"
+	count := 10
+
+	fn := func(evts Events) error {
+		return evts.Ack()
+	}
+
+	sub, err := b.BatchSubscribe(ctx, topic, fn)
+	if err != nil {
+		t.Fatalf("Unexpected error subscribing %v", err)
+	}
+
+	msgs := make([]*Message, 0, count)
+	for i := 0; i < count; i++ {
+		message := &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.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)
+	}
+}
+
+func TestMemoryBroker(t *testing.T) {
+	b := NewBroker()
+	ctx := context.Background()
+
+	if err := b.Connect(ctx); err != nil {
+		t.Fatalf("Unexpected connect error %v", err)
+	}
+
+	topic := "test"
+	count := 10
+
+	fn := func(p Event) error {
+		return nil
+	}
+
+	sub, err := b.Subscribe(ctx, topic, fn)
+	if err != nil {
+		t.Fatalf("Unexpected error subscribing %v", err)
+	}
+
+	msgs := make([]*Message, 0, count)
+	for i := 0; i < count; i++ {
+		message := &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

@@ -1,179 +0,0 @@
-package broker
-
-import (
-	"context"
-	"strings"
-	"sync"
-
-	"go.unistack.org/micro/v4/codec"
-	"go.unistack.org/micro/v4/metadata"
-	"go.unistack.org/micro/v4/options"
-)
-
-type NoopBroker struct {
-	funcPublish   FuncPublish
-	funcSubscribe FuncSubscribe
-	opts          Options
-	mu            sync.RWMutex
-}
-
-func (b *NoopBroker) newCodec(ct string) (codec.Codec, error) {
-	if idx := strings.IndexRune(ct, ';'); idx >= 0 {
-		ct = ct[:idx]
-	}
-	b.mu.RLock()
-	c, ok := b.opts.Codecs[ct]
-	b.mu.RUnlock()
-	if ok {
-		return c, nil
-	}
-	return nil, codec.ErrUnknownContentType
-}
-
-func NewBroker(opts ...Option) *NoopBroker {
-	b := &NoopBroker{opts: NewOptions(opts...)}
-	b.funcPublish = b.fnPublish
-	b.funcSubscribe = b.fnSubscribe
-
-	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.funcSubscribe = b.fnSubscribe
-
-	b.opts.Hooks.EachPrev(func(hook options.Hook) {
-		switch h := hook.(type) {
-		case HookPublish:
-			b.funcPublish = h(b.funcPublish)
-		case HookSubscribe:
-			b.funcSubscribe = h(b.funcSubscribe)
-		}
-	})
-
-	return nil
-}
-
-func (b *NoopBroker) Connect(_ context.Context) error {
-	return nil
-}
-
-func (b *NoopBroker) Disconnect(_ context.Context) error {
-	return nil
-}
-
-func (b *NoopBroker) Address() string {
-	return strings.Join(b.opts.Addrs, ",")
-}
-
-type noopMessage struct {
-	c    codec.Codec
-	ctx  context.Context
-	body []byte
-	hdr  metadata.Metadata
-	opts MessageOptions
-}
-
-func (m *noopMessage) Ack() error {
-	return nil
-}
-
-func (m *noopMessage) Body() []byte {
-	return m.body
-}
-
-func (m *noopMessage) Header() metadata.Metadata {
-	return m.hdr
-}
-
-func (m *noopMessage) Context() context.Context {
-	return m.ctx
-}
-
-func (m *noopMessage) Topic() string {
-	return ""
-}
-
-func (m *noopMessage) Unmarshal(dst interface{}, opts ...codec.Option) error {
-	return m.c.Unmarshal(m.body, dst)
-}
-
-func (b *NoopBroker) NewMessage(ctx context.Context, hdr metadata.Metadata, body interface{}, opts ...MessageOption) (Message, error) {
-	options := NewMessageOptions(opts...)
-	if options.ContentType == "" {
-		options.ContentType = b.opts.ContentType
-	}
-	m := &noopMessage{ctx: ctx, hdr: hdr, opts: options}
-	c, err := b.newCodec(m.opts.ContentType)
-	if err == nil {
-		m.body, err = c.Marshal(body)
-	}
-	if err != nil {
-		return nil, err
-	}
-
-	return m, nil
-}
-
-func (b *NoopBroker) fnPublish(_ context.Context, _ string, _ ...Message) error {
-	return nil
-}
-
-func (b *NoopBroker) Publish(ctx context.Context, topic string, msg ...Message) error {
-	return b.funcPublish(ctx, topic, msg...)
-}
-
-type NoopSubscriber struct {
-	ctx     context.Context
-	topic   string
-	handler interface{}
-	opts    SubscribeOptions
-}
-
-func (b *NoopBroker) fnSubscribe(ctx context.Context, topic string, handler interface{}, opts ...SubscribeOption) (Subscriber, error) {
-	return &NoopSubscriber{ctx: ctx, topic: topic, opts: NewSubscribeOptions(opts...), handler: handler}, nil
-}
-
-func (b *NoopBroker) Subscribe(ctx context.Context, topic string, handler interface{}, opts ...SubscribeOption) (Subscriber, error) {
-	return b.funcSubscribe(ctx, topic, handler, opts...)
-}
-
-func (s *NoopSubscriber) Options() SubscribeOptions {
-	return s.opts
-}
-
-func (s *NoopSubscriber) Topic() string {
-	return s.topic
-}
-
-func (s *NoopSubscriber) Unsubscribe(_ context.Context) error {
-	return nil
-}

broker/noop_test.go

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

broker/options.go

@@ -5,74 +5,55 @@ import (
 	"crypto/tls"
 	"time"
 
-	"go.unistack.org/micro/v4/codec"
+	"go.unistack.org/micro/v3/codec"
-	"go.unistack.org/micro/v4/logger"
+	"go.unistack.org/micro/v3/logger"
-	"go.unistack.org/micro/v4/meter"
+	"go.unistack.org/micro/v3/meter"
-	"go.unistack.org/micro/v4/options"
+	"go.unistack.org/micro/v3/register"
-	"go.unistack.org/micro/v4/register"
+	"go.unistack.org/micro/v3/tracer"
-	"go.unistack.org/micro/v4/sync"
-	"go.unistack.org/micro/v4/tracer"
 )
 
 // Options struct
 type Options struct {
-	// Name holds the broker name
-	Name string
-
 	// Tracer used for tracing
 	Tracer tracer.Tracer
 	// Register can be used for clustering
 	Register register.Register
-	// Codecs holds the codecs for marshal/unmarshal based on content-type
+	// Codec holds the codec for marshal/unmarshal
-	Codecs map[string]codec.Codec
+	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
-
+	// ErrorHandler used when broker can't unmarshal incoming message
+	ErrorHandler Handler
+	// BatchErrorHandler used when broker can't unmashal incoming messages
+	BatchErrorHandler BatchHandler
+	// Name holds the broker name
+	Name string
 	// 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
-
-	// ContentType will be used if no content-type set when creating message
-	ContentType string
 }
 
 // NewOptions create new Options
 func NewOptions(opts ...Option) Options {
 	options := Options{
-		Register:        register.DefaultRegister,
+		Register: register.DefaultRegister,
-		Logger:          logger.DefaultLogger,
+		Logger:   logger.DefaultLogger,
-		Context:         context.Background(),
+		Context:  context.Background(),
-		Meter:           meter.DefaultMeter,
+		Meter:    meter.DefaultMeter,
-		Codecs:          make(map[string]codec.Codec),
+		Codec:    codec.DefaultCodec,
-		Tracer:          tracer.DefaultTracer,
+		Tracer:   tracer.DefaultTracer,
-		GracefulTimeout: DefaultGracefulTimeout,
-		ContentType:     DefaultContentType,
 	}
-
 	for _, o := range opts {
 		o(&options)
 	}
-
 	return options
 }
 
-// DefaultContentType is the default content-type if not specified
-var DefaultContentType = ""
-
 // Context sets the context option
 func Context(ctx context.Context) Option {
 	return func(o *Options) {
@@ -80,27 +61,17 @@ func Context(ctx context.Context) Option {
 	}
 }
 
-// ContentType used by default if not specified
+// PublishOptions struct
-func ContentType(ct string) Option {
+type PublishOptions struct {
-	return func(o *Options) {
+	// Context holds external options
-		o.ContentType = ct
-	}
-}
-
-// MessageOptions struct
-type MessageOptions struct {
-	// ContentType for message body
-	ContentType string
-	// BodyOnly flag says the message contains raw body bytes and don't need
-	// codec Marshal method
-	BodyOnly bool
-	// Context holds custom options
 	Context context.Context
+	// BodyOnly flag says the message contains raw body bytes
+	BodyOnly bool
 }
 
-// NewMessageOptions creates MessageOptions struct
+// NewPublishOptions creates PublishOptions struct
-func NewMessageOptions(opts ...MessageOption) MessageOptions {
+func NewPublishOptions(opts ...PublishOption) PublishOptions {
-	options := MessageOptions{
+	options := PublishOptions{
 		Context: context.Background(),
 	}
 	for _, o := range opts {
@@ -113,6 +84,10 @@ func NewMessageOptions(opts ...MessageOption) MessageOptions {
 type SubscribeOptions struct {
 	// 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
@@ -128,20 +103,20 @@ type SubscribeOptions struct {
 // Option func
 type Option func(*Options)
 
-// MessageOption func
+// PublishOption func
-type MessageOption func(*MessageOptions)
+type PublishOption func(*PublishOptions)
 
-// MessageContentType sets message content-type that used to Marshal
+// PublishBodyOnly publish only body of the message
-func MessageContentType(ct string) MessageOption {
+func PublishBodyOnly(b bool) PublishOption {
-	return func(o *MessageOptions) {
+	return func(o *PublishOptions) {
-		o.ContentType = ct
+		o.BodyOnly = b
 	}
 }
 
-// MessageBodyOnly publish only body of the message
+// PublishContext sets the context
-func MessageBodyOnly(b bool) MessageOption {
+func PublishContext(ctx context.Context) PublishOption {
-	return func(o *MessageOptions) {
+	return func(o *PublishOptions) {
-		o.BodyOnly = b
+		o.Context = ctx
 	}
 }
 
@@ -152,10 +127,51 @@ func Addrs(addrs ...string) Option {
 	}
 }
 
-// Codec sets the codec used for encoding/decoding messages
+// Codec sets the codec used for encoding/decoding used where
-func Codec(ct string, c codec.Codec) Option {
+// a broker does not support headers
+func Codec(c codec.Codec) Option {
 	return func(o *Options) {
-		o.Codecs[ct] = c
+		o.Codec = c
+	}
+}
+
+// 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
+	}
+}
+
+// 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.Group = name
 	}
 }
 
@@ -208,13 +224,6 @@ func Name(n string) Option {
 	}
 }
 
-// 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) {
@@ -222,6 +231,14 @@ func SubscribeContext(ctx context.Context) SubscribeOption {
 	}
 }
 
+// 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 {

broker/subscriber.go

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

build/build.go

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

build/options.go

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

client/backoff.go

@@ -2,29 +2,14 @@ package client
 
 import (
 	"context"
-	"math"
 	"time"
 
-	"go.unistack.org/micro/v4/util/backoff"
+	"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)
 
-// BackoffExp using exponential backoff func
+func exponentialBackoff(ctx context.Context, req Request, attempts int) (time.Duration, error) {
-func BackoffExp(_ context.Context, _ Request, attempts int) (time.Duration, error) {
 	return backoff.Do(attempts), nil
 }
-
-// BackoffInterval specifies randomization interval for backoff func
-func BackoffInterval(minTime time.Duration, maxTime time.Duration) BackoffFunc {
-	return func(_ context.Context, _ Request, attempts int) (time.Duration, error) {
-		td := time.Duration(math.Pow(float64(attempts), math.E)) * time.Millisecond * 100
-		if td < minTime {
-			return minTime, nil
-		} else if td > maxTime {
-			return maxTime, nil
-		}
-		return td, nil
-	}
-}

client/backoff_test.go

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

client/client.go

@@ -1,21 +1,21 @@
 // Package client is an interface for an RPC client
-package client
+package client // import "go.unistack.org/micro/v3/client"
 
 import (
 	"context"
 	"time"
 
-	"go.unistack.org/micro/v4/codec"
+	"go.unistack.org/micro/v3/codec"
-	"go.unistack.org/micro/v4/metadata"
+	"go.unistack.org/micro/v3/metadata"
 )
 
 var (
 	// DefaultClient is the global default client
-	DefaultClient = NewClient()
+	DefaultClient Client = NewClient()
 	// DefaultContentType is the default content-type if not specified
-	DefaultContentType = ""
+	DefaultContentType = "application/json"
-	// DefaultBackoff is the default backoff function for retries (minimum 10 millisecond and maximum 5 second)
+	// DefaultBackoff is the default backoff function for retries
-	DefaultBackoff = BackoffInterval(10*time.Millisecond, 5*time.Second)
+	DefaultBackoff = exponentialBackoff
 	// DefaultRetry is the default check-for-retry function for retries
 	DefaultRetry = RetryNever
 	// DefaultRetries is the default number of times a request is tried
@@ -29,23 +29,27 @@ var (
 )
 
 // Client is the interface used to make requests to services.
+// It supports Request/Response via Transport and Publishing via the Broker.
 // It also supports bidirectional streaming of requests.
 type Client interface {
 	Name() string
 	Init(opts ...Option) error
 	Options() Options
+	NewMessage(topic string, msg interface{}, opts ...MessageOption) Message
 	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
 }
 
-type (
+// Message is the interface for publishing asynchronously
-	FuncCall   func(ctx context.Context, req Request, rsp interface{}, opts ...CallOption) error
+type Message interface {
-	HookCall   func(next FuncCall) FuncCall
+	Topic() string
-	FuncStream func(ctx context.Context, req Request, opts ...CallOption) (Stream, error)
+	Payload() interface{}
-	HookStream func(next FuncStream) FuncStream
+	ContentType() string
-)
+}
 
 // Request is the interface for a synchronous request used by Call or Stream
 type Request interface {
@@ -69,7 +73,7 @@ type Request interface {
 type Response interface {
 	// Read the response
 	Codec() codec.Codec
-	// Header data
+	// read the header
 	Header() metadata.Metadata
 	// Read the undecoded response
 	Read() ([]byte, error)
@@ -87,16 +91,10 @@ type Stream interface {
 	Send(msg interface{}) error
 	// Recv will decode and read a response
 	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
@@ -105,5 +103,11 @@ type Option func(*Options)
 // CallOption used by Call or Stream
 type CallOption func(*CallOptions)
 
+// PublishOption used by Publish
+type PublishOption func(*PublishOptions)
+
+// MessageOption used by NewMessage
+type MessageOption func(*MessageOptions)
+
 // RequestOption used by NewRequest
 type RequestOption func(*RequestOptions)

client/context.go

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

client/context_test.go

@@ -1,62 +0,0 @@
-package client
-
-import (
-	"context"
-	"testing"
-)
-
-func TestFromContext(t *testing.T) {
-	ctx := context.WithValue(context.TODO(), clientKey{}, NewClient())
-
-	c, ok := FromContext(ctx)
-	if c == nil || !ok {
-		t.Fatal("FromContext not works")
-	}
-}
-
-func TestFromNilContext(t *testing.T) {
-	// nolint: staticcheck
-	c, ok := FromContext(nil)
-	if ok || c != nil {
-		t.Fatal("FromContext not works")
-	}
-}
-
-func TestNewContext(t *testing.T) {
-	ctx := NewContext(context.TODO(), NewClient())
-	c, ok := FromContext(ctx)
-	if c == nil || !ok {
-		t.Fatal("NewContext not works")
-	}
-}
-
-func TestNewNilContext(t *testing.T) {
-	// nolint: staticcheck
-	ctx := NewContext(nil, NewClient())
-	c, ok := FromContext(ctx)
-	if c == nil || !ok {
-		t.Fatal("NewContext not works")
-	}
-}
-
-func TestSetCallOption(t *testing.T) {
-	type key struct{}
-	o := SetCallOption(key{}, "test")
-	opts := &CallOptions{}
-	o(opts)
-
-	if v, ok := opts.Context.Value(key{}).(string); !ok || v == "" {
-		t.Fatal("SetCallOption not works")
-	}
-}
-
-func TestSetOption(t *testing.T) {
-	type key struct{}
-	o := SetOption(key{}, "test")
-	opts := &Options{}
-	o(opts)
-
-	if v, ok := opts.Context.Value(key{}).(string); !ok || v == "" {
-		t.Fatal("SetOption not works")
-	}
-}

client/lookup.go

@@ -4,15 +4,15 @@ import (
 	"context"
 	"sort"
 
-	"go.unistack.org/micro/v4/errors"
+	"go.unistack.org/micro/v3/errors"
-	"go.unistack.org/micro/v4/router"
+	"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) {
+func LookupRoute(ctx context.Context, req Request, opts CallOptions) ([]string, error) {
 	// check to see if an address was provided as a call option
 	if len(opts.Address) > 0 {
 		return opts.Address, nil

client/noop.go

@@ -2,17 +2,11 @@ package client
 
 import (
 	"context"
-	"fmt"
-	"strconv"
-	"time"
 
-	"go.unistack.org/micro/v4/codec"
+	"go.unistack.org/micro/v3/broker"
-	"go.unistack.org/micro/v4/errors"
+	"go.unistack.org/micro/v3/codec"
-	"go.unistack.org/micro/v4/metadata"
+	"go.unistack.org/micro/v3/errors"
-	"go.unistack.org/micro/v4/options"
+	"go.unistack.org/micro/v3/metadata"
-	"go.unistack.org/micro/v4/selector"
-	"go.unistack.org/micro/v4/semconv"
-	"go.unistack.org/micro/v4/tracer"
 )
 
 // DefaultCodecs will be used to encode/decode data
@@ -21,9 +15,13 @@ var DefaultCodecs = map[string]codec.Codec{
 }
 
 type noopClient struct {
-	funcCall   FuncCall
+	opts Options
-	funcStream FuncStream
+}
-	opts       Options
+
+type noopMessage struct {
+	topic   string
+	payload interface{}
+	opts    MessageOptions
 }
 
 type noopRequest struct {
@@ -38,12 +36,16 @@ type noopRequest struct {
 
 // NewClient returns new noop client
 func NewClient(opts ...Option) Client {
-	n := &noopClient{opts: NewOptions(opts...)}
+	nc := &noopClient{opts: NewOptions(opts...)}
+	// wrap in reverse
 
-	n.funcCall = n.fnCall
+	c := Client(nc)
-	n.funcStream = n.fnStream
 
-	return n
+	for i := len(nc.opts.Wrappers); i > 0; i-- {
+		c = nc.opts.Wrappers[i-1](c)
+	}
+
+	return c
 }
 
 func (n *noopClient) Name() string {
@@ -95,13 +97,10 @@ func (n *noopResponse) Read() ([]byte, error) {
 	return nil, nil
 }
 
-type noopStream struct {
+type noopStream struct{}
-	err error
-	ctx context.Context
-}
 
 func (n *noopStream) Context() context.Context {
-	return n.ctx
+	return context.Background()
 }
 
 func (n *noopStream) Request() Request {
@@ -120,49 +119,40 @@ 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
+	return nil
 }
 
 func (n *noopStream) Close() error {
-	if sp, ok := tracer.SpanFromContext(n.ctx); ok && sp != nil {
+	return nil
-		if n.err != nil {
-			sp.SetStatus(tracer.SpanStatusError, n.err.Error())
-		}
-		sp.Finish()
-	}
-	return n.err
 }
 
-func (n *noopStream) CloseSend() error {
+func (n *noopMessage) Topic() string {
-	return n.err
+	return n.topic
+}
+
+func (n *noopMessage) Payload() interface{} {
+	return n.payload
+}
+
+func (n *noopMessage) ContentType() string {
+	return n.opts.ContentType
+}
+
+func (n *noopClient) newCodec(contentType string) (codec.Codec, error) {
+	if cf, ok := n.opts.Codecs[contentType]; ok {
+		return cf, nil
+	}
+	if 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.opts.Hooks.EachPrev(func(hook options.Hook) {
-		switch h := hook.(type) {
-		case HookCall:
-			n.funcCall = h(n.funcCall)
-		case HookStream:
-			n.funcStream = h(n.funcStream)
-		}
-	})
-
 	return nil
 }
 
@@ -175,328 +165,76 @@ func (n *noopClient) String() string {
 }
 
 func (n *noopClient) Call(ctx context.Context, req Request, rsp interface{}, opts ...CallOption) error {
-	ts := time.Now()
+	return nil
-	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 {
+func (n *noopClient) NewRequest(service, endpoint string, req interface{}, opts ...RequestOption) Request {
-	// 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()
+	return &noopStream{}, nil
-	n.opts.Meter.Counter(semconv.ClientRequestInflight, "endpoint", req.Endpoint()).Inc()
+}
-	var sp tracer.Span
+
-	ctx, sp = n.opts.Tracer.Start(ctx, "rpc-client",
+func (n *noopClient) BatchPublish(ctx context.Context, ps []Message, opts ...PublishOption) error {
-		tracer.WithSpanKind(tracer.SpanKindClient),
+	return n.publish(ctx, ps, opts...)
-		tracer.WithSpanLabels("endpoint", req.Endpoint()),
+}
+
+func (n *noopClient) Publish(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))
+
+	for _, p := range ps {
+		md, ok := metadata.FromOutgoingContext(ctx)
+		if !ok {
+			md = metadata.New(0)
+		}
+		md[metadata.HeaderContentType] = p.ContentType()
+
+		topic := p.Topic()
+
+		// get the exchange
+		if len(options.Exchange) > 0 {
+			topic = options.Exchange
+		}
+
+		md[metadata.HeaderTopic] = topic
+
+		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", err.Error())
+			}
+
+			// set the body
+			b, err := cf.Marshal(p.Payload())
+			if err != nil {
+				return errors.InternalServerError("go.micro.client", err.Error())
+			}
+			body = b
+		}
+
+		msgs = append(msgs, &broker.Message{Header: md, Body: body})
+	}
+
+	return n.opts.Broker.BatchPublish(ctx, msgs,
+		broker.PublishContext(options.Context),
+		broker.PublishBodyOnly(options.BodyOnly),
 	)
-	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
 }

client/options.go

@@ -3,34 +3,24 @@ package client
 import (
 	"context"
 	"crypto/tls"
-	"net"
 	"time"
 
-	"go.unistack.org/micro/v4/broker"
+	"go.unistack.org/micro/v3/broker"
-	"go.unistack.org/micro/v4/codec"
+	"go.unistack.org/micro/v3/codec"
-	"go.unistack.org/micro/v4/logger"
+	"go.unistack.org/micro/v3/logger"
-	"go.unistack.org/micro/v4/metadata"
+	"go.unistack.org/micro/v3/meter"
-	"go.unistack.org/micro/v4/meter"
+	"go.unistack.org/micro/v3/network/transport"
-	"go.unistack.org/micro/v4/options"
+	"go.unistack.org/micro/v3/register"
-	"go.unistack.org/micro/v4/register"
+	"go.unistack.org/micro/v3/router"
-	"go.unistack.org/micro/v4/router"
+	"go.unistack.org/micro/v3/selector"
-	"go.unistack.org/micro/v4/selector"
+	"go.unistack.org/micro/v3/selector/random"
-	"go.unistack.org/micro/v4/selector/random"
+	"go.unistack.org/micro/v3/tracer"
-	"go.unistack.org/micro/v4/tracer"
 )
 
 // Options holds client options
 type Options struct {
-	// Codecs map
+	// Transport used for transfer messages
-	Codecs map[string]codec.Codec
+	Transport transport.Transport
-
-	// Proxy is used for proxy requests
-	Proxy string
-	// ContentType is used to select codec
-	ContentType string
-	// Name is the client name
-	Name string
-
 	// Selector used to select needed address
 	Selector selector.Selector
 	// Logger used to log messages
@@ -45,24 +35,22 @@ type Options struct {
 	Context context.Context
 	// Router used to get route
 	Router router.Router
-
 	// TLSConfig specifies tls.Config for secure connection
 	TLSConfig *tls.Config
-
+	// Codecs map
+	Codecs map[string]codec.Codec
 	// Lookup func used to get destination addr
 	Lookup LookupFunc
-	// ContextDialer used to connect
+	// Proxy is used for proxy requests
-	ContextDialer func(context.Context, string) (net.Conn, error)
+	Proxy string
-
+	// ContentType is used to select codec
+	ContentType string
+	// Name is the client name
+	Name string
 	// Wrappers contains wrappers
 	Wrappers []Wrapper
-	// Hooks can be run before broker Publish/BatchPublish and
-	// Subscribe/BatchSubscribe methods
-	Hooks options.Hooks
-
 	// CallOptions contains default CallOptions
 	CallOptions CallOptions
-
 	// PoolSize connection pool size
 	PoolSize int
 	// PoolTTL connection pool ttl
@@ -80,16 +68,6 @@ func NewCallOptions(opts ...CallOption) CallOptions {
 
 // 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
@@ -97,39 +75,31 @@ type CallOptions struct {
 	// 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
+	// Network name
-	ContextDialer func(context.Context, string) (net.Conn, error)
+	Network string
-
+	// Content-Type
+	ContentType string
+	// AuthToken string
+	AuthToken string
 	// Address specifies static addr list
 	Address []string
 	// SelectOptions selector options
 	SelectOptions []selector.SelectOption
-
+	// CallWrappers call wrappers
+	CallWrappers []CallWrapper
 	// StreamTimeout stream timeout
 	StreamTimeout time.Duration
 	// RequestTimeout request timeout
 	RequestTimeout time.Duration
-
 	// DialTimeout dial timeout
 	DialTimeout time.Duration
 	// Retries specifies retries num
 	Retries int
 }
 
-// ContextDialer pass ContextDialer to client
-func ContextDialer(fn func(context.Context, string) (net.Conn, error)) Option {
-	return func(o *Options) {
-		o.ContextDialer = fn
-	}
-}
-
 // Context pass context to client
 func Context(ctx context.Context) Option {
 	return func(o *Options) {
@@ -137,6 +107,40 @@ func Context(ctx context.Context) Option {
 	}
 }
 
+// NewPublishOptions create new PublishOptions struct from option
+func NewPublishOptions(opts ...PublishOption) PublishOptions {
+	options := PublishOptions{}
+	for _, o := range opts {
+		o(&options)
+	}
+	return options
+}
+
+// PublishOptions holds publish options
+type PublishOptions struct {
+	// Context used for external options
+	Context context.Context
+	// Exchange topic exchange name
+	Exchange string
+	// BodyOnly will publish only message body
+	BodyOnly bool
+}
+
+// NewMessageOptions creates message options struct
+func NewMessageOptions(opts ...MessageOption) MessageOptions {
+	options := MessageOptions{}
+	for _, o := range opts {
+		o(&options)
+	}
+	return options
+}
+
+// MessageOptions holds client message options
+type MessageOptions struct {
+	// ContentType specify content-type of message
+	ContentType string
+}
+
 // NewRequestOptions creates new RequestOptions struct
 func NewRequestOptions(opts ...RequestOption) RequestOptions {
 	options := RequestOptions{}
@@ -161,23 +165,25 @@ func NewOptions(opts ...Option) Options {
 	options := Options{
 		Context:     context.Background(),
 		ContentType: DefaultContentType,
-		Codecs:      DefaultCodecs,
+		Codecs:      make(map[string]codec.Codec),
 		CallOptions: CallOptions{
 			Context:        context.Background(),
 			Backoff:        DefaultBackoff,
 			Retry:          DefaultRetry,
 			Retries:        DefaultRetries,
 			RequestTimeout: DefaultRequestTimeout,
+			DialTimeout:    transport.DefaultDialTimeout,
 		},
-		Lookup:   LookupRoute,
+		Lookup:    LookupRoute,
-		PoolSize: DefaultPoolSize,
+		PoolSize:  DefaultPoolSize,
-		PoolTTL:  DefaultPoolTTL,
+		PoolTTL:   DefaultPoolTTL,
-		Selector: random.NewSelector(),
+		Selector:  random.NewSelector(),
-		Logger:   logger.DefaultLogger,
+		Logger:    logger.DefaultLogger,
-		Broker:   broker.DefaultBroker,
+		Broker:    broker.DefaultBroker,
-		Meter:    meter.DefaultMeter,
+		Meter:     meter.DefaultMeter,
-		Tracer:   tracer.DefaultTracer,
+		Tracer:    tracer.DefaultTracer,
-		Router:   router.DefaultRouter,
+		Router:    router.DefaultRouter,
+		Transport: transport.DefaultTransport,
 	}
 
 	for _, o := range opts {
@@ -250,6 +256,13 @@ func PoolTTL(d time.Duration) Option {
 	}
 }
 
+// Transport to use for communication e.g http, rabbitmq, etc
+func Transport(t transport.Transport) Option {
+	return func(o *Options) {
+		o.Transport = t
+	}
+}
+
 // Register sets the routers register
 func Register(r register.Register) Option {
 	return func(o *Options) {
@@ -273,6 +286,20 @@ func Selector(s selector.Selector) Option {
 	}
 }
 
+// Wrap adds a wrapper to the list of options passed into the client
+func Wrap(w Wrapper) Option {
+	return func(o *Options) {
+		o.Wrappers = append(o.Wrappers, w)
+	}
+}
+
+// WrapCall adds a wrapper to the list of CallFunc wrappers
+func WrapCall(cw ...CallWrapper) Option {
+	return func(o *Options) {
+		o.CallOptions.CallWrappers = append(o.CallOptions.CallWrappers, cw...)
+	}
+}
+
 // Backoff is used to set the backoff function used when retrying Calls
 func Backoff(fn BackoffFunc) Option {
 	return func(o *Options) {
@@ -299,6 +326,14 @@ func TLSConfig(t *tls.Config) Option {
 	return func(o *Options) {
 		// set the internal tls
 		o.TLSConfig = t
+
+		// set the default transport if one is not
+		// already set. Required for Init call below.
+
+		// set the transport tls
+		_ = o.Transport.Init(
+			transport.TLSConfig(t),
+		)
 	}
 }
 
@@ -337,10 +372,40 @@ func DialTimeout(d time.Duration) Option {
 	}
 }
 
-// WithContextDialer pass ContextDialer to client call
+// WithExchange sets the exchange to route a message through
-func WithContextDialer(fn func(context.Context, string) (net.Conn, error)) CallOption {
+// Deprecated
-	return func(o *CallOptions) {
+func WithExchange(e string) PublishOption {
-		o.ContextDialer = fn
+	return func(o *PublishOptions) {
+		o.Exchange = e
+	}
+}
+
+// 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
 	}
 }
 
@@ -358,6 +423,13 @@ func WithAddress(a ...string) CallOption {
 	}
 }
 
+// WithCallWrapper is a CallOption which adds to the existing CallFunc wrappers
+func WithCallWrapper(cw ...CallWrapper) CallOption {
+	return func(o *CallOptions) {
+		o.CallWrappers = append(o.CallWrappers, cw...)
+	}
+}
+
 // WithBackoff is a CallOption which overrides that which
 // set in Options.CallOptions
 func WithBackoff(fn BackoffFunc) CallOption {
@@ -382,20 +454,6 @@ 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 {
@@ -427,6 +485,13 @@ func WithAuthToken(t string) CallOption {
 	}
 }
 
+// WithNetwork is a CallOption which sets the network attribute
+func WithNetwork(n string) CallOption {
+	return func(o *CallOptions) {
+		o.Network = n
+	}
+}
+
 // WithRouter sets the router to use for this call
 func WithRouter(r router.Router) CallOption {
 	return func(o *CallOptions) {
@@ -448,6 +513,21 @@ func WithSelectOptions(sops ...selector.SelectOption) CallOption {
 	}
 }
 
+// WithMessageContentType sets the message content type
+// Deprecated
+func WithMessageContentType(ct string) MessageOption {
+	return func(o *MessageOptions) {
+		o.ContentType = ct
+	}
+}
+
+// MessageContentType sets the message content type
+func MessageContentType(ct string) MessageOption {
+	return func(o *MessageOptions) {
+		o.ContentType = ct
+	}
+}
+
 // StreamingRequest specifies that request is streaming
 func StreamingRequest(b bool) RequestOption {
 	return func(o *RequestOptions) {
@@ -461,10 +541,3 @@ func RequestContentType(ct string) RequestOption {
 		o.ContentType = ct
 	}
 }
-
-// Hooks sets hook runs before action
-func Hooks(h ...options.Hook) Option {
-	return func(o *Options) {
-		o.Hooks = append(o.Hooks, h...)
-	}
-}

client/retry.go

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

client/retry_test.go

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

client/test_request.go

@@ -1,7 +1,7 @@
 package client
 
 import (
-	"go.unistack.org/micro/v4/codec"
+	"go.unistack.org/micro/v3/codec"
 )
 
 type testRequest struct {

cluster/cluster.go

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

cluster/hasql/cluster.go

@@ -1,235 +0,0 @@
-package sql
-
-import (
-	"context"
-	"database/sql"
-	"reflect"
-	"unsafe"
-
-	"golang.yandex/hasql/v2"
-)
-
-func newSQLRowError() *sql.Row {
-	row := &sql.Row{}
-	t := reflect.TypeOf(row).Elem()
-	field, _ := t.FieldByName("err")
-	rowPtr := unsafe.Pointer(row)
-	errFieldPtr := unsafe.Pointer(uintptr(rowPtr) + field.Offset)
-	errPtr := (*error)(errFieldPtr)
-	*errPtr = ErrorNoAliveNodes
-	return row
-}
-
-type ClusterQuerier interface {
-	Querier
-	WaitForNodes(ctx context.Context, criterion ...hasql.NodeStateCriterion) error
-}
-
-type Cluster struct {
-	hasql   *hasql.Cluster[Querier]
-	options ClusterOptions
-}
-
-// NewCluster returns [Querier] that provides cluster of nodes
-func NewCluster[T Querier](opts ...ClusterOption) (ClusterQuerier, error) {
-	options := ClusterOptions{Context: context.Background()}
-	for _, opt := range opts {
-		opt(&options)
-	}
-	if options.NodeChecker == nil {
-		return nil, ErrClusterChecker
-	}
-	if options.NodeDiscoverer == nil {
-		return nil, ErrClusterDiscoverer
-	}
-	if options.NodePicker == nil {
-		return nil, ErrClusterPicker
-	}
-
-	if options.Retries < 1 {
-		options.Retries = 1
-	}
-
-	if options.NodeStateCriterion == 0 {
-		options.NodeStateCriterion = hasql.Primary
-	}
-
-	options.Options = append(options.Options, hasql.WithNodePicker(options.NodePicker))
-	if p, ok := options.NodePicker.(*CustomPicker[Querier]); ok {
-		p.opts.Priority = options.NodePriority
-	}
-
-	c, err := hasql.NewCluster(
-		options.NodeDiscoverer,
-		options.NodeChecker,
-		options.Options...,
-	)
-	if err != nil {
-		return nil, err
-	}
-
-	return &Cluster{hasql: c, options: options}, nil
-}
-
-func (c *Cluster) BeginTx(ctx context.Context, opts *sql.TxOptions) (*sql.Tx, error) {
-	var tx *sql.Tx
-	var err error
-
-	retries := 0
-	c.hasql.NodesIter(c.getNodeStateCriterion(ctx))(func(n *hasql.Node[Querier]) bool {
-		for ; retries < c.options.Retries; retries++ {
-			if tx, err = n.DB().BeginTx(ctx, opts); err != nil && retries >= c.options.Retries {
-				return true
-			}
-		}
-		return false
-	})
-
-	if tx == nil && err == nil {
-		err = ErrorNoAliveNodes
-	}
-
-	return tx, err
-}
-
-func (c *Cluster) Close() error {
-	return c.hasql.Close()
-}
-
-func (c *Cluster) Conn(ctx context.Context) (*sql.Conn, error) {
-	var conn *sql.Conn
-	var err error
-
-	retries := 0
-	c.hasql.NodesIter(c.getNodeStateCriterion(ctx))(func(n *hasql.Node[Querier]) bool {
-		for ; retries < c.options.Retries; retries++ {
-			if conn, err = n.DB().Conn(ctx); err != nil && retries >= c.options.Retries {
-				return true
-			}
-		}
-		return false
-	})
-
-	if conn == nil && err == nil {
-		err = ErrorNoAliveNodes
-	}
-
-	return conn, err
-}
-
-func (c *Cluster) ExecContext(ctx context.Context, query string, args ...interface{}) (sql.Result, error) {
-	var res sql.Result
-	var err error
-
-	retries := 0
-	c.hasql.NodesIter(c.getNodeStateCriterion(ctx))(func(n *hasql.Node[Querier]) bool {
-		for ; retries < c.options.Retries; retries++ {
-			if res, err = n.DB().ExecContext(ctx, query, args...); err != nil && retries >= c.options.Retries {
-				return true
-			}
-		}
-		return false
-	})
-
-	if res == nil && err == nil {
-		err = ErrorNoAliveNodes
-	}
-
-	return res, err
-}
-
-func (c *Cluster) PrepareContext(ctx context.Context, query string) (*sql.Stmt, error) {
-	var res *sql.Stmt
-	var err error
-
-	retries := 0
-	c.hasql.NodesIter(c.getNodeStateCriterion(ctx))(func(n *hasql.Node[Querier]) bool {
-		for ; retries < c.options.Retries; retries++ {
-			if res, err = n.DB().PrepareContext(ctx, query); err != nil && retries >= c.options.Retries {
-				return true
-			}
-		}
-		return false
-	})
-
-	if res == nil && err == nil {
-		err = ErrorNoAliveNodes
-	}
-
-	return res, err
-}
-
-func (c *Cluster) QueryContext(ctx context.Context, query string, args ...interface{}) (*sql.Rows, error) {
-	var res *sql.Rows
-	var err error
-
-	retries := 0
-	c.hasql.NodesIter(c.getNodeStateCriterion(ctx))(func(n *hasql.Node[Querier]) bool {
-		for ; retries < c.options.Retries; retries++ {
-			if res, err = n.DB().QueryContext(ctx, query); err != nil && err != sql.ErrNoRows && retries >= c.options.Retries {
-				return true
-			}
-		}
-		return false
-	})
-
-	if res == nil && err == nil {
-		err = ErrorNoAliveNodes
-	}
-
-	return res, err
-}
-
-func (c *Cluster) QueryRowContext(ctx context.Context, query string, args ...interface{}) *sql.Row {
-	var res *sql.Row
-
-	retries := 0
-	c.hasql.NodesIter(c.getNodeStateCriterion(ctx))(func(n *hasql.Node[Querier]) bool {
-		for ; retries < c.options.Retries; retries++ {
-			res = n.DB().QueryRowContext(ctx, query, args...)
-			if res.Err() == nil {
-				return false
-			} else if res.Err() != nil && retries >= c.options.Retries {
-				return false
-			}
-		}
-		return true
-	})
-
-	if res == nil {
-		res = newSQLRowError()
-	}
-
-	return res
-}
-
-func (c *Cluster) PingContext(ctx context.Context) error {
-	var err error
-	var ok bool
-
-	retries := 0
-	c.hasql.NodesIter(c.getNodeStateCriterion(ctx))(func(n *hasql.Node[Querier]) bool {
-		ok = true
-		for ; retries < c.options.Retries; retries++ {
-			if err = n.DB().PingContext(ctx); err != nil && retries >= c.options.Retries {
-				return true
-			}
-		}
-		return false
-	})
-
-	if !ok {
-		err = ErrorNoAliveNodes
-	}
-
-	return err
-}
-
-func (c *Cluster) WaitForNodes(ctx context.Context, criterions ...hasql.NodeStateCriterion) error {
-	for _, criterion := range criterions {
-		if _, err := c.hasql.WaitForNode(ctx, criterion); err != nil {
-			return err
-		}
-	}
-	return nil
-}

cluster/hasql/cluster_test.go

@@ -1,171 +0,0 @@
-package sql
-
-import (
-	"context"
-	"fmt"
-	"testing"
-	"time"
-
-	"github.com/DATA-DOG/go-sqlmock"
-	"golang.yandex/hasql/v2"
-)
-
-func TestNewCluster(t *testing.T) {
-	dbMaster, dbMasterMock, err := sqlmock.New(sqlmock.MonitorPingsOption(true))
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer dbMaster.Close()
-	dbMasterMock.MatchExpectationsInOrder(false)
-
-	dbMasterMock.ExpectQuery(`.*pg_is_in_recovery.*`).WillReturnRows(
-		sqlmock.NewRowsWithColumnDefinition(
-			sqlmock.NewColumn("role").OfType("int8", 0),
-			sqlmock.NewColumn("replication_lag").OfType("int8", 0)).
-			AddRow(1, 0)).
-		RowsWillBeClosed().
-		WithoutArgs()
-
-	dbMasterMock.ExpectQuery(`SELECT node_name as name`).WillReturnRows(
-		sqlmock.NewRows([]string{"name"}).
-			AddRow("master-dc1"))
-
-	dbDRMaster, dbDRMasterMock, err := sqlmock.New(sqlmock.MonitorPingsOption(true))
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer dbDRMaster.Close()
-	dbDRMasterMock.MatchExpectationsInOrder(false)
-
-	dbDRMasterMock.ExpectQuery(`.*pg_is_in_recovery.*`).WillReturnRows(
-		sqlmock.NewRowsWithColumnDefinition(
-			sqlmock.NewColumn("role").OfType("int8", 0),
-			sqlmock.NewColumn("replication_lag").OfType("int8", 0)).
-			AddRow(2, 40)).
-		RowsWillBeClosed().
-		WithoutArgs()
-
-	dbDRMasterMock.ExpectQuery(`SELECT node_name as name`).WillReturnRows(
-		sqlmock.NewRows([]string{"name"}).
-			AddRow("drmaster1-dc2"))
-
-	dbDRMasterMock.ExpectQuery(`SELECT node_name as name`).WillReturnRows(
-		sqlmock.NewRows([]string{"name"}).
-			AddRow("drmaster"))
-
-	dbSlaveDC1, dbSlaveDC1Mock, err := sqlmock.New(sqlmock.MonitorPingsOption(true))
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer dbSlaveDC1.Close()
-	dbSlaveDC1Mock.MatchExpectationsInOrder(false)
-
-	dbSlaveDC1Mock.ExpectQuery(`.*pg_is_in_recovery.*`).WillReturnRows(
-		sqlmock.NewRowsWithColumnDefinition(
-			sqlmock.NewColumn("role").OfType("int8", 0),
-			sqlmock.NewColumn("replication_lag").OfType("int8", 0)).
-			AddRow(2, 50)).
-		RowsWillBeClosed().
-		WithoutArgs()
-
-	dbSlaveDC1Mock.ExpectQuery(`SELECT node_name as name`).WillReturnRows(
-		sqlmock.NewRows([]string{"name"}).
-			AddRow("slave-dc1"))
-
-	dbSlaveDC2, dbSlaveDC2Mock, err := sqlmock.New(sqlmock.MonitorPingsOption(true))
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer dbSlaveDC2.Close()
-	dbSlaveDC1Mock.MatchExpectationsInOrder(false)
-
-	dbSlaveDC2Mock.ExpectQuery(`.*pg_is_in_recovery.*`).WillReturnRows(
-		sqlmock.NewRowsWithColumnDefinition(
-			sqlmock.NewColumn("role").OfType("int8", 0),
-			sqlmock.NewColumn("replication_lag").OfType("int8", 0)).
-			AddRow(2, 50)).
-		RowsWillBeClosed().
-		WithoutArgs()
-
-	dbSlaveDC2Mock.ExpectQuery(`SELECT node_name as name`).WillReturnRows(
-		sqlmock.NewRows([]string{"name"}).
-			AddRow("slave-dc1"))
-
-	tctx, cancel := context.WithTimeout(t.Context(), 10*time.Second)
-	defer cancel()
-
-	c, err := NewCluster[Querier](
-		WithClusterContext(tctx),
-		WithClusterNodeChecker(hasql.PostgreSQLChecker),
-		WithClusterNodePicker(NewCustomPicker[Querier](
-			CustomPickerMaxLag(100),
-		)),
-		WithClusterNodes(
-			ClusterNode{"slave-dc1", dbSlaveDC1, 1},
-			ClusterNode{"master-dc1", dbMaster, 1},
-			ClusterNode{"slave-dc2", dbSlaveDC2, 2},
-			ClusterNode{"drmaster1-dc2", dbDRMaster, 0},
-		),
-		WithClusterOptions(
-			hasql.WithUpdateInterval[Querier](2*time.Second),
-			hasql.WithUpdateTimeout[Querier](1*time.Second),
-		),
-	)
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer c.Close()
-
-	if err = c.WaitForNodes(tctx, hasql.Primary, hasql.Standby); err != nil {
-		t.Fatal(err)
-	}
-
-	time.Sleep(500 * time.Millisecond)
-
-	node1Name := ""
-	fmt.Printf("check for Standby\n")
-	if row := c.QueryRowContext(NodeStateCriterion(tctx, hasql.Standby), "SELECT node_name as name"); row.Err() != nil {
-		t.Fatal(row.Err())
-	} else if err = row.Scan(&node1Name); err != nil {
-		t.Fatal(err)
-	} else if "slave-dc1" != node1Name {
-		t.Fatalf("invalid node name %s != %s", "slave-dc1", node1Name)
-	}
-
-	dbSlaveDC1Mock.ExpectQuery(`SELECT node_name as name`).WillReturnRows(
-		sqlmock.NewRows([]string{"name"}).
-			AddRow("slave-dc1"))
-
-	node2Name := ""
-	fmt.Printf("check for PreferStandby\n")
-	if row := c.QueryRowContext(NodeStateCriterion(tctx, hasql.PreferStandby), "SELECT node_name as name"); row.Err() != nil {
-		t.Fatal(row.Err())
-	} else if err = row.Scan(&node2Name); err != nil {
-		t.Fatal(err)
-	} else if "slave-dc1" != node2Name {
-		t.Fatalf("invalid node name %s != %s", "slave-dc1", node2Name)
-	}
-
-	node3Name := ""
-	fmt.Printf("check for PreferPrimary\n")
-	if row := c.QueryRowContext(NodeStateCriterion(tctx, hasql.PreferPrimary), "SELECT node_name as name"); row.Err() != nil {
-		t.Fatal(row.Err())
-	} else if err = row.Scan(&node3Name); err != nil {
-		t.Fatal(err)
-	} else if "master-dc1" != node3Name {
-		t.Fatalf("invalid node name %s != %s", "master-dc1", node3Name)
-	}
-
-	dbSlaveDC1Mock.ExpectQuery(`.*`).WillReturnRows(sqlmock.NewRows([]string{"role"}).RowError(1, fmt.Errorf("row error")))
-
-	time.Sleep(2 * time.Second)
-
-	fmt.Printf("check for PreferStandby\n")
-	if row := c.QueryRowContext(NodeStateCriterion(tctx, hasql.PreferStandby), "SELECT node_name as name"); row.Err() == nil {
-		t.Fatal("must return error")
-	}
-
-	if dbMasterErr := dbMasterMock.ExpectationsWereMet(); dbMasterErr != nil {
-		t.Error(dbMasterErr)
-	}
-}

cluster/hasql/db.go

@@ -1,25 +0,0 @@
-package sql
-
-import (
-	"context"
-	"database/sql"
-)
-
-type Querier interface {
-	// Basic connection methods
-	PingContext(ctx context.Context) error
-	Close() error
-
-	// Query methods with context
-	ExecContext(ctx context.Context, query string, args ...interface{}) (sql.Result, error)
-	QueryContext(ctx context.Context, query string, args ...interface{}) (*sql.Rows, error)
-	QueryRowContext(ctx context.Context, query string, args ...interface{}) *sql.Row
-
-	// Prepared statements with context
-	PrepareContext(ctx context.Context, query string) (*sql.Stmt, error)
-
-	// Transaction management with context
-	BeginTx(ctx context.Context, opts *sql.TxOptions) (*sql.Tx, error)
-
-	Conn(ctx context.Context) (*sql.Conn, error)
-}

cluster/hasql/driver.go

@@ -1,295 +0,0 @@
-package sql
-
-import (
-	"context"
-	"database/sql"
-	"database/sql/driver"
-	"io"
-	"sync"
-	"time"
-)
-
-// OpenDBWithCluster creates a [*sql.DB] that uses the [ClusterQuerier]
-func OpenDBWithCluster(db ClusterQuerier) (*sql.DB, error) {
-	driver := NewClusterDriver(db)
-	connector, err := driver.OpenConnector("")
-	if err != nil {
-		return nil, err
-	}
-	return sql.OpenDB(connector), nil
-}
-
-// ClusterDriver implements [driver.Driver] and driver.Connector for an existing [Querier]
-type ClusterDriver struct {
-	db ClusterQuerier
-}
-
-// NewClusterDriver creates a new [driver.Driver] that uses an existing [ClusterQuerier]
-func NewClusterDriver(db ClusterQuerier) *ClusterDriver {
-	return &ClusterDriver{db: db}
-}
-
-// Open implements [driver.Driver.Open]
-func (d *ClusterDriver) Open(name string) (driver.Conn, error) {
-	return d.Connect(context.Background())
-}
-
-// OpenConnector implements [driver.DriverContext.OpenConnector]
-func (d *ClusterDriver) OpenConnector(name string) (driver.Connector, error) {
-	return d, nil
-}
-
-// Connect implements [driver.Connector.Connect]
-func (d *ClusterDriver) Connect(ctx context.Context) (driver.Conn, error) {
-	conn, err := d.db.Conn(ctx)
-	if err != nil {
-		return nil, err
-	}
-	return &dbConn{conn: conn}, nil
-}
-
-// Driver implements [driver.Connector.Driver]
-func (d *ClusterDriver) Driver() driver.Driver {
-	return d
-}
-
-// dbConn implements driver.Conn with both context and legacy methods
-type dbConn struct {
-	conn *sql.Conn
-	mu   sync.Mutex
-}
-
-// Prepare implements [driver.Conn.Prepare] (legacy method)
-func (c *dbConn) Prepare(query string) (driver.Stmt, error) {
-	return c.PrepareContext(context.Background(), query)
-}
-
-// PrepareContext implements [driver.ConnPrepareContext.PrepareContext]
-func (c *dbConn) PrepareContext(ctx context.Context, query string) (driver.Stmt, error) {
-	c.mu.Lock()
-	defer c.mu.Unlock()
-
-	stmt, err := c.conn.PrepareContext(ctx, query)
-	if err != nil {
-		return nil, err
-	}
-
-	return &dbStmt{stmt: stmt}, nil
-}
-
-// Exec implements [driver.Execer.Exec] (legacy method)
-func (c *dbConn) Exec(query string, args []driver.Value) (driver.Result, error) {
-	namedArgs := make([]driver.NamedValue, len(args))
-	for i, value := range args {
-		namedArgs[i] = driver.NamedValue{Value: value}
-	}
-	return c.ExecContext(context.Background(), query, namedArgs)
-}
-
-// ExecContext implements [driver.ExecerContext.ExecContext]
-func (c *dbConn) ExecContext(ctx context.Context, query string, args []driver.NamedValue) (driver.Result, error) {
-	c.mu.Lock()
-	defer c.mu.Unlock()
-
-	// Convert driver.NamedValue to any
-	interfaceArgs := make([]any, len(args))
-	for i, arg := range args {
-		interfaceArgs[i] = arg.Value
-	}
-
-	return c.conn.ExecContext(ctx, query, interfaceArgs...)
-}
-
-// Query implements [driver.Queryer.Query] (legacy method)
-func (c *dbConn) Query(query string, args []driver.Value) (driver.Rows, error) {
-	namedArgs := make([]driver.NamedValue, len(args))
-	for i, value := range args {
-		namedArgs[i] = driver.NamedValue{Value: value}
-	}
-	return c.QueryContext(context.Background(), query, namedArgs)
-}
-
-// QueryContext implements [driver.QueryerContext.QueryContext]
-func (c *dbConn) QueryContext(ctx context.Context, query string, args []driver.NamedValue) (driver.Rows, error) {
-	c.mu.Lock()
-	defer c.mu.Unlock()
-
-	// Convert driver.NamedValue to any
-	interfaceArgs := make([]any, len(args))
-	for i, arg := range args {
-		interfaceArgs[i] = arg.Value
-	}
-
-	rows, err := c.conn.QueryContext(ctx, query, interfaceArgs...)
-	if err != nil {
-		return nil, err
-	}
-
-	return &dbRows{rows: rows}, nil
-}
-
-// Begin implements [driver.Conn.Begin] (legacy method)
-func (c *dbConn) Begin() (driver.Tx, error) {
-	return c.BeginTx(context.Background(), driver.TxOptions{})
-}
-
-// BeginTx implements [driver.ConnBeginTx.BeginTx]
-func (c *dbConn) BeginTx(ctx context.Context, opts driver.TxOptions) (driver.Tx, error) {
-	c.mu.Lock()
-	defer c.mu.Unlock()
-
-	sqlOpts := &sql.TxOptions{
-		Isolation: sql.IsolationLevel(opts.Isolation),
-		ReadOnly:  opts.ReadOnly,
-	}
-
-	tx, err := c.conn.BeginTx(ctx, sqlOpts)
-	if err != nil {
-		return nil, err
-	}
-
-	return &dbTx{tx: tx}, nil
-}
-
-// Ping implements [driver.Pinger.Ping]
-func (c *dbConn) Ping(ctx context.Context) error {
-	return c.conn.PingContext(ctx)
-}
-
-// Close implements [driver.Conn.Close]
-func (c *dbConn) Close() error {
-	return c.conn.Close()
-}
-
-// IsValid implements [driver.Validator.IsValid]
-func (c *dbConn) IsValid() bool {
-	// Ping with a short timeout to check if the connection is still valid
-	ctx, cancel := context.WithTimeout(context.Background(), 1*time.Second)
-	defer cancel()
-
-	return c.conn.PingContext(ctx) == nil
-}
-
-// dbStmt implements [driver.Stmt] with both context and legacy methods
-type dbStmt struct {
-	stmt *sql.Stmt
-	mu   sync.Mutex
-}
-
-// Close implements [driver.Stmt.Close]
-func (s *dbStmt) Close() error {
-	s.mu.Lock()
-	defer s.mu.Unlock()
-	return s.stmt.Close()
-}
-
-// Close implements [driver.Stmt.NumInput]
-func (s *dbStmt) NumInput() int {
-	return -1 // Number of parameters is unknown
-}
-
-// Exec implements [driver.Stmt.Exec] (legacy method)
-func (s *dbStmt) Exec(args []driver.Value) (driver.Result, error) {
-	namedArgs := make([]driver.NamedValue, len(args))
-	for i, value := range args {
-		namedArgs[i] = driver.NamedValue{Value: value}
-	}
-	return s.ExecContext(context.Background(), namedArgs)
-}
-
-// ExecContext implements [driver.StmtExecContext.ExecContext]
-func (s *dbStmt) ExecContext(ctx context.Context, args []driver.NamedValue) (driver.Result, error) {
-	s.mu.Lock()
-	defer s.mu.Unlock()
-
-	interfaceArgs := make([]any, len(args))
-	for i, arg := range args {
-		interfaceArgs[i] = arg.Value
-	}
-	return s.stmt.ExecContext(ctx, interfaceArgs...)
-}
-
-// Query implements [driver.Stmt.Query] (legacy method)
-func (s *dbStmt) Query(args []driver.Value) (driver.Rows, error) {
-	namedArgs := make([]driver.NamedValue, len(args))
-	for i, value := range args {
-		namedArgs[i] = driver.NamedValue{Value: value}
-	}
-	return s.QueryContext(context.Background(), namedArgs)
-}
-
-// QueryContext implements [driver.StmtQueryContext.QueryContext]
-func (s *dbStmt) QueryContext(ctx context.Context, args []driver.NamedValue) (driver.Rows, error) {
-	s.mu.Lock()
-	defer s.mu.Unlock()
-
-	interfaceArgs := make([]any, len(args))
-	for i, arg := range args {
-		interfaceArgs[i] = arg.Value
-	}
-
-	rows, err := s.stmt.QueryContext(ctx, interfaceArgs...)
-	if err != nil {
-		return nil, err
-	}
-
-	return &dbRows{rows: rows}, nil
-}
-
-// dbRows implements [driver.Rows]
-type dbRows struct {
-	rows *sql.Rows
-}
-
-// Columns implements [driver.Rows.Columns]
-func (r *dbRows) Columns() []string {
-	cols, err := r.rows.Columns()
-	if err != nil {
-		// This shouldn't happen if the query was successful
-		return []string{}
-	}
-	return cols
-}
-
-// Close implements [driver.Rows.Close]
-func (r *dbRows) Close() error {
-	return r.rows.Close()
-}
-
-// Next implements [driver.Rows.Next]
-func (r *dbRows) Next(dest []driver.Value) error {
-	if !r.rows.Next() {
-		if err := r.rows.Err(); err != nil {
-			return err
-		}
-		return io.EOF
-	}
-
-	// Create a slice of interfaces to scan into
-	scanArgs := make([]any, len(dest))
-	for i := range scanArgs {
-		scanArgs[i] = &dest[i]
-	}
-
-	return r.rows.Scan(scanArgs...)
-}
-
-// dbTx implements [driver.Tx]
-type dbTx struct {
-	tx *sql.Tx
-	mu sync.Mutex
-}
-
-// Commit implements [driver.Tx.Commit]
-func (t *dbTx) Commit() error {
-	t.mu.Lock()
-	defer t.mu.Unlock()
-	return t.tx.Commit()
-}
-
-// Rollback implements [driver.Tx.Rollback]
-func (t *dbTx) Rollback() error {
-	t.mu.Lock()
-	defer t.mu.Unlock()
-	return t.tx.Rollback()
-}

cluster/hasql/driver_test.go

@@ -1,141 +0,0 @@
-package sql
-
-import (
-	"context"
-	"testing"
-	"time"
-
-	"github.com/DATA-DOG/go-sqlmock"
-	"golang.yandex/hasql/v2"
-)
-
-func TestDriver(t *testing.T) {
-	dbMaster, dbMasterMock, err := sqlmock.New(sqlmock.MonitorPingsOption(true))
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer dbMaster.Close()
-	dbMasterMock.MatchExpectationsInOrder(false)
-
-	dbMasterMock.ExpectQuery(`.*pg_is_in_recovery.*`).WillReturnRows(
-		sqlmock.NewRowsWithColumnDefinition(
-			sqlmock.NewColumn("role").OfType("int8", 0),
-			sqlmock.NewColumn("replication_lag").OfType("int8", 0)).
-			AddRow(1, 0)).
-		RowsWillBeClosed().
-		WithoutArgs()
-
-	dbMasterMock.ExpectQuery(`SELECT node_name as name`).WillReturnRows(
-		sqlmock.NewRows([]string{"name"}).
-			AddRow("master-dc1"))
-
-	dbDRMaster, dbDRMasterMock, err := sqlmock.New(sqlmock.MonitorPingsOption(true))
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer dbDRMaster.Close()
-	dbDRMasterMock.MatchExpectationsInOrder(false)
-
-	dbDRMasterMock.ExpectQuery(`.*pg_is_in_recovery.*`).WillReturnRows(
-		sqlmock.NewRowsWithColumnDefinition(
-			sqlmock.NewColumn("role").OfType("int8", 0),
-			sqlmock.NewColumn("replication_lag").OfType("int8", 0)).
-			AddRow(2, 40)).
-		RowsWillBeClosed().
-		WithoutArgs()
-
-	dbDRMasterMock.ExpectQuery(`SELECT node_name as name`).WillReturnRows(
-		sqlmock.NewRows([]string{"name"}).
-			AddRow("drmaster1-dc2"))
-
-	dbDRMasterMock.ExpectQuery(`SELECT node_name as name`).WillReturnRows(
-		sqlmock.NewRows([]string{"name"}).
-			AddRow("drmaster"))
-
-	dbSlaveDC1, dbSlaveDC1Mock, err := sqlmock.New(sqlmock.MonitorPingsOption(true))
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer dbSlaveDC1.Close()
-	dbSlaveDC1Mock.MatchExpectationsInOrder(false)
-
-	dbSlaveDC1Mock.ExpectQuery(`.*pg_is_in_recovery.*`).WillReturnRows(
-		sqlmock.NewRowsWithColumnDefinition(
-			sqlmock.NewColumn("role").OfType("int8", 0),
-			sqlmock.NewColumn("replication_lag").OfType("int8", 0)).
-			AddRow(2, 50)).
-		RowsWillBeClosed().
-		WithoutArgs()
-
-	dbSlaveDC1Mock.ExpectQuery(`SELECT node_name as name`).WillReturnRows(
-		sqlmock.NewRows([]string{"name"}).
-			AddRow("slave-dc1"))
-
-	dbSlaveDC2, dbSlaveDC2Mock, err := sqlmock.New(sqlmock.MonitorPingsOption(true))
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer dbSlaveDC2.Close()
-	dbSlaveDC1Mock.MatchExpectationsInOrder(false)
-
-	dbSlaveDC2Mock.ExpectQuery(`.*pg_is_in_recovery.*`).WillReturnRows(
-		sqlmock.NewRowsWithColumnDefinition(
-			sqlmock.NewColumn("role").OfType("int8", 0),
-			sqlmock.NewColumn("replication_lag").OfType("int8", 0)).
-			AddRow(2, 50)).
-		RowsWillBeClosed().
-		WithoutArgs()
-
-	dbSlaveDC2Mock.ExpectQuery(`SELECT node_name as name`).WillReturnRows(
-		sqlmock.NewRows([]string{"name"}).
-			AddRow("slave-dc1"))
-
-	tctx, cancel := context.WithTimeout(t.Context(), 10*time.Second)
-	defer cancel()
-
-	c, err := NewCluster[Querier](
-		WithClusterContext(tctx),
-		WithClusterNodeChecker(hasql.PostgreSQLChecker),
-		WithClusterNodePicker(NewCustomPicker[Querier](
-			CustomPickerMaxLag(100),
-		)),
-		WithClusterNodes(
-			ClusterNode{"slave-dc1", dbSlaveDC1, 1},
-			ClusterNode{"master-dc1", dbMaster, 1},
-			ClusterNode{"slave-dc2", dbSlaveDC2, 2},
-			ClusterNode{"drmaster1-dc2", dbDRMaster, 0},
-		),
-		WithClusterOptions(
-			hasql.WithUpdateInterval[Querier](2*time.Second),
-			hasql.WithUpdateTimeout[Querier](1*time.Second),
-		),
-	)
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer c.Close()
-
-	if err = c.WaitForNodes(tctx, hasql.Primary, hasql.Standby); err != nil {
-		t.Fatal(err)
-	}
-
-	db, err := OpenDBWithCluster(c)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	// Use context methods
-	row := db.QueryRowContext(NodeStateCriterion(t.Context(), hasql.Primary), "SELECT node_name as name")
-	if err = row.Err(); err != nil {
-		t.Fatal(err)
-	}
-
-	nodeName := ""
-	if err = row.Scan(&nodeName); err != nil {
-		t.Fatal(err)
-	}
-
-	if nodeName != "master-dc1" {
-		t.Fatalf("invalid node_name %s != %s", "master-dc1", nodeName)
-	}
-}

cluster/hasql/error.go

@@ -1,10 +0,0 @@
-package sql
-
-import "errors"
-
-var (
-	ErrClusterChecker    = errors.New("cluster node checker required")
-	ErrClusterDiscoverer = errors.New("cluster node discoverer required")
-	ErrClusterPicker     = errors.New("cluster node picker required")
-	ErrorNoAliveNodes    = errors.New("cluster no alive nodes")
-)

cluster/hasql/options.go

@@ -1,110 +0,0 @@
-package sql
-
-import (
-	"context"
-	"math"
-
-	"golang.yandex/hasql/v2"
-)
-
-// ClusterOptions contains cluster specific options
-type ClusterOptions struct {
-	NodeChecker        hasql.NodeChecker
-	NodePicker         hasql.NodePicker[Querier]
-	NodeDiscoverer     hasql.NodeDiscoverer[Querier]
-	Options            []hasql.ClusterOpt[Querier]
-	Context            context.Context
-	Retries            int
-	NodePriority       map[string]int32
-	NodeStateCriterion hasql.NodeStateCriterion
-}
-
-// ClusterOption apply cluster options to ClusterOptions
-type ClusterOption func(*ClusterOptions)
-
-// WithClusterNodeChecker pass hasql.NodeChecker to cluster options
-func WithClusterNodeChecker(c hasql.NodeChecker) ClusterOption {
-	return func(o *ClusterOptions) {
-		o.NodeChecker = c
-	}
-}
-
-// WithClusterNodePicker pass hasql.NodePicker to cluster options
-func WithClusterNodePicker(p hasql.NodePicker[Querier]) ClusterOption {
-	return func(o *ClusterOptions) {
-		o.NodePicker = p
-	}
-}
-
-// WithClusterNodeDiscoverer pass hasql.NodeDiscoverer to cluster options
-func WithClusterNodeDiscoverer(d hasql.NodeDiscoverer[Querier]) ClusterOption {
-	return func(o *ClusterOptions) {
-		o.NodeDiscoverer = d
-	}
-}
-
-// WithRetries retry count on other nodes in case of error
-func WithRetries(n int) ClusterOption {
-	return func(o *ClusterOptions) {
-		o.Retries = n
-	}
-}
-
-// WithClusterContext pass context.Context to cluster options and used for checks
-func WithClusterContext(ctx context.Context) ClusterOption {
-	return func(o *ClusterOptions) {
-		o.Context = ctx
-	}
-}
-
-// WithClusterOptions pass hasql.ClusterOpt
-func WithClusterOptions(opts ...hasql.ClusterOpt[Querier]) ClusterOption {
-	return func(o *ClusterOptions) {
-		o.Options = append(o.Options, opts...)
-	}
-}
-
-// WithClusterNodeStateCriterion pass default hasql.NodeStateCriterion
-func WithClusterNodeStateCriterion(c hasql.NodeStateCriterion) ClusterOption {
-	return func(o *ClusterOptions) {
-		o.NodeStateCriterion = c
-	}
-}
-
-type ClusterNode struct {
-	Name     string
-	DB       Querier
-	Priority int32
-}
-
-// WithClusterNodes create cluster with static NodeDiscoverer
-func WithClusterNodes(cns ...ClusterNode) ClusterOption {
-	return func(o *ClusterOptions) {
-		nodes := make([]*hasql.Node[Querier], 0, len(cns))
-		if o.NodePriority == nil {
-			o.NodePriority = make(map[string]int32, len(cns))
-		}
-		for _, cn := range cns {
-			nodes = append(nodes, hasql.NewNode(cn.Name, cn.DB))
-			if cn.Priority == 0 {
-				cn.Priority = math.MaxInt32
-			}
-			o.NodePriority[cn.Name] = cn.Priority
-		}
-		o.NodeDiscoverer = hasql.NewStaticNodeDiscoverer(nodes...)
-	}
-}
-
-type nodeStateCriterionKey struct{}
-
-// NodeStateCriterion inject hasql.NodeStateCriterion to context
-func NodeStateCriterion(ctx context.Context, c hasql.NodeStateCriterion) context.Context {
-	return context.WithValue(ctx, nodeStateCriterionKey{}, c)
-}
-
-func (c *Cluster) getNodeStateCriterion(ctx context.Context) hasql.NodeStateCriterion {
-	if v, ok := ctx.Value(nodeStateCriterionKey{}).(hasql.NodeStateCriterion); ok {
-		return v
-	}
-	return c.options.NodeStateCriterion
-}

cluster/hasql/picker.go

@@ -1,113 +0,0 @@
-package sql
-
-import (
-	"fmt"
-	"math"
-	"time"
-
-	"golang.yandex/hasql/v2"
-)
-
-// compile time guard
-var _ hasql.NodePicker[Querier] = (*CustomPicker[Querier])(nil)
-
-// CustomPickerOptions holds options to pick nodes
-type CustomPickerOptions struct {
-	MaxLag   int
-	Priority map[string]int32
-	Retries  int
-}
-
-// CustomPickerOption func apply option to CustomPickerOptions
-type CustomPickerOption func(*CustomPickerOptions)
-
-// CustomPickerMaxLag specifies max lag for which node can be used
-func CustomPickerMaxLag(n int) CustomPickerOption {
-	return func(o *CustomPickerOptions) {
-		o.MaxLag = n
-	}
-}
-
-// NewCustomPicker creates new node picker
-func NewCustomPicker[T Querier](opts ...CustomPickerOption) *CustomPicker[Querier] {
-	options := CustomPickerOptions{}
-	for _, o := range opts {
-		o(&options)
-	}
-	return &CustomPicker[Querier]{opts: options}
-}
-
-// CustomPicker holds node picker options
-type CustomPicker[T Querier] struct {
-	opts CustomPickerOptions
-}
-
-// PickNode used to return specific node
-func (p *CustomPicker[T]) PickNode(cnodes []hasql.CheckedNode[T]) hasql.CheckedNode[T] {
-	for _, n := range cnodes {
-		fmt.Printf("node %s\n", n.Node.String())
-	}
-	return cnodes[0]
-}
-
-func (p *CustomPicker[T]) getPriority(nodeName string) int32 {
-	if prio, ok := p.opts.Priority[nodeName]; ok {
-		return prio
-	}
-	return math.MaxInt32 // Default to lowest priority
-}
-
-// CompareNodes used to sort nodes
-func (p *CustomPicker[T]) CompareNodes(a, b hasql.CheckedNode[T]) int {
-	// Get replication lag values
-	aLag := a.Info.(interface{ ReplicationLag() int }).ReplicationLag()
-	bLag := b.Info.(interface{ ReplicationLag() int }).ReplicationLag()
-
-	// First check that lag lower then MaxLag
-	if aLag > p.opts.MaxLag && bLag > p.opts.MaxLag {
-		return 0 // both are equal
-	}
-
-	// If one node exceeds MaxLag and the other doesn't, prefer the one that doesn't
-	if aLag > p.opts.MaxLag {
-		return 1 // b is better
-	}
-	if bLag > p.opts.MaxLag {
-		return -1 // a is better
-	}
-
-	// Get node priorities
-	aPrio := p.getPriority(a.Node.String())
-	bPrio := p.getPriority(b.Node.String())
-
-	// if both priority equals
-	if aPrio == bPrio {
-		// First compare by replication lag
-		if aLag < bLag {
-			return -1
-		}
-		if aLag > bLag {
-			return 1
-		}
-		// If replication lag is equal, compare by latency
-		aLatency := a.Info.(interface{ Latency() time.Duration }).Latency()
-		bLatency := b.Info.(interface{ Latency() time.Duration }).Latency()
-
-		if aLatency < bLatency {
-			return -1
-		}
-		if aLatency > bLatency {
-			return 1
-		}
-
-		// If lag and latency is equal
-		return 0
-	}
-
-	// If priorities are different, prefer the node with lower priority value
-	if aPrio < bPrio {
-		return -1
-	}
-
-	return 1
-}

codec/codec.go

@@ -1,8 +1,19 @@
 // Package codec is an interface for encoding messages
-package codec
+package codec // import "go.unistack.org/micro/v3/codec"
 
 import (
 	"errors"
+	"io"
+
+	"go.unistack.org/micro/v3/metadata"
+)
+
+// Message types
+const (
+	Error MessageType = iota
+	Request
+	Response
+	Event
 )
 
 var (
@@ -13,63 +24,63 @@ var (
 )
 
 var (
+	// DefaultMaxMsgSize specifies how much data codec can handle
+	DefaultMaxMsgSize = 1024 * 1024 * 4 // 4Mb
 	// DefaultCodec is the global default codec
-	DefaultCodec = NewCodec()
+	DefaultCodec Codec = NewCodec()
 	// DefaultTagName specifies struct tag name to control codec Marshal/Unmarshal
 	DefaultTagName = "codec"
 )
 
-// Codec encodes/decodes various types of messages.
+// MessageType specifies message type for codec
+type MessageType int
+
+// Codec encodes/decodes various types of messages used within micro.
+// ReadHeader and ReadBody are called in pairs to read requests/responses
+// from the connection. Close is called when finished with the
+// connection. ReadBody may be called with a nil argument to force the
+// body to be read and discarded.
 type Codec interface {
+	ReadHeader(r io.Reader, m *Message, mt MessageType) error
+	ReadBody(r io.Reader, v interface{}) error
+	Write(w io.Writer, m *Message, v interface{}) error
 	Marshal(v interface{}, opts ...Option) ([]byte, error)
 	Unmarshal(b []byte, v interface{}, opts ...Option) error
 	String() string
 }
 
-type CodecV2 interface {
+// Message represents detailed information about
-	Marshal(buf []byte, v interface{}, opts ...Option) ([]byte, error)
+// the communication, likely followed by the body.
-	Unmarshal(buf []byte, v interface{}, opts ...Option) error
+// In the case of an error, body may be nil.
-	String() string
+type Message struct {
+	Header   metadata.Metadata
+	Target   string
+	Method   string
+	Endpoint string
+	Error    string
+	ID       string
+	Body     []byte
+	Type     MessageType
 }
 
-// RawMessage is a raw encoded JSON value.
+// NewMessage creates new codec message
-// It implements Marshaler and Unmarshaler and can be used to delay decoding or precompute a encoding.
+func NewMessage(t MessageType) *Message {
-type RawMessage []byte
+	return &Message{Type: t, Header: metadata.New(0)}
+}
 
-// MarshalJSON returns m as the JSON encoding of m.
+// MarshalAppend calls codec.Marshal(v) and returns the data appended to buf.
-func (m *RawMessage) MarshalJSON() ([]byte, error) {
+// If codec implements MarshalAppend, that is called instead.
-	if m == nil {
+func MarshalAppend(buf []byte, c Codec, v interface{}, opts ...Option) ([]byte, error) {
-		return []byte("null"), nil
+	if nc, ok := c.(interface {
-	} else if len(*m) == 0 {
+		MarshalAppend([]byte, interface{}, ...Option) ([]byte, error)
-		return []byte("null"), nil
+	}); ok {
+		return nc.MarshalAppend(buf, v, opts...)
 	}
-	return *m, nil
-}
 
-// UnmarshalJSON sets *m to a copy of data.
+	mbuf, err := c.Marshal(v, opts...)
-func (m *RawMessage) UnmarshalJSON(data []byte) error {
+	if err != nil {
-	if m == nil {
+		return nil, err
-		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.
+	return append(buf, mbuf...), nil
-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(data []byte) error {
-	if m == nil {
-		return errors.New("RawMessage UnmarshalYAML on nil pointer")
-	}
-	*m = append((*m)[0:0], data...)
-	return nil
 }

codec/context.go

@@ -15,15 +15,6 @@ func FromContext(ctx context.Context) (Codec, bool) {
 	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 {

codec/context_test.go

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

codec/frame.go

@@ -5,51 +5,29 @@ 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()
+	return m.Data, nil
 }
 
-// UnmarshalJSON set frame data
 func (m *Frame) UnmarshalJSON(data []byte) error {
-	return m.Unmarshal(data)
+	m.Data = data
-}
-
-// MarshalYAML returns frame data
-func (m *Frame) MarshalYAML() ([]byte, error) {
-	return m.Marshal()
-}
-
-// UnmarshalYAML set frame data
-func (m *Frame) UnmarshalYAML(data []byte) error {
-	m.Data = append((m.Data)[0:0], data...)
 	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

@@ -17,7 +17,7 @@ syntax = "proto3";
 package micro.codec;
 
 option cc_enable_arenas = true;
-option go_package = "go.unistack.org/micro/v4/codec;codec";
+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";

codec/noop.go

@@ -2,14 +2,70 @@ package codec
 
 import (
 	"encoding/json"
-
+	"io"
-	codecpb "go.unistack.org/micro-proto/v4/codec"
 )
 
 type noopCodec struct {
 	opts Options
 }
 
+func (c *noopCodec) ReadHeader(conn io.Reader, m *Message, t MessageType) error {
+	return nil
+}
+
+func (c *noopCodec) ReadBody(conn io.Reader, b interface{}) error {
+	// read bytes
+	buf, err := io.ReadAll(conn)
+	if err != nil {
+		return err
+	}
+
+	if b == nil {
+		return nil
+	}
+
+	switch v := b.(type) {
+	case *string:
+		*v = string(buf)
+	case *[]byte:
+		*v = buf
+	case *Frame:
+		v.Data = buf
+	default:
+		return json.Unmarshal(buf, v)
+	}
+
+	return nil
+}
+
+func (c *noopCodec) Write(conn io.Writer, m *Message, b interface{}) error {
+	if b == nil {
+		return nil
+	}
+
+	var v []byte
+	switch vb := b.(type) {
+	case *Frame:
+		v = vb.Data
+	case string:
+		v = []byte(vb)
+	case *string:
+		v = []byte(*vb)
+	case *[]byte:
+		v = *vb
+	case []byte:
+		v = vb
+	default:
+		var err error
+		v, err = json.Marshal(vb)
+		if err != nil {
+			return err
+		}
+	}
+	_, err := conn.Write(v)
+	return err
+}
+
 func (c *noopCodec) String() string {
 	return "noop"
 }
@@ -35,8 +91,8 @@ func (c *noopCodec) Marshal(v interface{}, opts ...Option) ([]byte, error) {
 		return ve, nil
 	case *Frame:
 		return ve.Data, nil
-	case *codecpb.Frame:
+	case *Message:
-		return ve.Data, nil
+		return ve.Body, nil
 	}
 
 	return json.Marshal(v)
@@ -50,17 +106,14 @@ func (c *noopCodec) Unmarshal(d []byte, v interface{}, opts ...Option) error {
 	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:
+	case *Message:
-		ve.Data = d
+		ve.Body = d
 		return nil
 	}
 

codec/noop_test.go

@@ -5,23 +5,9 @@ import (
 	"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
+	rsp := make([]byte, len(req))
 
 	nc := NewCodec()
 	if err := nc.Unmarshal(req, &rsp); err != nil {

codec/options.go

@@ -3,9 +3,9 @@ package codec
 import (
 	"context"
 
-	"go.unistack.org/micro/v4/logger"
+	"go.unistack.org/micro/v3/logger"
-	"go.unistack.org/micro/v4/meter"
+	"go.unistack.org/micro/v3/meter"
-	"go.unistack.org/micro/v4/tracer"
+	"go.unistack.org/micro/v3/tracer"
 )
 
 // Option func
@@ -23,8 +23,15 @@ type Options struct {
 	Context context.Context
 	// TagName specifies tag name in struct to control codec
 	TagName string
-	// Flatten specifies that struct must be analyzed for flatten tag
+	// MaxMsgSize specifies max messages size that reads by codec
-	Flatten bool
+	MaxMsgSize int
+}
+
+// MaxMsgSize sets the max message size
+func MaxMsgSize(n int) Option {
+	return func(o *Options) {
+		o.MaxMsgSize = n
+	}
 }
 
 // TagName sets the codec tag name in struct
@@ -34,13 +41,6 @@ func TagName(n string) Option {
 	}
 }
 
-// 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) {
@@ -65,12 +65,12 @@ func Meter(m meter.Meter) Option {
 // NewOptions returns new options
 func NewOptions(opts ...Option) Options {
 	options := Options{
-		Context: context.Background(),
+		Context:    context.Background(),
-		Logger:  logger.DefaultLogger,
+		Logger:     logger.DefaultLogger,
-		Meter:   meter.DefaultMeter,
+		Meter:      meter.DefaultMeter,
-		Tracer:  tracer.DefaultTracer,
+		Tracer:     tracer.DefaultTracer,
-		TagName: DefaultTagName,
+		MaxMsgSize: DefaultMaxMsgSize,
-		Flatten: false,
+		TagName:    DefaultTagName,
 	}
 
 	for _, o := range opts {

config/config.go

@@ -1,19 +1,14 @@
 // Package config is an interface for dynamic configuration.
-package config
+package config // import "go.unistack.org/micro/v3/config"
 
 import (
 	"context"
 	"errors"
-	"reflect"
 	"time"
 )
 
-type Validator interface {
-	Validate() error
-}
-
 // DefaultConfig default config
-var DefaultConfig = NewConfig()
+var DefaultConfig Config = NewConfig()
 
 // DefaultWatcherMinInterval default min interval for poll changes
 var DefaultWatcherMinInterval = 5 * time.Second
@@ -28,8 +23,6 @@ var (
 	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
@@ -50,13 +43,6 @@ type Config interface {
 	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
@@ -79,81 +65,11 @@ func Load(ctx context.Context, cs []Config, opts ...LoadOption) error {
 	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)
+				c.Options().Logger.Errorf(ctx, "%s AfterLoad err: %v", c.String(), err)
 				if !c.Options().AllowFail {
 					return err
 				}
@@ -161,29 +77,11 @@ var (
 		}
 		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)
+				c.Options().Logger.Errorf(ctx, "%s AfterSave err: %v", c.String(), err)
 				if !c.Options().AllowFail {
 					return err
 				}
@@ -191,14 +89,11 @@ var (
 		}
 		return nil
 	}
-	// DefaultBeforeInit default func that runs befora config Init
+
-	DefaultBeforeInit = func(ctx context.Context, c Config) error {
+	DefaultBeforeLoad = func(ctx context.Context, c Config) error {
-		for _, fn := range c.Options().BeforeInit {
+		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()+" BeforeInit error", err)
+				c.Options().Logger.Errorf(ctx, "%s BeforeLoad err: %v", c.String(), err)
 				if !c.Options().AllowFail {
 					return err
 				}
@@ -206,14 +101,11 @@ var (
 		}
 		return nil
 	}
-	// DefaultAfterInit default func that runs after config Init
+
-	DefaultAfterInit = func(ctx context.Context, c Config) error {
+	DefaultBeforeSave = func(ctx context.Context, c Config) error {
-		for _, fn := range c.Options().AfterSave {
+		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()+" AfterInit error", err)
+				c.Options().Logger.Errorf(ctx, "%s BeforeSavec err: %v", c.String(), err)
 				if !c.Options().AllowFail {
 					return err
 				}

config/context.go

@@ -15,15 +15,6 @@ func FromContext(ctx context.Context) (Config, bool) {
 	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 {
@@ -61,13 +52,3 @@ func SetLoadOption(k, v interface{}) LoadOption {
 		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

@@ -1,86 +0,0 @@
-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")
-	}
-}

config/default.go

@@ -2,23 +2,17 @@ package config
 
 import (
 	"context"
+	"fmt"
 	"reflect"
 	"strconv"
 	"strings"
-	"time"
 
-	"dario.cat/mergo"
+	"github.com/imdario/mergo"
-	"github.com/google/uuid"
+	rutil "go.unistack.org/micro/v3/util/reflect"
-	"go.unistack.org/micro/v4/options"
-	mid "go.unistack.org/micro/v4/util/id"
-	rutil "go.unistack.org/micro/v4/util/reflect"
-	mtime "go.unistack.org/micro/v4/util/time"
 )
 
 type defaultConfig struct {
-	funcLoad FuncLoad
+	opts Options
-	funcSave FuncSave
-	opts     Options
 }
 
 func (c *defaultConfig) Options() Options {
@@ -29,42 +23,11 @@ func (c *defaultConfig) Init(opts ...Option) error {
 	for _, o := range opts {
 		o(&c.opts)
 	}
-
-	if err := DefaultBeforeInit(c.opts.Context, c); err != nil && !c.opts.AllowFail {
-		return err
-	}
-
-	c.funcLoad = c.fnLoad
-	c.funcSave = c.fnSave
-
-	c.opts.Hooks.EachPrev(func(hook options.Hook) {
-		switch h := hook.(type) {
-		case HookLoad:
-			c.funcLoad = h(c.funcLoad)
-		case HookSave:
-			c.funcSave = h(c.funcSave)
-		}
-	})
-
-	if err := DefaultAfterInit(c.opts.Context, c); err != nil && !c.opts.AllowFail {
-		return err
-	}
-
 	return nil
 }
 
 func (c *defaultConfig) Load(ctx context.Context, opts ...LoadOption) error {
-	return c.funcLoad(ctx, opts...)
+	if err := DefaultBeforeLoad(ctx, c); err != nil {
-}
-
-func (c *defaultConfig) fnLoad(ctx context.Context, opts ...LoadOption) error {
-	var err error
-
-	if c.opts.SkipLoad != nil && c.opts.SkipLoad(ctx, c) {
-		return nil
-	}
-
-	if err = DefaultBeforeLoad(ctx, c); err != nil && !c.opts.AllowFail {
 		return err
 	}
 
@@ -87,20 +50,21 @@ func (c *defaultConfig) fnLoad(ctx context.Context, opts ...LoadOption) error {
 		if !c.opts.AllowFail {
 			return err
 		}
-		if err = DefaultAfterLoad(ctx, c); err != nil && !c.opts.AllowFail {
+		return DefaultAfterLoad(ctx, c)
-			return err
-		}
 	}
 
 	if err = fillValues(reflect.ValueOf(src), c.opts.StructTag); err == nil {
 		err = mergo.Merge(dst, src, mopts...)
 	}
 
-	if err != nil && !c.opts.AllowFail {
+	if err != nil {
-		return err
+		c.opts.Logger.Errorf(ctx, "default load error: %v", err)
+		if !c.opts.AllowFail {
+			return err
+		}
 	}
 
-	if err := DefaultAfterLoad(ctx, c); err != nil && !c.opts.AllowFail {
+	if err := DefaultAfterLoad(ctx, c); err != nil {
 		return err
 	}
 
@@ -112,7 +76,6 @@ func fillValue(value reflect.Value, val string) error {
 	if !rutil.IsEmpty(value) {
 		return nil
 	}
-
 	switch value.Kind() {
 	case reflect.Map:
 		t := value.Type()
@@ -151,20 +114,6 @@ func fillValue(value reflect.Value, val string) error {
 		}
 		value.Set(reflect.ValueOf(v))
 	case reflect.String:
-		switch val {
-		case "micro:generate uuid":
-			uid, err := uuid.NewRandom()
-			if err != nil {
-				return err
-			}
-			val = uid.String()
-		case "micro:generate id":
-			uid, err := mid.New()
-			if err != nil {
-				return err
-			}
-			val = uid
-		}
 		value.Set(reflect.ValueOf(val))
 	case reflect.Float32:
 		v, err := strconv.ParseFloat(val, 32)
@@ -203,26 +152,11 @@ func fillValue(value reflect.Value, val string) error {
 		}
 		value.Set(reflect.ValueOf(int32(v)))
 	case reflect.Int64:
-		switch {
+		v, err := strconv.ParseInt(val, 10, 64)
-		case value.Type().String() == "time.Duration" && value.Type().PkgPath() == "time":
+		if err != nil {
-			v, err := time.ParseDuration(val)
+			return err
-			if err != nil {
-				return err
-			}
-			value.Set(reflect.ValueOf(v))
-		case value.Type().String() == "time.Duration" && value.Type().PkgPath() == "go.unistack.org/micro/v4/util/time":
-			v, err := mtime.ParseDuration(val)
-			if err != nil {
-				return err
-			}
-			value.SetInt(int64(v))
-		default:
-			v, err := strconv.ParseInt(val, 10, 64)
-			if err != nil {
-				return err
-			}
-			value.Set(reflect.ValueOf(v))
 		}
+		value.Set(reflect.ValueOf(v))
 	case reflect.Uint:
 		v, err := strconv.ParseUint(val, 10, 0)
 		if err != nil {
@@ -254,7 +188,6 @@ func fillValue(value reflect.Value, val string) error {
 		}
 		value.Set(reflect.ValueOf(v))
 	}
-
 	return nil
 }
 
@@ -318,14 +251,6 @@ func fillValues(valueOf reflect.Value, tname string) error {
 }
 
 func (c *defaultConfig) Save(ctx context.Context, opts ...SaveOption) error {
-	return c.funcSave(ctx, opts...)
-}
-
-func (c *defaultConfig) fnSave(ctx context.Context, opts ...SaveOption) error {
-	if c.opts.SkipSave != nil && c.opts.SkipSave(ctx, c) {
-		return nil
-	}
-
 	if err := DefaultBeforeSave(ctx, c); err != nil {
 		return err
 	}
@@ -345,8 +270,8 @@ func (c *defaultConfig) Name() string {
 	return c.opts.Name
 }
 
-func (c *defaultConfig) Watch(_ context.Context, _ ...WatchOption) (Watcher, error) {
+func (c *defaultConfig) Watch(ctx context.Context, opts ...WatchOption) (Watcher, error) {
-	return nil, ErrWatcherNotImplemented
+	return nil, fmt.Errorf("not implemented")
 }
 
 // NewConfig returns new default config source
@@ -355,9 +280,5 @@ func NewConfig(opts ...Option) Config {
 	if len(options.StructTag) == 0 {
 		options.StructTag = "default"
 	}
-	c := &defaultConfig{opts: options}
+	return &defaultConfig{opts: options}
-	c.funcLoad = c.fnLoad
-	c.funcSave = c.fnSave
-
-	return c
 }

config/default_test.go

@@ -3,90 +3,35 @@ package config_test
 import (
 	"context"
 	"fmt"
-	"reflect"
 	"testing"
-	"time"
 
-	"go.unistack.org/micro/v4/config"
+	"go.unistack.org/micro/v3/config"
-	mtime "go.unistack.org/micro/v4/util/time"
 )
 
-type cfg struct {
+type Cfg struct {
-	MapValue    map[string]bool `default:"key1=true,key2=false"`
-	StructValue *cfgStructValue
-
 	StringValue string `default:"string_value"`
 	IgnoreValue string `json:"-"`
-	UUIDValue   string `default:"micro:generate uuid"`
+	StructValue struct {
-	IDValue     string `default:"micro:generate id"`
+		StringValue string `default:"string_value"`
-
-	DurationValue  time.Duration  `default:"10s"`
-	MDurationValue mtime.Duration `default:"10s"`
-	IntValue       int            `default:"99"`
-}
-
-type cfgStructValue struct {
-	StringValue string `default:"string_value"`
-}
-
-func (c *cfg) Validate() error {
-	if c.IntValue != 10 {
-		return fmt.Errorf("invalid IntValue %d != %d", 10, c.IntValue)
-	}
-	return nil
-}
-
-func (c *cfgStructValue) Validate() error {
-	if c.StringValue != "string_value" {
-		return fmt.Errorf("invalid StringValue %s != %s", "string_value", c.StringValue)
-	}
-	return nil
-}
-
-type testHook struct {
-	f bool
-}
-
-func (t *testHook) Load(fn config.FuncLoad) config.FuncLoad {
-	return func(ctx context.Context, opts ...config.LoadOption) error {
-		t.f = true
-		return fn(ctx, opts...)
-	}
-}
-
-func TestHook(t *testing.T) {
-	h := &testHook{}
-
-	c := config.NewConfig(config.Struct(h), config.Hooks(config.HookLoad(h.Load)))
-
-	if err := c.Init(); err != nil {
-		t.Fatal(err)
-	}
-
-	if err := c.Load(context.TODO()); err != nil {
-		t.Fatal(err)
-	}
-
-	if !h.f {
-		t.Fatal("hook not works")
 	}
+	IntValue int `default:"99"`
 }
 
 func TestDefault(t *testing.T) {
 	ctx := context.Background()
-	conf := &cfg{IntValue: 10}
+	conf := &Cfg{IntValue: 10}
-	blfn := func(_ context.Context, c config.Config) error {
+	blfn := func(ctx context.Context, cfg config.Config) error {
-		nconf, ok := c.Options().Struct.(*cfg)
+		nconf, ok := cfg.Options().Struct.(*Cfg)
 		if !ok {
-			return fmt.Errorf("failed to get Struct from options: %v", c.Options())
+			return fmt.Errorf("failed to get Struct from options: %v", cfg.Options())
 		}
 		nconf.StringValue = "before_load"
 		return nil
 	}
-	alfn := func(_ context.Context, c config.Config) error {
+	alfn := func(ctx context.Context, cfg config.Config) error {
-		nconf, ok := c.Options().Struct.(*cfg)
+		nconf, ok := cfg.Options().Struct.(*Cfg)
 		if !ok {
-			return fmt.Errorf("failed to get Struct from options: %v", c.Options())
+			return fmt.Errorf("failed to get Struct from options: %v", cfg.Options())
 		}
 		nconf.StringValue = "after_load"
 		return nil
@@ -102,45 +47,6 @@ func TestDefault(t *testing.T) {
 	if conf.StringValue != "after_load" {
 		t.Fatal("AfterLoad option not working")
 	}
-	if len(conf.MapValue) != 2 {
-		t.Fatalf("map value invalid: %#+v\n", conf.MapValue)
-	}
-
-	if conf.UUIDValue == "" {
-		t.Fatalf("uuid value empty")
-	} else if len(conf.UUIDValue) != 36 {
-		t.Fatalf("uuid value invalid: %s", conf.UUIDValue)
-	}
-
-	if conf.IDValue == "" {
-		t.Fatalf("id value empty")
-	}
 	_ = conf
 	// t.Logf("%#+v\n", conf)
 }
-
-func TestValidate(t *testing.T) {
-	ctx := context.Background()
-	conf := &cfg{IntValue: 10}
-	cfg := config.NewConfig(config.Struct(conf))
-	if err := cfg.Init(); err != nil {
-		t.Fatal(err)
-	}
-	if err := cfg.Load(ctx); err != nil {
-		t.Fatal(err)
-	}
-
-	if err := config.Validate(ctx, conf); err != nil {
-		t.Fatal(err)
-	}
-}
-
-func Test_SizeOf(t *testing.T) {
-	st := cfg{}
-
-	tVal := reflect.TypeOf(st)
-	for i := 0; i < tVal.NumField(); i++ {
-		field := tVal.Field(i)
-		fmt.Printf("Field: %s, Offset: %d, Size: %d\n", field.Name, field.Offset, field.Type.Size())
-	}
-}

config/options.go

@@ -4,11 +4,10 @@ import (
 	"context"
 	"time"
 
-	"go.unistack.org/micro/v4/codec"
+	"go.unistack.org/micro/v3/codec"
-	"go.unistack.org/micro/v4/logger"
+	"go.unistack.org/micro/v3/logger"
-	"go.unistack.org/micro/v4/meter"
+	"go.unistack.org/micro/v3/meter"
-	"go.unistack.org/micro/v4/options"
+	"go.unistack.org/micro/v3/tracer"
-	"go.unistack.org/micro/v4/tracer"
 )
 
 // Options hold the config options
@@ -29,26 +28,14 @@ type Options struct {
 	Name string
 	// StructTag name
 	StructTag string
-	// BeforeSave contains slice of funcs that runs before Save
+	// BeforeSave contains slice of funcs that runs before save
 	BeforeSave []func(context.Context, Config) error
-	// AfterSave contains slice of funcs that runs after Save
+	// AfterLoad contains slice of funcs that runs after load
-	AfterSave []func(context.Context, Config) error
-	// BeforeLoad contains slice of funcs that runs before Load
-	BeforeLoad []func(context.Context, Config) error
-	// AfterLoad contains slice of funcs that runs after Load
 	AfterLoad []func(context.Context, Config) error
-	// BeforeInit contains slice of funcs that runs before Init
+	// BeforeLoad contains slice of funcs that runs before load
-	BeforeInit []func(context.Context, Config) error
+	BeforeLoad []func(context.Context, Config) error
-	// AfterInit contains slice of funcs that runs after Init
+	// AfterSave contains slice of funcs that runs after save
-	AfterInit []func(context.Context, Config) error
+	AfterSave []func(context.Context, Config) error
-
-	// SkipLoad runs only if condition returns true
-	SkipLoad func(context.Context, Config) bool
-	// SkipSave runs only if condition returns true
-	SkipSave func(context.Context, Config) bool
-	// Hooks can be run before/after config Save/Load
-	Hooks options.Hooks
-
 	// AllowFail flag to allow fail in config source
 	AllowFail bool
 }
@@ -77,12 +64,11 @@ type LoadOption func(o *LoadOptions)
 // LoadOptions struct
 type LoadOptions struct {
 	Struct   interface{}
-	Context  context.Context
 	Override bool
 	Append   bool
+	Context  context.Context
 }
 
-// NewLoadOptions create LoadOptions struct with provided opts
 func NewLoadOptions(opts ...LoadOption) LoadOptions {
 	options := LoadOptions{}
 	for _, o := range opts {
@@ -144,20 +130,6 @@ func AllowFail(b bool) Option {
 	}
 }
 
-// BeforeInit run funcs before config Init
-func BeforeInit(fn ...func(context.Context, Config) error) Option {
-	return func(o *Options) {
-		o.BeforeInit = fn
-	}
-}
-
-// AfterInit run funcs after config Init
-func AfterInit(fn ...func(context.Context, Config) error) Option {
-	return func(o *Options) {
-		o.AfterInit = fn
-	}
-}
-
 // BeforeLoad run funcs before config load
 func BeforeLoad(fn ...func(context.Context, Config) error) Option {
 	return func(o *Options) {
@@ -249,10 +221,8 @@ type WatchOptions struct {
 	Coalesce bool
 }
 
-// WatchOption func signature
 type WatchOption func(*WatchOptions)
 
-// NewWatchOptions create WatchOptions struct with provided opts
 func NewWatchOptions(opts ...WatchOption) WatchOptions {
 	options := WatchOptions{
 		Context:     context.Background(),
@@ -280,10 +250,10 @@ func WatchCoalesce(b bool) WatchOption {
 }
 
 // WatchInterval specifies min and max time.Duration for pulling changes
-func WatchInterval(minTime, maxTime time.Duration) WatchOption {
+func WatchInterval(min, max time.Duration) WatchOption {
 	return func(o *WatchOptions) {
-		o.MinInterval = minTime
+		o.MinInterval = min
-		o.MaxInterval = maxTime
+		o.MaxInterval = max
 	}
 }
 
@@ -293,10 +263,3 @@ func WatchStruct(src interface{}) WatchOption {
 		o.Struct = src
 	}
 }
-
-// Hooks sets hook runs before action
-func Hooks(h ...options.Hook) Option {
-	return func(o *Options) {
-		o.Hooks = append(o.Hooks, h...)
-	}
-}

context_test.go

@@ -1,24 +0,0 @@
-package micro
-
-import (
-	"context"
-	"testing"
-)
-
-func TestFromContext(t *testing.T) {
-	ctx := context.WithValue(context.TODO(), serviceKey{}, NewService())
-
-	c, ok := FromContext(ctx)
-	if c == nil || !ok {
-		t.Fatal("FromContext not works")
-	}
-}
-
-func TestNewContext(t *testing.T) {
-	ctx := NewContext(context.TODO(), NewService())
-
-	c, ok := FromContext(ctx)
-	if c == nil || !ok {
-		t.Fatal("NewContext not works")
-	}
-}

database/dsn.go

@@ -1,157 +0,0 @@
-package database
-
-import (
-	"crypto/tls"
-	"errors"
-	"fmt"
-	"net/url"
-	"strings"
-)
-
-var (
-	ErrInvalidDSNAddr      = errors.New("invalid dsn addr")
-	ErrInvalidDSNUnescaped = errors.New("dsn must be escaped")
-	ErrInvalidDSNNoSlash   = errors.New("dsn must contains slash")
-)
-
-type Config struct {
-	TLSConfig *tls.Config
-	Username  string
-	Password  string
-	Scheme    string
-	Host      string
-	Port      string
-	Database  string
-	Params    []string
-}
-
-func (cfg *Config) FormatDSN() string {
-	var s strings.Builder
-
-	if len(cfg.Scheme) > 0 {
-		s.WriteString(cfg.Scheme + "://")
-	}
-	// [username[:password]@]
-	if len(cfg.Username) > 0 {
-		s.WriteString(cfg.Username)
-		if len(cfg.Password) > 0 {
-			s.WriteByte(':')
-			s.WriteString(url.PathEscape(cfg.Password))
-		}
-		s.WriteByte('@')
-	}
-
-	// [host:port]
-	if len(cfg.Host) > 0 {
-		s.WriteString(cfg.Host)
-		if len(cfg.Port) > 0 {
-			s.WriteByte(':')
-			s.WriteString(cfg.Port)
-		}
-	}
-
-	// /dbname
-	s.WriteByte('/')
-	s.WriteString(url.PathEscape(cfg.Database))
-
-	for i := 0; i < len(cfg.Params); i += 2 {
-		if i == 0 {
-			s.WriteString("?")
-		} else {
-			s.WriteString("&")
-		}
-		s.WriteString(cfg.Params[i])
-		s.WriteString("=")
-		s.WriteString(cfg.Params[i+1])
-	}
-
-	return s.String()
-}
-
-func ParseDSN(dsn string) (*Config, error) {
-	cfg := &Config{}
-
-	// [user[:password]@][net[(addr)]]/dbname[?param1=value1&paramN=valueN]
-	// Find last '/' that goes before dbname
-	foundSlash := false
-	for i := len(dsn) - 1; i >= 0; i-- {
-		if dsn[i] == '/' {
-			foundSlash = true
-			var j, k int
-
-			// left part is empty if i <= 0
-			if i > 0 {
-				// Find the first ':' in dsn
-				for j = i; j >= 0; j-- {
-					if dsn[j] == ':' {
-						cfg.Scheme = dsn[0:j]
-					}
-				}
-
-				// [username[:password]@][host]
-				// Find the last '@' in dsn[:i]
-				for j = i; j >= 0; j-- {
-					if dsn[j] == '@' {
-						// username[:password]
-						// Find the second ':' in dsn[:j]
-						for k = 0; k < j; k++ {
-							if dsn[k] == ':' {
-								if cfg.Scheme == dsn[:k] {
-									continue
-								}
-								var err error
-								cfg.Password, err = url.PathUnescape(dsn[k+1 : j])
-								if err != nil {
-									return nil, err
-								}
-								break
-							}
-						}
-						cfg.Username = dsn[len(cfg.Scheme)+3 : k]
-						break
-					}
-				}
-
-				for k = j + 1; k < i; k++ {
-					if dsn[k] == ':' {
-						cfg.Host = dsn[j+1 : k]
-						cfg.Port = dsn[k+1 : i]
-						break
-					}
-				}
-
-			}
-
-			// dbname[?param1=value1&...&paramN=valueN]
-			// Find the first '?' in dsn[i+1:]
-			for j = i + 1; j < len(dsn); j++ {
-				if dsn[j] == '?' {
-					parts := strings.Split(dsn[j+1:], "&")
-					cfg.Params = make([]string, 0, len(parts)*2)
-					for _, p := range parts {
-						k, v, found := strings.Cut(p, "=")
-						if !found {
-							continue
-						}
-						cfg.Params = append(cfg.Params, k, v)
-					}
-
-					break
-				}
-			}
-			var err error
-			dbname := dsn[i+1 : j]
-			if cfg.Database, err = url.PathUnescape(dbname); err != nil {
-				return nil, fmt.Errorf("invalid dbname %q: %w", dbname, err)
-			}
-
-			break
-		}
-	}
-
-	if !foundSlash && len(dsn) > 0 {
-		return nil, ErrInvalidDSNNoSlash
-	}
-
-	return cfg, nil
-}

database/dsn_test.go

@@ -1,31 +0,0 @@
-package database
-
-import (
-	"net/url"
-	"testing"
-)
-
-func TestParseDSN(t *testing.T) {
-	cfg, err := ParseDSN("postgres://username:p@ssword#@host:12345/dbname?key1=val2&key2=val2")
-	if err != nil {
-		t.Fatal(err)
-	}
-	if cfg.Password != "p@ssword#" {
-		t.Fatalf("parsing error")
-	}
-}
-
-func TestFormatDSN(t *testing.T) {
-	src := "postgres://username:p@ssword#@host:12345/dbname?key1=val2&key2=val2"
-	cfg, err := ParseDSN(src)
-	if err != nil {
-		t.Fatal(err)
-	}
-	dst, err := url.PathUnescape(cfg.FormatDSN())
-	if err != nil {
-		t.Fatal(err)
-	}
-	if src != dst {
-		t.Fatalf("\n%s\n%s", src, dst)
-	}
-}

errors/errors.go

@@ -1,20 +1,11 @@
 // Package errors provides a way to return detailed information
 // for an RPC request error. The error is normally JSON encoded.
-package errors
+package errors // import "go.unistack.org/micro/v3/errors"
 
 import (
-	"bytes"
-	"context"
 	"encoding/json"
-	"errors"
 	"fmt"
-	"io"
 	"net/http"
-	"strconv"
-	"strings"
-
-	"google.golang.org/grpc/codes"
-	"google.golang.org/grpc/status"
 )
 
 var (
@@ -44,20 +35,6 @@ var (
 	ErrGatewayTimeout = &Error{Code: 504}
 )
 
-const ProblemContentType = "application/problem+json"
-
-type Problem struct {
-	Type     string `json:"type,omitempty"`
-	Title    string `json:"title,omitempty"`
-	Detail   string `json:"detail,omitempty"`
-	Instance string `json:"instance,omitempty"`
-	Errors   []struct {
-		Title  string `json:"title,omitempty"`
-		Detail string `json:"detail,omitempty"`
-	} `json:"errors,omitempty"`
-	Status int `json:"status,omitempty"`
-}
-
 // Error type
 type Error struct {
 	// ID holds error id or service, usually someting like my_service or id
@@ -76,22 +53,6 @@ func (e *Error) Error() string {
 	return string(b)
 }
 
-/*
-// Generator struct holds id of error
-type Generator struct {
-	id string
-}
-
-// Generator can emit new error with static id
-func NewGenerator(id string) *Generator {
-	return &Generator{id: id}
-}
-
-func (g *Generator) BadRequest(format string, args ...interface{}) error {
-	return BadRequest(g.id, format, args...)
-}
-*/
-
 // New generates a custom error
 func New(id, detail string, code int32) error {
 	return &Error{
@@ -105,130 +66,130 @@ func New(id, detail string, code int32) error {
 // Parse tries to parse a JSON string into an error. If that
 // fails, it will set the given string as the error detail.
 func Parse(err string) *Error {
-	e := &Error{}
+	e := new(Error)
-	nerr := json.Unmarshal([]byte(err), e)
+	errr := json.Unmarshal([]byte(err), e)
-	if nerr != nil {
+	if errr != nil {
 		e.Detail = err
 	}
 	return e
 }
 
 // BadRequest generates a 400 error.
-func BadRequest(id, format string, args ...interface{}) error {
+func BadRequest(id, format string, a ...interface{}) error {
 	return &Error{
 		ID:     id,
 		Code:   400,
-		Detail: fmt.Sprintf(format, args...),
+		Detail: fmt.Sprintf(format, a...),
 		Status: http.StatusText(400),
 	}
 }
 
 // Unauthorized generates a 401 error.
-func Unauthorized(id, format string, args ...interface{}) error {
+func Unauthorized(id, format string, a ...interface{}) error {
 	return &Error{
 		ID:     id,
 		Code:   401,
-		Detail: fmt.Sprintf(format, args...),
+		Detail: fmt.Sprintf(format, a...),
 		Status: http.StatusText(401),
 	}
 }
 
 // Forbidden generates a 403 error.
-func Forbidden(id, format string, args ...interface{}) error {
+func Forbidden(id, format string, a ...interface{}) error {
 	return &Error{
 		ID:     id,
 		Code:   403,
-		Detail: fmt.Sprintf(format, args...),
+		Detail: fmt.Sprintf(format, a...),
 		Status: http.StatusText(403),
 	}
 }
 
 // NotFound generates a 404 error.
-func NotFound(id, format string, args ...interface{}) error {
+func NotFound(id, format string, a ...interface{}) error {
 	return &Error{
 		ID:     id,
 		Code:   404,
-		Detail: fmt.Sprintf(format, args...),
+		Detail: fmt.Sprintf(format, a...),
 		Status: http.StatusText(404),
 	}
 }
 
 // MethodNotAllowed generates a 405 error.
-func MethodNotAllowed(id, format string, args ...interface{}) error {
+func MethodNotAllowed(id, format string, a ...interface{}) error {
 	return &Error{
 		ID:     id,
 		Code:   405,
-		Detail: fmt.Sprintf(format, args...),
+		Detail: fmt.Sprintf(format, a...),
 		Status: http.StatusText(405),
 	}
 }
 
 // Timeout generates a 408 error.
-func Timeout(id, format string, args ...interface{}) error {
+func Timeout(id, format string, a ...interface{}) error {
 	return &Error{
 		ID:     id,
 		Code:   408,
-		Detail: fmt.Sprintf(format, args...),
+		Detail: fmt.Sprintf(format, a...),
 		Status: http.StatusText(408),
 	}
 }
 
 // Conflict generates a 409 error.
-func Conflict(id, format string, args ...interface{}) error {
+func Conflict(id, format string, a ...interface{}) error {
 	return &Error{
 		ID:     id,
 		Code:   409,
-		Detail: fmt.Sprintf(format, args...),
+		Detail: fmt.Sprintf(format, a...),
 		Status: http.StatusText(409),
 	}
 }
 
 // InternalServerError generates a 500 error.
-func InternalServerError(id, format string, args ...interface{}) error {
+func InternalServerError(id, format string, a ...interface{}) error {
 	return &Error{
 		ID:     id,
 		Code:   500,
-		Detail: fmt.Sprintf(format, args...),
+		Detail: fmt.Sprintf(format, a...),
 		Status: http.StatusText(500),
 	}
 }
 
 // NotImplemented generates a 501 error
-func NotImplemented(id, format string, args ...interface{}) error {
+func NotImplemented(id, format string, a ...interface{}) error {
 	return &Error{
 		ID:     id,
 		Code:   501,
-		Detail: fmt.Sprintf(format, args...),
+		Detail: fmt.Sprintf(format, a...),
 		Status: http.StatusText(501),
 	}
 }
 
 // BadGateway generates a 502 error
-func BadGateway(id, format string, args ...interface{}) error {
+func BadGateway(id, format string, a ...interface{}) error {
 	return &Error{
 		ID:     id,
 		Code:   502,
-		Detail: fmt.Sprintf(format, args...),
+		Detail: fmt.Sprintf(format, a...),
 		Status: http.StatusText(502),
 	}
 }
 
 // ServiceUnavailable generates a 503 error
-func ServiceUnavailable(id, format string, args ...interface{}) error {
+func ServiceUnavailable(id, format string, a ...interface{}) error {
 	return &Error{
 		ID:     id,
 		Code:   503,
-		Detail: fmt.Sprintf(format, args...),
+		Detail: fmt.Sprintf(format, a...),
 		Status: http.StatusText(503),
 	}
 }
 
 // GatewayTimeout generates a 504 error
-func GatewayTimeout(id, format string, args ...interface{}) error {
+func GatewayTimeout(id, format string, a ...interface{}) error {
 	return &Error{
 		ID:     id,
 		Code:   504,
-		Detail: fmt.Sprintf(format, args...),
+		Detail: fmt.Sprintf(format, a...),
 		Status: http.StatusText(504),
 	}
 }
@@ -253,246 +214,11 @@ func Equal(err1 error, err2 error) bool {
 	return true
 }
 
-// CodeIn return true if err has specified code
-func CodeIn(err interface{}, codes ...int32) bool {
-	var code int32
-	switch verr := err.(type) {
-	case *Error:
-		code = verr.Code
-	case int32:
-		code = verr
-	default:
-		return false
-	}
-
-	for _, check := range codes {
-		if code == check {
-			return true
-		}
-	}
-
-	return false
-}
-
 // FromError try to convert go error to *Error
 func FromError(err error) *Error {
-	if err == nil {
-		return nil
-	}
-
 	if verr, ok := err.(*Error); ok && verr != nil {
 		return verr
 	}
 
 	return Parse(err.Error())
 }
-
-// MarshalJSON returns error data
-func (e *Error) MarshalJSON() ([]byte, error) {
-	return e.Marshal()
-}
-
-// UnmarshalJSON set error data
-func (e *Error) UnmarshalJSON(data []byte) error {
-	return e.Unmarshal(data)
-}
-
-// ProtoMessage noop func
-func (e *Error) ProtoMessage() {}
-
-// Reset resets error
-func (e *Error) Reset() {
-	*e = Error{}
-}
-
-// String returns error as string
-func (e *Error) String() string {
-	return fmt.Sprintf(`{"id":"%s","detail":"%s","status":"%s","code":%d}`, addslashes(e.ID), addslashes(e.Detail), addslashes(e.Status), e.Code)
-}
-
-// Marshal returns error data
-func (e *Error) Marshal() ([]byte, error) {
-	return []byte(e.String()), nil
-}
-
-// Unmarshal set error data
-func (e *Error) Unmarshal(data []byte) error {
-	str := string(data)
-	if len(data) < 41 {
-		return fmt.Errorf("invalid data")
-	}
-	parts := strings.FieldsFunc(str[1:len(str)-1], func(r rune) bool {
-		return r == ','
-	})
-	for _, part := range parts {
-		nparts := strings.FieldsFunc(part, func(r rune) bool {
-			return r == ':'
-		})
-		for idx := 0; idx < len(nparts)/2; idx += 2 {
-			val := strings.Trim(nparts[idx+1], `"`)
-			if len(val) == 0 {
-				continue
-			}
-			switch {
-			case nparts[idx] == `"id"`:
-				e.ID = val
-			case nparts[idx] == `"detail"`:
-				e.Detail = val
-			case nparts[idx] == `"status"`:
-				e.Status = val
-			case nparts[idx] == `"code"`:
-				c, err := strconv.ParseInt(val, 10, 32)
-				if err != nil {
-					return err
-				}
-				e.Code = int32(c)
-			}
-			idx++
-		}
-	}
-	return nil
-}
-
-func addslashes(str string) string {
-	var buf bytes.Buffer
-	for _, char := range str {
-		switch char {
-		case '\'', '"', '\\':
-			buf.WriteRune('\\')
-		}
-		buf.WriteRune(char)
-	}
-	return buf.String()
-}
-
-type retryableError struct {
-	err error
-}
-
-// Retryable returns error that can be retried later
-func Retryable(err error) error {
-	return &retryableError{err: err}
-}
-
-type IsRetryableFunc func(error) bool
-
-var (
-	RetrayableOracleErrors = []IsRetryableFunc{
-		func(err error) bool {
-			errmsg := err.Error()
-			switch {
-			case strings.Contains(errmsg, `ORA-`):
-				return true
-			case strings.Contains(errmsg, `can not assign`):
-				return true
-			case strings.Contains(errmsg, `can't assign`):
-				return true
-			}
-			return false
-		},
-	}
-	RetrayablePostgresErrors = []IsRetryableFunc{
-		func(err error) bool {
-			errmsg := err.Error()
-			switch {
-			case strings.Contains(errmsg, `number of field descriptions must equal number of`):
-				return true
-			case strings.Contains(errmsg, `not a pointer`):
-				return true
-			case strings.Contains(errmsg, `values, but dst struct has only`):
-				return true
-			case strings.Contains(errmsg, `struct doesn't have corresponding row field`):
-				return true
-			case strings.Contains(errmsg, `cannot find field`):
-				return true
-			case strings.Contains(errmsg, `cannot scan`) || strings.Contains(errmsg, `cannot convert`):
-				return true
-			case strings.Contains(errmsg, `failed to connect to`):
-				return true
-			}
-			return false
-		},
-	}
-	RetryableMicroErrors = []IsRetryableFunc{
-		func(err error) bool {
-			switch verr := err.(type) {
-			case *Error:
-				switch verr.Code {
-				case 401, 403, 408, 500, 501, 502, 503, 504:
-					return true
-				default:
-					return false
-				}
-			case *retryableError:
-				return true
-			}
-			return false
-		},
-	}
-	RetryableGoErrors = []IsRetryableFunc{
-		func(err error) bool {
-			switch verr := err.(type) {
-			case interface{ SafeToRetry() bool }:
-				return verr.SafeToRetry()
-			case interface{ Timeout() bool }:
-				return verr.Timeout()
-			}
-			switch {
-			case errors.Is(err, io.EOF), errors.Is(err, io.ErrUnexpectedEOF):
-				return true
-			case errors.Is(err, context.DeadlineExceeded):
-				return true
-			case errors.Is(err, io.ErrClosedPipe), errors.Is(err, io.ErrShortBuffer), errors.Is(err, io.ErrShortWrite):
-				return true
-			}
-			return false
-		},
-	}
-	RetryableGrpcErrors = []IsRetryableFunc{
-		func(err error) bool {
-			st, ok := status.FromError(err)
-			if !ok {
-				return false
-			}
-			switch st.Code() {
-			case codes.Unavailable, codes.ResourceExhausted:
-				return true
-			case codes.DeadlineExceeded:
-				return true
-			case codes.Internal:
-				switch {
-				case strings.Contains(st.Message(), `transport: received the unexpected content-type "text/html; charset=UTF-8"`):
-					return true
-				case strings.Contains(st.Message(), io.ErrUnexpectedEOF.Error()):
-					return true
-				case strings.Contains(st.Message(), `stream terminated by RST_STREAM with error code: INTERNAL_ERROR`):
-					return true
-				}
-			}
-			return false
-		},
-	}
-)
-
-// Unwrap provides error wrapping
-func (e *retryableError) Unwrap() error {
-	return e.err
-}
-
-// Error returns the error string
-func (e *retryableError) Error() string {
-	if e.err == nil {
-		return ""
-	}
-	return e.err.Error()
-}
-
-// IsRetryable checks error for ability to retry later
-func IsRetryable(err error, fns ...IsRetryableFunc) bool {
-	for _, fn := range fns {
-		if ok := fn(err); ok {
-			return true
-		}
-	}
-	return false
-}

errors/errors.proto

@@ -1,31 +0,0 @@
-// 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.errors;
-
-option cc_enable_arenas = true;
-option go_package = "go.unistack.org/micro/v4/errors;errors";
-option java_multiple_files = true;
-option java_outer_classname = "MicroErrors";
-option java_package = "micro.errors";
-option objc_class_prefix = "MERRORS";
-
-message Error {
-  string id = 1;
-  string detail = 2;
-  string status = 3;
-  uint32 code = 4;
-}

errors/errors_test.go

@@ -1,48 +1,18 @@
 package errors
 
 import (
-	"encoding/json"
+	er "errors"
-	"errors"
-	"fmt"
 	"net/http"
 	"testing"
 )
 
-func TestIsRetrayable(t *testing.T) {
-	err := fmt.Errorf("ORA-")
-	if !IsRetryable(err, RetrayableOracleErrors...) {
-		t.Fatalf("IsRetrayable not works")
-	}
-}
-
-func TestMarshalJSON(t *testing.T) {
-	e := InternalServerError("id", "err: %v", fmt.Errorf("err: %v", `xxx: "UNIX_TIMESTAMP": invalid identifier`))
-	_, err := json.Marshal(e)
-	if err != nil {
-		t.Fatal(err)
-	}
-}
-
-func TestEmpty(t *testing.T) {
-	msg := "test"
-	var err *Error
-	err = FromError(errors.New(msg))
-	if err.Detail != msg {
-		t.Fatalf("invalid error %v", err)
-	}
-	err = FromError(fmt.Errorf(`{"id":"","detail":"%s","status":"%s","code":0}`, msg, msg))
-	if err.Detail != msg || err.Status != msg {
-		t.Fatalf("invalid error %#+v", err)
-	}
-}
-
 func TestFromError(t *testing.T) {
 	err := NotFound("go.micro.test", "%s", "example")
 	merr := FromError(err)
 	if merr.ID != "go.micro.test" || merr.Code != 404 {
 		t.Fatalf("invalid conversation %v != %v", err, merr)
 	}
-	err = errors.New(err.Error())
+	err = er.New(err.Error())
 	merr = FromError(err)
 	if merr.ID != "go.micro.test" || merr.Code != 404 {
 		t.Fatalf("invalid conversation %v != %v", err, merr)
@@ -57,7 +27,7 @@ func TestEqual(t *testing.T) {
 		t.Fatal("errors must be equal")
 	}
 
-	err3 := errors.New("my test err")
+	err3 := er.New("my test err")
 	if Equal(err1, err3) {
 		t.Fatal("errors must be not equal")
 	}
@@ -103,19 +73,3 @@ func TestErrors(t *testing.T) {
 		}
 	}
 }
-
-func TestCodeIn(t *testing.T) {
-	err := InternalServerError("id", "%s", "msg")
-
-	if ok := CodeIn(err, 400, 500); !ok {
-		t.Fatalf("CodeIn not works: %v", err)
-	}
-
-	if ok := CodeIn(err.(*Error).Code, 500); !ok {
-		t.Fatalf("CodeIn not works: %v", err)
-	}
-
-	if ok := CodeIn(err, 100); ok {
-		t.Fatalf("CodeIn not works: %v", err)
-	}
-}

event.go

@@ -0,0 +1,27 @@
+package micro
+
+import (
+	"context"
+
+	"go.unistack.org/micro/v3/client"
+)
+
+// Event is used to publish messages to a topic
+type Event interface {
+	// Publish publishes a message to the event topic
+	Publish(ctx context.Context, msg interface{}, opts ...client.PublishOption) error
+}
+
+type event struct {
+	c     client.Client
+	topic string
+}
+
+// NewEvent creates a new event publisher
+func NewEvent(topic string, c client.Client) Event {
+	return &event{c, topic}
+}
+
+func (e *event) Publish(ctx context.Context, msg interface{}, opts ...client.PublishOption) error {
+	return e.c.Publish(ctx, e.c.NewMessage(e.topic, msg), opts...)
+}

flow/context_test.go

@@ -1,55 +0,0 @@
-//go:build ignore
-
-package flow
-
-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, NewFlow())
-
-	c, ok := FromContext(ctx)
-	if c == nil || !ok {
-		t.Fatal("NewContext not works")
-	}
-}
-
-func TestFromContext(t *testing.T) {
-	ctx := context.WithValue(context.TODO(), flowKey{}, NewFlow())
-
-	c, ok := FromContext(ctx)
-	if c == nil || !ok {
-		t.Fatal("FromContext not works")
-	}
-}
-
-func TestNewContext(t *testing.T) {
-	ctx := NewContext(context.TODO(), NewFlow())
-
-	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")
-	}
-}