fixup coverage job

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

.github/ISSUE_TEMPLATE/bug_report.md

@@ -1,6 +1,6 @@
 ---
 name: Bug report
-about: For reporting bugs in go-micro
+about: For reporting bugs in micro
 title: "[BUG]"
 labels: ''
 assignees: ''
@@ -16,9 +16,3 @@ 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 go-micro
+about: If you have a need not served by micro
 title: "[FEATURE]"
 labels: ''
 assignees: ''

.github/ISSUE_TEMPLATE/question.md

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

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

.github/dependabot.yml

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

.github/workflows/autoapprove.yml

@@ -1,20 +0,0 @@
-name: "autoapprove"
-
-on:
-  pull_request_target:
-    types: [assigned, opened, synchronize, reopened]
-
-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/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/workflows/build.yml

@@ -1,47 +0,0 @@
-name: build
-on:
- push:
-    branches:
-    - master
-    - v3
-jobs:
-  test:
-    name: test
-    runs-on: ubuntu-latest
-    steps:
-    - name: setup
-      uses: actions/setup-go@v3
-      with:
-        go-version: 1.17
-    - name: checkout
-      uses: actions/checkout@v3
-    - name: cache
-      uses: actions/cache@v3
-      with:
-        path: ~/go/pkg/mod
-        key: ${{ runner.os }}-go-${{ hashFiles('**/go.sum') }}
-        restore-keys: ${{ runner.os }}-go-
-    - name: deps
-      run: go get -v -t -d ./...
-    - name: test
-      env:
-        INTEGRATION_TESTS: yes
-      run: go test -mod readonly -v ./...
-  lint:
-    name: lint
-    runs-on: ubuntu-latest
-    steps:
-      - name: checkout
-        uses: actions/checkout@v3
-      - name: lint
-        uses: golangci/golangci-lint-action@v3.4.0
-        continue-on-error: true
-        with:
-          # Required: the version of golangci-lint is required and must be specified without patch version: we always use the latest patch version.
-          version: v1.30
-          # Optional: working directory, useful for monorepos
-          # working-directory: somedir
-          # Optional: golangci-lint command line arguments.
-          # args: --issues-exit-code=0
-          # Optional: show only new issues if it's a pull request. The default value is `false`.
-          # only-new-issues: true

.github/workflows/codeql-analysis.yml

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

.github/workflows/dependabot-automerge.yml

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

.github/workflows/job_coverage.yml

@@ -0,0 +1,55 @@
+name: coverage
+
+on:
+  push:
+    branches: [ main, v3, v4 ]
+    paths-ignore:
+      - '.github/**'
+      - '.gitea/**'
+  pull_request:
+    branches: [ main, v3, v4 ]
+  # Allows you to run this workflow manually from the Actions tab
+  workflow_dispatch:
+
+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

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

@@ -0,0 +1,57 @@
+name: sync
+
+on:
+  schedule:
+    - cron: '*/5 * * * *'
+#  push:
+#    branches: [ master, v3, v4 ]
+#    paths-ignore:
+#      - '.github/**'
+#      - '.gitea/**'
+  # 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: sync master
+      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 --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: sync v3
+      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
+        git push origin v3 --progress
+        cd ../
+        rm -rf repo
+
+    - name: sync v4
+      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
+        git push origin v4 --progress
+        cd ../
+        rm -rf repo

.github/workflows/job_test.yml

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

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

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

.golangci.yml

@@ -1,44 +1,5 @@
 run:
-  concurrency: 4
+  concurrency: 8
-  deadline: 5m
+  timeout: 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
-    - golint
-    - gosec
-    - makezero
-    - misspell
-    - nakedret
-    - nestif
-    - nilerr
-    - noctx
-    - prealloc
-    - unconvert
-    - unparam
-  disable-all: false

codec.go

@@ -1,7 +1,7 @@
 package grpc
 
 import (
-	"go.unistack.org/micro/v3/codec"
+	"go.unistack.org/micro/v4/codec"
 	"google.golang.org/grpc/encoding"
 )
 

error.go

@@ -6,7 +6,7 @@ import (
 	"net/http"
 	"os"
 
-	"go.unistack.org/micro/v3/errors"
+	"go.unistack.org/micro/v4/errors"
 	"google.golang.org/grpc/codes"
 )
 

generate.go

@@ -1,4 +1,4 @@
 package grpc
 
 //go:generate go install google.golang.org/grpc/cmd/protoc-gen-go-grpc@latest
-//go:generate sh -c "protoc -I./proto -I$(go list -f '{{ .Dir }}' -m go.unistack.org/micro-proto/v3) -I. --go-grpc_out=paths=source_relative:./proto --go_out=paths=source_relative:./proto proto/test.proto"
+//go:generate sh -c "protoc -I./proto -I$(go list -f '{{ .Dir }}' -m go.unistack.org/micro-proto/v4) -I. --go-grpc_out=paths=source_relative:./proto --go_out=paths=source_relative:./proto proto/test.proto"

go.mod

@@ -1,20 +1,24 @@
-module go.unistack.org/micro-server-grpc/v3
+module go.unistack.org/micro-server-grpc/v4
 
-go 1.22
+go 1.23.0
 
-toolchain go1.23.1
+toolchain go1.24.2
 
 require (
-	github.com/golang/protobuf v1.5.4
+	go.unistack.org/micro/v4 v4.1.8
-	go.unistack.org/micro/v3 v3.10.97
+	golang.org/x/net v0.39.0
-	golang.org/x/net v0.30.0
+	google.golang.org/grpc v1.72.0
-	google.golang.org/grpc v1.67.1
+	google.golang.org/protobuf v1.36.6
-	google.golang.org/protobuf v1.35.1
 )
 
 require (
-	go.unistack.org/micro-proto/v3 v3.4.1 // indirect
+	github.com/ash3in/uuidv8 v1.2.0 // indirect
-	golang.org/x/sys v0.26.0 // indirect
+	github.com/google/uuid v1.6.0 // indirect
-	golang.org/x/text v0.19.0 // indirect
+	github.com/matoous/go-nanoid v1.5.1 // indirect
-	google.golang.org/genproto/googleapis/rpc v0.0.0-20241007155032-5fefd90f89a9 // indirect
+	github.com/spf13/cast v1.7.1 // indirect
+	go.unistack.org/micro-proto/v4 v4.1.0 // indirect
+	golang.org/x/sys v0.32.0 // indirect
+	golang.org/x/text v0.24.0 // indirect
+	google.golang.org/genproto/googleapis/rpc v0.0.0-20250428153025-10db94c68c34 // indirect
+	gopkg.in/yaml.v3 v3.0.1 // indirect
 )

go.sum

@@ -1,20 +1,65 @@
+github.com/DATA-DOG/go-sqlmock v1.5.2 h1:OcvFkGmslmlZibjAjaHm3L//6LiuBgolP7OputlJIzU=
+github.com/DATA-DOG/go-sqlmock v1.5.2/go.mod h1:88MAG/4G7SMwSE3CeA0ZKzrT5CiOU3OJ+JlNzwDqpNU=
+github.com/ash3in/uuidv8 v1.2.0 h1:2oogGdtCPwaVtyvPPGin4TfZLtOGE5F+W++E880G6SI=
+github.com/ash3in/uuidv8 v1.2.0/go.mod h1:BnU0wJBxnzdEKmVg4xckBkD+VZuecTFTUP3M0dWgyY4=
+github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc h1:U9qPSI2PIWSS1VwoXQT9A3Wy9MM3WgvqSxFWenqJduM=
+github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/frankban/quicktest v1.14.6 h1:7Xjx+VpznH+oBnejlPUj8oUpdxnVs4f8XU8WnHkI4W8=
+github.com/frankban/quicktest v1.14.6/go.mod h1:4ptaffx2x8+WTWXmUCuVU6aPUX1/Mz7zb5vbUoiM6w0=
+github.com/go-logr/logr v1.4.2 h1:6pFjapn8bFcIbiKo3XT4j/BhANplGihG6tvd+8rYgrY=
+github.com/go-logr/logr v1.4.2/go.mod h1:9T104GzyrTigFIr8wt5mBrctHMim0Nb2HLGrmQ40KvY=
+github.com/go-logr/stdr v1.2.2 h1:hSWxHoqTgW2S2qGc0LTAI563KZ5YKYRhT3MFKZMbjag=
+github.com/go-logr/stdr v1.2.2/go.mod h1:mMo/vtBO5dYbehREoey6XUKy/eSumjCCveDpRre4VKE=
 github.com/golang/protobuf v1.5.4 h1:i7eJL8qZTpSEXOPTxNKhASYpMn+8e5Q6AdndVa1dWek=
 github.com/golang/protobuf v1.5.4/go.mod h1:lnTiLA8Wa4RWRcIUkrtSVa5nRhsEGBg48fD6rSs7xps=
 github.com/google/go-cmp v0.6.0 h1:ofyhxvXcZhMsU5ulbFiLKl/XBFqE1GSq7atu8tAmTRI=
 github.com/google/go-cmp v0.6.0/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY=
-go.unistack.org/micro-proto/v3 v3.4.1 h1:UTjLSRz2YZuaHk9iSlVqqsA50JQNAEK2ZFboGqtEa9Q=
+github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0=
-go.unistack.org/micro-proto/v3 v3.4.1/go.mod h1:okx/cnOhzuCX0ggl/vToatbCupi0O44diiiLLsZ93Zo=
+github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
-go.unistack.org/micro/v3 v3.10.97 h1:8l7fv+i06/PjPrBBhRC/ZQkWGIOuHPg3jJN0vktYE78=
+github.com/kr/pretty v0.3.1 h1:flRD4NNwYAUpkphVc1HcthR4KEIFJ65n8Mw5qdRn3LE=
-go.unistack.org/micro/v3 v3.10.97/go.mod h1:YzMldzHN9Ei+zy5t/Psu7RUWDZwUfrNYiStSQtTz90g=
+github.com/kr/pretty v0.3.1/go.mod h1:hoEshYVHaxMs3cyo3Yncou5ZscifuDolrwPKZanG3xk=
-golang.org/x/net v0.30.0 h1:AcW1SDZMkb8IpzCdQUaIq2sP4sZ4zw+55h6ynffypl4=
+github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY=
-golang.org/x/net v0.30.0/go.mod h1:2wGyMJ5iFasEhkwi13ChkO/t1ECNC4X4eBKkVFyYFlU=
+github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE=
-golang.org/x/sys v0.26.0 h1:KHjCJyddX0LoSTb3J+vWpupP9p0oznkqVk/IfjymZbo=
+github.com/matoous/go-nanoid v1.5.1 h1:aCjdvTyO9LLnTIi0fgdXhOPPvOHjpXN6Ik9DaNjIct4=
-golang.org/x/sys v0.26.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
+github.com/matoous/go-nanoid v1.5.1/go.mod h1:zyD2a71IubI24efhpvkJz+ZwfwagzgSO6UNiFsZKN7U=
-golang.org/x/text v0.19.0 h1:kTxAhCbGbxhK0IwgSKiMO5awPoDQ0RpfiVYBfK860YM=
+github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2 h1:Jamvg5psRIccs7FGNTlIRMkT8wgtp5eCXdBlqhYGL6U=
-golang.org/x/text v0.19.0/go.mod h1:BuEKDfySbSR4drPmRPG/7iBdf8hvFMuRexcpahXilzY=
+github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
-google.golang.org/genproto/googleapis/rpc v0.0.0-20241007155032-5fefd90f89a9 h1:QCqS/PdaHTSWGvupk2F/ehwHtGc0/GYkT+3GAcR1CCc=
+github.com/rogpeppe/go-internal v1.13.1 h1:KvO1DLK/DRN07sQ1LQKScxyZJuNnedQ5/wKSR38lUII=
-google.golang.org/genproto/googleapis/rpc v0.0.0-20241007155032-5fefd90f89a9/go.mod h1:GX3210XPVPUjJbTUbvwI8f2IpZDMZuPJWDzDuebbviI=
+github.com/rogpeppe/go-internal v1.13.1/go.mod h1:uMEvuHeurkdAXX61udpOXGD/AzZDWNMNyH2VO9fmH0o=
-google.golang.org/grpc v1.67.1 h1:zWnc1Vrcno+lHZCOofnIMvycFcc0QRGIzm9dhnDX68E=
+github.com/spf13/cast v1.7.1 h1:cuNEagBQEHWN1FnbGEjCXL2szYEXqfJPbP2HNUaca9Y=
-google.golang.org/grpc v1.67.1/go.mod h1:1gLDyUQU7CTLJI90u3nXZ9ekeghjeM7pTDZlqFNg2AA=
+github.com/spf13/cast v1.7.1/go.mod h1:ancEpBxwJDODSW/UG4rDrAqiKolqNNh2DX3mk86cAdo=
-google.golang.org/protobuf v1.35.1 h1:m3LfL6/Ca+fqnjnlqQXNpFPABW1UD7mjh8KO2mKFytA=
+github.com/stretchr/testify v1.10.0 h1:Xv5erBjTwe/5IxqUQTdXv5kgmIvbHo3QQyRwhJsOfJA=
-google.golang.org/protobuf v1.35.1/go.mod h1:9fA7Ob0pmnwhb644+1+CVWFRbNajQ6iRojtC/QF5bRE=
+github.com/stretchr/testify v1.10.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
+go.opentelemetry.io/auto/sdk v1.1.0 h1:cH53jehLUN6UFLY71z+NDOiNJqDdPRaXzTel0sJySYA=
+go.opentelemetry.io/auto/sdk v1.1.0/go.mod h1:3wSPjt5PWp2RhlCcmmOial7AvC4DQqZb7a7wCow3W8A=
+go.opentelemetry.io/otel v1.34.0 h1:zRLXxLCgL1WyKsPVrgbSdMN4c0FMkDAskSTQP+0hdUY=
+go.opentelemetry.io/otel v1.34.0/go.mod h1:OWFPOQ+h4G8xpyjgqo4SxJYdDQ/qmRH+wivy7zzx9oI=
+go.opentelemetry.io/otel/metric v1.34.0 h1:+eTR3U0MyfWjRDhmFMxe2SsW64QrZ84AOhvqS7Y+PoQ=
+go.opentelemetry.io/otel/metric v1.34.0/go.mod h1:CEDrp0fy2D0MvkXE+dPV7cMi8tWZwX3dmaIhwPOaqHE=
+go.opentelemetry.io/otel/sdk v1.34.0 h1:95zS4k/2GOy069d321O8jWgYsW3MzVV+KuSPKp7Wr1A=
+go.opentelemetry.io/otel/sdk v1.34.0/go.mod h1:0e/pNiaMAqaykJGKbi+tSjWfNNHMTxoC9qANsCzbyxU=
+go.opentelemetry.io/otel/sdk/metric v1.34.0 h1:5CeK9ujjbFVL5c1PhLuStg1wxA7vQv7ce1EK0Gyvahk=
+go.opentelemetry.io/otel/sdk/metric v1.34.0/go.mod h1:jQ/r8Ze28zRKoNRdkjCZxfs6YvBTG1+YIqyFVFYec5w=
+go.opentelemetry.io/otel/trace v1.34.0 h1:+ouXS2V8Rd4hp4580a8q23bg0azF2nI8cqLYnC8mh/k=
+go.opentelemetry.io/otel/trace v1.34.0/go.mod h1:Svm7lSjQD7kG7KJ/MUHPVXSDGz2OX4h0M2jHBhmSfRE=
+go.unistack.org/micro-proto/v4 v4.1.0 h1:qPwL2n/oqh9RE3RTTDgt28XK3QzV597VugQPaw9lKUk=
+go.unistack.org/micro-proto/v4 v4.1.0/go.mod h1:ArmK7o+uFvxSY3dbJhKBBX4Pm1rhWdLEFf3LxBrMtec=
+go.unistack.org/micro/v4 v4.1.8 h1:bbqnQ7nzTYNIYt4HhRgmh/++qzwGJvlNbrTOoXzkQiU=
+go.unistack.org/micro/v4 v4.1.8/go.mod h1:b4dr7RFlbpSfSsKCva9UuX4zLtkYQteEK+Uuac39qJE=
+golang.org/x/net v0.39.0 h1:ZCu7HMWDxpXpaiKdhzIfaltL9Lp31x/3fCP11bc6/fY=
+golang.org/x/net v0.39.0/go.mod h1:X7NRbYVEA+ewNkCNyJ513WmMdQ3BineSwVtN2zD/d+E=
+golang.org/x/sys v0.32.0 h1:s77OFDvIQeibCmezSnk/q6iAfkdiQaJi4VzroCFrN20=
+golang.org/x/sys v0.32.0/go.mod h1:BJP2sWEmIv4KK5OTEluFJCKSidICx8ciO85XgH3Ak8k=
+golang.org/x/text v0.24.0 h1:dd5Bzh4yt5KYA8f9CJHCP4FB4D51c2c6JvN37xJJkJ0=
+golang.org/x/text v0.24.0/go.mod h1:L8rBsPeo2pSS+xqN0d5u2ikmjtmoJbDBT1b7nHvFCdU=
+google.golang.org/genproto/googleapis/rpc v0.0.0-20250428153025-10db94c68c34 h1:h6p3mQqrmT1XkHVTfzLdNz1u7IhINeZkz67/xTbOuWs=
+google.golang.org/genproto/googleapis/rpc v0.0.0-20250428153025-10db94c68c34/go.mod h1:qQ0YXyHHx3XkvlzUtpXDkS29lDSafHMZBAZDc03LQ3A=
+google.golang.org/grpc v1.72.0 h1:S7UkcVa60b5AAQTaO6ZKamFp1zMZSU0fGDK2WZLbBnM=
+google.golang.org/grpc v1.72.0/go.mod h1:wH5Aktxcg25y1I3w7H69nHfXdOG3UiadoBtjh3izSDM=
+google.golang.org/protobuf v1.36.6 h1:z1NpPI8ku2WgiWnf+t9wTPsn6eP1L7ksHUlkfLvd9xY=
+google.golang.org/protobuf v1.36.6/go.mod h1:jduwjTPXsFjZGTmRluh+L6NjiWu7pchiJ2/5YcXBHnY=
+gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk=
+gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c/go.mod h1:JHkPIbrfpd72SG/EVd6muEfDQjcINNoR0C8j2r3qZ4Q=
+gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
+gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=

grpc.go

@@ -10,27 +10,24 @@ import (
 	"slices"
 	"sort"
 	"strconv"
-	"strings"
 	"sync"
+	"sync/atomic"
 	"time"
 
 	greflection "google.golang.org/grpc/reflection"
 	reflectionv1pb "google.golang.org/grpc/reflection/grpc_reflection_v1"
 
 	// nolint: staticcheck
-	oldproto "github.com/golang/protobuf/proto"
+
-	"go.unistack.org/micro/v3/broker"
+	"go.unistack.org/micro/v4/errors"
-	"go.unistack.org/micro/v3/codec"
+	"go.unistack.org/micro/v4/logger"
-	"go.unistack.org/micro/v3/errors"
+	"go.unistack.org/micro/v4/metadata"
-	"go.unistack.org/micro/v3/logger"
+	"go.unistack.org/micro/v4/meter"
-	"go.unistack.org/micro/v3/metadata"
+	"go.unistack.org/micro/v4/options"
-	"go.unistack.org/micro/v3/meter"
+	"go.unistack.org/micro/v4/register"
-	"go.unistack.org/micro/v3/options"
+	"go.unistack.org/micro/v4/semconv"
-	"go.unistack.org/micro/v3/register"
+	"go.unistack.org/micro/v4/server"
-	"go.unistack.org/micro/v3/semconv"
+	"go.unistack.org/micro/v4/tracer"
-	"go.unistack.org/micro/v3/server"
-	msync "go.unistack.org/micro/v3/sync"
-	"go.unistack.org/micro/v3/tracer"
 	"golang.org/x/net/netutil"
 	"google.golang.org/grpc"
 	"google.golang.org/grpc/codes"
@@ -39,19 +36,13 @@ import (
 	"google.golang.org/grpc/peer"
 	"google.golang.org/grpc/status"
 	"google.golang.org/protobuf/proto"
+	"google.golang.org/protobuf/protoadapt"
 )
 
 const (
 	DefaultContentType = "application/grpc"
 )
 
-/*
-type ServerReflection struct {
-	srv *grpc.Server
-	s   *serverReflectionServer
-}
-*/
-
 type streamWrapper struct {
 	ctx context.Context
 	grpc.ServerStream
@@ -68,16 +59,17 @@ type Server struct {
 	handlers       map[string]server.Handler
 	srv            *grpc.Server
 	exit           chan chan error
-	wg             *msync.WaitGroup
 	rsvc           *register.Service
-	subscribers    map[*subscriber][]broker.Subscriber
 	rpc            *rServer
 	opts           server.Options
 	unknownHandler grpc.StreamHandler
 	sync.RWMutex
-	started    bool
+	stateLive   *atomic.Uint32
-	registered bool
+	stateReady  *atomic.Uint32
-	reflection bool
+	stateHealth *atomic.Uint32
+	started     bool
+	registered  bool
+	// reflection  bool
 }
 
 func newServer(opts ...server.Option) *Server {
@@ -88,8 +80,10 @@ func newServer(opts ...server.Option) *Server {
 			serviceMap: make(map[string]*service),
 		},
 		handlers:    make(map[string]server.Handler),
-		subscribers: make(map[*subscriber][]broker.Subscriber),
 		exit:        make(chan chan error),
+		stateLive:   &atomic.Uint32{},
+		stateReady:  &atomic.Uint32{},
+		stateHealth: &atomic.Uint32{},
 	}
 
 	g.opts.Meter = g.opts.Meter.Clone(meter.Labels("type", "grpc"))
@@ -97,22 +91,6 @@ func newServer(opts ...server.Option) *Server {
 	return g
 }
 
-/*
-type grpcRouter struct {
- h func(context.Context, server.Request, interface{}) error
- m func(context.Context, server.Message) error
-}
-
-func (r grpcRouter) ProcessMessage(ctx context.Context, msg server.Message) error {
- return r.m(ctx, msg)
-}
-
-func (r grpcRouter) ServeRequest(ctx context.Context, req server.Request, rsp server.Response) error {
- return r.h(ctx, req, rsp)
-}
-
-*/
-
 func (g *Server) configure(opts ...server.Option) error {
 	g.Lock()
 	defer g.Unlock()
@@ -208,26 +186,9 @@ func (g *Server) handler(srv interface{}, stream grpc.ServerStream) error {
 		return status.Errorf(codes.Internal, "method does not exist in context")
 	}
 
-	ts := time.Now()
+	var gmd map[string][]string
-	var sp tracer.Span
-	if !slices.Contains(tracer.DefaultSkipEndpoints, fullMethod) {
-		ctx, sp = g.opts.Tracer.Start(ctx, fullMethod+" rpc-server",
-			tracer.WithSpanKind(tracer.SpanKindServer),
-			tracer.WithSpanLabels(
-				"endpoint", fullMethod,
-			),
-		)
-		defer func() {
-			st := status.Convert(err)
-			if st != nil || st.Code() != codes.OK {
-				sp.SetStatus(tracer.SpanStatusError, err.Error())
-			}
-			sp.Finish()
-		}()
-	}
-
 	// get grpc metadata
-	gmd, ok := gmetadata.FromIncomingContext(ctx)
+	gmd, ok = gmetadata.FromIncomingContext(ctx)
 	if !ok {
 		gmd = gmetadata.MD{}
 	}
@@ -239,25 +200,44 @@ func (g *Server) handler(srv interface{}, stream grpc.ServerStream) error {
 		return err
 	}
 
-	md := metadata.New(len(gmd))
+	endpointName := serviceName + "/" + methodName
-	for k, v := range gmd {
+
-		md.Set(k, strings.Join(v, ", "))
+	ts := time.Now()
+	var sp tracer.Span
+	if !slices.Contains(tracer.DefaultSkipEndpoints, endpointName) {
+		ctx, sp = g.opts.Tracer.Start(ctx, "rpc-server",
+			tracer.WithSpanKind(tracer.SpanKindServer),
+			tracer.WithSpanLabels(
+				"endpoint", endpointName,
+				"server", "grpc",
+			),
+		)
+		defer func() {
+			st := status.Convert(err)
+			if st != nil || st.Code() != codes.OK {
+				sp.SetStatus(tracer.SpanStatusError, err.Error())
+			}
+			sp.Finish()
+		}()
 	}
-	md.Set("Path", fullMethod)
+
-	md.Set("Micro-Server", "grpc")
+	md := metadata.Copy(gmd)
+
+	md.Set("path", fullMethod)
+	md.Set("micro-server", "grpc")
 	md.Set(metadata.HeaderEndpoint, methodName)
 	md.Set(metadata.HeaderService, serviceName)
 
 	var td string
 	// timeout for server deadline
-	if v, ok := md.Get("timeout"); ok {
+	if v := md.Get("timeout"); v != nil {
 		md.Del("timeout")
-		td = v
+		td = v[0]
 	}
-	if v, ok := md.Get("Grpc-Timeout"); ok {
+	if v := md.Get("grpc-timeout"); v != nil {
-		md.Del("Grpc-Timeout")
+		md.Del("grpc-timeout")
-		td = v[:len(v)-1]
+		td = v[0][:len(v)-1]
-		switch v[len(v)-1:] {
+		switch v[0][len(v)-1:] {
 		case "S":
 			td += "s"
 		case "M":
@@ -276,31 +256,29 @@ func (g *Server) handler(srv interface{}, stream grpc.ServerStream) error {
 	// get content type
 	ct := DefaultContentType
 
-	if ctype, ok := md.Get("content-type"); ok {
+	if ctype := md.Get("content-type"); ctype != nil {
-		ct = ctype
+		ct = ctype[0]
-	} else if ctype, ok := md.Get("x-content-type"); ok {
-		ct = ctype
-		md.Del("x-content-type")
 	}
 
 	// create new context
 	ctx = metadata.NewIncomingContext(ctx, md)
+	ctx = metadata.NewOutgoingContext(ctx, metadata.New(0))
 
 	stream = &streamWrapper{ctx, stream}
 
-	if !slices.Contains(meter.DefaultSkipEndpoints, fullMethod) {
+	if !slices.Contains(meter.DefaultSkipEndpoints, endpointName) {
-		g.opts.Meter.Counter(semconv.ServerRequestInflight, "endpoint", fullMethod).Inc()
+		g.opts.Meter.Counter(semconv.ServerRequestInflight, "endpoint", endpointName, "server", "grpc").Inc()
 		defer func() {
 			te := time.Since(ts)
-			g.opts.Meter.Summary(semconv.ServerRequestLatencyMicroseconds, "endpoint", fullMethod).Update(te.Seconds())
+			g.opts.Meter.Summary(semconv.ServerRequestLatencyMicroseconds, "endpoint", endpointName, "server", "grpc").Update(te.Seconds())
-			g.opts.Meter.Histogram(semconv.ServerRequestDurationSeconds, "endpoint", fullMethod).Update(te.Seconds())
+			g.opts.Meter.Histogram(semconv.ServerRequestDurationSeconds, "endpoint", endpointName, "server", "grpc").Update(te.Seconds())
-			g.opts.Meter.Counter(semconv.ServerRequestInflight, "endpoint", fullMethod).Dec()
+			g.opts.Meter.Counter(semconv.ServerRequestInflight, "endpoint", endpointName, "server", "grpc").Dec()
 
 			st := status.Convert(err)
 			if st == nil || st.Code() == codes.OK {
-				g.opts.Meter.Counter(semconv.ServerRequestTotal, "endpoint", fullMethod, "status", "success", "code", strconv.Itoa(int(codes.OK))).Inc()
+				g.opts.Meter.Counter(semconv.ServerRequestTotal, "endpoint", endpointName, "server", "grpc", "status", "success", "code", strconv.Itoa(int(codes.OK))).Inc()
 			} else {
-				g.opts.Meter.Counter(semconv.ServerRequestTotal, "endpoint", fullMethod, "status", "failure", "code", strconv.Itoa(int(st.Code()))).Inc()
+				g.opts.Meter.Counter(semconv.ServerRequestTotal, "endpoint", endpointName, "server", "grpc", "status", "failure", "code", strconv.Itoa(int(st.Code()))).Inc()
 			}
 		}()
 	}
@@ -312,7 +290,7 @@ func (g *Server) handler(srv interface{}, stream grpc.ServerStream) error {
 
 	// get peer from context
 	if p, ok := peer.FromContext(ctx); ok {
-		md.Set("Remote", p.Addr.String())
+		md.Set("remote", p.Addr.String())
 		ctx = peer.NewContext(ctx, p)
 	}
 
@@ -409,7 +387,7 @@ func (g *Server) processRequest(ctx context.Context, stream grpc.ServerStream, s
 		return err
 	}
 
-	g.opts.Hooks.EachNext(func(hook options.Hook) {
+	g.opts.Hooks.EachPrev(func(hook options.Hook) {
 		if h, ok := hook.(server.HookHandler); ok {
 			fn = h(fn)
 		}
@@ -420,7 +398,7 @@ func (g *Server) processRequest(ctx context.Context, stream grpc.ServerStream, s
 	// execute the handler
 	appErr := fn(ctx, r, replyv.Interface())
 	if outmd, ok := metadata.FromOutgoingContext(ctx); ok {
-		if err = stream.SendHeader(gmetadata.New(outmd)); err != nil {
+		if err = stream.SendHeader(gmetadata.MD(outmd.Copy())); err != nil {
 			return err
 		}
 	}
@@ -435,7 +413,7 @@ func (g *Server) processRequest(ctx context.Context, stream grpc.ServerStream, s
 			// user defined error that proto based we can attach it to grpc status
 			statusCode = convertCode(appErr)
 			statusDesc = appErr.Error()
-			errStatus, err = status.New(statusCode, statusDesc).WithDetails(oldproto.MessageV1(verr))
+			errStatus, err = status.New(statusCode, statusDesc).WithDetails(protoadapt.MessageV1Of(verr))
 			if err != nil {
 				return err
 			}
@@ -493,7 +471,7 @@ func (g *Server) processStream(ctx context.Context, stream grpc.ServerStream, se
 		return nil
 	}
 
-	opts.Hooks.EachNext(func(hook options.Hook) {
+	opts.Hooks.EachPrev(func(hook options.Hook) {
 		if h, ok := hook.(server.HookHandler); ok {
 			fn = h(fn)
 		}
@@ -504,7 +482,7 @@ func (g *Server) processStream(ctx context.Context, stream grpc.ServerStream, se
 
 	appErr := fn(ctx, r, ss)
 	if outmd, ok := metadata.FromOutgoingContext(ctx); ok {
-		if err := stream.SendHeader(gmetadata.New(outmd)); err != nil {
+		if err := stream.SendHeader(gmetadata.MD(outmd.Copy())); err != nil {
 			return err
 		}
 	}
@@ -520,7 +498,7 @@ func (g *Server) processStream(ctx context.Context, stream grpc.ServerStream, se
 			// user defined error that proto based we can attach it to grpc status
 			statusCode = convertCode(appErr)
 			statusDesc = appErr.Error()
-			errStatus, err = status.New(statusCode, statusDesc).WithDetails(oldproto.MessageV1(verr))
+			errStatus, err = status.New(statusCode, statusDesc).WithDetails(protoadapt.MessageV1Of(verr))
 			if err != nil {
 				return err
 			}
@@ -540,21 +518,6 @@ func (g *Server) processStream(ctx context.Context, stream grpc.ServerStream, se
 	return status.New(statusCode, statusDesc).Err()
 }
 
-func (g *Server) newCodec(ct string) (codec.Codec, error) {
-	g.RLock()
-	defer g.RUnlock()
-
-	if idx := strings.IndexRune(ct, ';'); idx >= 0 {
-		ct = ct[:idx]
-	}
-
-	if c, ok := g.opts.Codecs[ct]; ok {
-		return c, nil
-	}
-
-	return nil, codec.ErrUnknownContentType
-}
-
 func (g *Server) Options() server.Options {
 	g.RLock()
 	opts := g.opts
@@ -580,34 +543,6 @@ func (g *Server) Handle(h server.Handler) error {
 	return nil
 }
 
-func (g *Server) NewSubscriber(topic string, sb interface{}, opts ...server.SubscriberOption) server.Subscriber {
-	return newSubscriber(topic, sb, opts...)
-}
-
-func (g *Server) Subscribe(sb server.Subscriber) error {
-	sub, ok := sb.(*subscriber)
-	if !ok {
-		return fmt.Errorf("invalid subscriber: expected *subscriber")
-	}
-	if len(sub.handlers) == 0 {
-		return fmt.Errorf("invalid subscriber: no handler functions")
-	}
-
-	if err := server.ValidateSubscriber(sb); err != nil {
-		return err
-	}
-
-	g.Lock()
-	if _, ok = g.subscribers[sub]; ok {
-		g.Unlock()
-		return fmt.Errorf("subscriber %v already exists", sub)
-	}
-
-	g.subscribers[sub] = nil
-	g.Unlock()
-	return nil
-}
-
 func (g *Server) Register() error {
 	g.RLock()
 	rsvc := g.rsvc
@@ -637,28 +572,8 @@ func (g *Server) Register() error {
 
 	sort.Strings(handlerList)
 
-	subscriberList := make([]*subscriber, 0, len(g.subscribers))
-	for e := range g.subscribers {
-		// Only advertise non internal subscribers
-		subscriberList = append(subscriberList, e)
-	}
-	sort.Slice(subscriberList, func(i, j int) bool {
-		return subscriberList[i].topic > subscriberList[j].topic
-	})
-
-	endpoints := make([]*register.Endpoint, 0, len(handlerList)+len(subscriberList))
-	for _, n := range handlerList {
-		endpoints = append(endpoints, g.handlers[n].Endpoints()...)
-	}
-	for _, e := range subscriberList {
-		endpoints = append(endpoints, e.Endpoints()...)
-	}
 	g.RUnlock()
 
-	service.Nodes[0].Metadata["protocol"] = "grpc"
-	service.Nodes[0].Metadata["transport"] = service.Nodes[0].Metadata["protocol"]
-	service.Endpoints = endpoints
-
 	g.RLock()
 	registered := g.registered
 	g.RUnlock()
@@ -718,26 +633,6 @@ func (g *Server) Deregister() error {
 
 	g.registered = false
 
-	wg := sync.WaitGroup{}
-	for sb, subs := range g.subscribers {
-		for _, sub := range subs {
-			wg.Add(1)
-			go func(s broker.Subscriber) {
-				defer wg.Done()
-				if config.Logger.V(logger.InfoLevel) {
-					config.Logger.Info(config.Context, "Unsubscribing from topic: "+s.Topic())
-				}
-				if err := s.Unsubscribe(g.opts.Context); err != nil {
-					if config.Logger.V(logger.ErrorLevel) {
-						config.Logger.Error(config.Context, "Unsubscribing from topic: "+s.Topic(), err)
-					}
-				}
-			}(sub)
-		}
-		g.subscribers[sb] = nil
-	}
-	wg.Wait()
-
 	g.Unlock()
 	return nil
 }
@@ -785,21 +680,6 @@ func (g *Server) Start() error {
 	}
 	g.Unlock()
 
-	// only connect if we're subscribed
-	if len(g.subscribers) > 0 {
-		// connect to the broker
-		if err = config.Broker.Connect(config.Context); err != nil {
-			if config.Logger.V(logger.ErrorLevel) {
-				config.Logger.Error(config.Context, fmt.Sprintf("broker [%s] connect error", config.Broker.String()), err)
-			}
-			return err
-		}
-
-		if config.Logger.V(logger.InfoLevel) {
-			config.Logger.Info(config.Context, fmt.Sprintf("broker [%s] Connected to %s", config.Broker.String(), config.Broker.Address()))
-		}
-	}
-
 	// use RegisterCheck func before register
 	// nolint: nestif
 	if err = g.opts.RegisterCheck(config.Context); err != nil {
@@ -815,10 +695,6 @@ func (g *Server) Start() error {
 		}
 	}
 
-	if err = g.subscribe(); err != nil {
-		return err
-	}
-
 	// micro: go ts.Accept(s.accept)
 	go func() {
 		if err = g.srv.Serve(ts); err != nil {
@@ -831,6 +707,9 @@ func (g *Server) Start() error {
 				}
 			}
 		}
+		g.stateLive.Store(1)
+		g.stateReady.Store(1)
+		g.stateHealth.Store(1)
 	}()
 
 	go func() {
@@ -900,12 +779,18 @@ func (g *Server) Start() error {
 		go func() {
 			g.srv.GracefulStop()
 			close(exit)
+			g.stateLive.Store(0)
+			g.stateReady.Store(0)
+			g.stateHealth.Store(0)
 		}()
 
 		select {
 		case <-exit:
 		case <-time.After(g.opts.GracefulTimeout):
 			g.srv.Stop()
+			g.stateLive.Store(0)
+			g.stateReady.Store(0)
+			g.stateHealth.Store(0)
 		}
 
 		// close transport
@@ -962,6 +847,18 @@ func (g *Server) GRPCServer() *grpc.Server {
 	return g.srv
 }
 
+func (g *Server) Live() bool {
+	return g.stateLive.Load() == 1
+}
+
+func (g *Server) Ready() bool {
+	return g.stateReady.Load() == 1
+}
+
+func (g *Server) Health() bool {
+	return g.stateHealth.Load() == 1
+}
+
 func NewServer(opts ...server.Option) *Server {
 	return newServer(opts...)
 }

handler.go

@@ -3,43 +3,25 @@ package grpc
 import (
 	"reflect"
 
-	"go.unistack.org/micro/v3/register"
+	"go.unistack.org/micro/v4/server"
-	"go.unistack.org/micro/v3/server"
 )
 
 type rpcHandler struct {
-	opts      server.HandlerOptions
+	opts    server.HandlerOptions
-	handler   interface{}
+	handler interface{}
-	name      string
+	name    string
-	endpoints []*register.Endpoint
 }
 
 func newRPCHandler(handler interface{}, opts ...server.HandlerOption) server.Handler {
 	options := server.NewHandlerOptions(opts...)
 
-	typ := reflect.TypeOf(handler)
 	hdlr := reflect.ValueOf(handler)
 	name := reflect.Indirect(hdlr).Type().Name()
 
-	var endpoints []*register.Endpoint
-
-	for m := 0; m < typ.NumMethod(); m++ {
-		if e := register.ExtractEndpoint(typ.Method(m)); e != nil {
-			e.Name = name + "." + e.Name
-
-			for k, v := range options.Metadata[e.Name] {
-				e.Metadata[k] = v
-			}
-
-			endpoints = append(endpoints, e)
-		}
-	}
-
 	return &rpcHandler{
-		name:      name,
+		name:    name,
-		handler:   handler,
+		handler: handler,
-		endpoints: endpoints,
+		opts:    options,
-		opts:      options,
 	}
 }
 
@@ -51,10 +33,6 @@ func (r *rpcHandler) Handler() interface{} {
 	return r.handler
 }
 
-func (r *rpcHandler) Endpoints() []*register.Endpoint {
-	return r.endpoints
-}
-
 func (r *rpcHandler) Options() server.HandlerOptions {
 	return r.opts
 }

options.go

@@ -3,7 +3,7 @@ package grpc
 import (
 	"context"
 
-	"go.unistack.org/micro/v3/server"
+	"go.unistack.org/micro/v4/server"
 	"google.golang.org/grpc"
 	"google.golang.org/grpc/encoding"
 )

reflection_old.go

@@ -1,489 +0,0 @@
-//go:build ignore
-// +build ignore
-
-/*
- *
- * Copyright 2016 gRPC authors.
- *
- * 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.
- *
- */
-
-/*
-Package reflection implements server reflection service.
-
-The service implemented is defined in:
-https://github.com/grpc/grpc/blob/master/src/proto/grpc/reflection/v1alpha/reflection.proto.
-
-To register server reflection on a gRPC server:
-
-	import "google.golang.org/grpc/reflection"
-
-	s := grpc.NewServer()
-	pb.RegisterYourOwnServer(s, &server{})
-
-	// Register reflection service on gRPC server.
-	reflection.Register(s)
-
-	s.Serve(lis)
-*/
-package grpc
-
-import (
-	"bytes"
-	"compress/gzip"
-	"fmt"
-	"io"
-	"io/ioutil"
-	"reflect"
-	"sort"
-	"sync"
-
-	"github.com/golang/protobuf/proto"
-	dpb "github.com/golang/protobuf/protoc-gen-go/descriptor"
-	"google.golang.org/grpc"
-	"google.golang.org/grpc/codes"
-	rpb "google.golang.org/grpc/reflection/grpc_reflection_v1alpha"
-	"google.golang.org/grpc/status"
-)
-
-type serverReflectionServer struct {
-	rpb.UnimplementedServerReflectionServer
-	s *grpc.Server
-
-	initSymbols  sync.Once
-	serviceNames []string
-	symbols      map[string]*dpb.FileDescriptorProto // map of fully-qualified names to files
-}
-
-// Register registers the server reflection service on the given gRPC server.
-func Register(s *grpc.Server) {
-	rpb.RegisterServerReflectionServer(s, &serverReflectionServer{
-		s: s,
-	})
-}
-
-// protoMessage is used for type assertion on proto messages.
-// Generated proto message implements function Descriptor(), but Descriptor()
-// is not part of interface proto.Message. This interface is needed to
-// call Descriptor().
-type protoMessage interface {
-	Descriptor() ([]byte, []int)
-}
-
-func (s *serverReflectionServer) getSymbols() (svcNames []string, symbolIndex map[string]*dpb.FileDescriptorProto) {
-	s.initSymbols.Do(func() {
-		serviceInfo := s.s.GetServiceInfo()
-
-		s.symbols = map[string]*dpb.FileDescriptorProto{}
-		s.serviceNames = make([]string, 0, len(serviceInfo))
-		processed := map[string]struct{}{}
-		for svc, info := range serviceInfo {
-			s.serviceNames = append(s.serviceNames, svc)
-			fdenc, ok := parseMetadata(info.Metadata)
-			if !ok {
-				continue
-			}
-			fd, err := decodeFileDesc(fdenc)
-			if err != nil {
-				continue
-			}
-			s.processFile(fd, processed)
-		}
-		sort.Strings(s.serviceNames)
-	})
-
-	return s.serviceNames, s.symbols
-}
-
-func (s *serverReflectionServer) processFile(fd *dpb.FileDescriptorProto, processed map[string]struct{}) {
-	filename := fd.GetName()
-	if _, ok := processed[filename]; ok {
-		return
-	}
-	processed[filename] = struct{}{}
-
-	prefix := fd.GetPackage()
-
-	for _, msg := range fd.MessageType {
-		s.processMessage(fd, prefix, msg)
-	}
-	for _, en := range fd.EnumType {
-		s.processEnum(fd, prefix, en)
-	}
-	for _, ext := range fd.Extension {
-		s.processField(fd, prefix, ext)
-	}
-	for _, svc := range fd.Service {
-		svcName := fqn(prefix, svc.GetName())
-		s.symbols[svcName] = fd
-		for _, meth := range svc.Method {
-			name := fqn(svcName, meth.GetName())
-			s.symbols[name] = fd
-		}
-	}
-
-	for _, dep := range fd.Dependency {
-		fdenc := proto.FileDescriptor(dep)
-		fdDep, err := decodeFileDesc(fdenc)
-		if err != nil {
-			continue
-		}
-		s.processFile(fdDep, processed)
-	}
-}
-
-func (s *serverReflectionServer) processMessage(fd *dpb.FileDescriptorProto, prefix string, msg *dpb.DescriptorProto) {
-	msgName := fqn(prefix, msg.GetName())
-	s.symbols[msgName] = fd
-
-	for _, nested := range msg.NestedType {
-		s.processMessage(fd, msgName, nested)
-	}
-	for _, en := range msg.EnumType {
-		s.processEnum(fd, msgName, en)
-	}
-	for _, ext := range msg.Extension {
-		s.processField(fd, msgName, ext)
-	}
-	for _, fld := range msg.Field {
-		s.processField(fd, msgName, fld)
-	}
-	for _, oneof := range msg.OneofDecl {
-		oneofName := fqn(msgName, oneof.GetName())
-		s.symbols[oneofName] = fd
-	}
-}
-
-func (s *serverReflectionServer) processEnum(fd *dpb.FileDescriptorProto, prefix string, en *dpb.EnumDescriptorProto) {
-	enName := fqn(prefix, en.GetName())
-	s.symbols[enName] = fd
-
-	for _, val := range en.Value {
-		valName := fqn(enName, val.GetName())
-		s.symbols[valName] = fd
-	}
-}
-
-func (s *serverReflectionServer) processField(fd *dpb.FileDescriptorProto, prefix string, fld *dpb.FieldDescriptorProto) {
-	fldName := fqn(prefix, fld.GetName())
-	s.symbols[fldName] = fd
-}
-
-func fqn(prefix, name string) string {
-	if prefix == "" {
-		return name
-	}
-	return prefix + "." + name
-}
-
-// fileDescForType gets the file descriptor for the given type.
-// The given type should be a proto message.
-func (s *serverReflectionServer) fileDescForType(st reflect.Type) (*dpb.FileDescriptorProto, error) {
-	m, ok := reflect.Zero(reflect.PtrTo(st)).Interface().(protoMessage)
-	if !ok {
-		return nil, fmt.Errorf("failed to create message from type: %v", st)
-	}
-	enc, _ := m.Descriptor()
-
-	return decodeFileDesc(enc)
-}
-
-// decodeFileDesc does decompression and unmarshalling on the given
-// file descriptor byte slice.
-func decodeFileDesc(enc []byte) (*dpb.FileDescriptorProto, error) {
-	raw, err := decompress(enc)
-	if err != nil {
-		return nil, fmt.Errorf("failed to decompress enc: %v", err)
-	}
-
-	fd := new(dpb.FileDescriptorProto)
-	if err := proto.Unmarshal(raw, fd); err != nil {
-		return nil, fmt.Errorf("bad descriptor: %v", err)
-	}
-	return fd, nil
-}
-
-// decompress does gzip decompression.
-func decompress(b []byte) ([]byte, error) {
-	r, err := gzip.NewReader(bytes.NewReader(b))
-	if err != nil {
-		return nil, fmt.Errorf("bad gzipped descriptor: %v", err)
-	}
-	out, err := ioutil.ReadAll(r)
-	if err != nil {
-		return nil, fmt.Errorf("bad gzipped descriptor: %v", err)
-	}
-	return out, nil
-}
-
-func typeForName(name string) (reflect.Type, error) {
-	pt := proto.MessageType(name)
-	if pt == nil {
-		return nil, fmt.Errorf("unknown type: %q", name)
-	}
-	st := pt.Elem()
-
-	return st, nil
-}
-
-func fileDescContainingExtension(st reflect.Type, ext int32) (*dpb.FileDescriptorProto, error) {
-	m, ok := reflect.Zero(reflect.PtrTo(st)).Interface().(proto.Message)
-	if !ok {
-		return nil, fmt.Errorf("failed to create message from type: %v", st)
-	}
-
-	var extDesc *proto.ExtensionDesc
-	for id, desc := range proto.RegisteredExtensions(m) {
-		if id == ext {
-			extDesc = desc
-			break
-		}
-	}
-
-	if extDesc == nil {
-		return nil, fmt.Errorf("failed to find registered extension for extension number %v", ext)
-	}
-
-	return decodeFileDesc(proto.FileDescriptor(extDesc.Filename))
-}
-
-func (s *serverReflectionServer) allExtensionNumbersForType(st reflect.Type) ([]int32, error) {
-	m, ok := reflect.Zero(reflect.PtrTo(st)).Interface().(proto.Message)
-	if !ok {
-		return nil, fmt.Errorf("failed to create message from type: %v", st)
-	}
-
-	exts := proto.RegisteredExtensions(m)
-	out := make([]int32, 0, len(exts))
-	for id := range exts {
-		out = append(out, id)
-	}
-	return out, nil
-}
-
-// fileDescWithDependencies returns a slice of serialized fileDescriptors in
-// wire format ([]byte). The fileDescriptors will include fd and all the
-// transitive dependencies of fd with names not in sentFileDescriptors.
-func fileDescWithDependencies(fd *dpb.FileDescriptorProto, sentFileDescriptors map[string]bool) ([][]byte, error) {
-	r := [][]byte{}
-	queue := []*dpb.FileDescriptorProto{fd}
-	for len(queue) > 0 {
-		currentfd := queue[0]
-		queue = queue[1:]
-		if sent := sentFileDescriptors[currentfd.GetName()]; len(r) == 0 || !sent {
-			sentFileDescriptors[currentfd.GetName()] = true
-			currentfdEncoded, err := proto.Marshal(currentfd)
-			if err != nil {
-				return nil, err
-			}
-			r = append(r, currentfdEncoded)
-		}
-		for _, dep := range currentfd.Dependency {
-			fdenc := proto.FileDescriptor(dep)
-			fdDep, err := decodeFileDesc(fdenc)
-			if err != nil {
-				continue
-			}
-			queue = append(queue, fdDep)
-		}
-	}
-	return r, nil
-}
-
-// fileDescEncodingByFilename finds the file descriptor for given filename,
-// finds all of its previously unsent transitive dependencies, does marshalling
-// on them, and returns the marshalled result.
-func (s *serverReflectionServer) fileDescEncodingByFilename(name string, sentFileDescriptors map[string]bool) ([][]byte, error) {
-	enc := proto.FileDescriptor(name)
-	if enc == nil {
-		return nil, fmt.Errorf("unknown file: %v", name)
-	}
-	fd, err := decodeFileDesc(enc)
-	if err != nil {
-		return nil, err
-	}
-	return fileDescWithDependencies(fd, sentFileDescriptors)
-}
-
-// parseMetadata finds the file descriptor bytes specified meta.
-// For SupportPackageIsVersion4, m is the name of the proto file, we
-// call proto.FileDescriptor to get the byte slice.
-// For SupportPackageIsVersion3, m is a byte slice itself.
-func parseMetadata(meta interface{}) ([]byte, bool) {
-	// Check if meta is the file name.
-	if fileNameForMeta, ok := meta.(string); ok {
-		return proto.FileDescriptor(fileNameForMeta), true
-	}
-
-	// Check if meta is the byte slice.
-	if enc, ok := meta.([]byte); ok {
-		return enc, true
-	}
-
-	return nil, false
-}
-
-// fileDescEncodingContainingSymbol finds the file descriptor containing the
-// given symbol, finds all of its previously unsent transitive dependencies,
-// does marshalling on them, and returns the marshalled result. The given symbol
-// can be a type, a service or a method.
-func (s *serverReflectionServer) fileDescEncodingContainingSymbol(name string, sentFileDescriptors map[string]bool) ([][]byte, error) {
-	_, symbols := s.getSymbols()
-	fd := symbols[name]
-	if fd == nil {
-		// Check if it's a type name that was not present in the
-		// transitive dependencies of the registered services.
-		if st, err := typeForName(name); err == nil {
-			fd, err = s.fileDescForType(st)
-			if err != nil {
-				return nil, err
-			}
-		}
-	}
-
-	if fd == nil {
-		return nil, fmt.Errorf("unknown symbol: %v", name)
-	}
-
-	return fileDescWithDependencies(fd, sentFileDescriptors)
-}
-
-// fileDescEncodingContainingExtension finds the file descriptor containing
-// given extension, finds all of its previously unsent transitive dependencies,
-// does marshalling on them, and returns the marshalled result.
-func (s *serverReflectionServer) fileDescEncodingContainingExtension(typeName string, extNum int32, sentFileDescriptors map[string]bool) ([][]byte, error) {
-	st, err := typeForName(typeName)
-	if err != nil {
-		return nil, err
-	}
-	fd, err := fileDescContainingExtension(st, extNum)
-	if err != nil {
-		return nil, err
-	}
-	return fileDescWithDependencies(fd, sentFileDescriptors)
-}
-
-// allExtensionNumbersForTypeName returns all extension numbers for the given type.
-func (s *serverReflectionServer) allExtensionNumbersForTypeName(name string) ([]int32, error) {
-	st, err := typeForName(name)
-	if err != nil {
-		return nil, err
-	}
-	extNums, err := s.allExtensionNumbersForType(st)
-	if err != nil {
-		return nil, err
-	}
-	return extNums, nil
-}
-
-// ServerReflectionInfo is the reflection service handler.
-func (s *serverReflectionServer) ServerReflectionInfo(stream rpb.ServerReflection_ServerReflectionInfoServer) error {
-	sentFileDescriptors := make(map[string]bool)
-	for {
-		in, err := stream.Recv()
-		if err == io.EOF {
-			return nil
-		}
-		if err != nil {
-			return err
-		}
-
-		out := &rpb.ServerReflectionResponse{
-			ValidHost:       in.Host,
-			OriginalRequest: in,
-		}
-		switch req := in.MessageRequest.(type) {
-		case *rpb.ServerReflectionRequest_FileByFilename:
-			b, err := s.fileDescEncodingByFilename(req.FileByFilename, sentFileDescriptors)
-			if err != nil {
-				out.MessageResponse = &rpb.ServerReflectionResponse_ErrorResponse{
-					ErrorResponse: &rpb.ErrorResponse{
-						ErrorCode:    int32(codes.NotFound),
-						ErrorMessage: err.Error(),
-					},
-				}
-			} else {
-				out.MessageResponse = &rpb.ServerReflectionResponse_FileDescriptorResponse{
-					FileDescriptorResponse: &rpb.FileDescriptorResponse{FileDescriptorProto: b},
-				}
-			}
-		case *rpb.ServerReflectionRequest_FileContainingSymbol:
-			b, err := s.fileDescEncodingContainingSymbol(req.FileContainingSymbol, sentFileDescriptors)
-			if err != nil {
-				out.MessageResponse = &rpb.ServerReflectionResponse_ErrorResponse{
-					ErrorResponse: &rpb.ErrorResponse{
-						ErrorCode:    int32(codes.NotFound),
-						ErrorMessage: err.Error(),
-					},
-				}
-			} else {
-				out.MessageResponse = &rpb.ServerReflectionResponse_FileDescriptorResponse{
-					FileDescriptorResponse: &rpb.FileDescriptorResponse{FileDescriptorProto: b},
-				}
-			}
-		case *rpb.ServerReflectionRequest_FileContainingExtension:
-			typeName := req.FileContainingExtension.ContainingType
-			extNum := req.FileContainingExtension.ExtensionNumber
-			b, err := s.fileDescEncodingContainingExtension(typeName, extNum, sentFileDescriptors)
-			if err != nil {
-				out.MessageResponse = &rpb.ServerReflectionResponse_ErrorResponse{
-					ErrorResponse: &rpb.ErrorResponse{
-						ErrorCode:    int32(codes.NotFound),
-						ErrorMessage: err.Error(),
-					},
-				}
-			} else {
-				out.MessageResponse = &rpb.ServerReflectionResponse_FileDescriptorResponse{
-					FileDescriptorResponse: &rpb.FileDescriptorResponse{FileDescriptorProto: b},
-				}
-			}
-		case *rpb.ServerReflectionRequest_AllExtensionNumbersOfType:
-			extNums, err := s.allExtensionNumbersForTypeName(req.AllExtensionNumbersOfType)
-			if err != nil {
-				out.MessageResponse = &rpb.ServerReflectionResponse_ErrorResponse{
-					ErrorResponse: &rpb.ErrorResponse{
-						ErrorCode:    int32(codes.NotFound),
-						ErrorMessage: err.Error(),
-					},
-				}
-			} else {
-				out.MessageResponse = &rpb.ServerReflectionResponse_AllExtensionNumbersResponse{
-					AllExtensionNumbersResponse: &rpb.ExtensionNumberResponse{
-						BaseTypeName:    req.AllExtensionNumbersOfType,
-						ExtensionNumber: extNums,
-					},
-				}
-			}
-		case *rpb.ServerReflectionRequest_ListServices:
-			svcNames, _ := s.getSymbols()
-			serviceResponses := make([]*rpb.ServiceResponse, len(svcNames))
-			for i, n := range svcNames {
-				serviceResponses[i] = &rpb.ServiceResponse{
-					Name: n,
-				}
-			}
-			out.MessageResponse = &rpb.ServerReflectionResponse_ListServicesResponse{
-				ListServicesResponse: &rpb.ListServiceResponse{
-					Service: serviceResponses,
-				},
-			}
-		default:
-			return status.Errorf(codes.InvalidArgument, "invalid MessageRequest: %v", in.MessageRequest)
-		}
-
-		if err := stream.Send(out); err != nil {
-			return err
-		}
-	}
-}

reflection_test.go

@@ -4,8 +4,7 @@ import (
 	"fmt"
 	"testing"
 	
-	_ "go.unistack.org/micro-server-grpc/v3/proto"
+	"go.unistack.org/micro/v4/server"
-	"go.unistack.org/micro/v3/server"
 	"google.golang.org/grpc"
 	"google.golang.org/protobuf/reflect/protoreflect"
 	"google.golang.org/protobuf/reflect/protoregistry"
@@ -50,6 +49,7 @@ func (r *reflector) RangeExtensionsByMessage(message protoreflect.FullName, f fu
 }
 
 func TestReflector(t *testing.T) {
+	t.Skip()
 	srv := NewServer(Reflection(&reflector{}), server.Address(":12345"))
 	if err := srv.Init(); err != nil {
 		t.Fatal(err)

request.go

@@ -1,17 +1,14 @@
 package grpc
 
 import (
-	"io"
+	"go.unistack.org/micro/v4/codec"
-
+	"go.unistack.org/micro/v4/metadata"
-	"go.unistack.org/micro/v3/codec"
+	"go.unistack.org/micro/v4/server"
-	"go.unistack.org/micro/v3/metadata"
-	"go.unistack.org/micro/v3/server"
 )
 
 var _ server.Request = &rpcRequest{}
 
 type rpcRequest struct {
-	rw          io.ReadWriter
 	payload     interface{}
 	codec       codec.Codec
 	header      metadata.Metadata

response.go

@@ -1,17 +1,14 @@
 package grpc
 
 import (
-	"io"
+	"go.unistack.org/micro/v4/codec"
-
+	"go.unistack.org/micro/v4/metadata"
-	"go.unistack.org/micro/v3/codec"
+	"go.unistack.org/micro/v4/server"
-	"go.unistack.org/micro/v3/metadata"
-	"go.unistack.org/micro/v3/server"
 )
 
 var _ server.Response = &rpcResponse{}
 
 type rpcResponse struct {
-	rw     io.ReadWriter
 	header metadata.Metadata
 	codec  codec.Codec
 }

server.go

@@ -14,7 +14,7 @@ import (
 	"unicode"
 	"unicode/utf8"
 
-	"go.unistack.org/micro/v3/server"
+	"go.unistack.org/micro/v4/server"
 )
 
 // Precompute the reflect type for error. Can't use error directly
@@ -47,8 +47,8 @@ type rServer struct {
 
 // Is this an exported - upper case - name?
 func isExported(name string) bool {
-	rune, _ := utf8.DecodeRuneInString(name)
+	r, _ := utf8.DecodeRuneInString(name)
-	return unicode.IsUpper(rune)
+	return unicode.IsUpper(r)
 }
 
 // Is this type exported or a builtin?
@@ -123,43 +123,43 @@ func prepareEndpoint(method reflect.Method) (*methodType, error) {
 	return &methodType{method: method, ArgType: argType, ReplyType: replyType, ContextType: contextType, stream: stream}, nil
 }
 
-func (server *rServer) register(rcvr interface{}) error {
+func (s *rServer) register(rcvr interface{}) error {
-	server.mu.Lock()
+	s.mu.Lock()
-	defer server.mu.Unlock()
+	defer s.mu.Unlock()
-	if server.serviceMap == nil {
+	if s.serviceMap == nil {
-		server.serviceMap = make(map[string]*service)
+		s.serviceMap = make(map[string]*service)
 	}
-	s := &service{}
+	srv := &service{}
-	s.typ = reflect.TypeOf(rcvr)
+	srv.typ = reflect.TypeOf(rcvr)
-	s.rcvr = reflect.ValueOf(rcvr)
+	srv.rcvr = reflect.ValueOf(rcvr)
-	sname := reflect.Indirect(s.rcvr).Type().Name()
+	sname := reflect.Indirect(srv.rcvr).Type().Name()
 	if sname == "" {
-		return fmt.Errorf("rpc: no service name for type %v", s.typ.String())
+		return fmt.Errorf("rpc: no service name for type %v", srv.typ.String())
 	}
 	if !isExported(sname) {
 		return fmt.Errorf("rpc Register: type %s is not exported", sname)
 	}
-	if _, present := server.serviceMap[sname]; present {
+	if _, present := s.serviceMap[sname]; present {
-		return fmt.Errorf("rpc: service already defined: " + sname)
+		return fmt.Errorf("rpc: service already defined: %s", sname)
 	}
-	s.name = sname
+	srv.name = sname
-	s.method = make(map[string]*methodType)
+	srv.method = make(map[string]*methodType)
 
 	// Install the methods
-	for m := 0; m < s.typ.NumMethod(); m++ {
+	for m := 0; m < srv.typ.NumMethod(); m++ {
-		method := s.typ.Method(m)
+		method := srv.typ.Method(m)
 		mt, err := prepareEndpoint(method)
 		if mt != nil && err == nil {
-			s.method[method.Name] = mt
+			srv.method[method.Name] = mt
 		} else if err != nil {
 			return err
 		}
 	}
 
-	if len(s.method) == 0 {
+	if len(srv.method) == 0 {
 		return fmt.Errorf("rpc Register: type %s has no exported methods of suitable type", sname)
 	}
-	server.serviceMap[s.name] = s
+	s.serviceMap[srv.name] = srv
 	return nil
 }
 

stream.go

@@ -3,7 +3,7 @@ package grpc
 import (
 	"context"
 
-	"go.unistack.org/micro/v3/server"
+	"go.unistack.org/micro/v4/server"
 	"google.golang.org/grpc"
 )
 

subscriber.go

@@ -1,285 +0,0 @@
-package grpc
-
-import (
-	"context"
-	"fmt"
-	"reflect"
-	"strings"
-
-	"go.unistack.org/micro/v3/broker"
-	"go.unistack.org/micro/v3/codec"
-	"go.unistack.org/micro/v3/logger"
-	"go.unistack.org/micro/v3/metadata"
-	"go.unistack.org/micro/v3/options"
-	"go.unistack.org/micro/v3/register"
-	"go.unistack.org/micro/v3/server"
-)
-
-var _ server.Message = &rpcMessage{}
-
-type rpcMessage struct {
-	payload     interface{}
-	codec       codec.Codec
-	header      metadata.Metadata
-	topic       string
-	contentType string
-}
-
-func (r *rpcMessage) ContentType() string {
-	return r.contentType
-}
-
-func (r *rpcMessage) Topic() string {
-	return r.topic
-}
-
-func (r *rpcMessage) Body() interface{} {
-	return r.payload
-}
-
-func (r *rpcMessage) Header() metadata.Metadata {
-	return r.header
-}
-
-func (r *rpcMessage) Codec() codec.Codec {
-	return r.codec
-}
-
-type handler struct {
-	reqType reflect.Type
-	ctxType reflect.Type
-	method  reflect.Value
-}
-
-type subscriber struct {
-	topic      string
-	rcvr       reflect.Value
-	typ        reflect.Type
-	subscriber interface{}
-	handlers   []*handler
-	endpoints  []*register.Endpoint
-	opts       server.SubscriberOptions
-}
-
-func newSubscriber(topic string, sub interface{}, opts ...server.SubscriberOption) server.Subscriber {
-	options := server.NewSubscriberOptions(opts...)
-
-	var endpoints []*register.Endpoint
-	var handlers []*handler
-
-	if typ := reflect.TypeOf(sub); typ.Kind() == reflect.Func {
-		h := &handler{
-			method: reflect.ValueOf(sub),
-		}
-
-		switch typ.NumIn() {
-		case 1:
-			h.reqType = typ.In(0)
-		case 2:
-			h.ctxType = typ.In(0)
-			h.reqType = typ.In(1)
-		}
-
-		handlers = append(handlers, h)
-
-		endpoints = append(endpoints, &register.Endpoint{
-			Name:    "Func",
-			Request: register.ExtractSubValue(typ),
-			Metadata: map[string]string{
-				"topic":      topic,
-				"subscriber": "true",
-			},
-		})
-	} else {
-		hdlr := reflect.ValueOf(sub)
-		name := reflect.Indirect(hdlr).Type().Name()
-
-		for m := 0; m < typ.NumMethod(); m++ {
-			method := typ.Method(m)
-			h := &handler{
-				method: method.Func,
-			}
-
-			switch method.Type.NumIn() {
-			case 2:
-				h.reqType = method.Type.In(1)
-			case 3:
-				h.ctxType = method.Type.In(1)
-				h.reqType = method.Type.In(2)
-			}
-
-			handlers = append(handlers, h)
-
-			endpoints = append(endpoints, &register.Endpoint{
-				Name:    name + "." + method.Name,
-				Request: register.ExtractSubValue(method.Type),
-				Metadata: map[string]string{
-					"topic":      topic,
-					"subscriber": "true",
-				},
-			})
-		}
-	}
-
-	return &subscriber{
-		rcvr:       reflect.ValueOf(sub),
-		typ:        reflect.TypeOf(sub),
-		topic:      topic,
-		subscriber: sub,
-		handlers:   handlers,
-		endpoints:  endpoints,
-		opts:       options,
-	}
-}
-
-func (g *Server) createSubHandler(sb *subscriber, opts server.Options) broker.Handler {
-	return func(p broker.Event) (err error) {
-		msg := p.Message()
-		// if we don't have headers, create empty map
-		if msg.Header == nil {
-			msg.Header = make(map[string]string)
-		}
-
-		ct := msg.Header["Content-Type"]
-		if len(ct) == 0 {
-			msg.Header["Content-Type"] = DefaultContentType
-			ct = DefaultContentType
-		}
-		cf, err := g.newCodec(ct)
-		if err != nil {
-			return err
-		}
-
-		hdr := make(map[string]string, len(msg.Header))
-		for k, v := range msg.Header {
-			hdr[k] = v
-		}
-
-		ctx := metadata.NewIncomingContext(sb.opts.Context, hdr)
-
-		results := make(chan error, len(sb.handlers))
-
-		for i := 0; i < len(sb.handlers); i++ {
-			handler := sb.handlers[i]
-
-			var isVal bool
-			var req reflect.Value
-
-			if handler.reqType.Kind() == reflect.Ptr {
-				req = reflect.New(handler.reqType.Elem())
-			} else {
-				req = reflect.New(handler.reqType)
-				isVal = true
-			}
-			if isVal {
-				req = req.Elem()
-			}
-
-			if err = cf.Unmarshal(msg.Body, req.Interface()); err != nil {
-				return err
-			}
-
-			fn := func(ctx context.Context, msg server.Message) error {
-				var vals []reflect.Value
-				if sb.typ.Kind() != reflect.Func {
-					vals = append(vals, sb.rcvr)
-				}
-				if handler.ctxType != nil {
-					vals = append(vals, reflect.ValueOf(ctx))
-				}
-
-				vals = append(vals, reflect.ValueOf(msg.Body()))
-
-				returnValues := handler.method.Call(vals)
-				if rerr := returnValues[0].Interface(); rerr != nil {
-					return rerr.(error)
-				}
-				return nil
-			}
-
-			opts.Hooks.EachNext(func(hook options.Hook) {
-				if h, ok := hook.(server.HookSubHandler); ok {
-					fn = h(fn)
-				}
-			})
-
-			if g.wg != nil {
-				g.wg.Add(1)
-			}
-			go func() {
-				if g.wg != nil {
-					defer g.wg.Done()
-				}
-				cerr := fn(ctx, &rpcMessage{
-					topic:       sb.topic,
-					contentType: ct,
-					payload:     req.Interface(),
-					header:      msg.Header,
-				})
-				results <- cerr
-			}()
-		}
-		var errors []string
-		for i := 0; i < len(sb.handlers); i++ {
-			if rerr := <-results; rerr != nil {
-				errors = append(errors, rerr.Error())
-			}
-		}
-		if len(errors) > 0 {
-			err = fmt.Errorf("subscriber error: %s", strings.Join(errors, "\n"))
-		}
-
-		return err
-	}
-}
-
-func (s *subscriber) Topic() string {
-	return s.topic
-}
-
-func (s *subscriber) Subscriber() interface{} {
-	return s.subscriber
-}
-
-func (s *subscriber) Endpoints() []*register.Endpoint {
-	return s.endpoints
-}
-
-func (s *subscriber) Options() server.SubscriberOptions {
-	return s.opts
-}
-
-func (g *Server) subscribe() error {
-	config := g.opts
-	subCtx := config.Context
-
-	for sb := range g.subscribers {
-
-		if cx := sb.Options().Context; cx != nil {
-			subCtx = cx
-		}
-
-		opts := []broker.SubscribeOption{
-			broker.SubscribeContext(subCtx),
-			broker.SubscribeAutoAck(sb.Options().AutoAck),
-			broker.SubscribeBodyOnly(sb.Options().BodyOnly),
-		}
-
-		if queue := sb.Options().Queue; len(queue) > 0 {
-			opts = append(opts, broker.SubscribeGroup(queue))
-		}
-
-		if config.Logger.V(logger.InfoLevel) {
-			config.Logger.Info(config.Context, "subscribing to topic: "+sb.Topic())
-		}
-
-		sub, err := config.Broker.Subscribe(subCtx, sb.Topic(), g.createSubHandler(sb, config), opts...)
-		if err != nil {
-			return err
-		}
-
-		g.subscribers[sb] = []broker.Subscriber{sub}
-	}
-
-	return nil
-}

util_test.go

@@ -26,6 +26,7 @@ func TestServiceMethod(t *testing.T) {
 		if err != nil && test.err == true {
 			continue
 		}
+		t.Logf("input %s service %s method %s", test.input, service, method)
 		// unexpected error
 		if err != nil && test.err == false {
 			t.Fatalf("unexpected err %v for %+v", err, test)