http transport data race issue (#2436)

* [fix] #2431 http transport data race issue

.github/FUNDING.yml

@@ -1 +1,3 @@
+# These are supported funding model platforms
+
 github: asim

.github/ISSUE_TEMPLATE/bug_report.md

@@ -1,44 +1,24 @@
 ---
 name: Bug report
-about: Create a report to help us improve
-title: '[BUG] '
-labels: bug
+about: For reporting bugs in go-micro
+title: "[BUG]"
+labels: ''
 assignees: ''
+
 ---
 
-## Describe the bug
-A clear and concise description of what the bug is.
+**Describe the bug**
 
-## To Reproduce
-Steps to reproduce the behavior:
-1. Create service with '...'
-2. Configure plugin '...'
-3. Run command '...'
-4. See error
+1. What are you trying to do?
+2. What did you expect to happen?
+3. What happens instead?
 
-## Expected behavior
-A clear and concise description of what you expected to happen.
+**How to reproduce the bug:**
 
-## Code sample
-```go
-// Minimal reproducible code
+If possible, please include a minimal code snippet here.
+
+**Environment:**
+Go Version: please paste `go version` output here
 ```
-
-## Environment
-- Go Micro version: [e.g. v5.3.0]
-- Go version: [e.g. 1.21.0]
-- OS: [e.g. Ubuntu 22.04]
-- Plugins used: [e.g. consul registry, nats broker]
-
-## Logs
+please paste `go env` output here
 ```
-Paste relevant logs here
-```
-
-## Additional context
-Add any other context about the problem here.
-
-## Resources
-- [Documentation](https://github.com/micro/go-micro/tree/master/internal/website/docs)
-- [Examples](https://github.com/micro/go-micro/tree/master/internal/website/docs/examples)
-- [API Reference](https://pkg.go.dev/go-micro.dev/v5)

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

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

.github/ISSUE_TEMPLATE/feature_request.md

@@ -1,30 +0,0 @@
----
-name: Feature request
-about: Suggest an idea for this project
-title: '[FEATURE] '
-labels: enhancement
-assignees: ''
----
-
-## Is your feature request related to a problem?
-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.
-
-## Describe alternatives you've considered
-A clear and concise description of any alternative solutions or features you've considered.
-
-## Use case
-Describe how this feature would be used in practice. What problem does it solve?
-
-## Additional context
-Add any other context, code examples, or screenshots about the feature request here.
-
-## Willing to contribute?
-- [ ] I'd be willing to submit a PR for this feature
-
-## Resources
-- [Documentation](https://github.com/micro/go-micro/tree/master/internal/website/docs)
-- [Plugins](https://github.com/micro/go-micro/tree/master/internal/website/docs/plugins.md)
-- [Roadmap](https://github.com/micro/go-micro/blob/master/ROADMAP.md)

.github/ISSUE_TEMPLATE/question.md

@@ -1,31 +1,14 @@
 ---
 name: Question
-about: Ask a question about using Go Micro
-title: '[QUESTION] '
-labels: question
+about: Ask a question about go-micro
+title: ''
+labels: ''
 assignees: ''
+
 ---
 
-## Your question
-A clear and concise question about Go Micro usage.
+Before asking, please check if your question has already been answered: 
 
-## What have you tried?
-Describe what you've already attempted or researched.
-
-## Code sample (if applicable)
-```go
-// Your code here
-```
-
-## Context
-Provide any additional context that might help answer your question.
-
-## Resources you've checked
-- [ ] [Getting Started Guide](https://github.com/micro/go-micro/tree/master/internal/website/docs/getting-started.md)
-- [ ] [Examples](https://github.com/micro/go-micro/tree/master/internal/website/docs/examples)
-- [ ] [API Documentation](https://pkg.go.dev/go-micro.dev/v5)
-- [ ] Searched existing issues
-
-## Helpful links
-- [Documentation](https://github.com/micro/go-micro/tree/master/internal/website/docs)
-- [Plugins Guide](https://github.com/micro/go-micro/tree/master/internal/website/docs/plugins.md)
+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/PULL_REQUEST_TEMPLATE.md

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

.github/generate.sh

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

.github/workflows/pr.yml

@@ -0,0 +1,28 @@
+name: PR Sanity Check
+on: pull_request
+
+jobs:
+
+  prtest:
+    name: PR sanity check
+    runs-on: ubuntu-latest
+    steps:
+
+    - name: Set up Go 1.15
+      uses: actions/setup-go@v1
+      with:
+        go-version: 1.15
+      id: go
+
+    - name: Check out code into the Go module directory
+      uses: actions/checkout@v2
+
+    - name: Get dependencies
+      run: |
+        go get -v -t -d ./...
+
+    - name: Run tests
+      id: tests
+      env:
+        IN_TRAVIS_CI: yes
+      run: go test -v ./...

.github/workflows/tests.yaml

@@ -1,74 +0,0 @@
-name: Run Tests
-on:
-  push:
-    branches:
-      - "**"
-  pull_request:
-    types:
-      - opened
-      - reopened
-    branches:
-      - "**"
-jobs:
-  unittests:
-    name: Unit Tests
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v3
-      - name: Set up Go
-        uses: actions/setup-go@v3
-        with:
-          go-version: 1.24
-          check-latest: true
-          cache: true
-      - name: Get dependencies
-        run: |
-          go install github.com/kyoh86/richgo@latest
-          go get -v -t -d ./...
-      - name: Run tests
-        id: tests
-        run: richgo test -v -race -cover ./...
-        env:
-          IN_TRAVIS_CI: yes
-          RICHGO_FORCE_COLOR: 1
-  
-  etcd-integration:
-    name: Etcd Integration Tests
-    runs-on: ubuntu-latest
-    permissions:
-      contents: read
-    services:
-      etcd:
-        image: quay.io/coreos/etcd:v3.5.2
-        env:
-          ETCD_LISTEN_CLIENT_URLS: http://0.0.0.0:2379
-          ETCD_ADVERTISE_CLIENT_URLS: http://0.0.0.0:2379
-        ports:
-          - 2379:2379
-        options: >-
-          --health-cmd "etcdctl endpoint health"
-          --health-interval 10s
-          --health-timeout 5s
-          --health-retries 5
-    steps:
-      - uses: actions/checkout@v3
-      - name: Set up Go
-        uses: actions/setup-go@v3
-        with:
-          go-version: 1.24
-          check-latest: true
-          cache: true
-      - name: Get dependencies
-        run: |
-          go install github.com/kyoh86/richgo@latest
-          go get -v -t -d ./...
-      - name: Wait for etcd
-        run: |
-          timeout 30 bash -c 'until curl -s http://localhost:2379/health; do sleep 1; done'
-      - name: Run etcd integration tests
-        run: richgo test -v -race ./registry/etcd/...
-        env:
-          ETCD_ADDRESS: localhost:2379
-          IN_TRAVIS_CI: yes
-          RICHGO_FORCE_COLOR: 1
-

.github/workflows/tests.yml

@@ -0,0 +1,29 @@
+name: Run tests
+on: [push]
+
+jobs:
+
+  test:
+    name: Test repo
+    runs-on: ubuntu-latest
+    steps:
+
+    - name: Set up Go 1.15
+      uses: actions/setup-go@v1
+      with:
+        go-version: 1.15
+      id: go
+
+    - name: Check out code into the Go module directory
+      uses: actions/checkout@v2
+
+    - name: Get dependencies
+      run: |
+        go get -v -t -d ./...
+
+    - name: Run tests
+      id: tests
+      env:
+        IN_TRAVIS_CI: yes
+      run: go test -v ./...
+

.github/workflows/website.yml

@@ -1,51 +0,0 @@
-# Sample workflow for building and deploying a Jekyll site to GitHub Pages
-name: Deploy Jekyll with GitHub Pages dependencies preinstalled
-
-on:
-  # Runs on pushes targeting the default branch
-  push:
-    branches: ["master"]
-
-  # Allows you to run this workflow manually from the Actions tab
-  workflow_dispatch:
-
-# Sets permissions of the GITHUB_TOKEN to allow deployment to GitHub Pages
-permissions:
-  contents: read
-  pages: write
-  id-token: write
-
-# Allow only one concurrent deployment, skipping runs queued between the run in-progress and latest queued.
-# However, do NOT cancel in-progress runs as we want to allow these production deployments to complete.
-concurrency:
-  group: "pages"
-  cancel-in-progress: false
-
-jobs:
-  # Build job
-  build:
-    runs-on: ubuntu-latest
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v4
-      - name: Setup Pages
-        uses: actions/configure-pages@v5
-      - name: Build with Jekyll
-        uses: actions/jekyll-build-pages@v1
-        with:
-          source: ./internal/website
-          destination: ./_site
-      - name: Upload artifact
-        uses: actions/upload-pages-artifact@v3
-
-  # Deployment job
-  deploy:
-    environment:
-      name: github-pages
-      url: ${{ steps.deployment.outputs.page_url }}
-    runs-on: ubuntu-latest
-    needs: build
-    steps:
-      - name: Deploy to GitHub Pages
-        id: deployment
-        uses: actions/deploy-pages@v4

.gitignore

@@ -1,7 +1,6 @@
 # Develop tools
 /.vscode/
 /.idea/
-/.trunk
 
 # Binaries for programs and plugins
 *.exe
@@ -35,7 +34,3 @@ _cgo_export.*
 *~
 *.swp
 *.swo
-
-# go work files
-go.work
-go.work.sum

.golangci.yaml

@@ -1,251 +0,0 @@
-# This file contains all available configuration options
-# with their default values.
-
-# options for analysis running
-run:
-  # go: '1.18'
-  # default concurrency is a available CPU number
-  # concurrency: 4
-
-  # timeout for analysis, e.g. 30s, 5m, default is 1m
-  deadline: 10m
-
-  # exit code when at least one issue was found, default is 1
-  issues-exit-code: 1
-
-  # include test files or not, default is true
-  tests: true
-
-  # which files to skip: they will be analyzed, but issues from them
-  # won't be reported. Default value is empty list, but there is
-  # no need to include all autogenerated files, we confidently recognize
-  # autogenerated files. If it's not please let us know.
-  skip-files:
-    []
-    # - .*\\.pb\\.go$
-
-  allow-parallel-runners: true
-
-  # list of build tags, all linters use it. Default is empty list.
-  build-tags: []
-
-# output configuration options
-output:
-  # Format: colored-line-number|line-number|json|tab|checkstyle|code-climate|junit-xml|github-actions
-  #
-  # Multiple can be specified by separating them by comma, output can be provided
-  # for each of them by separating format name and path by colon symbol.
-  # Output path can be either `stdout`, `stderr` or path to the file to write to.
-  # Example: "checkstyle:report.json,colored-line-number"
-  #
-  # Default: colored-line-number
-  format: colored-line-number
-  # Print lines of code with issue.
-  # Default: true
-  print-issued-lines: true
-  # Print linter name in the end of issue text.
-  # Default: true
-  print-linter-name: true
-  # Make issues output unique by line.
-  # Default: true
-  uniq-by-line: true
-  # Add a prefix to the output file references.
-  # Default is no prefix.
-  path-prefix: ""
-  # Sort results by: filepath, line and column.
-  sort-results: true
-
-# all available settings of specific linters
-linters-settings:
-  wsl:
-    allow-cuddle-with-calls: ["Lock", "RLock", "defer"]
-  funlen:
-    lines: 80
-    statements: 60
-  varnamelen:
-    # The longest distance, in source lines, that is being considered a "small scope".
-    # Variables used in at most this many lines will be ignored.
-    # Default: 5
-    max-distance: 26
-    ignore-names:
-      - err
-      - id
-      - ch
-      - wg
-      - mu
-    ignore-decls:
-      - c echo.Context
-      - t testing.T
-      - f *foo.Bar
-      - e error
-      - i int
-      - const C
-      - T any
-      - m map[string]int
-  errcheck:
-    # report about not checking of errors in type assetions: `a := b.(MyStruct)`;
-    # default is false: such cases aren't reported by default.
-    check-type-assertions: true
-
-    # report about assignment of errors to blank identifier: `num, _ := strconv.Atoi(numStr)`;
-    # default is false: such cases aren't reported by default.
-    check-blank: true
-  govet:
-    # report about shadowed variables
-    check-shadowing: false
-  gofmt:
-    # simplify code: gofmt with `-s` option, true by default
-    simplify: true
-  gocyclo:
-    # minimal code complexity to report, 30 by default (but we recommend 10-20)
-    min-complexity: 15
-  maligned:
-    # print struct with more effective memory layout or not, false by default
-    suggest-new: true
-  dupl:
-    # tokens count to trigger issue, 150 by default
-    threshold: 100
-  goconst:
-    # minimal length of string constant, 3 by default
-    min-len: 3
-    # minimal occurrences count to trigger, 3 by default
-    min-occurrences: 3
-  depguard:
-    list-type: blacklist
-    # Packages listed here will reported as error if imported
-    packages:
-      - github.com/golang/protobuf/proto
-  misspell:
-    # Correct spellings using locale preferences for US or UK.
-    # Default is to use a neutral variety of English.
-    # Setting locale to US will correct the British spelling of 'colour' to 'color'.
-    locale: US
-  lll:
-    # max line length, lines longer will be reported. Default is 120.
-    # '\t' is counted as 1 character by default, and can be changed with the tab-width option
-    line-length: 120
-    # tab width in spaces. Default to 1.
-    tab-width: 1
-  unused:
-    # treat code as a program (not a library) and report unused exported identifiers; default is false.
-    # XXX: if you enable this setting, unused will report a lot of false-positives in text editors:
-    # if it's called for subdir of a project it can't find funcs usages. All text editor integrations
-    # with golangci-lint call it on a directory with the changed file.
-    check-exported: false
-  unparam:
-    # call graph construction algorithm (cha, rta). In general, use cha for libraries,
-    # and rta for programs with main packages. Default is cha.
-    algo: cha
-
-    # Inspect exported functions, default is false. Set to true if no external program/library imports your code.
-    # XXX: if you enable this setting, unparam will report a lot of false-positives in text editors:
-    # if it's called for subdir of a project it can't find external interfaces. All text editor integrations
-    # with golangci-lint call it on a directory with the changed file.
-    check-exported: false
-  nakedret:
-    # make an issue if func has more lines of code than this setting and it has naked returns; default is 30
-    max-func-lines: 60
-  nolintlint:
-    allow-unused: false
-    allow-leading-space: false
-    allow-no-explanation: []
-    require-explanation: false
-    require-specific: true
-  prealloc:
-    # XXX: we don't recommend using this linter before doing performance profiling.
-    # For most programs usage of prealloc will be a premature optimization.
-
-    # Report preallocation suggestions only on simple loops that have no returns/breaks/continues/gotos in them.
-    # True by default.
-    simple: true
-    range-loops: true # Report preallocation suggestions on range loops, true by default
-    for-loops: false # Report preallocation suggestions on for loops, false by default
-  cyclop:
-    # the maximal code complexity to report
-    max-complexity: 20
-  gomoddirectives:
-    replace-local: true
-    retract-allow-no-explanation: false
-    exclude-forbidden: true
-
-linters:
-  enable-all: true
-  disable-all: false
-  fast: false
-  disable:
-    - golint
-    - varcheck
-    - ifshort
-    - structcheck
-    - deadcode
-    # - nosnakecase
-    - interfacer
-    - maligned
-    - scopelint
-    - exhaustivestruct
-    - testpackage
-    - promlinter
-    - nonamedreturns
-    - makezero
-    - gofumpt
-    - nlreturn
-    - thelper
-
-    # Can be considered to be enabled
-    - gochecknoinits
-    - gochecknoglobals # RIP
-    - dogsled
-    - wrapcheck
-    - paralleltest
-    - ireturn
-    - gomnd
-    - goerr113
-    - exhaustruct
-    - containedctx
-    - godox
-    - forcetypeassert
-    - gci
-    - lll
-
-issues:
-  # List of regexps of issue texts to exclude, empty list by default.
-  # But independently from this option we use default exclude patterns,
-  # it can be disabled by `exclude-use-default: false`. To list all
-  # excluded by default patterns execute `golangci-lint run --help`
-  # exclude:
-  #   - package comment should be of the form "Package services ..." # revive
-  #   - ^ST1000 # ST1000: at least one file in a package should have a package comment (stylecheck)
-
-  # exclude-rules:
-  #   - path: internal/app/machined/pkg/system/services
-  #     linters:
-  #       - dupl
-  exclude-rules:
-    - path: _test\.go
-      linters:
-        - gocyclo
-        - dupl
-        - gosec
-        - funlen
-        - varnamelen
-        - wsl
-
-  # Independently from option `exclude` we use default exclude patterns,
-  # it can be disabled by this option. To list all
-  # excluded by default patterns execute `golangci-lint run --help`.
-  # Default value for this option is true.
-  exclude-use-default: false
-
-  # Maximum issues count per one linter. Set to 0 to disable. Default is 50.
-  max-issues-per-linter: 0
-
-  # Maximum count of issues with the same text. Set to 0 to disable. Default is 3.
-  max-same-issues: 0
-
-  # Show only new issues: if there are unstaged changes or untracked files,
-  # only those changes are analyzed, else only changes in HEAD~ are analyzed.
-  # It's a super-useful option for integration of golangci-lint into existing
-  # large codebase. It's not practical to fix all existing issues at the moment
-  # of integration: much better don't allow issues in new code.
-  # Default is false.
-  new: false

.richstyle.yaml

@@ -1,29 +0,0 @@
-labelType: long
-coverThreshold: 70
-buildStyle:
-  bold: true
-  foreground: yellow
-startStyle:
-  foreground: lightBlack
-passStyle:
-  foreground: green
-failStyle:
-  bold: true
-  foreground: "#821515"
-skipStyle:
-  foreground: lightBlack
-passPackageStyle:
-  foreground: green
-  hide: false
-failPackageStyle:
-  bold: true
-  foreground: "#821515"
-coveredStyle:
-  foreground: green
-uncoveredStyle:
-  bold: true
-  foreground: yellow
-fileStyle:
-  foreground: cyan
-lineStyle:
-  foreground: magenta

CONTRIBUTING.md

@@ -1,207 +0,0 @@
-# Contributing to Go Micro
-
-Thank you for your interest in contributing to Go Micro! This document provides guidelines and instructions for contributing.
-
-## Code of Conduct
-
-Be respectful, inclusive, and collaborative. We're all here to build great software together.
-
-## Getting Started
-
-1. Fork the repository
-2. Clone your fork: `git clone https://github.com/YOUR_USERNAME/go-micro.git`
-3. Add upstream remote: `git remote add upstream https://github.com/micro/go-micro.git`
-4. Create a feature branch: `git checkout -b feature/my-feature`
-
-## Development Setup
-
-```bash
-# Install dependencies
-go mod download
-
-# Run tests
-go test ./...
-
-# Run tests with coverage
-go test -race -coverprofile=coverage.out ./...
-
-# Run linter (install golangci-lint first)
-golangci-lint run
-```
-
-## Making Changes
-
-### Code Guidelines
-
-- Follow standard Go conventions (use `gofmt`, `golint`)
-- Write clear, descriptive commit messages
-- Add tests for new functionality
-- Update documentation for API changes
-- Keep PRs focused - one feature/fix per PR
-
-### Commit Messages
-
-Use conventional commits format:
-
-```
-type(scope): subject
-
-body
-
-footer
-```
-
-Types:
-- `feat`: New feature
-- `fix`: Bug fix
-- `docs`: Documentation changes
-- `test`: Test additions/changes
-- `refactor`: Code refactoring
-- `perf`: Performance improvements
-- `chore`: Maintenance tasks
-
-Examples:
-```
-feat(registry): add kubernetes registry plugin
-fix(broker): resolve nats connection leak
-docs(examples): add streaming example
-```
-
-### Testing
-
-- Write unit tests for all new code
-- Ensure existing tests pass
-- Add integration tests for plugin implementations
-- Test with multiple Go versions (1.20+)
-
-```bash
-# Run specific package tests
-go test ./registry/...
-
-# Run with verbose output
-go test -v ./...
-
-# Run specific test
-go test -run TestMyFunction ./pkg/...
-```
-
-### Documentation
-
-- Update relevant markdown files in `internal/website/docs/`
-- Add examples to `internal/website/docs/examples/` for new features
-- Update README.md for major features
-- Add godoc comments for exported functions/types
-
-## Pull Request Process
-
-1. **Update your branch**
-   ```bash
-   git fetch upstream
-   git rebase upstream/master
-   ```
-
-2. **Run tests and linting**
-   ```bash
-   go test ./...
-   golangci-lint run
-   ```
-
-3. **Push to your fork**
-   ```bash
-   git push origin feature/my-feature
-   ```
-
-4. **Create Pull Request**
-   - Use a descriptive title
-   - Reference any related issues
-   - Describe what changed and why
-   - Add screenshots for UI changes
-   - Mark as draft if work in progress
-
-5. **PR Review**
-   - Respond to feedback promptly
-   - Make requested changes
-   - Re-request review after updates
-
-### PR Checklist
-
-- [ ] Tests pass locally
-- [ ] Code follows Go conventions
-- [ ] Documentation updated
-- [ ] Commit messages are clear
-- [ ] Branch is up to date with master
-- [ ] No merge conflicts
-
-## Adding Plugins
-
-New plugins should:
-
-1. Live in the appropriate interface directory (e.g., `registry/myplugin/`)
-2. Implement the interface completely
-3. Include comprehensive tests
-4. Provide usage examples
-5. Document configuration options (env vars, options)
-6. Add to plugin documentation
-
-Example structure:
-```
-registry/myplugin/
-├── myplugin.go          # Main implementation
-├── myplugin_test.go     # Tests
-├── options.go           # Plugin-specific options
-└── README.md            # Usage and configuration
-```
-
-## Reporting Issues
-
-Before creating an issue:
-
-1. Search existing issues
-2. Check documentation
-3. Try the latest version
-
-When reporting bugs:
-- Use the bug report template
-- Include minimal reproduction code
-- Specify versions (Go, Go Micro, plugins)
-- Provide relevant logs
-
-## Documentation Contributions
-
-Documentation improvements are always welcome!
-
-- Fix typos and grammar
-- Improve clarity
-- Add missing examples
-- Update outdated information
-
-Documentation lives in `internal/website/docs/`. Preview locally with Jekyll:
-
-```bash
-cd internal/website
-bundle install
-bundle exec jekyll serve --livereload
-```
-
-## Community
-
-- GitHub Issues: Bug reports and feature requests
-- GitHub Discussions: Questions, ideas, and community chat
-- Sponsorship: [GitHub Sponsors](https://github.com/sponsors/micro)
-
-## Release Process
-
-Maintainers handle releases:
-
-1. Update CHANGELOG.md
-2. Tag release: `git tag -a v5.x.x -m "Release v5.x.x"`
-3. Push tag: `git push origin v5.x.x`
-4. GitHub Actions creates release
-
-## Questions?
-
-- Check [documentation](internal/website/docs/)
-- Browse [examples](internal/website/docs/examples/)
-- Open a [question issue](.github/ISSUE_TEMPLATE/question.md)
-
-Thank you for contributing to Go Micro! 🎉

LICENSE

@@ -1,3 +1,4 @@
+
                                  Apache License
                            Version 2.0, January 2004
                         http://www.apache.org/licenses/
@@ -175,18 +176,7 @@
 
    END OF TERMS AND CONDITIONS
 
-   APPENDIX: How to apply the Apache License to your work.
-
-      To apply the Apache License to your work, attach the following
-      boilerplate notice, with the fields enclosed by brackets "[]"
-      replaced with your own identifying information. (Don't include
-      the brackets!)  The text should be enclosed in the appropriate
-      comment syntax for the file format. We also recommend that a
-      file or class name and description of purpose be included on the
-      same "printed page" as the copyright notice for easier
-      identification within third-party archives.
-
-   Copyright [yyyy] [name of copyright owner]
+   Copyright 2015 Asim Aslam.
 
    Licensed under the Apache License, Version 2.0 (the "License");
    you may not use this file except in compliance with the License.

README.md

@@ -1,226 +1,92 @@
-# Go Micro [![Go.Dev reference](https://img.shields.io/badge/go.dev-reference-007d9c?logo=go&logoColor=white&style=flat-square)](https://pkg.go.dev/go-micro.dev/v5?tab=doc) [![Go Report Card](https://goreportcard.com/badge/github.com/go-micro/go-micro)](https://goreportcard.com/report/github.com/go-micro/go-micro) 
+# Go Micro [![License](https://img.shields.io/:license-apache-blue.svg)](https://opensource.org/licenses/Apache-2.0) [![Go.Dev reference](https://img.shields.io/badge/go.dev-reference-007d9c?logo=go&logoColor=white&style=flat-square)](https://pkg.go.dev/github.com/asim/go-micro/v3?tab=doc)
 
 Go Micro is a framework for distributed systems development.
 
-**[📖 Documentation](https://go-micro.dev/docs/)** | [Sponsor the project](https://github.com/sponsors/micro)
-
 ## Overview
 
-Go Micro provides the core requirements for distributed systems development including RPC and Event driven communication.
-The Go Micro philosophy is sane defaults with a pluggable architecture. We provide defaults to get you started quickly
-but everything can be easily swapped out.
+Go Micro provides the core requirements for distributed systems development including RPC and Event driven communication. 
+The **Micro** philosophy is sane defaults with a pluggable architecture. We provide defaults to get you started quickly 
+but everything can be easily swapped out. 
 
 ## Features
 
 Go 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.
+- **Authentication** - Auth is built in as a first class citizen. Authentication and authorization enable secure 
+zero trust networking by providing every service an identity and certificates. This additionally includes rule 
+based access control.
 
-- **Dynamic Config** - Load and hot reload dynamic config from anywhere. The config interface provides a way to load application
-  level config from any source such as env vars, file, etcd. You can merge the sources and even define fallbacks.
+- **Dynamic Config** - Load and hot reload dynamic config from anywhere. The config interface provides a way to load application 
+level config from any source such as env vars, file, etcd. You can merge the sources and even define fallbacks.
 
-- **Data Storage** - A simple data store interface to read, write and delete records. It includes support for many storage backends
-in the plugins repo. State and persistence becomes a core requirement beyond prototyping and Micro looks to build that into the framework.
+- **Data Storage** - A simple data store interface to read, write and delete records. It includes support for memory, file and 
+CockroachDB by default. State and persistence becomes a core requirement beyond prototyping and Micro looks to build that into the framework.
 
-- **Service Discovery** - Automatic service registration and name resolution. Service discovery is at the core of micro service
-  development. When service A needs to speak to service B it needs the location of that service. The default discovery mechanism is
-  multicast DNS (mdns), a zeroconf system.
+- **Service Discovery** - Automatic service registration and name resolution. Service discovery is at the core of micro service 
+development. When service A needs to speak to service B it needs the location of that service. The default discovery mechanism is 
+multicast DNS (mdns), a zeroconf system.
 
-- **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.
+- **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. This includes protobuf and json by default.
+- **Message Encoding** - Dynamic message encoding based on content-type. The client and server will use codecs along with content-type 
+to seamlessly encode and decode Go types for you. Any variety of messages could be encoded and sent from different clients. The client 
+and server handle this by default. This includes protobuf and json by default.
 
-- **RPC Client/Server** - RPC based request/response with support for bidirectional streaming. We provide an abstraction for synchronous
-  communication. A request made to a service will be automatically resolved, load balanced, dialled and streamed.
+- **RPC Client/Server** - RPC based request/response with support for bidirectional streaming. We provide an abstraction for synchronous 
+communication. A request made to a service will be automatically resolved, load balanced, dialled and streamed.
 
-- **Async Messaging** - PubSub is built in as a first class citizen for asynchronous communication and event driven architectures.
-  Event notifications are a core pattern in micro service development. The default messaging system is a HTTP event message broker.
+- **Async Messaging** - PubSub is built in as a first class citizen for asynchronous communication and event driven architectures. 
+Event notifications are a core pattern in micro service development. The default messaging system is a HTTP event message broker.
 
-- **Pluggable Interfaces** - Go Micro makes use of Go interfaces for each distributed system abstraction. Because of this these interfaces
-  are pluggable and allows Go Micro to be runtime agnostic. You can plugin any underlying technology.
+- **Synchronization** - Distributed systems are often built in an eventually consistent manner. Support for distributed locking and 
+leadership are built in as a Sync interface. When using an eventually consistent database or scheduling use the Sync interface.
+
+- **Pluggable Interfaces** - Go Micro makes use of Go interfaces for each distributed system abstraction. Because of this these interfaces 
+are pluggable and allows Go Micro to be runtime agnostic. You can plugin any underlying technology.
 
 ## Getting Started
 
-To make use of Go Micro 
+To make use of Go Micro
 
-```bash
-go get go-micro.dev/v5@latest
-```
+```golang
+import "github.com/asim/go-micro/v3"
 
-Create a service and register a handler
-
-```go
-package main
-
-import (
-        "go-micro.dev/v5"
-)
-
-type Request struct {
-        Name string `json:"name"`
-}
-
-type Response struct {
-        Message string `json:"message"`
-}
-
-type Say struct{}
-
-func (h *Say) Hello(ctx context.Context, req *Request, rsp *Response) error {
-        rsp.Message = "Hello " + req.Name
-        return nil
-}
-
-func main() {
-        // create the service
-        service := micro.New("helloworld")
-
-        // register handler
-        service.Handle(new(Say))
-
-        // run the service
-        service.Run()
-}
-```
-
-Set a fixed address
-
-```go
+// create a new service
 service := micro.NewService(
     micro.Name("helloworld"),
-    micro.Address(":8080"),
 )
+
+// initialise flags
+service.Init()
+
+// start the service
+service.Run()
 ```
 
-Call it via curl
+See the [examples](https://github.com/micro/go-micro/tree/master/examples) for detailed information on usage.
 
-```bash
-curl -XPOST \
-     -H 'Content-Type: application/json' \
-     -H 'Micro-Endpoint: Say.Hello' \
-     -d '{"name": "alice"}' \
-      http://localhost:8080
-```
+## Command Line Interface
 
-## Experimental
+See [cmd/gomu](https://github.com/asim/go-micro/tree/master/cmd/gomu) for the command line interface.
 
-There's a new `genai` package for generative AI capabilities.
+## Code Generation
 
-## Protobuf
+See [cmd/protoc-gen-micro](https://github.com/micro/go-micro/tree/master/cmd/protoc-gen-micro) for protobuf code generation.
 
-Install the code generator and see usage in the docs:
+## Example Usage
 
-```bash
-go install go-micro.dev/v5/cmd/protoc-gen-micro@v5.13.0
-```
+See [examples](https://github.com/micro/go-micro/tree/master/examples) directory for usage examples.
 
-> **Note:** Use a specific version instead of `@latest` to avoid module path conflicts. See [releases](https://github.com/micro/go-micro/releases) for the latest version.
+## Plugins
 
-Docs: [`internal/website/docs/getting-started.md`](internal/website/docs/getting-started.md)
+See [plugins](https://github.com/micro/go-micro/tree/master/plugins) directory for all the plugins.
 
-## Command Line
+## Services
 
-Install the CLI:
+See [services](https://github.com/micro/go-micro/tree/master/services) directory for third party services.
 
-```
-go install go-micro.dev/v5/cmd/micro@v5.13.0
-```
+## License
 
-> **Note:** Use a specific version instead of `@latest` to avoid module path conflicts. See [releases](https://github.com/micro/go-micro/releases) for the latest version.
-
-### Quick Start
-
-```bash
-micro new helloworld   # Create a new service
-cd helloworld
-micro run              # Run with API gateway
-```
-
-Then open http://localhost:8080 to see your service and call it from the browser.
-
-### micro run
-
-`micro run` starts your services with:
-- **API Gateway** - HTTP to RPC proxy at `/api/{service}/{method}`
-- **Web Dashboard** - Browse and call services at `/`
-- **Health Checks** - Aggregated health at `/health`
-- **Hot Reload** - Auto-rebuild on file changes
-
-```bash
-micro run                    # Gateway on :8080
-micro run --address :3000    # Custom gateway port
-micro run --no-gateway       # Services only
-micro run --env production   # Use production environment
-```
-
-### Configuration
-
-For multi-service projects, create a `micro.mu` file:
-
-```
-service users
-    path ./users
-    port 8081
-
-service posts
-    path ./posts
-    port 8082
-    depends users
-
-env development
-    DATABASE_URL sqlite://./dev.db
-```
-
-The gateway runs on :8080 by default, so services should use other ports.
-
-### Deployment
-
-Deploy to any Linux server with systemd:
-
-```bash
-# On your server (one-time setup)
-curl -fsSL https://go-micro.dev/install.sh | sh
-sudo micro init --server
-
-# From your laptop
-micro deploy user@your-server
-```
-
-The deploy command:
-1. Builds binaries for Linux
-2. Copies via SSH to the server
-3. Sets up systemd services
-4. Verifies services are healthy
-
-Manage deployed services:
-```bash
-micro status --remote user@server    # Check status
-micro logs --remote user@server      # View logs
-micro logs myservice --remote user@server -f  # Follow specific service
-```
-
-No Docker required. No Kubernetes. Just systemd.
-
-See [docs/deployment.md](docs/deployment.md) for full deployment guide.
-
-See [cmd/micro/README.md](cmd/micro/README.md) for full CLI documentation.
-
-Docs: [`internal/website/docs`](internal/website/docs)
-
-Package reference: https://pkg.go.dev/go-micro.dev/v5
-
-Selected topics:
-- Getting Started: [`internal/website/docs/getting-started.md`](internal/website/docs/getting-started.md)
-- Plugins overview: [`internal/website/docs/plugins.md`](internal/website/docs/plugins.md)
-- Learn by Example: [`internal/website/docs/examples/index.md`](internal/website/docs/examples/index.md)
-- Performance Considerations: [`docs/performance.md`](docs/performance.md)
-
-## Adopters
-
-- [Sourse](https://sourse.eu) - Work in the field of earth observation, including embedded Kubernetes running onboard aircraft, and we’ve built a mission management SaaS platform using Go Micro.
+Go Micro is Apache 2.0 licensed.

ROADMAP.md

@@ -1,163 +0,0 @@
-# Go Micro Roadmap
-
-This roadmap outlines the planned features and improvements for Go Micro. Community feedback and contributions are welcome!
-
-## Current Focus (Q1 2026)
-
-### Documentation & Developer Experience
-- [x] Modernize documentation structure
-- [x] Add learn-by-example guides
-- [x] Update issue templates
-- [ ] Create video tutorials
-- [ ] Interactive documentation site
-- [ ] Plugin discovery dashboard
-
-### Observability
-- [ ] OpenTelemetry native support
-- [ ] Auto-instrumentation for handlers
-- [ ] Metrics export standardization
-- [ ] Distributed tracing examples
-- [ ] Integration with popular observability platforms
-
-### Developer Tools
-- [ ] `micro dev` with hot reload
-- [ ] Service templates (`micro new --template`)
-- [ ] Better error messages with suggestions
-- [ ] Debug tooling improvements
-- [ ] VS Code extension for Go Micro
-
-## Q2 2026
-
-### Production Readiness
-- [ ] Health check standardization
-- [ ] Graceful shutdown improvements
-- [ ] Resource cleanup best practices
-- [ ] Load testing framework integration
-- [ ] Performance benchmarking suite
-
-### Cloud Native
-- [ ] Kubernetes operator
-- [ ] Helm charts for common setups
-- [ ] Service mesh integration guides (Istio, Linkerd)
-- [ ] Cloud provider quickstarts (AWS, GCP, Azure)
-- [ ] Multi-cluster patterns
-
-### Security
-- [ ] mTLS by default option
-- [ ] Secret management integration (Vault, AWS Secrets Manager)
-- [ ] RBAC improvements
-- [ ] Security audit and hardening
-- [ ] CVE scanning and response process
-
-## Q3 2026
-
-### Plugin Ecosystem
-- [ ] Plugin marketplace/registry
-- [ ] Plugin quality standards
-- [ ] Community plugin contributions
-- [ ] Plugin compatibility matrix
-- [ ] Auto-discovery of available plugins
-
-### Streaming & Async
-- [ ] Improved streaming support
-- [ ] Server-sent events (SSE) support
-- [ ] WebSocket plugin
-- [ ] Event sourcing patterns
-- [ ] CQRS examples
-
-### Testing
-- [ ] Mock generation tooling
-- [ ] Integration test helpers
-- [ ] Contract testing support
-- [ ] Chaos engineering examples
-- [ ] E2E testing framework
-
-## Q4 2026
-
-### Performance
-- [ ] Connection pooling optimizations
-- [ ] Zero-allocation paths
-- [ ] gRPC performance improvements
-- [ ] Caching strategies guide
-- [ ] Performance profiling tools
-
-### Developer Productivity
-- [ ] Code generation improvements
-- [ ] Better IDE support
-- [ ] Debugging tools
-- [ ] Migration automation tools
-- [ ] Upgrade helpers
-
-### Community
-- [ ] Regular blog posts and case studies
-- [ ] Community spotlight program
-- [ ] Contribution rewards
-- [ ] Monthly community calls
-- [ ] Conference presence
-
-## Long-term Vision
-
-### Core Framework
-- Maintain backward compatibility (Go Micro v5+)
-- Progressive disclosure of complexity
-- Best-in-class developer experience
-- Production-grade reliability
-- Comprehensive plugin ecosystem
-
-### Ecosystem Goals
-- 100+ production deployments documented
-- 50+ community plugins
-- Active contributor community
-- Regular releases (monthly patches, quarterly features)
-- Comprehensive benchmarks vs alternatives
-
-### Differentiation
-- **Batteries included, fully swappable** - Start simple, scale complex
-- **Zero-config local development** - No infrastructure required to start
-- **Plugin ecosystem in-repo** - No version compatibility hell
-- **Progressive complexity** - Learn as you grow
-- **Cloud-native first** - Built for Kubernetes and containers
-
-## Contributing
-
-We welcome contributions to any roadmap items! See [CONTRIBUTING.md](CONTRIBUTING.md) for guidelines.
-
-### High Priority Areas
-1. Documentation improvements
-2. Real-world examples
-3. Plugin development
-4. Performance optimizations
-5. Testing infrastructure
-
-### How to Contribute
-- Pick an item from the roadmap
-- Open an issue to discuss approach
-- Submit a PR with implementation
-- Help review others' contributions
-
-## Feedback
-
-Have suggestions for the roadmap? 
-
-- Open a [feature request](.github/ISSUE_TEMPLATE/feature_request.md)
-- Start a discussion in GitHub Discussions
-- Comment on existing roadmap issues
-
-## Version Compatibility
-
-We follow semantic versioning:
-- Major versions (v5 → v6): Breaking changes
-- Minor versions (v5.3 → v5.4): New features, backward compatible
-- Patch versions (v5.3.0 → v5.3.1): Bug fixes, no API changes
-
-## Support Timeline
-
-- v5: Active development (current)
-- v4: Security fixes only (until v6 release)
-- v3: End of life
-
----
-
-Last updated: November 2025
-
-This roadmap is subject to change based on community needs and priorities. Star the repo to stay updated! ⭐

_config.yml

@@ -0,0 +1 @@
+theme: jekyll-theme-architect

api/api.go

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

api/api_test.go

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

api/handler/api/api.go

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

api/handler/api/util.go

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

api/handler/api/util_test.go

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

api/handler/event/event.go

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

api/handler/handler.go

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

api/handler/http/http.go

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

api/handler/http/http_test.go

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

api/handler/options.go

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

api/handler/rpc/rpc.go

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

api/handler/rpc/rpc_test.go

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

api/handler/rpc/stream.go

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

api/handler/web/web.go

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

api/internal/proto/message.pb.go

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

api/proto/api.pb.go

@@ -0,0 +1,335 @@
+// Code generated by protoc-gen-go. DO NOT EDIT.
+// source: api/proto/api.proto
+
+package go_api
+
+import (
+	fmt "fmt"
+	proto "github.com/golang/protobuf/proto"
+	math "math"
+)
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ = proto.Marshal
+var _ = fmt.Errorf
+var _ = math.Inf
+
+// This is a compile-time assertion to ensure that this generated file
+// is compatible with the proto package it is being compiled against.
+// A compilation error at this line likely means your copy of the
+// proto package needs to be updated.
+const _ = proto.ProtoPackageIsVersion3 // please upgrade the proto package
+
+type Pair struct {
+	Key                  string   `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"`
+	Values               []string `protobuf:"bytes,2,rep,name=values,proto3" json:"values,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *Pair) Reset()         { *m = Pair{} }
+func (m *Pair) String() string { return proto.CompactTextString(m) }
+func (*Pair) ProtoMessage()    {}
+func (*Pair) Descriptor() ([]byte, []int) {
+	return fileDescriptor_2df576b66d12087a, []int{0}
+}
+
+func (m *Pair) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_Pair.Unmarshal(m, b)
+}
+func (m *Pair) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_Pair.Marshal(b, m, deterministic)
+}
+func (m *Pair) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_Pair.Merge(m, src)
+}
+func (m *Pair) XXX_Size() int {
+	return xxx_messageInfo_Pair.Size(m)
+}
+func (m *Pair) XXX_DiscardUnknown() {
+	xxx_messageInfo_Pair.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_Pair proto.InternalMessageInfo
+
+func (m *Pair) GetKey() string {
+	if m != nil {
+		return m.Key
+	}
+	return ""
+}
+
+func (m *Pair) GetValues() []string {
+	if m != nil {
+		return m.Values
+	}
+	return nil
+}
+
+// A HTTP request as RPC
+// Forward by the api handler
+type Request struct {
+	Method               string           `protobuf:"bytes,1,opt,name=method,proto3" json:"method,omitempty"`
+	Path                 string           `protobuf:"bytes,2,opt,name=path,proto3" json:"path,omitempty"`
+	Header               map[string]*Pair `protobuf:"bytes,3,rep,name=header,proto3" json:"header,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
+	Get                  map[string]*Pair `protobuf:"bytes,4,rep,name=get,proto3" json:"get,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
+	Post                 map[string]*Pair `protobuf:"bytes,5,rep,name=post,proto3" json:"post,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
+	Body                 string           `protobuf:"bytes,6,opt,name=body,proto3" json:"body,omitempty"`
+	Url                  string           `protobuf:"bytes,7,opt,name=url,proto3" json:"url,omitempty"`
+	XXX_NoUnkeyedLiteral struct{}         `json:"-"`
+	XXX_unrecognized     []byte           `json:"-"`
+	XXX_sizecache        int32            `json:"-"`
+}
+
+func (m *Request) Reset()         { *m = Request{} }
+func (m *Request) String() string { return proto.CompactTextString(m) }
+func (*Request) ProtoMessage()    {}
+func (*Request) Descriptor() ([]byte, []int) {
+	return fileDescriptor_2df576b66d12087a, []int{1}
+}
+
+func (m *Request) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_Request.Unmarshal(m, b)
+}
+func (m *Request) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_Request.Marshal(b, m, deterministic)
+}
+func (m *Request) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_Request.Merge(m, src)
+}
+func (m *Request) XXX_Size() int {
+	return xxx_messageInfo_Request.Size(m)
+}
+func (m *Request) XXX_DiscardUnknown() {
+	xxx_messageInfo_Request.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_Request proto.InternalMessageInfo
+
+func (m *Request) GetMethod() string {
+	if m != nil {
+		return m.Method
+	}
+	return ""
+}
+
+func (m *Request) GetPath() string {
+	if m != nil {
+		return m.Path
+	}
+	return ""
+}
+
+func (m *Request) GetHeader() map[string]*Pair {
+	if m != nil {
+		return m.Header
+	}
+	return nil
+}
+
+func (m *Request) GetGet() map[string]*Pair {
+	if m != nil {
+		return m.Get
+	}
+	return nil
+}
+
+func (m *Request) GetPost() map[string]*Pair {
+	if m != nil {
+		return m.Post
+	}
+	return nil
+}
+
+func (m *Request) GetBody() string {
+	if m != nil {
+		return m.Body
+	}
+	return ""
+}
+
+func (m *Request) GetUrl() string {
+	if m != nil {
+		return m.Url
+	}
+	return ""
+}
+
+// A HTTP response as RPC
+// Expected response for the api handler
+type Response struct {
+	StatusCode           int32            `protobuf:"varint,1,opt,name=statusCode,proto3" json:"statusCode,omitempty"`
+	Header               map[string]*Pair `protobuf:"bytes,2,rep,name=header,proto3" json:"header,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
+	Body                 string           `protobuf:"bytes,3,opt,name=body,proto3" json:"body,omitempty"`
+	XXX_NoUnkeyedLiteral struct{}         `json:"-"`
+	XXX_unrecognized     []byte           `json:"-"`
+	XXX_sizecache        int32            `json:"-"`
+}
+
+func (m *Response) Reset()         { *m = Response{} }
+func (m *Response) String() string { return proto.CompactTextString(m) }
+func (*Response) ProtoMessage()    {}
+func (*Response) Descriptor() ([]byte, []int) {
+	return fileDescriptor_2df576b66d12087a, []int{2}
+}
+
+func (m *Response) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_Response.Unmarshal(m, b)
+}
+func (m *Response) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_Response.Marshal(b, m, deterministic)
+}
+func (m *Response) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_Response.Merge(m, src)
+}
+func (m *Response) XXX_Size() int {
+	return xxx_messageInfo_Response.Size(m)
+}
+func (m *Response) XXX_DiscardUnknown() {
+	xxx_messageInfo_Response.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_Response proto.InternalMessageInfo
+
+func (m *Response) GetStatusCode() int32 {
+	if m != nil {
+		return m.StatusCode
+	}
+	return 0
+}
+
+func (m *Response) GetHeader() map[string]*Pair {
+	if m != nil {
+		return m.Header
+	}
+	return nil
+}
+
+func (m *Response) GetBody() string {
+	if m != nil {
+		return m.Body
+	}
+	return ""
+}
+
+// A HTTP event as RPC
+// Forwarded by the event handler
+type Event struct {
+	// e.g login
+	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
+	// uuid
+	Id string `protobuf:"bytes,2,opt,name=id,proto3" json:"id,omitempty"`
+	// unix timestamp of event
+	Timestamp int64 `protobuf:"varint,3,opt,name=timestamp,proto3" json:"timestamp,omitempty"`
+	// event headers
+	Header map[string]*Pair `protobuf:"bytes,4,rep,name=header,proto3" json:"header,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
+	// the event data
+	Data                 string   `protobuf:"bytes,5,opt,name=data,proto3" json:"data,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *Event) Reset()         { *m = Event{} }
+func (m *Event) String() string { return proto.CompactTextString(m) }
+func (*Event) ProtoMessage()    {}
+func (*Event) Descriptor() ([]byte, []int) {
+	return fileDescriptor_2df576b66d12087a, []int{3}
+}
+
+func (m *Event) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_Event.Unmarshal(m, b)
+}
+func (m *Event) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_Event.Marshal(b, m, deterministic)
+}
+func (m *Event) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_Event.Merge(m, src)
+}
+func (m *Event) XXX_Size() int {
+	return xxx_messageInfo_Event.Size(m)
+}
+func (m *Event) XXX_DiscardUnknown() {
+	xxx_messageInfo_Event.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_Event proto.InternalMessageInfo
+
+func (m *Event) GetName() string {
+	if m != nil {
+		return m.Name
+	}
+	return ""
+}
+
+func (m *Event) GetId() string {
+	if m != nil {
+		return m.Id
+	}
+	return ""
+}
+
+func (m *Event) GetTimestamp() int64 {
+	if m != nil {
+		return m.Timestamp
+	}
+	return 0
+}
+
+func (m *Event) GetHeader() map[string]*Pair {
+	if m != nil {
+		return m.Header
+	}
+	return nil
+}
+
+func (m *Event) GetData() string {
+	if m != nil {
+		return m.Data
+	}
+	return ""
+}
+
+func init() {
+	proto.RegisterType((*Pair)(nil), "go.api.Pair")
+	proto.RegisterType((*Request)(nil), "go.api.Request")
+	proto.RegisterMapType((map[string]*Pair)(nil), "go.api.Request.GetEntry")
+	proto.RegisterMapType((map[string]*Pair)(nil), "go.api.Request.HeaderEntry")
+	proto.RegisterMapType((map[string]*Pair)(nil), "go.api.Request.PostEntry")
+	proto.RegisterType((*Response)(nil), "go.api.Response")
+	proto.RegisterMapType((map[string]*Pair)(nil), "go.api.Response.HeaderEntry")
+	proto.RegisterType((*Event)(nil), "go.api.Event")
+	proto.RegisterMapType((map[string]*Pair)(nil), "go.api.Event.HeaderEntry")
+}
+
+func init() { proto.RegisterFile("api/proto/api.proto", fileDescriptor_2df576b66d12087a) }
+
+var fileDescriptor_2df576b66d12087a = []byte{
+	// 393 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x53, 0xcd, 0xce, 0xd3, 0x30,
+	0x10, 0x54, 0xe2, 0x24, 0x6d, 0xb6, 0x08, 0x21, 0x23, 0x21, 0x53, 0x2a, 0x54, 0xe5, 0x54, 0x21,
+	0x91, 0x42, 0xcb, 0x01, 0x71, 0x85, 0xaa, 0x1c, 0x2b, 0xbf, 0x81, 0xab, 0x58, 0x6d, 0x44, 0x13,
+	0x9b, 0xd8, 0xa9, 0xd4, 0x87, 0xe3, 0xc0, 0x63, 0xf0, 0x36, 0xc8, 0x1b, 0xf7, 0xe7, 0xab, 0xfa,
+	0x5d, 0xbe, 0xaf, 0xb7, 0x89, 0x3d, 0x3b, 0x3b, 0x3b, 0xeb, 0xc0, 0x6b, 0xa1, 0xcb, 0xa9, 0x6e,
+	0x94, 0x55, 0x53, 0xa1, 0xcb, 0x1c, 0x11, 0x4d, 0x36, 0x2a, 0x17, 0xba, 0xcc, 0x3e, 0x41, 0xb4,
+	0x12, 0x65, 0x43, 0x5f, 0x01, 0xf9, 0x25, 0x0f, 0x2c, 0x18, 0x07, 0x93, 0x94, 0x3b, 0x48, 0xdf,
+	0x40, 0xb2, 0x17, 0xbb, 0x56, 0x1a, 0x16, 0x8e, 0xc9, 0x24, 0xe5, 0xfe, 0x2b, 0xfb, 0x4b, 0xa0,
+	0xc7, 0xe5, 0xef, 0x56, 0x1a, 0xeb, 0x38, 0x95, 0xb4, 0x5b, 0x55, 0xf8, 0x42, 0xff, 0x45, 0x29,
+	0x44, 0x5a, 0xd8, 0x2d, 0x0b, 0xf1, 0x14, 0x31, 0x9d, 0x43, 0xb2, 0x95, 0xa2, 0x90, 0x0d, 0x23,
+	0x63, 0x32, 0x19, 0xcc, 0xde, 0xe5, 0x9d, 0x85, 0xdc, 0x8b, 0xe5, 0x3f, 0xf1, 0x76, 0x51, 0xdb,
+	0xe6, 0xc0, 0x3d, 0x95, 0x7e, 0x00, 0xb2, 0x91, 0x96, 0x45, 0x58, 0xc1, 0xae, 0x2b, 0x96, 0xd2,
+	0x76, 0x74, 0x47, 0xa2, 0x1f, 0x21, 0xd2, 0xca, 0x58, 0x16, 0x23, 0xf9, 0xed, 0x35, 0x79, 0xa5,
+	0x8c, 0x67, 0x23, 0xcd, 0x79, 0x5c, 0xab, 0xe2, 0xc0, 0x92, 0xce, 0xa3, 0xc3, 0x2e, 0x85, 0xb6,
+	0xd9, 0xb1, 0x5e, 0x97, 0x42, 0xdb, 0xec, 0x86, 0x4b, 0x18, 0x5c, 0xf8, 0xba, 0x11, 0x53, 0x06,
+	0x31, 0x06, 0x83, 0xb3, 0x0e, 0x66, 0x2f, 0x8e, 0x6d, 0x5d, 0xaa, 0xbc, 0xbb, 0xfa, 0x16, 0x7e,
+	0x0d, 0x86, 0x3f, 0xa0, 0x7f, 0xb4, 0xfb, 0x0c, 0x95, 0x05, 0xa4, 0xa7, 0x39, 0x9e, 0x2e, 0x93,
+	0xfd, 0x09, 0xa0, 0xcf, 0xa5, 0xd1, 0xaa, 0x36, 0x92, 0xbe, 0x07, 0x30, 0x56, 0xd8, 0xd6, 0x7c,
+	0x57, 0x85, 0x44, 0xb5, 0x98, 0x5f, 0x9c, 0xd0, 0x2f, 0xa7, 0xc5, 0x85, 0x98, 0xec, 0xe8, 0x9c,
+	0x6c, 0xa7, 0x70, 0x73, 0x73, 0xc7, 0x78, 0xc9, 0x39, 0xde, 0xbb, 0x85, 0x99, 0xfd, 0x0b, 0x20,
+	0x5e, 0xec, 0x65, 0x8d, 0x5b, 0xac, 0x45, 0x25, 0xbd, 0x08, 0x62, 0xfa, 0x12, 0xc2, 0xb2, 0xf0,
+	0x6f, 0x2f, 0x2c, 0x0b, 0x3a, 0x82, 0xd4, 0x96, 0x95, 0x34, 0x56, 0x54, 0x1a, 0xfd, 0x10, 0x7e,
+	0x3e, 0xa0, 0x9f, 0x4f, 0xe3, 0x45, 0x0f, 0x1f, 0x0e, 0x36, 0x78, 0x6c, 0xb6, 0x42, 0x58, 0xc1,
+	0xe2, 0xae, 0xa9, 0xc3, 0x77, 0x9b, 0x6d, 0x9d, 0xe0, 0x0f, 0x3a, 0xff, 0x1f, 0x00, 0x00, 0xff,
+	0xff, 0xd4, 0x6d, 0x70, 0x51, 0xb7, 0x03, 0x00, 0x00,
+}

api/proto/api.pb.micro.go

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

api/proto/api.proto

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

api/resolver/grpc/grpc.go

@@ -0,0 +1,38 @@
+// Package grpc resolves a grpc service like /greeter.Say/Hello to greeter service
+package grpc
+
+import (
+	"errors"
+	"net/http"
+	"strings"
+
+	"github.com/asim/go-micro/v3/api/resolver"
+)
+
+type Resolver struct{}
+
+func (r *Resolver) Resolve(req *http.Request) (*resolver.Endpoint, error) {
+	// /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,
+	}, nil
+}
+
+func (r *Resolver) String() string {
+	return "grpc"
+}
+
+func NewResolver(opts ...resolver.Option) resolver.Resolver {
+	return &Resolver{}
+}

api/resolver/host/host.go

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

api/resolver/options.go

@@ -0,0 +1,33 @@
+package resolver
+
+import (
+	"net/http"
+)
+
+// NewOptions returns new initialised options
+func NewOptions(opts ...Option) Options {
+	var options Options
+	for _, o := range opts {
+		o(&options)
+	}
+
+	if options.Namespace == nil {
+		options.Namespace = StaticNamespace("go.micro")
+	}
+
+	return options
+}
+
+// WithHandler sets the handler being used
+func WithHandler(h string) Option {
+	return func(o *Options) {
+		o.Handler = h
+	}
+}
+
+// WithNamespace sets the function which determines the namespace for a request
+func WithNamespace(n func(*http.Request) string) Option {
+	return func(o *Options) {
+		o.Namespace = n
+	}
+}

api/resolver/path/path.go

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

api/resolver/resolver.go

@@ -0,0 +1,44 @@
+// Package resolver resolves a http request to an endpoint
+package resolver
+
+import (
+	"errors"
+	"net/http"
+)
+
+var (
+	ErrNotFound    = errors.New("not found")
+	ErrInvalidPath = errors.New("invalid path")
+)
+
+// Resolver resolves requests to endpoints
+type Resolver interface {
+	Resolve(r *http.Request) (*Endpoint, error)
+	String() string
+}
+
+// Endpoint is the endpoint for a http request
+type Endpoint struct {
+	// 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
+}
+
+type Options struct {
+	Handler   string
+	Namespace func(*http.Request) string
+}
+
+type Option func(o *Options)
+
+// StaticNamespace returns the same namespace for each request
+func StaticNamespace(ns string) func(*http.Request) string {
+	return func(*http.Request) string {
+		return ns
+	}
+}

api/resolver/vpath/vpath.go

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

api/router/options.go

@@ -0,0 +1,52 @@
+package router
+
+import (
+	"github.com/asim/go-micro/v3/api/resolver"
+	"github.com/asim/go-micro/v3/api/resolver/vpath"
+	"github.com/asim/go-micro/v3/registry"
+)
+
+type Options struct {
+	Handler  string
+	Registry registry.Registry
+	Resolver resolver.Resolver
+}
+
+type Option func(o *Options)
+
+func NewOptions(opts ...Option) Options {
+	options := Options{
+		Handler:  "meta",
+		Registry: registry.DefaultRegistry,
+	}
+
+	for _, o := range opts {
+		o(&options)
+	}
+
+	if options.Resolver == nil {
+		options.Resolver = vpath.NewResolver(
+			resolver.WithHandler(options.Handler),
+		)
+	}
+
+	return options
+}
+
+func WithHandler(h string) Option {
+	return func(o *Options) {
+		o.Handler = h
+	}
+}
+
+func WithRegistry(r registry.Registry) Option {
+	return func(o *Options) {
+		o.Registry = r
+	}
+}
+
+func WithResolver(r resolver.Resolver) Option {
+	return func(o *Options) {
+		o.Resolver = r
+	}
+}

api/router/registry/registry.go

@@ -0,0 +1,498 @@
+// Package registry provides a dynamic api service router
+package registry
+
+import (
+	"errors"
+	"fmt"
+	"net/http"
+	"regexp"
+	"strings"
+	"sync"
+	"time"
+
+	"github.com/asim/go-micro/v3/api"
+	"github.com/asim/go-micro/v3/api/router"
+	"github.com/asim/go-micro/v3/api/router/util"
+	"github.com/asim/go-micro/v3/logger"
+	"github.com/asim/go-micro/v3/metadata"
+	"github.com/asim/go-micro/v3/registry"
+	"github.com/asim/go-micro/v3/registry/cache"
+)
+
+// endpoint struct, that holds compiled pcre
+type endpoint struct {
+	hostregs []*regexp.Regexp
+	pathregs []util.Pattern
+	pcreregs []*regexp.Regexp
+}
+
+// router is the default router
+type registryRouter struct {
+	exit chan bool
+	opts router.Options
+
+	// registry cache
+	rc cache.Cache
+
+	sync.RWMutex
+	eps map[string]*api.Service
+	// compiled regexp for host and path
+	ceps map[string]*endpoint
+}
+
+func (r *registryRouter) isClosed() bool {
+	select {
+	case <-r.exit:
+		return true
+	default:
+		return false
+	}
+}
+
+// refresh list of api services
+func (r *registryRouter) refresh() {
+	var attempts int
+
+	for {
+		services, err := r.opts.Registry.ListServices()
+		if err != nil {
+			attempts++
+			if logger.V(logger.ErrorLevel, logger.DefaultLogger) {
+				logger.Errorf("unable to list services: %v", err)
+			}
+			time.Sleep(time.Duration(attempts) * time.Second)
+			continue
+		}
+
+		attempts = 0
+
+		// for each service, get service and store endpoints
+		for _, s := range services {
+			service, err := r.rc.GetService(s.Name)
+			if err != nil {
+				if logger.V(logger.ErrorLevel, logger.DefaultLogger) {
+					logger.Errorf("unable to get service: %v", err)
+				}
+				continue
+			}
+			r.store(service)
+		}
+
+		// refresh list in 10 minutes... cruft
+		// use registry watching
+		select {
+		case <-time.After(time.Minute * 10):
+		case <-r.exit:
+			return
+		}
+	}
+}
+
+// process watch event
+func (r *registryRouter) process(res *registry.Result) {
+	// skip these things
+	if res == nil || res.Service == nil {
+		return
+	}
+
+	// get entry from cache
+	service, err := r.rc.GetService(res.Service.Name)
+	if err != nil {
+		if logger.V(logger.ErrorLevel, logger.DefaultLogger) {
+			logger.Errorf("unable to get service: %v", err)
+		}
+		return
+	}
+
+	// update our local endpoints
+	r.store(service)
+}
+
+// store local endpoint cache
+func (r *registryRouter) store(services []*registry.Service) {
+	// endpoints
+	eps := map[string]*api.Service{}
+
+	// services
+	names := map[string]bool{}
+
+	// create a new endpoint mapping
+	for _, service := range services {
+		// set names we need later
+		names[service.Name] = true
+
+		// map per endpoint
+		for _, sep := range service.Endpoints {
+			// create a key service:endpoint_name
+			key := fmt.Sprintf("%s.%s", service.Name, sep.Name)
+			// decode endpoint
+			end := api.Decode(sep.Metadata)
+
+			// if we got nothing skip
+			if err := api.Validate(end); err != nil {
+				if logger.V(logger.TraceLevel, logger.DefaultLogger) {
+					logger.Tracef("endpoint validation failed: %v", err)
+				}
+				continue
+			}
+
+			// try get endpoint
+			ep, ok := eps[key]
+			if !ok {
+				ep = &api.Service{Name: service.Name}
+			}
+
+			// overwrite the endpoint
+			ep.Endpoint = end
+			// append services
+			ep.Services = append(ep.Services, service)
+			// store it
+			eps[key] = ep
+		}
+	}
+
+	r.Lock()
+	defer r.Unlock()
+
+	// delete any existing eps for services we know
+	for key, service := range r.eps {
+		// skip what we don't care about
+		if !names[service.Name] {
+			continue
+		}
+
+		// ok we know this thing
+		// delete delete delete
+		delete(r.eps, key)
+	}
+
+	// now set the eps we have
+	for name, ep := range eps {
+		r.eps[name] = ep
+		cep := &endpoint{}
+
+		for _, h := range ep.Endpoint.Host {
+			if h == "" || h == "*" {
+				continue
+			}
+			hostreg, err := regexp.CompilePOSIX(h)
+			if err != nil {
+				if logger.V(logger.TraceLevel, logger.DefaultLogger) {
+					logger.Tracef("endpoint have invalid host regexp: %v", err)
+				}
+				continue
+			}
+			cep.hostregs = append(cep.hostregs, hostreg)
+		}
+
+		for _, p := range ep.Endpoint.Path {
+			var pcreok bool
+
+			if p[0] == '^' && p[len(p)-1] == '$' {
+				pcrereg, err := regexp.CompilePOSIX(p)
+				if err == nil {
+					cep.pcreregs = append(cep.pcreregs, pcrereg)
+					pcreok = true
+				}
+			}
+
+			rule, err := util.Parse(p)
+			if err != nil && !pcreok {
+				if logger.V(logger.TraceLevel, logger.DefaultLogger) {
+					logger.Tracef("endpoint have invalid path pattern: %v", err)
+				}
+				continue
+			} else if err != nil && pcreok {
+				continue
+			}
+
+			tpl := rule.Compile()
+			pathreg, err := util.NewPattern(tpl.Version, tpl.OpCodes, tpl.Pool, "")
+			if err != nil {
+				if logger.V(logger.TraceLevel, logger.DefaultLogger) {
+					logger.Tracef("endpoint have invalid path pattern: %v", err)
+				}
+				continue
+			}
+			cep.pathregs = append(cep.pathregs, pathreg)
+		}
+
+		r.ceps[name] = cep
+	}
+}
+
+// watch for endpoint changes
+func (r *registryRouter) watch() {
+	var attempts int
+
+	for {
+		if r.isClosed() {
+			return
+		}
+
+		// watch for changes
+		w, err := r.opts.Registry.Watch()
+		if err != nil {
+			attempts++
+			if logger.V(logger.ErrorLevel, logger.DefaultLogger) {
+				logger.Errorf("error watching endpoints: %v", err)
+			}
+			time.Sleep(time.Duration(attempts) * time.Second)
+			continue
+		}
+
+		ch := make(chan bool)
+
+		go func() {
+			select {
+			case <-ch:
+				w.Stop()
+			case <-r.exit:
+				w.Stop()
+			}
+		}()
+
+		// reset if we get here
+		attempts = 0
+
+		for {
+			// process next event
+			res, err := w.Next()
+			if err != nil {
+				if logger.V(logger.ErrorLevel, logger.DefaultLogger) {
+					logger.Errorf("error getting next endoint: %v", err)
+				}
+				close(ch)
+				break
+			}
+			r.process(res)
+		}
+	}
+}
+
+func (r *registryRouter) Options() router.Options {
+	return r.opts
+}
+
+func (r *registryRouter) Close() error {
+	select {
+	case <-r.exit:
+		return nil
+	default:
+		close(r.exit)
+		r.rc.Stop()
+	}
+	return nil
+}
+
+func (r *registryRouter) Register(ep *api.Endpoint) error {
+	return nil
+}
+
+func (r *registryRouter) Deregister(ep *api.Endpoint) error {
+	return nil
+}
+
+func (r *registryRouter) Endpoint(req *http.Request) (*api.Service, error) {
+	if r.isClosed() {
+		return nil, errors.New("router closed")
+	}
+
+	r.RLock()
+	defer r.RUnlock()
+
+	var idx int
+	if len(req.URL.Path) > 0 && req.URL.Path != "/" {
+		idx = 1
+	}
+	path := strings.Split(req.URL.Path[idx:], "/")
+
+	// use the first match
+	// TODO: weighted matching
+	for n, e := range r.eps {
+		cep, ok := r.ceps[n]
+		if !ok {
+			continue
+		}
+		ep := e.Endpoint
+		var mMatch, hMatch, pMatch bool
+		// 1. try method
+		for _, m := range ep.Method {
+			if m == req.Method {
+				mMatch = true
+				break
+			}
+		}
+		if !mMatch {
+			continue
+		}
+		if logger.V(logger.DebugLevel, logger.DefaultLogger) {
+			logger.Debugf("api method match %s", req.Method)
+		}
+
+		// 2. try host
+		if len(ep.Host) == 0 {
+			hMatch = true
+		} else {
+			for idx, h := range ep.Host {
+				if h == "" || h == "*" {
+					hMatch = true
+					break
+				} else {
+					if cep.hostregs[idx].MatchString(req.URL.Host) {
+						hMatch = true
+						break
+					}
+				}
+			}
+		}
+		if !hMatch {
+			continue
+		}
+		if logger.V(logger.DebugLevel, logger.DefaultLogger) {
+			logger.Debugf("api host match %s", req.URL.Host)
+		}
+
+		// 3. try path via google.api path matching
+		for _, pathreg := range cep.pathregs {
+			matches, err := pathreg.Match(path, "")
+			if err != nil {
+				if logger.V(logger.DebugLevel, logger.DefaultLogger) {
+					logger.Debugf("api gpath not match %s != %v", path, pathreg)
+				}
+				continue
+			}
+			if logger.V(logger.DebugLevel, logger.DefaultLogger) {
+				logger.Debugf("api gpath match %s = %v", path, pathreg)
+			}
+			pMatch = true
+			ctx := req.Context()
+			md, ok := metadata.FromContext(ctx)
+			if !ok {
+				md = make(metadata.Metadata)
+			}
+			for k, v := range matches {
+				md[fmt.Sprintf("x-api-field-%s", k)] = v
+			}
+			md["x-api-body"] = ep.Body
+			*req = *req.Clone(metadata.NewContext(ctx, md))
+			break
+		}
+
+		if !pMatch {
+			// 4. try path via pcre path matching
+			for _, pathreg := range cep.pcreregs {
+				if !pathreg.MatchString(req.URL.Path) {
+					if logger.V(logger.DebugLevel, logger.DefaultLogger) {
+						logger.Debugf("api pcre path not match %s != %v", path, pathreg)
+					}
+					continue
+				}
+				if logger.V(logger.DebugLevel, logger.DefaultLogger) {
+					logger.Debugf("api pcre path match %s != %v", path, pathreg)
+				}
+				pMatch = true
+				break
+			}
+		}
+
+		if !pMatch {
+			continue
+		}
+
+		// TODO: Percentage traffic
+		// we got here, so its a match
+		return e, nil
+	}
+
+	// no match
+	return nil, errors.New("not found")
+}
+
+func (r *registryRouter) Route(req *http.Request) (*api.Service, error) {
+	if r.isClosed() {
+		return nil, errors.New("router closed")
+	}
+
+	// try get an endpoint
+	ep, err := r.Endpoint(req)
+	if err == nil {
+		return ep, nil
+	}
+
+	// error not nil
+	// ignore that shit
+	// TODO: don't ignore that shit
+
+	// get the service name
+	rp, err := r.opts.Resolver.Resolve(req)
+	if err != nil {
+		return nil, err
+	}
+
+	// service name
+	name := rp.Name
+
+	// get service
+	services, err := r.rc.GetService(name)
+	if err != nil {
+		return nil, err
+	}
+
+	// only use endpoint matching when the meta handler is set aka api.Default
+	switch r.opts.Handler {
+	// rpc handlers
+	case "meta", "api", "rpc":
+		handler := r.opts.Handler
+
+		// set default handler to api
+		if r.opts.Handler == "meta" {
+			handler = "rpc"
+		}
+
+		// construct api service
+		return &api.Service{
+			Name: name,
+			Endpoint: &api.Endpoint{
+				Name:    rp.Method,
+				Handler: handler,
+			},
+			Services: services,
+		}, nil
+	// http handler
+	case "http", "proxy", "web":
+		// construct api service
+		return &api.Service{
+			Name: name,
+			Endpoint: &api.Endpoint{
+				Name:    req.URL.String(),
+				Handler: r.opts.Handler,
+				Host:    []string{req.Host},
+				Method:  []string{req.Method},
+				Path:    []string{req.URL.Path},
+			},
+			Services: services,
+		}, nil
+	}
+
+	return nil, errors.New("unknown handler")
+}
+
+func newRouter(opts ...router.Option) *registryRouter {
+	options := router.NewOptions(opts...)
+	r := &registryRouter{
+		exit: make(chan bool),
+		opts: options,
+		rc:   cache.New(options.Registry),
+		eps:  make(map[string]*api.Service),
+		ceps: make(map[string]*endpoint),
+	}
+	go r.watch()
+	go r.refresh()
+	return r
+}
+
+// NewRouter returns the default router
+func NewRouter(opts ...router.Option) router.Router {
+	return newRouter(opts...)
+}

api/router/registry/registry_test.go

@@ -0,0 +1,34 @@
+package registry
+
+import (
+	"testing"
+
+	"github.com/asim/go-micro/v3/registry"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestStoreRegex(t *testing.T) {
+	router := newRouter()
+	router.store([]*registry.Service{
+		{
+			Name:    "Foobar",
+			Version: "latest",
+			Endpoints: []*registry.Endpoint{
+				{
+					Name: "foo",
+					Metadata: map[string]string{
+						"endpoint":    "FooEndpoint",
+						"description": "Some description",
+						"method":      "POST",
+						"path":        "^/foo/$",
+						"handler":     "rpc",
+					},
+				},
+			},
+			Metadata: map[string]string{},
+		},
+	},
+	)
+
+	assert.Len(t, router.ceps["Foobar.foo"].pcreregs, 1)
+}

api/router/router.go

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

api/router/static/static.go

@@ -0,0 +1,356 @@
+package static
+
+import (
+	"errors"
+	"fmt"
+	"net/http"
+	"regexp"
+	"strings"
+	"sync"
+
+	"github.com/asim/go-micro/v3/api"
+	"github.com/asim/go-micro/v3/api/router"
+	"github.com/asim/go-micro/v3/api/router/util"
+	"github.com/asim/go-micro/v3/logger"
+	"github.com/asim/go-micro/v3/metadata"
+	"github.com/asim/go-micro/v3/registry"
+	rutil "github.com/asim/go-micro/v3/util/registry"
+)
+
+type endpoint struct {
+	apiep    *api.Endpoint
+	hostregs []*regexp.Regexp
+	pathregs []util.Pattern
+	pcreregs []*regexp.Regexp
+}
+
+// router is the default router
+type staticRouter struct {
+	exit chan bool
+	opts router.Options
+	sync.RWMutex
+	eps map[string]*endpoint
+}
+
+func (r *staticRouter) isClosed() bool {
+	select {
+	case <-r.exit:
+		return true
+	default:
+		return false
+	}
+}
+
+/*
+// watch for endpoint changes
+func (r *staticRouter) watch() {
+	var attempts int
+
+	for {
+		if r.isClosed() {
+			return
+		}
+
+		// watch for changes
+		w, err := r.opts.Registry.Watch()
+		if err != nil {
+			attempts++
+			log.Println("Error watching endpoints", err)
+			time.Sleep(time.Duration(attempts) * time.Second)
+			continue
+		}
+
+		ch := make(chan bool)
+
+		go func() {
+			select {
+			case <-ch:
+				w.Stop()
+			case <-r.exit:
+				w.Stop()
+			}
+		}()
+
+		// reset if we get here
+		attempts = 0
+
+		for {
+			// process next event
+			res, err := w.Next()
+			if err != nil {
+				log.Println("Error getting next endpoint", err)
+				close(ch)
+				break
+			}
+			r.process(res)
+		}
+	}
+}
+*/
+
+func (r *staticRouter) Register(ep *api.Endpoint) error {
+	if err := api.Validate(ep); err != nil {
+		return err
+	}
+
+	var pathregs []util.Pattern
+	var hostregs []*regexp.Regexp
+	var pcreregs []*regexp.Regexp
+
+	for _, h := range ep.Host {
+		if h == "" || h == "*" {
+			continue
+		}
+		hostreg, err := regexp.CompilePOSIX(h)
+		if err != nil {
+			return err
+		}
+		hostregs = append(hostregs, hostreg)
+	}
+
+	for _, p := range ep.Path {
+		var pcreok bool
+
+		// pcre only when we have start and end markers
+		if p[0] == '^' && p[len(p)-1] == '$' {
+			pcrereg, err := regexp.CompilePOSIX(p)
+			if err == nil {
+				pcreregs = append(pcreregs, pcrereg)
+				pcreok = true
+			}
+		}
+
+		rule, err := util.Parse(p)
+		if err != nil && !pcreok {
+			return err
+		} else if err != nil && pcreok {
+			continue
+		}
+
+		tpl := rule.Compile()
+		pathreg, err := util.NewPattern(tpl.Version, tpl.OpCodes, tpl.Pool, "")
+		if err != nil {
+			return err
+		}
+		pathregs = append(pathregs, pathreg)
+	}
+
+	r.Lock()
+	r.eps[ep.Name] = &endpoint{
+		apiep:    ep,
+		pcreregs: pcreregs,
+		pathregs: pathregs,
+		hostregs: hostregs,
+	}
+	r.Unlock()
+	return nil
+}
+
+func (r *staticRouter) Deregister(ep *api.Endpoint) error {
+	if err := api.Validate(ep); err != nil {
+		return err
+	}
+	r.Lock()
+	delete(r.eps, ep.Name)
+	r.Unlock()
+	return nil
+}
+
+func (r *staticRouter) Options() router.Options {
+	return r.opts
+}
+
+func (r *staticRouter) Close() error {
+	select {
+	case <-r.exit:
+		return nil
+	default:
+		close(r.exit)
+	}
+	return nil
+}
+
+func (r *staticRouter) Endpoint(req *http.Request) (*api.Service, error) {
+	ep, err := r.endpoint(req)
+	if err != nil {
+		return nil, err
+	}
+
+	epf := strings.Split(ep.apiep.Name, ".")
+	services, err := r.opts.Registry.GetService(epf[0])
+	if err != nil {
+		return nil, err
+	}
+
+	// hack for stream endpoint
+	if ep.apiep.Stream {
+		svcs := rutil.Copy(services)
+		for _, svc := range svcs {
+			if len(svc.Endpoints) == 0 {
+				e := &registry.Endpoint{}
+				e.Name = strings.Join(epf[1:], ".")
+				e.Metadata = make(map[string]string)
+				e.Metadata["stream"] = "true"
+				svc.Endpoints = append(svc.Endpoints, e)
+			}
+			for _, e := range svc.Endpoints {
+				e.Name = strings.Join(epf[1:], ".")
+				e.Metadata = make(map[string]string)
+				e.Metadata["stream"] = "true"
+			}
+		}
+
+		services = svcs
+	}
+
+	svc := &api.Service{
+		Name: epf[0],
+		Endpoint: &api.Endpoint{
+			Name:    strings.Join(epf[1:], "."),
+			Handler: "rpc",
+			Host:    ep.apiep.Host,
+			Method:  ep.apiep.Method,
+			Path:    ep.apiep.Path,
+			Body:    ep.apiep.Body,
+			Stream:  ep.apiep.Stream,
+		},
+		Services: services,
+	}
+
+	return svc, nil
+}
+
+func (r *staticRouter) endpoint(req *http.Request) (*endpoint, error) {
+	if r.isClosed() {
+		return nil, errors.New("router closed")
+	}
+
+	r.RLock()
+	defer r.RUnlock()
+
+	var idx int
+	if len(req.URL.Path) > 0 && req.URL.Path != "/" {
+		idx = 1
+	}
+	path := strings.Split(req.URL.Path[idx:], "/")
+	// use the first match
+	// TODO: weighted matching
+
+	for _, ep := range r.eps {
+		var mMatch, hMatch, pMatch bool
+
+		// 1. try method
+		for _, m := range ep.apiep.Method {
+			if m == req.Method {
+				mMatch = true
+				break
+			}
+		}
+		if !mMatch {
+			continue
+		}
+		if logger.V(logger.DebugLevel, logger.DefaultLogger) {
+			logger.Debugf("api method match %s", req.Method)
+		}
+
+		// 2. try host
+		if len(ep.apiep.Host) == 0 {
+			hMatch = true
+		} else {
+			for idx, h := range ep.apiep.Host {
+				if h == "" || h == "*" {
+					hMatch = true
+					break
+				} else {
+					if ep.hostregs[idx].MatchString(req.URL.Host) {
+						hMatch = true
+						break
+					}
+				}
+			}
+		}
+		if !hMatch {
+			continue
+		}
+		if logger.V(logger.DebugLevel, logger.DefaultLogger) {
+			logger.Debugf("api host match %s", req.URL.Host)
+		}
+
+		// 3. try google.api path
+		for _, pathreg := range ep.pathregs {
+			matches, err := pathreg.Match(path, "")
+			if err != nil {
+				if logger.V(logger.DebugLevel, logger.DefaultLogger) {
+					logger.Debugf("api gpath not match %s != %v", path, pathreg)
+				}
+				continue
+			}
+			if logger.V(logger.DebugLevel, logger.DefaultLogger) {
+				logger.Debugf("api gpath match %s = %v", path, pathreg)
+			}
+			pMatch = true
+			ctx := req.Context()
+			md, ok := metadata.FromContext(ctx)
+			if !ok {
+				md = make(metadata.Metadata)
+			}
+			for k, v := range matches {
+				md[fmt.Sprintf("x-api-field-%s", k)] = v
+			}
+			md["x-api-body"] = ep.apiep.Body
+			*req = *req.Clone(metadata.NewContext(ctx, md))
+			break
+		}
+
+		if !pMatch {
+			// 4. try path via pcre path matching
+			for _, pathreg := range ep.pcreregs {
+				if !pathreg.MatchString(req.URL.Path) {
+					if logger.V(logger.DebugLevel, logger.DefaultLogger) {
+						logger.Debugf("api pcre path not match %s != %v", req.URL.Path, pathreg)
+					}
+					continue
+				}
+				pMatch = true
+				break
+			}
+		}
+
+		if !pMatch {
+			continue
+		}
+		// TODO: Percentage traffic
+
+		// we got here, so its a match
+		return ep, nil
+	}
+
+	// no match
+	return nil, fmt.Errorf("endpoint not found for %v", req.URL)
+}
+
+func (r *staticRouter) Route(req *http.Request) (*api.Service, error) {
+	if r.isClosed() {
+		return nil, errors.New("router closed")
+	}
+
+	// try get an endpoint
+	ep, err := r.Endpoint(req)
+	if err != nil {
+		return nil, err
+	}
+
+	return ep, nil
+}
+
+func NewRouter(opts ...router.Option) *staticRouter {
+	options := router.NewOptions(opts...)
+	r := &staticRouter{
+		exit: make(chan bool),
+		opts: options,
+		eps:  make(map[string]*endpoint),
+	}
+	//go r.watch()
+	//go r.refresh()
+	return r
+}

api/router/util/LICENSE.txt

@@ -0,0 +1,27 @@
+Copyright (c) 2015, Gengo, Inc.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+    * Redistributions of source code must retain the above copyright notice,
+      this list of conditions and the following disclaimer.
+
+    * Redistributions in binary form must reproduce the above copyright notice,
+      this list of conditions and the following disclaimer in the documentation
+      and/or other materials provided with the distribution.
+
+    * Neither the name of Gengo, Inc. nor the names of its
+      contributors may be used to endorse or promote products derived from this
+      software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

api/router/util/compile.go

@@ -0,0 +1,115 @@
+package util
+
+// download from https://raw.githubusercontent.com/grpc-ecosystem/grpc-gateway/master/protoc-gen-grpc-gateway/httprule/compile.go
+
+const (
+	opcodeVersion = 1
+)
+
+// Template is a compiled representation of path templates.
+type Template struct {
+	// Version is the version number of the format.
+	Version int
+	// OpCodes is a sequence of operations.
+	OpCodes []int
+	// Pool is a constant pool
+	Pool []string
+	// Verb is a VERB part in the template.
+	Verb string
+	// Fields is a list of field paths bound in this template.
+	Fields []string
+	// Original template (example: /v1/a_bit_of_everything)
+	Template string
+}
+
+// Compiler compiles utilities representation of path templates into marshallable operations.
+// They can be unmarshalled by runtime.NewPattern.
+type Compiler interface {
+	Compile() Template
+}
+
+type op struct {
+	// code is the opcode of the operation
+	code OpCode
+
+	// str is a string operand of the code.
+	// operand is ignored if str is not empty.
+	str string
+
+	// operand is a numeric operand of the code.
+	operand int
+}
+
+func (w wildcard) compile() []op {
+	return []op{
+		{code: OpPush},
+	}
+}
+
+func (w deepWildcard) compile() []op {
+	return []op{
+		{code: OpPushM},
+	}
+}
+
+func (l literal) compile() []op {
+	return []op{
+		{
+			code: OpLitPush,
+			str:  string(l),
+		},
+	}
+}
+
+func (v variable) compile() []op {
+	var ops []op
+	for _, s := range v.segments {
+		ops = append(ops, s.compile()...)
+	}
+	ops = append(ops, op{
+		code:    OpConcatN,
+		operand: len(v.segments),
+	}, op{
+		code: OpCapture,
+		str:  v.path,
+	})
+
+	return ops
+}
+
+func (t template) Compile() Template {
+	var rawOps []op
+	for _, s := range t.segments {
+		rawOps = append(rawOps, s.compile()...)
+	}
+
+	var (
+		ops    []int
+		pool   []string
+		fields []string
+	)
+	consts := make(map[string]int)
+	for _, op := range rawOps {
+		ops = append(ops, int(op.code))
+		if op.str == "" {
+			ops = append(ops, op.operand)
+		} else {
+			if _, ok := consts[op.str]; !ok {
+				consts[op.str] = len(pool)
+				pool = append(pool, op.str)
+			}
+			ops = append(ops, consts[op.str])
+		}
+		if op.code == OpCapture {
+			fields = append(fields, op.str)
+		}
+	}
+	return Template{
+		Version:  opcodeVersion,
+		OpCodes:  ops,
+		Pool:     pool,
+		Verb:     t.verb,
+		Fields:   fields,
+		Template: t.template,
+	}
+}

api/router/util/compile_test.go

@@ -0,0 +1,122 @@
+package util
+
+// download from https://raw.githubusercontent.com/grpc-ecosystem/grpc-gateway/master/protoc-gen-grpc-gateway/httprule/compile_test.go
+
+import (
+	"reflect"
+	"testing"
+)
+
+const (
+	operandFiller = 0
+)
+
+func TestCompile(t *testing.T) {
+	for _, spec := range []struct {
+		segs []segment
+		verb string
+
+		ops    []int
+		pool   []string
+		fields []string
+	}{
+		{},
+		{
+			segs: []segment{
+				wildcard{},
+			},
+			ops: []int{int(OpPush), operandFiller},
+		},
+		{
+			segs: []segment{
+				deepWildcard{},
+			},
+			ops: []int{int(OpPushM), operandFiller},
+		},
+		{
+			segs: []segment{
+				literal("v1"),
+			},
+			ops:  []int{int(OpLitPush), 0},
+			pool: []string{"v1"},
+		},
+		{
+			segs: []segment{
+				literal("v1"),
+			},
+			verb: "LOCK",
+			ops:  []int{int(OpLitPush), 0},
+			pool: []string{"v1"},
+		},
+		{
+			segs: []segment{
+				variable{
+					path: "name.nested",
+					segments: []segment{
+						wildcard{},
+					},
+				},
+			},
+			ops: []int{
+				int(OpPush), operandFiller,
+				int(OpConcatN), 1,
+				int(OpCapture), 0,
+			},
+			pool:   []string{"name.nested"},
+			fields: []string{"name.nested"},
+		},
+		{
+			segs: []segment{
+				literal("obj"),
+				variable{
+					path: "name.nested",
+					segments: []segment{
+						literal("a"),
+						wildcard{},
+						literal("b"),
+					},
+				},
+				variable{
+					path: "obj",
+					segments: []segment{
+						deepWildcard{},
+					},
+				},
+			},
+			ops: []int{
+				int(OpLitPush), 0,
+				int(OpLitPush), 1,
+				int(OpPush), operandFiller,
+				int(OpLitPush), 2,
+				int(OpConcatN), 3,
+				int(OpCapture), 3,
+				int(OpPushM), operandFiller,
+				int(OpConcatN), 1,
+				int(OpCapture), 0,
+			},
+			pool:   []string{"obj", "a", "b", "name.nested"},
+			fields: []string{"name.nested", "obj"},
+		},
+	} {
+		tmpl := template{
+			segments: spec.segs,
+			verb:     spec.verb,
+		}
+		compiled := tmpl.Compile()
+		if got, want := compiled.Version, opcodeVersion; got != want {
+			t.Errorf("tmpl.Compile().Version = %d; want %d; segs=%#v, verb=%q", got, want, spec.segs, spec.verb)
+		}
+		if got, want := compiled.OpCodes, spec.ops; !reflect.DeepEqual(got, want) {
+			t.Errorf("tmpl.Compile().OpCodes = %v; want %v; segs=%#v, verb=%q", got, want, spec.segs, spec.verb)
+		}
+		if got, want := compiled.Pool, spec.pool; !reflect.DeepEqual(got, want) {
+			t.Errorf("tmpl.Compile().Pool = %q; want %q; segs=%#v, verb=%q", got, want, spec.segs, spec.verb)
+		}
+		if got, want := compiled.Verb, spec.verb; got != want {
+			t.Errorf("tmpl.Compile().Verb = %q; want %q; segs=%#v, verb=%q", got, want, spec.segs, spec.verb)
+		}
+		if got, want := compiled.Fields, spec.fields; !reflect.DeepEqual(got, want) {
+			t.Errorf("tmpl.Compile().Fields = %q; want %q; segs=%#v, verb=%q", got, want, spec.segs, spec.verb)
+		}
+	}
+}

api/router/util/parse.go

@@ -0,0 +1,363 @@
+package util
+
+// download from https://raw.githubusercontent.com/grpc-ecosystem/grpc-gateway/master/protoc-gen-grpc-gateway/httprule/parse.go
+
+import (
+	"fmt"
+	"strings"
+
+	"github.com/asim/go-micro/v3/logger"
+)
+
+// InvalidTemplateError indicates that the path template is not valid.
+type InvalidTemplateError struct {
+	tmpl string
+	msg  string
+}
+
+func (e InvalidTemplateError) Error() string {
+	return fmt.Sprintf("%s: %s", e.msg, e.tmpl)
+}
+
+// Parse parses the string representation of path template
+func Parse(tmpl string) (Compiler, error) {
+	if !strings.HasPrefix(tmpl, "/") {
+		return template{}, InvalidTemplateError{tmpl: tmpl, msg: "no leading /"}
+	}
+	tokens, verb := tokenize(tmpl[1:])
+
+	p := parser{tokens: tokens}
+	segs, err := p.topLevelSegments()
+	if err != nil {
+		return template{}, InvalidTemplateError{tmpl: tmpl, msg: err.Error()}
+	}
+
+	return template{
+		segments: segs,
+		verb:     verb,
+		template: tmpl,
+	}, nil
+}
+
+func tokenize(path string) (tokens []string, verb string) {
+	if path == "" {
+		return []string{eof}, ""
+	}
+
+	const (
+		init = iota
+		field
+		nested
+	)
+	var (
+		st = init
+	)
+	for path != "" {
+		var idx int
+		switch st {
+		case init:
+			idx = strings.IndexAny(path, "/{")
+		case field:
+			idx = strings.IndexAny(path, ".=}")
+		case nested:
+			idx = strings.IndexAny(path, "/}")
+		}
+		if idx < 0 {
+			tokens = append(tokens, path)
+			break
+		}
+		switch r := path[idx]; r {
+		case '/', '.':
+		case '{':
+			st = field
+		case '=':
+			st = nested
+		case '}':
+			st = init
+		}
+		if idx == 0 {
+			tokens = append(tokens, path[idx:idx+1])
+		} else {
+			tokens = append(tokens, path[:idx], path[idx:idx+1])
+		}
+		path = path[idx+1:]
+	}
+
+	l := len(tokens)
+	t := tokens[l-1]
+	if idx := strings.LastIndex(t, ":"); idx == 0 {
+		tokens, verb = tokens[:l-1], t[1:]
+	} else if idx > 0 {
+		tokens[l-1], verb = t[:idx], t[idx+1:]
+	}
+	tokens = append(tokens, eof)
+	return tokens, verb
+}
+
+// parser is a parser of the template syntax defined in github.com/googleapis/googleapis/google/api/http.proto.
+type parser struct {
+	tokens   []string
+	accepted []string
+}
+
+// topLevelSegments is the target of this parser.
+func (p *parser) topLevelSegments() ([]segment, error) {
+	if logger.V(logger.DebugLevel, logger.DefaultLogger) {
+		logger.Debugf("Parsing %q", p.tokens)
+	}
+	segs, err := p.segments()
+	if err != nil {
+		return nil, err
+	}
+	if logger.V(logger.DebugLevel, logger.DefaultLogger) {
+		logger.Debugf("accept segments: %q; %q", p.accepted, p.tokens)
+	}
+	if _, err := p.accept(typeEOF); err != nil {
+		return nil, fmt.Errorf("unexpected token %q after segments %q", p.tokens[0], strings.Join(p.accepted, ""))
+	}
+	if logger.V(logger.DebugLevel, logger.DefaultLogger) {
+		logger.Debugf("accept eof: %q; %q", p.accepted, p.tokens)
+	}
+	return segs, nil
+}
+
+func (p *parser) segments() ([]segment, error) {
+	s, err := p.segment()
+	if err != nil {
+		return nil, err
+	}
+
+	if logger.V(logger.DebugLevel, logger.DefaultLogger) {
+		logger.Debugf("accept segment: %q; %q", p.accepted, p.tokens)
+	}
+	segs := []segment{s}
+	for {
+		if _, err := p.accept("/"); err != nil {
+			return segs, nil
+		}
+		s, err := p.segment()
+		if err != nil {
+			return segs, err
+		}
+		segs = append(segs, s)
+		if logger.V(logger.DebugLevel, logger.DefaultLogger) {
+			logger.Debugf("accept segment: %q; %q", p.accepted, p.tokens)
+		}
+	}
+}
+
+func (p *parser) segment() (segment, error) {
+	if _, err := p.accept("*"); err == nil {
+		return wildcard{}, nil
+	}
+	if _, err := p.accept("**"); err == nil {
+		return deepWildcard{}, nil
+	}
+	if l, err := p.literal(); err == nil {
+		return l, nil
+	}
+
+	v, err := p.variable()
+	if err != nil {
+		return nil, fmt.Errorf("segment neither wildcards, literal or variable: %v", err)
+	}
+	return v, err
+}
+
+func (p *parser) literal() (segment, error) {
+	lit, err := p.accept(typeLiteral)
+	if err != nil {
+		return nil, err
+	}
+	return literal(lit), nil
+}
+
+func (p *parser) variable() (segment, error) {
+	if _, err := p.accept("{"); err != nil {
+		return nil, err
+	}
+
+	path, err := p.fieldPath()
+	if err != nil {
+		return nil, err
+	}
+
+	var segs []segment
+	if _, err := p.accept("="); err == nil {
+		segs, err = p.segments()
+		if err != nil {
+			return nil, fmt.Errorf("invalid segment in variable %q: %v", path, err)
+		}
+	} else {
+		segs = []segment{wildcard{}}
+	}
+
+	if _, err := p.accept("}"); err != nil {
+		return nil, fmt.Errorf("unterminated variable segment: %s", path)
+	}
+	return variable{
+		path:     path,
+		segments: segs,
+	}, nil
+}
+
+func (p *parser) fieldPath() (string, error) {
+	c, err := p.accept(typeIdent)
+	if err != nil {
+		return "", err
+	}
+	components := []string{c}
+	for {
+		if _, err = p.accept("."); err != nil {
+			return strings.Join(components, "."), nil
+		}
+		c, err := p.accept(typeIdent)
+		if err != nil {
+			return "", fmt.Errorf("invalid field path component: %v", err)
+		}
+		components = append(components, c)
+	}
+}
+
+// A termType is a type of terminal symbols.
+type termType string
+
+// These constants define some of valid values of termType.
+// They improve readability of parse functions.
+//
+// You can also use "/", "*", "**", "." or "=" as valid values.
+const (
+	typeIdent   = termType("ident")
+	typeLiteral = termType("literal")
+	typeEOF     = termType("$")
+)
+
+const (
+	// eof is the terminal symbol which always appears at the end of token sequence.
+	eof = "\u0000"
+)
+
+// accept tries to accept a token in "p".
+// This function consumes a token and returns it if it matches to the specified "term".
+// If it doesn't match, the function does not consume any tokens and return an error.
+func (p *parser) accept(term termType) (string, error) {
+	t := p.tokens[0]
+	switch term {
+	case "/", "*", "**", ".", "=", "{", "}":
+		if t != string(term) && t != "/" {
+			return "", fmt.Errorf("expected %q but got %q", term, t)
+		}
+	case typeEOF:
+		if t != eof {
+			return "", fmt.Errorf("expected EOF but got %q", t)
+		}
+	case typeIdent:
+		if err := expectIdent(t); err != nil {
+			return "", err
+		}
+	case typeLiteral:
+		if err := expectPChars(t); err != nil {
+			return "", err
+		}
+	default:
+		return "", fmt.Errorf("unknown termType %q", term)
+	}
+	p.tokens = p.tokens[1:]
+	p.accepted = append(p.accepted, t)
+	return t, nil
+}
+
+// expectPChars determines if "t" consists of only pchars defined in RFC3986.
+//
+// https://www.ietf.org/rfc/rfc3986.txt, P.49
+//   pchar         = unreserved / pct-encoded / sub-delims / ":" / "@"
+//   unreserved    = ALPHA / DIGIT / "-" / "." / "_" / "~"
+//   sub-delims    = "!" / "$" / "&" / "'" / "(" / ")"
+//                 / "*" / "+" / "," / ";" / "="
+//   pct-encoded   = "%" HEXDIG HEXDIG
+func expectPChars(t string) error {
+	const (
+		init = iota
+		pct1
+		pct2
+	)
+	st := init
+	for _, r := range t {
+		if st != init {
+			if !isHexDigit(r) {
+				return fmt.Errorf("invalid hexdigit: %c(%U)", r, r)
+			}
+			switch st {
+			case pct1:
+				st = pct2
+			case pct2:
+				st = init
+			}
+			continue
+		}
+
+		// unreserved
+		switch {
+		case 'A' <= r && r <= 'Z':
+			continue
+		case 'a' <= r && r <= 'z':
+			continue
+		case '0' <= r && r <= '9':
+			continue
+		}
+		switch r {
+		case '-', '.', '_', '~':
+			// unreserved
+		case '!', '$', '&', '\'', '(', ')', '*', '+', ',', ';', '=':
+			// sub-delims
+		case ':', '@':
+			// rest of pchar
+		case '%':
+			// pct-encoded
+			st = pct1
+		default:
+			return fmt.Errorf("invalid character in path segment: %q(%U)", r, r)
+		}
+	}
+	if st != init {
+		return fmt.Errorf("invalid percent-encoding in %q", t)
+	}
+	return nil
+}
+
+// expectIdent determines if "ident" is a valid identifier in .proto schema ([[:alpha:]_][[:alphanum:]_]*).
+func expectIdent(ident string) error {
+	if ident == "" {
+		return fmt.Errorf("empty identifier")
+	}
+	for pos, r := range ident {
+		switch {
+		case '0' <= r && r <= '9':
+			if pos == 0 {
+				return fmt.Errorf("identifier starting with digit: %s", ident)
+			}
+			continue
+		case 'A' <= r && r <= 'Z':
+			continue
+		case 'a' <= r && r <= 'z':
+			continue
+		case r == '_':
+			continue
+		default:
+			return fmt.Errorf("invalid character %q(%U) in identifier: %s", r, r, ident)
+		}
+	}
+	return nil
+}
+
+func isHexDigit(r rune) bool {
+	switch {
+	case '0' <= r && r <= '9':
+		return true
+	case 'A' <= r && r <= 'F':
+		return true
+	case 'a' <= r && r <= 'f':
+		return true
+	}
+	return false
+}

api/router/util/parse_test.go

@@ -0,0 +1,321 @@
+package util
+
+// download from https://raw.githubusercontent.com/grpc-ecosystem/grpc-gateway/master/protoc-gen-grpc-gateway/httprule/parse_test.go
+
+import (
+	"flag"
+	"fmt"
+	"reflect"
+	"testing"
+
+	"github.com/asim/go-micro/v3/logger"
+)
+
+func TestTokenize(t *testing.T) {
+	for _, spec := range []struct {
+		src    string
+		tokens []string
+	}{
+		{
+			src:    "",
+			tokens: []string{eof},
+		},
+		{
+			src:    "v1",
+			tokens: []string{"v1", eof},
+		},
+		{
+			src:    "v1/b",
+			tokens: []string{"v1", "/", "b", eof},
+		},
+		{
+			src:    "v1/endpoint/*",
+			tokens: []string{"v1", "/", "endpoint", "/", "*", eof},
+		},
+		{
+			src:    "v1/endpoint/**",
+			tokens: []string{"v1", "/", "endpoint", "/", "**", eof},
+		},
+		{
+			src: "v1/b/{bucket_name=*}",
+			tokens: []string{
+				"v1", "/",
+				"b", "/",
+				"{", "bucket_name", "=", "*", "}",
+				eof,
+			},
+		},
+		{
+			src: "v1/b/{bucket_name=buckets/*}",
+			tokens: []string{
+				"v1", "/",
+				"b", "/",
+				"{", "bucket_name", "=", "buckets", "/", "*", "}",
+				eof,
+			},
+		},
+		{
+			src: "v1/b/{bucket_name=buckets/*}/o",
+			tokens: []string{
+				"v1", "/",
+				"b", "/",
+				"{", "bucket_name", "=", "buckets", "/", "*", "}", "/",
+				"o",
+				eof,
+			},
+		},
+		{
+			src: "v1/b/{bucket_name=buckets/*}/o/{name}",
+			tokens: []string{
+				"v1", "/",
+				"b", "/",
+				"{", "bucket_name", "=", "buckets", "/", "*", "}", "/",
+				"o", "/", "{", "name", "}",
+				eof,
+			},
+		},
+		{
+			src: "v1/a=b&c=d;e=f:g/endpoint.rdf",
+			tokens: []string{
+				"v1", "/",
+				"a=b&c=d;e=f:g", "/",
+				"endpoint.rdf",
+				eof,
+			},
+		},
+	} {
+		tokens, verb := tokenize(spec.src)
+		if got, want := tokens, spec.tokens; !reflect.DeepEqual(got, want) {
+			t.Errorf("tokenize(%q) = %q, _; want %q, _", spec.src, got, want)
+		}
+		if got, want := verb, ""; got != want {
+			t.Errorf("tokenize(%q) = _, %q; want _, %q", spec.src, got, want)
+		}
+
+		src := fmt.Sprintf("%s:%s", spec.src, "LOCK")
+		tokens, verb = tokenize(src)
+		if got, want := tokens, spec.tokens; !reflect.DeepEqual(got, want) {
+			t.Errorf("tokenize(%q) = %q, _; want %q, _", src, got, want)
+		}
+		if got, want := verb, "LOCK"; got != want {
+			t.Errorf("tokenize(%q) = _, %q; want _, %q", src, got, want)
+		}
+	}
+}
+
+func TestParseSegments(t *testing.T) {
+	flag.Set("v", "3")
+	for _, spec := range []struct {
+		tokens []string
+		want   []segment
+	}{
+		{
+			tokens: []string{"v1", eof},
+			want: []segment{
+				literal("v1"),
+			},
+		},
+		{
+			tokens: []string{"/", eof},
+			want: []segment{
+				wildcard{},
+			},
+		},
+		{
+			tokens: []string{"-._~!$&'()*+,;=:@", eof},
+			want: []segment{
+				literal("-._~!$&'()*+,;=:@"),
+			},
+		},
+		{
+			tokens: []string{"%e7%ac%ac%e4%b8%80%e7%89%88", eof},
+			want: []segment{
+				literal("%e7%ac%ac%e4%b8%80%e7%89%88"),
+			},
+		},
+		{
+			tokens: []string{"v1", "/", "*", eof},
+			want: []segment{
+				literal("v1"),
+				wildcard{},
+			},
+		},
+		{
+			tokens: []string{"v1", "/", "**", eof},
+			want: []segment{
+				literal("v1"),
+				deepWildcard{},
+			},
+		},
+		{
+			tokens: []string{"{", "name", "}", eof},
+			want: []segment{
+				variable{
+					path: "name",
+					segments: []segment{
+						wildcard{},
+					},
+				},
+			},
+		},
+		{
+			tokens: []string{"{", "name", "=", "*", "}", eof},
+			want: []segment{
+				variable{
+					path: "name",
+					segments: []segment{
+						wildcard{},
+					},
+				},
+			},
+		},
+		{
+			tokens: []string{"{", "field", ".", "nested", ".", "nested2", "=", "*", "}", eof},
+			want: []segment{
+				variable{
+					path: "field.nested.nested2",
+					segments: []segment{
+						wildcard{},
+					},
+				},
+			},
+		},
+		{
+			tokens: []string{"{", "name", "=", "a", "/", "b", "/", "*", "}", eof},
+			want: []segment{
+				variable{
+					path: "name",
+					segments: []segment{
+						literal("a"),
+						literal("b"),
+						wildcard{},
+					},
+				},
+			},
+		},
+		{
+			tokens: []string{
+				"v1", "/",
+				"{",
+				"name", ".", "nested", ".", "nested2",
+				"=",
+				"a", "/", "b", "/", "*",
+				"}", "/",
+				"o", "/",
+				"{",
+				"another_name",
+				"=",
+				"a", "/", "b", "/", "*", "/", "c",
+				"}", "/",
+				"**",
+				eof},
+			want: []segment{
+				literal("v1"),
+				variable{
+					path: "name.nested.nested2",
+					segments: []segment{
+						literal("a"),
+						literal("b"),
+						wildcard{},
+					},
+				},
+				literal("o"),
+				variable{
+					path: "another_name",
+					segments: []segment{
+						literal("a"),
+						literal("b"),
+						wildcard{},
+						literal("c"),
+					},
+				},
+				deepWildcard{},
+			},
+		},
+	} {
+		p := parser{tokens: spec.tokens}
+		segs, err := p.topLevelSegments()
+		if err != nil {
+			t.Errorf("parser{%q}.segments() failed with %v; want success", spec.tokens, err)
+			continue
+		}
+		if got, want := segs, spec.want; !reflect.DeepEqual(got, want) {
+			t.Errorf("parser{%q}.segments() = %#v; want %#v", spec.tokens, got, want)
+		}
+		if got := p.tokens; len(got) > 0 {
+			t.Errorf("p.tokens = %q; want []; spec.tokens=%q", got, spec.tokens)
+		}
+	}
+}
+
+func TestParseSegmentsWithErrors(t *testing.T) {
+	flag.Set("v", "3")
+	for _, spec := range []struct {
+		tokens []string
+	}{
+		{
+			// double slash
+			tokens: []string{"//", eof},
+		},
+		{
+			// invalid literal
+			tokens: []string{"a?b", eof},
+		},
+		{
+			// invalid percent-encoding
+			tokens: []string{"%", eof},
+		},
+		{
+			// invalid percent-encoding
+			tokens: []string{"%2", eof},
+		},
+		{
+			// invalid percent-encoding
+			tokens: []string{"a%2z", eof},
+		},
+		{
+			// empty segments
+			tokens: []string{eof},
+		},
+		{
+			// unterminated variable
+			tokens: []string{"{", "name", eof},
+		},
+		{
+			// unterminated variable
+			tokens: []string{"{", "name", "=", eof},
+		},
+		{
+			// unterminated variable
+			tokens: []string{"{", "name", "=", "*", eof},
+		},
+		{
+			// empty component in field path
+			tokens: []string{"{", "name", ".", "}", eof},
+		},
+		{
+			// empty component in field path
+			tokens: []string{"{", "name", ".", ".", "nested", "}", eof},
+		},
+		{
+			// invalid character in identifier
+			tokens: []string{"{", "field-name", "}", eof},
+		},
+		{
+			// no slash between segments
+			tokens: []string{"v1", "endpoint", eof},
+		},
+		{
+			// no slash between segments
+			tokens: []string{"v1", "{", "name", "}", eof},
+		},
+	} {
+		p := parser{tokens: spec.tokens}
+		segs, err := p.topLevelSegments()
+		if err == nil {
+			t.Errorf("parser{%q}.segments() succeeded; want InvalidTemplateError; accepted %#v", spec.tokens, segs)
+			continue
+		}
+		logger.Info(err)
+	}
+}

api/router/util/pattern.go

@@ -0,0 +1,24 @@
+package util
+
+// download from https://raw.githubusercontent.com/grpc-ecosystem/grpc-gateway/master/utilities/pattern.go
+
+// An OpCode is a opcode of compiled path patterns.
+type OpCode int
+
+// These constants are the valid values of OpCode.
+const (
+	// OpNop does nothing
+	OpNop = OpCode(iota)
+	// OpPush pushes a component to stack
+	OpPush
+	// OpLitPush pushes a component to stack if it matches to the literal
+	OpLitPush
+	// OpPushM concatenates the remaining components and pushes it to stack
+	OpPushM
+	// OpConcatN pops N items from stack, concatenates them and pushes it back to stack
+	OpConcatN
+	// OpCapture pops an item and binds it to the variable
+	OpCapture
+	// OpEnd is the least positive invalid opcode.
+	OpEnd
+)

api/router/util/runtime.go

@@ -0,0 +1,283 @@
+package util
+
+// download from https://raw.githubusercontent.com/grpc-ecosystem/grpc-gateway/master/runtime/pattern.go
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+
+	"github.com/asim/go-micro/v3/logger"
+)
+
+var (
+	// ErrNotMatch indicates that the given HTTP request path does not match to the pattern.
+	ErrNotMatch = errors.New("not match to the path pattern")
+	// ErrInvalidPattern indicates that the given definition of Pattern is not valid.
+	ErrInvalidPattern = errors.New("invalid pattern")
+)
+
+type rop struct {
+	code    OpCode
+	operand int
+}
+
+// Pattern is a template pattern of http request paths defined in github.com/googleapis/googleapis/google/api/http.proto.
+type Pattern struct {
+	// ops is a list of operations
+	ops []rop
+	// pool is a constant pool indexed by the operands or vars.
+	pool []string
+	// vars is a list of variables names to be bound by this pattern
+	vars []string
+	// stacksize is the max depth of the stack
+	stacksize int
+	// tailLen is the length of the fixed-size segments after a deep wildcard
+	tailLen int
+	// verb is the VERB part of the path pattern. It is empty if the pattern does not have VERB part.
+	verb string
+	// assumeColonVerb indicates whether a path suffix after a final
+	// colon may only be interpreted as a verb.
+	assumeColonVerb bool
+}
+
+type patternOptions struct {
+	assumeColonVerb bool
+}
+
+// PatternOpt is an option for creating Patterns.
+type PatternOpt func(*patternOptions)
+
+// NewPattern returns a new Pattern from the given definition values.
+// "ops" is a sequence of op codes. "pool" is a constant pool.
+// "verb" is the verb part of the pattern. It is empty if the pattern does not have the part.
+// "version" must be 1 for now.
+// It returns an error if the given definition is invalid.
+func NewPattern(version int, ops []int, pool []string, verb string, opts ...PatternOpt) (Pattern, error) {
+	options := patternOptions{
+		assumeColonVerb: true,
+	}
+	for _, o := range opts {
+		o(&options)
+	}
+
+	if version != 1 {
+		if logger.V(logger.DebugLevel, logger.DefaultLogger) {
+			logger.Debugf("unsupported version: %d", version)
+		}
+		return Pattern{}, ErrInvalidPattern
+	}
+
+	l := len(ops)
+	if l%2 != 0 {
+		if logger.V(logger.DebugLevel, logger.DefaultLogger) {
+			logger.Debugf("odd number of ops codes: %d", l)
+		}
+		return Pattern{}, ErrInvalidPattern
+	}
+
+	var (
+		typedOps        []rop
+		stack, maxstack int
+		tailLen         int
+		pushMSeen       bool
+		vars            []string
+	)
+	for i := 0; i < l; i += 2 {
+		op := rop{code: OpCode(ops[i]), operand: ops[i+1]}
+		switch op.code {
+		case OpNop:
+			continue
+		case OpPush:
+			if pushMSeen {
+				tailLen++
+			}
+			stack++
+		case OpPushM:
+			if pushMSeen {
+				if logger.V(logger.DebugLevel, logger.DefaultLogger) {
+					logger.Debug("pushM appears twice")
+				}
+				return Pattern{}, ErrInvalidPattern
+			}
+			pushMSeen = true
+			stack++
+		case OpLitPush:
+			if op.operand < 0 || len(pool) <= op.operand {
+				if logger.V(logger.DebugLevel, logger.DefaultLogger) {
+					logger.Debugf("negative literal index: %d", op.operand)
+				}
+				return Pattern{}, ErrInvalidPattern
+			}
+			if pushMSeen {
+				tailLen++
+			}
+			stack++
+		case OpConcatN:
+			if op.operand <= 0 {
+				if logger.V(logger.DebugLevel, logger.DefaultLogger) {
+					logger.Debugf("negative concat size: %d", op.operand)
+				}
+				return Pattern{}, ErrInvalidPattern
+			}
+			stack -= op.operand
+			if stack < 0 {
+				if logger.V(logger.DebugLevel, logger.DefaultLogger) {
+					logger.Debug("stack underflow")
+				}
+				return Pattern{}, ErrInvalidPattern
+			}
+			stack++
+		case OpCapture:
+			if op.operand < 0 || len(pool) <= op.operand {
+				if logger.V(logger.DebugLevel, logger.DefaultLogger) {
+					logger.Debugf("variable name index out of bound: %d", op.operand)
+				}
+				return Pattern{}, ErrInvalidPattern
+			}
+			v := pool[op.operand]
+			op.operand = len(vars)
+			vars = append(vars, v)
+			stack--
+			if stack < 0 {
+				if logger.V(logger.DebugLevel, logger.DefaultLogger) {
+					logger.Debug("stack underflow")
+				}
+				return Pattern{}, ErrInvalidPattern
+			}
+		default:
+			if logger.V(logger.DebugLevel, logger.DefaultLogger) {
+				logger.Debugf("invalid opcode: %d", op.code)
+			}
+			return Pattern{}, ErrInvalidPattern
+		}
+
+		if maxstack < stack {
+			maxstack = stack
+		}
+		typedOps = append(typedOps, op)
+	}
+	return Pattern{
+		ops:             typedOps,
+		pool:            pool,
+		vars:            vars,
+		stacksize:       maxstack,
+		tailLen:         tailLen,
+		verb:            verb,
+		assumeColonVerb: options.assumeColonVerb,
+	}, nil
+}
+
+// MustPattern is a helper function which makes it easier to call NewPattern in variable initialization.
+func MustPattern(p Pattern, err error) Pattern {
+	if err != nil {
+		if logger.V(logger.DebugLevel, logger.DefaultLogger) {
+			logger.Fatalf("Pattern initialization failed: %v", err)
+		}
+	}
+	return p
+}
+
+// Match examines components if it matches to the Pattern.
+// If it matches, the function returns a mapping from field paths to their captured values.
+// If otherwise, the function returns an error.
+func (p Pattern) Match(components []string, verb string) (map[string]string, error) {
+	if p.verb != verb {
+		if p.assumeColonVerb || p.verb != "" {
+			return nil, ErrNotMatch
+		}
+		if len(components) == 0 {
+			components = []string{":" + verb}
+		} else {
+			components = append([]string{}, components...)
+			components[len(components)-1] += ":" + verb
+		}
+		verb = ""
+	}
+
+	var pos int
+	stack := make([]string, 0, p.stacksize)
+	captured := make([]string, len(p.vars))
+	l := len(components)
+	for _, op := range p.ops {
+		switch op.code {
+		case OpNop:
+			continue
+		case OpPush, OpLitPush:
+			if pos >= l {
+				return nil, ErrNotMatch
+			}
+			c := components[pos]
+			if op.code == OpLitPush {
+				if lit := p.pool[op.operand]; c != lit {
+					return nil, ErrNotMatch
+				}
+			}
+			stack = append(stack, c)
+			pos++
+		case OpPushM:
+			end := len(components)
+			if end < pos+p.tailLen {
+				return nil, ErrNotMatch
+			}
+			end -= p.tailLen
+			stack = append(stack, strings.Join(components[pos:end], "/"))
+			pos = end
+		case OpConcatN:
+			n := op.operand
+			l := len(stack) - n
+			stack = append(stack[:l], strings.Join(stack[l:], "/"))
+		case OpCapture:
+			n := len(stack) - 1
+			captured[op.operand] = stack[n]
+			stack = stack[:n]
+		}
+	}
+	if pos < l {
+		return nil, ErrNotMatch
+	}
+	bindings := make(map[string]string)
+	for i, val := range captured {
+		bindings[p.vars[i]] = val
+	}
+	return bindings, nil
+}
+
+// Verb returns the verb part of the Pattern.
+func (p Pattern) Verb() string { return p.verb }
+
+func (p Pattern) String() string {
+	var stack []string
+	for _, op := range p.ops {
+		switch op.code {
+		case OpNop:
+			continue
+		case OpPush:
+			stack = append(stack, "*")
+		case OpLitPush:
+			stack = append(stack, p.pool[op.operand])
+		case OpPushM:
+			stack = append(stack, "**")
+		case OpConcatN:
+			n := op.operand
+			l := len(stack) - n
+			stack = append(stack[:l], strings.Join(stack[l:], "/"))
+		case OpCapture:
+			n := len(stack) - 1
+			stack[n] = fmt.Sprintf("{%s=%s}", p.vars[op.operand], stack[n])
+		}
+	}
+	segs := strings.Join(stack, "/")
+	if p.verb != "" {
+		return fmt.Sprintf("/%s:%s", segs, p.verb)
+	}
+	return "/" + segs
+}
+
+// AssumeColonVerbOpt indicates whether a path suffix after a final
+// colon may only be interpreted as a verb.
+func AssumeColonVerbOpt(val bool) PatternOpt {
+	return PatternOpt(func(o *patternOptions) {
+		o.assumeColonVerb = val
+	})
+}

api/router/util/types.go

@@ -0,0 +1,62 @@
+package util
+
+// download from https://raw.githubusercontent.com/grpc-ecosystem/grpc-gateway/master/protoc-gen-grpc-gateway/httprule/types.go
+
+import (
+	"fmt"
+	"strings"
+)
+
+type template struct {
+	segments []segment
+	verb     string
+	template string
+}
+
+type segment interface {
+	fmt.Stringer
+	compile() (ops []op)
+}
+
+type wildcard struct{}
+
+type deepWildcard struct{}
+
+type literal string
+
+type variable struct {
+	path     string
+	segments []segment
+}
+
+func (wildcard) String() string {
+	return "*"
+}
+
+func (deepWildcard) String() string {
+	return "**"
+}
+
+func (l literal) String() string {
+	return string(l)
+}
+
+func (v variable) String() string {
+	var segs []string
+	for _, s := range v.segments {
+		segs = append(segs, s.String())
+	}
+	return fmt.Sprintf("{%s=%s}", v.path, strings.Join(segs, "/"))
+}
+
+func (t template) String() string {
+	var segs []string
+	for _, s := range t.segments {
+		segs = append(segs, s.String())
+	}
+	str := strings.Join(segs, "/")
+	if t.verb != "" {
+		str = fmt.Sprintf("%s:%s", str, t.verb)
+	}
+	return "/" + str
+}

api/router/util/types_test.go

@@ -0,0 +1,93 @@
+package util
+
+// download from https://raw.githubusercontent.com/grpc-ecosystem/grpc-gateway/master/protoc-gen-grpc-gateway/httprule/types_test.go
+
+import (
+	"fmt"
+	"testing"
+)
+
+func TestTemplateStringer(t *testing.T) {
+	for _, spec := range []struct {
+		segs []segment
+		want string
+	}{
+		{
+			segs: []segment{
+				literal("v1"),
+			},
+			want: "/v1",
+		},
+		{
+			segs: []segment{
+				wildcard{},
+			},
+			want: "/*",
+		},
+		{
+			segs: []segment{
+				deepWildcard{},
+			},
+			want: "/**",
+		},
+		{
+			segs: []segment{
+				variable{
+					path: "name",
+					segments: []segment{
+						literal("a"),
+					},
+				},
+			},
+			want: "/{name=a}",
+		},
+		{
+			segs: []segment{
+				variable{
+					path: "name",
+					segments: []segment{
+						literal("a"),
+						wildcard{},
+						literal("b"),
+					},
+				},
+			},
+			want: "/{name=a/*/b}",
+		},
+		{
+			segs: []segment{
+				literal("v1"),
+				variable{
+					path: "name",
+					segments: []segment{
+						literal("a"),
+						wildcard{},
+						literal("b"),
+					},
+				},
+				literal("c"),
+				variable{
+					path: "field.nested",
+					segments: []segment{
+						wildcard{},
+						literal("d"),
+					},
+				},
+				wildcard{},
+				literal("e"),
+				deepWildcard{},
+			},
+			want: "/v1/{name=a/*/b}/c/{field.nested=*/d}/*/e/**",
+		},
+	} {
+		tmpl := template{segments: spec.segs}
+		if got, want := tmpl.String(), spec.want; got != want {
+			t.Errorf("%#v.String() = %q; want %q", tmpl, got, want)
+		}
+
+		tmpl.verb = "LOCK"
+		if got, want := tmpl.String(), fmt.Sprintf("%s:LOCK", spec.want); got != want {
+			t.Errorf("%#v.String() = %q; want %q", tmpl, got, want)
+		}
+	}
+}

api/server/acme/acme.go

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

api/server/acme/autocert/autocert.go

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

api/server/acme/autocert/autocert_test.go

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

api/server/acme/autocert/cache.go

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

api/server/acme/options.go

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

api/server/cors/cors.go

@@ -0,0 +1,57 @@
+package cors
+
+import (
+	"net/http"
+)
+
+type Config struct {
+	AllowOrigin      string
+	AllowCredentials bool
+	AllowMethods     string
+	AllowHeaders     string
+}
+
+// CombinedCORSHandler wraps a server and provides CORS headers
+func CombinedCORSHandler(h http.Handler, config *Config) http.Handler {
+	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		if config != nil {
+			SetHeaders(w, r, config)
+		}
+		if r.Method == "OPTIONS" {
+			return
+		}
+
+		h.ServeHTTP(w, r)
+	})
+}
+
+// SetHeaders sets the CORS headers
+func SetHeaders(w http.ResponseWriter, _ *http.Request, config *Config) {
+	set := func(w http.ResponseWriter, k, v string) {
+		if v := w.Header().Get(k); len(v) > 0 {
+			return
+		}
+		w.Header().Set(k, v)
+	}
+	//For forward-compatible code, default values may not be provided in the future
+	if config.AllowCredentials {
+		set(w, "Access-Control-Allow-Credentials", "true")
+	} else {
+		set(w, "Access-Control-Allow-Credentials", "false")
+	}
+	if config.AllowOrigin == "" {
+		set(w, "Access-Control-Allow-Origin", "*")
+	} else {
+		set(w, "Access-Control-Allow-Origin", config.AllowOrigin)
+	}
+	if config.AllowMethods == "" {
+		set(w, "Access-Control-Allow-Methods", "POST, PATCH, GET, OPTIONS, PUT, DELETE")
+	} else {
+		set(w, "Access-Control-Allow-Methods", config.AllowMethods)
+	}
+	if config.AllowHeaders == "" {
+		set(w, "Access-Control-Allow-Headers", "Accept, Content-Type, Content-Length, Accept-Encoding, X-CSRF-Token, Authorization")
+	} else {
+		set(w, "Access-Control-Allow-Headers", config.AllowHeaders)
+	}
+}

api/server/http/http.go

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

api/server/http/http_test.go

@@ -0,0 +1,114 @@
+package http
+
+import (
+	"fmt"
+	"github.com/asim/go-micro/v3/api/server"
+	"github.com/asim/go-micro/v3/api/server/cors"
+	"io/ioutil"
+	"net/http"
+	"testing"
+)
+
+func TestHTTPServer(t *testing.T) {
+	testResponse := "hello world"
+
+	s := NewServer("localhost:0")
+
+	s.Handle("/", http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		fmt.Fprint(w, testResponse)
+	}))
+
+	if err := s.Start(); err != nil {
+		t.Fatal(err)
+	}
+
+	rsp, err := http.Get(fmt.Sprintf("http://%s/", s.Address()))
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer rsp.Body.Close()
+
+	b, err := ioutil.ReadAll(rsp.Body)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	if string(b) != testResponse {
+		t.Fatalf("Unexpected response, got %s, expected %s", string(b), testResponse)
+	}
+
+	if err := s.Stop(); err != nil {
+		t.Fatal(err)
+	}
+}
+
+func TestCORSHTTPServer(t *testing.T) {
+	testResponse := "hello world"
+	testAllowOrigin := "*"
+	testAllowCredentials := true
+	testAllowMethods := "GET"
+	testAllowHeaders := "Accept, Content-Type, Content-Length"
+
+	s := NewServer("localhost:0",
+		server.EnableCORS(true),
+		server.CORSConfig(&cors.Config{
+			AllowCredentials: testAllowCredentials,
+			AllowOrigin:      testAllowOrigin,
+			AllowMethods:     testAllowMethods,
+			AllowHeaders:     testAllowHeaders,
+		}),
+	)
+
+	s.Handle("/", http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		fmt.Fprint(w, testResponse)
+	}))
+
+	if err := s.Start(); err != nil {
+		t.Fatal(err)
+	}
+
+	rsp, err := http.Get(fmt.Sprintf("http://%s/", s.Address()))
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer rsp.Body.Close()
+
+	b, err := ioutil.ReadAll(rsp.Body)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	if string(b) != testResponse {
+		t.Fatalf("Unexpected response, got %s, expected %s", string(b), testResponse)
+	}
+
+	allowCredentials := rsp.Header.Get("Access-Control-Allow-Credentials")
+	getTestCredentialsStr := func() string {
+		if testAllowCredentials == true {
+			return "true"
+		} else {
+			return "false"
+		}
+	}
+	if getTestCredentialsStr() != allowCredentials {
+		t.Fatalf("Unexpected Access-Control-Allow-Credentials, got %s, expected %s", allowCredentials, getTestCredentialsStr())
+	}
+
+	allowOrigin := rsp.Header.Get("Access-Control-Allow-Origin")
+	if testAllowOrigin != allowOrigin {
+		t.Fatalf("Unexpected Access-Control-Allow-Origins, got %s, expected %s", allowOrigin, testAllowOrigin)
+	}
+
+	allowMethods := rsp.Header.Get("Access-Control-Allow-Methods")
+	if testAllowMethods != allowMethods {
+		t.Fatalf("Unexpected Access-Control-Allow-Methods, got %s, expected %s", allowMethods, testAllowMethods)
+	}
+	allowHeaders := rsp.Header.Get("Access-Control-Allow-Headers")
+	if testAllowHeaders != allowHeaders {
+		t.Fatalf("Unexpected Access-Control-Allow-Headers, got %s, expected %s", allowHeaders, testAllowHeaders)
+	}
+
+	if err := s.Stop(); err != nil {
+		t.Fatal(err)
+	}
+}

api/server/options.go

@@ -0,0 +1,80 @@
+package server
+
+import (
+	"crypto/tls"
+	"github.com/asim/go-micro/v3/api/server/cors"
+	"net/http"
+
+	"github.com/asim/go-micro/v3/api/resolver"
+	"github.com/asim/go-micro/v3/api/server/acme"
+)
+
+type Option func(o *Options)
+
+type Options struct {
+	EnableACME   bool
+	EnableCORS   bool
+	CORSConfig   *cors.Config
+	ACMEProvider acme.Provider
+	EnableTLS    bool
+	ACMEHosts    []string
+	TLSConfig    *tls.Config
+	Resolver     resolver.Resolver
+	Wrappers     []Wrapper
+}
+
+type Wrapper func(h http.Handler) http.Handler
+
+func WrapHandler(w Wrapper) Option {
+	return func(o *Options) {
+		o.Wrappers = append(o.Wrappers, w)
+	}
+}
+
+func EnableCORS(b bool) Option {
+	return func(o *Options) {
+		o.EnableCORS = b
+	}
+}
+
+func CORSConfig(c *cors.Config) Option {
+	return func(o *Options) {
+		o.CORSConfig = c
+	}
+}
+
+func EnableACME(b bool) Option {
+	return func(o *Options) {
+		o.EnableACME = b
+	}
+}
+
+func ACMEHosts(hosts ...string) Option {
+	return func(o *Options) {
+		o.ACMEHosts = hosts
+	}
+}
+
+func ACMEProvider(p acme.Provider) Option {
+	return func(o *Options) {
+		o.ACMEProvider = p
+	}
+}
+
+func EnableTLS(b bool) Option {
+	return func(o *Options) {
+		o.EnableTLS = b
+	}
+}
+
+func TLSConfig(t *tls.Config) Option {
+	return func(o *Options) {
+		o.TLSConfig = t
+	}
+}
+
+func Resolver(r resolver.Resolver) Option {
+	return func(o *Options) {
+		o.Resolver = r
+	}
+}

api/server/server.go

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

auth/auth.go

@@ -8,22 +8,22 @@ import (
 )
 
 const (
-	// BearerScheme used for Authorization header.
+	// BearerScheme used for Authorization header
 	BearerScheme = "Bearer "
-	// ScopePublic is the scope applied to a rule to allow access to the public.
+	// 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 is the scope applied to a rule to limit to users with any valid account
 	ScopeAccount = "*"
 )
 
 var (
-	// ErrInvalidToken is when the token provided is not valid.
+	// 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 is when a user does not have the necessary scope to access a resource
 	ErrForbidden = errors.New("resource forbidden")
 )
 
-// Auth provides authentication and authorization.
+// Auth provides authentication and authorization
 type Auth interface {
 	// Init the auth
 	Init(opts ...Option)
@@ -39,7 +39,7 @@ type Auth interface {
 	String() string
 }
 
-// Rules manages access to resources.
+// Rules manages access to resources
 type Rules interface {
 	// Verify an account has access to a resource using the rules
 	Verify(acc *Account, res *Resource, opts ...VerifyOption) error
@@ -51,40 +51,40 @@ type Rules interface {
 	List(...ListOption) ([]*Rule, error)
 }
 
-// Account provided by an auth provider.
+// Account provided by an auth provider
 type Account struct {
-	// Any other associated metadata
-	Metadata map[string]string `json:"metadata"`
 	// ID of the account e.g. email
 	ID string `json:"id"`
 	// Type of the account, e.g. service
 	Type string `json:"type"`
 	// Issuer of the account
 	Issuer string `json:"issuer"`
-	// Secret for the account, e.g. the password
-	Secret string `json:"secret"`
+	// Any other associated metadata
+	Metadata map[string]string `json:"metadata"`
 	// Scopes the account has access to
 	Scopes []string `json:"scopes"`
+	// Secret for the account, e.g. the password
+	Secret string `json:"secret"`
 }
 
-// Token can be short or long lived.
+// 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"`
+	// Time of token creation
+	Created time.Time `json:"created"`
+	// Time of token expiry
+	Expiry time.Time `json:"expiry"`
 }
 
-// Expired returns a boolean indicating if the token needs to be refreshed.
+// 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.
+// 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"`
@@ -94,25 +94,25 @@ type Resource struct {
 	Endpoint string `json:"endpoint"`
 }
 
-// Access defines the type of access a rule grants.
+// Access defines the type of access a rule grants
 type Access int
 
 const (
-	// AccessGranted to a resource.
+	// AccessGranted to a resource
 	AccessGranted Access = iota
-	// AccessDenied to a resource.
+	// AccessDenied to a resource
 	AccessDenied
 )
 
-// Rule is used to verify access to a resource.
+// Rule is used to verify access to a resource
 type Rule struct {
-	// Resource the rule applies to
-	Resource *Resource
 	// ID of the rule, e.g. "public"
 	ID string
 	// Scope the rule requires, a blank scope indicates open to the public and * indicates the rule
 	// applies to any valid account
 	Scope string
+	// Resource the rule applies to
+	Resource *Resource
 	// Access determines if the rule grants or denies access to the resource
 	Access Access
 	// Priority the rule should take when verifying a request, the higher the value the sooner the
@@ -125,13 +125,13 @@ 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.
+// when there was a problem retrieving an account
 func AccountFromContext(ctx context.Context) (*Account, bool) {
 	acc, ok := ctx.Value(accountKey{}).(*Account)
 	return acc, ok
 }
 
-// ContextWithAccount sets the account in the context.
+// ContextWithAccount sets the account in the context
 func ContextWithAccount(ctx context.Context, account *Account) context.Context {
 	return context.WithValue(ctx, accountKey{}, account)
 }

auth/jwt/token/test/sample_key 2

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

auth/noop.go

@@ -30,24 +30,24 @@ type noop struct {
 
 type noopRules struct{}
 
-// String returns the name of the implementation.
+// String returns the name of the implementation
 func (n *noop) String() string {
 	return "noop"
 }
 
-// Init the auth.
+// Init the auth
 func (n *noop) Init(opts ...Option) {
 	for _, o := range opts {
 		o(&n.opts)
 	}
 }
 
-// Options set for auth.
+// Options set for auth
 func (n *noop) Options() Options {
 	return n.opts
 }
 
-// Generate a new account.
+// Generate a new account
 func (n *noop) Generate(id string, opts ...GenerateOption) (*Account, error) {
 	options := NewGenerateOptions(opts...)
 
@@ -60,18 +60,18 @@ func (n *noop) Generate(id string, opts ...GenerateOption) (*Account, error) {
 	}, nil
 }
 
-// Grant access to a resource.
+// Grant access to a resource
 func (n *noopRules) Grant(rule *Rule) error {
 	return nil
 }
 
-// Revoke access to a resource.
+// Revoke access to a resource
 func (n *noopRules) Revoke(rule *Rule) error {
 	return nil
 }
 
 // Rules used to verify requests
-// Verify an account has access to a resource.
+// Verify an account has access to a resource
 func (n *noopRules) Verify(acc *Account, res *Resource, opts ...VerifyOption) error {
 	return nil
 }
@@ -80,12 +80,12 @@ func (n *noopRules) List(opts ...ListOption) ([]*Rule, error) {
 	return []*Rule{}, nil
 }
 
-// Inspect a token.
+// Inspect a token
 func (n *noop) Inspect(token string) (*Account, error) {
 	return &Account{ID: uuid.New().String(), Issuer: n.Options().Namespace}, nil
 }
 
-// Token generation using an account id and secret.
+// Token generation using an account id and secret
 func (n *noop) Token(opts ...TokenOption) (*Token, error) {
 	return &Token{}, nil
 }

auth/options.go

@@ -3,33 +3,25 @@ package auth
 import (
 	"context"
 	"time"
-
-	"go-micro.dev/v5/logger"
 )
 
 func NewOptions(opts ...Option) Options {
-	options := Options{
-		Logger: logger.DefaultLogger,
-	}
-
+	var options Options
 	for _, o := range opts {
 		o(&options)
 	}
-
 	return options
 }
 
 type Options struct {
-	// Logger is the underline logger
-	Logger logger.Logger
-	// Token is the services token used to authenticate itself
-	Token *Token
 	// Namespace the service belongs to
 	Namespace string
 	// ID is the services auth ID
 	ID string
 	// Secret is used to authenticate the service
 	Secret string
+	// Token is the services token used to authenticate itself
+	Token *Token
 	// PublicKey for decoding JWTs
 	PublicKey string
 	// PrivateKey for encoding JWTs
@@ -40,42 +32,35 @@ type Options struct {
 
 type Option func(o *Options)
 
-// Addrs is the auth addresses to use.
+// Addrs is the auth addresses to use
 func Addrs(addrs ...string) Option {
 	return func(o *Options) {
 		o.Addrs = addrs
 	}
 }
 
-// Namespace the service belongs to.
+// Namespace the service belongs to
 func Namespace(n string) Option {
 	return func(o *Options) {
 		o.Namespace = n
 	}
 }
 
-// PublicKey is the JWT public key.
+// PublicKey is the JWT public key
 func PublicKey(key string) Option {
 	return func(o *Options) {
 		o.PublicKey = key
 	}
 }
 
-// PrivateKey is the JWT private key.
+// PrivateKey is the JWT private key
 func PrivateKey(key string) Option {
 	return func(o *Options) {
 		o.PrivateKey = key
 	}
 }
 
-// WithLogger sets the underline logger.
-func WithLogger(l logger.Logger) Option {
-	return func(o *Options) {
-		o.Logger = l
-	}
-}
-
-// Credentials sets the auth credentials.
+// Credentials sets the auth credentials
 func Credentials(id, secret string) Option {
 	return func(o *Options) {
 		o.ID = id
@@ -83,7 +68,7 @@ func Credentials(id, secret string) Option {
 	}
 }
 
-// ClientToken sets the auth token to use when making requests.
+// ClientToken sets the auth token to use when making requests
 func ClientToken(token *Token) Option {
 	return func(o *Options) {
 		o.Token = token
@@ -93,54 +78,54 @@ func ClientToken(token *Token) Option {
 type GenerateOptions struct {
 	// Metadata associated with the account
 	Metadata map[string]string
+	// Scopes the account has access too
+	Scopes []string
 	// Provider of the account, e.g. oauth
 	Provider string
 	// Type of the account, e.g. user
 	Type string
 	// Secret used to authenticate the account
 	Secret string
-	// Scopes the account has access too
-	Scopes []string
 }
 
 type GenerateOption func(o *GenerateOptions)
 
-// WithSecret for the generated account.
+// WithSecret for the generated account
 func WithSecret(s string) GenerateOption {
 	return func(o *GenerateOptions) {
 		o.Secret = s
 	}
 }
 
-// WithType for the generated account.
+// WithType for the generated account
 func WithType(t string) GenerateOption {
 	return func(o *GenerateOptions) {
 		o.Type = t
 	}
 }
 
-// WithMetadata for the generated account.
+// WithMetadata for the generated account
 func WithMetadata(md map[string]string) GenerateOption {
 	return func(o *GenerateOptions) {
 		o.Metadata = md
 	}
 }
 
-// WithProvider for the generated account.
+// WithProvider for the generated account
 func WithProvider(p string) GenerateOption {
 	return func(o *GenerateOptions) {
 		o.Provider = p
 	}
 }
 
-// WithScopes for the generated account.
+// WithScopes for the generated account
 func WithScopes(s ...string) GenerateOption {
 	return func(o *GenerateOptions) {
 		o.Scopes = s
 	}
 }
 
-// NewGenerateOptions from a slice of options.
+// NewGenerateOptions from a slice of options
 func NewGenerateOptions(opts ...GenerateOption) GenerateOptions {
 	var options GenerateOptions
 	for _, o := range opts {
@@ -162,7 +147,7 @@ type TokenOptions struct {
 
 type TokenOption func(o *TokenOptions)
 
-// WithExpiry for the token.
+// WithExpiry for the token
 func WithExpiry(ex time.Duration) TokenOption {
 	return func(o *TokenOptions) {
 		o.Expiry = ex
@@ -182,14 +167,14 @@ func WithToken(rt string) TokenOption {
 	}
 }
 
-// NewTokenOptions from a slice of options.
+// 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
+	// set defualt expiry of token
 	if options.Expiry == 0 {
 		options.Expiry = time.Minute
 	}

auth/rules.go

@@ -8,7 +8,7 @@ import (
 
 // Verify 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.
+// will be returned
 func Verify(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}

auth/rules_test.go

@@ -42,7 +42,7 @@ func TestVerify(t *testing.T) {
 			Account:  &Account{},
 			Resource: srvResource,
 			Rules: []*Rule{
-				{
+				&Rule{
 					Scope:    "",
 					Resource: catchallResource,
 				},
@@ -52,7 +52,7 @@ func TestVerify(t *testing.T) {
 			Name:     "CatchallPublicNoAccount",
 			Resource: srvResource,
 			Rules: []*Rule{
-				{
+				&Rule{
 					Scope:    "",
 					Resource: catchallResource,
 				},
@@ -63,7 +63,7 @@ func TestVerify(t *testing.T) {
 			Account:  &Account{},
 			Resource: srvResource,
 			Rules: []*Rule{
-				{
+				&Rule{
 					Scope:    "*",
 					Resource: catchallResource,
 				},
@@ -73,7 +73,7 @@ func TestVerify(t *testing.T) {
 			Name:     "CatchallPrivateNoAccount",
 			Resource: srvResource,
 			Rules: []*Rule{
-				{
+				&Rule{
 					Scope:    "*",
 					Resource: catchallResource,
 				},
@@ -85,7 +85,7 @@ func TestVerify(t *testing.T) {
 			Resource: srvResource,
 			Account:  &Account{},
 			Rules: []*Rule{
-				{
+				&Rule{
 					Scope: "*",
 					Resource: &Resource{
 						Type:     srvResource.Type,
@@ -100,7 +100,7 @@ func TestVerify(t *testing.T) {
 			Resource: srvResource,
 			Account:  &Account{},
 			Rules: []*Rule{
-				{
+				&Rule{
 					Scope: "*",
 					Resource: &Resource{
 						Type:     srvResource.Type,
@@ -118,7 +118,7 @@ func TestVerify(t *testing.T) {
 				Scopes: []string{"neededscope"},
 			},
 			Rules: []*Rule{
-				{
+				&Rule{
 					Scope:    "neededscope",
 					Resource: srvResource,
 				},
@@ -131,7 +131,7 @@ func TestVerify(t *testing.T) {
 				Scopes: []string{"neededscope"},
 			},
 			Rules: []*Rule{
-				{
+				&Rule{
 					Scope:    "invalidscope",
 					Resource: srvResource,
 				},
@@ -143,7 +143,7 @@ func TestVerify(t *testing.T) {
 			Resource: srvResource,
 			Account:  &Account{},
 			Rules: []*Rule{
-				{
+				&Rule{
 					Scope:    "*",
 					Resource: catchallResource,
 					Access:   AccessDenied,
@@ -156,7 +156,7 @@ func TestVerify(t *testing.T) {
 			Resource: srvResource,
 			Account:  &Account{},
 			Rules: []*Rule{
-				{
+				&Rule{
 					Scope:    "*",
 					Resource: catchallResource,
 					Access:   AccessDenied,
@@ -169,13 +169,13 @@ func TestVerify(t *testing.T) {
 			Resource: srvResource,
 			Account:  &Account{},
 			Rules: []*Rule{
-				{
+				&Rule{
 					Scope:    "*",
 					Resource: catchallResource,
 					Access:   AccessGranted,
 					Priority: 1,
 				},
-				{
+				&Rule{
 					Scope:    "*",
 					Resource: catchallResource,
 					Access:   AccessDenied,
@@ -188,13 +188,13 @@ func TestVerify(t *testing.T) {
 			Resource: srvResource,
 			Account:  &Account{},
 			Rules: []*Rule{
-				{
+				&Rule{
 					Scope:    "*",
 					Resource: catchallResource,
 					Access:   AccessGranted,
 					Priority: 0,
 				},
-				{
+				&Rule{
 					Scope:    "*",
 					Resource: catchallResource,
 					Access:   AccessDenied,
@@ -208,7 +208,7 @@ func TestVerify(t *testing.T) {
 			Resource: webResource,
 			Account:  &Account{},
 			Rules: []*Rule{
-				{
+				&Rule{
 					Scope:    "*",
 					Resource: webResource,
 				},
@@ -219,7 +219,7 @@ func TestVerify(t *testing.T) {
 			Resource: webResource,
 			Account:  &Account{},
 			Rules: []*Rule{
-				{
+				&Rule{
 					Scope: "*",
 					Resource: &Resource{
 						Type:     webResource.Type,
@@ -235,7 +235,7 @@ func TestVerify(t *testing.T) {
 			Resource: webResource,
 			Account:  &Account{},
 			Rules: []*Rule{
-				{
+				&Rule{
 					Scope: "*",
 					Resource: &Resource{
 						Type:     webResource.Type,
@@ -250,7 +250,7 @@ func TestVerify(t *testing.T) {
 			Resource: webResource,
 			Account:  &Account{},
 			Rules: []*Rule{
-				{
+				&Rule{
 					Scope: "*",
 					Resource: &Resource{
 						Type:     webResource.Type,
@@ -265,7 +265,7 @@ func TestVerify(t *testing.T) {
 			Resource: webResource,
 			Account:  &Account{},
 			Rules: []*Rule{
-				{
+				&Rule{
 					Scope: "*",
 					Resource: &Resource{
 						Type:     webResource.Type,

broker/broker.go

@@ -18,13 +18,12 @@ type Broker interface {
 // message and optional Ack method to acknowledge receipt of the message.
 type Handler func(Event) error
 
-// Message is a message send/received from the broker.
 type Message struct {
 	Header map[string]string
 	Body   []byte
 }
 
-// Event is given to a subscription handler for processing.
+// Event is given to a subscription handler for processing
 type Event interface {
 	Topic() string
 	Message() *Message
@@ -32,7 +31,7 @@ type Event interface {
 	Error() error
 }
 
-// Subscriber is a convenience return type for the Subscribe method.
+// Subscriber is a convenience return type for the Subscribe method
 type Subscriber interface {
 	Options() SubscribeOptions
 	Topic() string
@@ -40,8 +39,7 @@ type Subscriber interface {
 }
 
 var (
-	// DefaultBroker is the default Broker.
-	DefaultBroker = NewHttpBroker()
+	DefaultBroker Broker = NewBroker()
 )
 
 func Init(opts ...Option) error {
@@ -64,7 +62,6 @@ func Subscribe(topic string, handler Handler, opts ...SubscribeOption) (Subscrib
 	return DefaultBroker.Subscribe(topic, handler, opts...)
 }
 
-// String returns the name of the Broker.
 func String() string {
 	return DefaultBroker.String()
 }

broker/http.go

@@ -1,11 +1,14 @@
+// Package http provides a http based message broker
 package broker
 
 import (
 	"bytes"
+	"context"
 	"crypto/tls"
 	"errors"
 	"fmt"
 	"io"
+	"io/ioutil"
 	"math/rand"
 	"net"
 	"net/http"
@@ -14,54 +17,51 @@ import (
 	"sync"
 	"time"
 
+	"github.com/asim/go-micro/v3/codec/json"
+	merr "github.com/asim/go-micro/v3/errors"
+	"github.com/asim/go-micro/v3/registry"
+	"github.com/asim/go-micro/v3/registry/cache"
+	maddr "github.com/asim/go-micro/v3/util/addr"
+	mnet "github.com/asim/go-micro/v3/util/net"
+	mls "github.com/asim/go-micro/v3/util/tls"
 	"github.com/google/uuid"
-	"go-micro.dev/v5/codec/json"
-	merr "go-micro.dev/v5/errors"
-	"go-micro.dev/v5/registry"
-	"go-micro.dev/v5/registry/cache"
-	"go-micro.dev/v5/transport/headers"
-	maddr "go-micro.dev/v5/util/addr"
-	mnet "go-micro.dev/v5/util/net"
-	mls "go-micro.dev/v5/util/tls"
 	"golang.org/x/net/http2"
 )
 
-// HTTP Broker is a point to point async broker.
+// HTTP Broker is a point to point async broker
 type httpBroker struct {
-	opts Options
-
-	r registry.Registry
+	id      string
+	address string
+	opts    Options
 
 	mux *http.ServeMux
 
-	c           *http.Client
-	subscribers map[string][]*httpSubscriber
-	exit        chan chan error
-
-	inbox   map[string][][]byte
-	id      string
-	address string
+	c *http.Client
+	r registry.Registry
 
 	sync.RWMutex
+	subscribers map[string][]*httpSubscriber
+	running     bool
+	exit        chan chan error
 
 	// offline message inbox
-	mtx     sync.RWMutex
-	running bool
+	mtx   sync.RWMutex
+	inbox map[string][][]byte
 }
 
 type httpSubscriber struct {
 	opts  SubscribeOptions
+	id    string
+	topic string
 	fn    Handler
 	svc   *registry.Service
 	hb    *httpBroker
-	id    string
-	topic string
 }
 
 type httpEvent struct {
-	err error
 	m   *Message
 	t   string
+	err error
 }
 
 var (
@@ -74,12 +74,14 @@ var (
 )
 
 func init() {
+	rand.Seed(time.Now().Unix())
 }
 
 func newTransport(config *tls.Config) *http.Transport {
 	if config == nil {
-		// Use environment-based config - secure by default
-		config = mls.Config()
+		config = &tls.Config{
+			InsecureSkipVerify: true,
+		}
 	}
 
 	dialTLS := func(network string, addr string) (net.Conn, error) {
@@ -106,10 +108,11 @@ func newTransport(config *tls.Config) *http.Transport {
 }
 
 func newHttpBroker(opts ...Option) Broker {
-	options := *NewOptions(opts...)
-
-	options.Registry = registry.DefaultRegistry
-	options.Codec = json.Marshaler{}
+	options := Options{
+		Codec:    json.Marshaler{},
+		Context:  context.TODO(),
+		Registry: registry.DefaultRegistry,
+	}
 
 	for _, o := range opts {
 		o(&options)
@@ -297,7 +300,7 @@ func (h *httpBroker) ServeHTTP(w http.ResponseWriter, req *http.Request) {
 
 	req.ParseForm()
 
-	b, err := io.ReadAll(req.Body)
+	b, err := ioutil.ReadAll(req.Body)
 	if err != nil {
 		errr := merr.InternalServerError("go.micro.broker", "Error reading request body: %v", err)
 		w.WriteHeader(500)
@@ -313,8 +316,8 @@ func (h *httpBroker) ServeHTTP(w http.ResponseWriter, req *http.Request) {
 		return
 	}
 
-	topic := m.Header[headers.Message]
-	// delete(m.Header, ":topic")
+	topic := m.Header["Micro-Topic"]
+	//delete(m.Header, ":topic")
 
 	if len(topic) == 0 {
 		errr := merr.InternalServerError("go.micro.broker", "Topic not found")
@@ -517,7 +520,7 @@ func (h *httpBroker) Publish(topic string, msg *Message, opts ...PublishOption)
 		m.Header[k] = v
 	}
 
-	m.Header[headers.Message] = topic
+	m.Header["Micro-Topic"] = topic
 
 	// encode the message
 	b, err := h.opts.Codec.Marshal(m)
@@ -555,7 +558,7 @@ func (h *httpBroker) Publish(topic string, msg *Message, opts ...PublishOption)
 		}
 
 		// discard response body
-		io.Copy(io.Discard, r.Body)
+		io.Copy(ioutil.Discard, r.Body)
 		r.Body.Close()
 		return nil
 	}
@@ -702,7 +705,7 @@ func (h *httpBroker) String() string {
 	return "http"
 }
 
-// NewHttpBroker returns a new http broker.
-func NewHttpBroker(opts ...Option) Broker {
+// NewBroker returns a new http broker
+func NewBroker(opts ...Option) Broker {
 	return newHttpBroker(opts...)
 }

broker/http_test.go

@@ -5,13 +5,13 @@ import (
 	"testing"
 	"time"
 
+	"github.com/asim/go-micro/v3/broker"
+	"github.com/asim/go-micro/v3/registry"
 	"github.com/google/uuid"
-	"go-micro.dev/v5/broker"
-	"go-micro.dev/v5/registry"
 )
 
 var (
-	// mock data.
+	// mock data
 	testData = map[string][]*registry.Service{
 		"foo": {
 			{
@@ -56,19 +56,19 @@ func newTestRegistry() registry.Registry {
 	return registry.NewMemoryRegistry(registry.Services(testData))
 }
 
-func sub(b *testing.B, c int) {
-	b.StopTimer()
+func sub(be *testing.B, c int) {
+	be.StopTimer()
 	m := newTestRegistry()
 
-	brker := broker.NewHttpBroker(broker.Registry(m))
+	b := broker.NewBroker(broker.Registry(m))
 	topic := uuid.New().String()
 
-	if err := brker.Init(); err != nil {
-		b.Fatalf("Unexpected init error: %v", err)
+	if err := b.Init(); err != nil {
+		be.Fatalf("Unexpected init error: %v", err)
 	}
 
-	if err := brker.Connect(); err != nil {
-		b.Fatalf("Unexpected connect error: %v", err)
+	if err := b.Connect(); err != nil {
+		be.Fatalf("Unexpected connect error: %v", err)
 	}
 
 	msg := &broker.Message{
@@ -82,54 +82,52 @@ func sub(b *testing.B, c int) {
 	done := make(chan bool, c)
 
 	for i := 0; i < c; i++ {
-		sub, err := brker.Subscribe(topic, func(p broker.Event) error {
+		sub, err := b.Subscribe(topic, func(p broker.Event) error {
 			done <- true
 			m := p.Message()
 
 			if string(m.Body) != string(msg.Body) {
-				b.Fatalf("Unexpected msg %s, expected %s", string(m.Body), string(msg.Body))
+				be.Fatalf("Unexpected msg %s, expected %s", string(m.Body), string(msg.Body))
 			}
 
 			return nil
 		}, broker.Queue("shared"))
 		if err != nil {
-			b.Fatalf("Unexpected subscribe error: %v", err)
+			be.Fatalf("Unexpected subscribe error: %v", err)
 		}
 		subs = append(subs, sub)
 	}
 
-	for i := 0; i < b.N; i++ {
-		b.StartTimer()
-		if err := brker.Publish(topic, msg); err != nil {
-			b.Fatalf("Unexpected publish error: %v", err)
+	for i := 0; i < be.N; i++ {
+		be.StartTimer()
+		if err := b.Publish(topic, msg); err != nil {
+			be.Fatalf("Unexpected publish error: %v", err)
 		}
 		<-done
-		b.StopTimer()
+		be.StopTimer()
 	}
 
 	for _, sub := range subs {
-		if err := sub.Unsubscribe(); err != nil {
-			b.Fatalf("Unexpected unsubscribe error: %v", err)
-		}
+		sub.Unsubscribe()
 	}
 
-	if err := brker.Disconnect(); err != nil {
-		b.Fatalf("Unexpected disconnect error: %v", err)
+	if err := b.Disconnect(); err != nil {
+		be.Fatalf("Unexpected disconnect error: %v", err)
 	}
 }
 
-func pub(b *testing.B, c int) {
-	b.StopTimer()
+func pub(be *testing.B, c int) {
+	be.StopTimer()
 	m := newTestRegistry()
-	brk := broker.NewHttpBroker(broker.Registry(m))
+	b := broker.NewBroker(broker.Registry(m))
 	topic := uuid.New().String()
 
-	if err := brk.Init(); err != nil {
-		b.Fatalf("Unexpected init error: %v", err)
+	if err := b.Init(); err != nil {
+		be.Fatalf("Unexpected init error: %v", err)
 	}
 
-	if err := brk.Connect(); err != nil {
-		b.Fatalf("Unexpected connect error: %v", err)
+	if err := b.Connect(); err != nil {
+		be.Fatalf("Unexpected connect error: %v", err)
 	}
 
 	msg := &broker.Message{
@@ -141,27 +139,27 @@ func pub(b *testing.B, c int) {
 
 	done := make(chan bool, c*4)
 
-	sub, err := brk.Subscribe(topic, func(p broker.Event) error {
+	sub, err := b.Subscribe(topic, func(p broker.Event) error {
 		done <- true
 		m := p.Message()
 		if string(m.Body) != string(msg.Body) {
-			b.Fatalf("Unexpected msg %s, expected %s", string(m.Body), string(msg.Body))
+			be.Fatalf("Unexpected msg %s, expected %s", string(m.Body), string(msg.Body))
 		}
 		return nil
 	}, broker.Queue("shared"))
 	if err != nil {
-		b.Fatalf("Unexpected subscribe error: %v", err)
+		be.Fatalf("Unexpected subscribe error: %v", err)
 	}
 
 	var wg sync.WaitGroup
 	ch := make(chan int, c*4)
-	b.StartTimer()
+	be.StartTimer()
 
 	for i := 0; i < c; i++ {
 		go func() {
 			for range ch {
-				if err := brk.Publish(topic, msg); err != nil {
-					b.Fatalf("Unexpected publish error: %v", err)
+				if err := b.Publish(topic, msg); err != nil {
+					be.Fatalf("Unexpected publish error: %v", err)
 				}
 				select {
 				case <-done:
@@ -172,25 +170,25 @@ func pub(b *testing.B, c int) {
 		}()
 	}
 
-	for i := 0; i < b.N; i++ {
+	for i := 0; i < be.N; i++ {
 		wg.Add(1)
 		ch <- i
 	}
 
 	wg.Wait()
-	b.StopTimer()
+	be.StopTimer()
 	sub.Unsubscribe()
 	close(ch)
 	close(done)
 
-	if err := brk.Disconnect(); err != nil {
-		b.Fatalf("Unexpected disconnect error: %v", err)
+	if err := b.Disconnect(); err != nil {
+		be.Fatalf("Unexpected disconnect error: %v", err)
 	}
 }
 
 func TestBroker(t *testing.T) {
 	m := newTestRegistry()
-	b := broker.NewHttpBroker(broker.Registry(m))
+	b := broker.NewBroker(broker.Registry(m))
 
 	if err := b.Init(); err != nil {
 		t.Fatalf("Unexpected init error: %v", err)
@@ -228,9 +226,7 @@ func TestBroker(t *testing.T) {
 	}
 
 	<-done
-	if err := sub.Unsubscribe(); err != nil {
-		t.Fatalf("Unexpected unsubscribe error: %v", err)
-	}
+	sub.Unsubscribe()
 
 	if err := b.Disconnect(); err != nil {
 		t.Fatalf("Unexpected disconnect error: %v", err)
@@ -239,7 +235,7 @@ func TestBroker(t *testing.T) {
 
 func TestConcurrentSubBroker(t *testing.T) {
 	m := newTestRegistry()
-	b := broker.NewHttpBroker(broker.Registry(m))
+	b := broker.NewBroker(broker.Registry(m))
 
 	if err := b.Init(); err != nil {
 		t.Fatalf("Unexpected init error: %v", err)
@@ -286,9 +282,7 @@ func TestConcurrentSubBroker(t *testing.T) {
 	wg.Wait()
 
 	for _, sub := range subs {
-		if err := sub.Unsubscribe(); err != nil {
-			t.Fatalf("Unexpected unsubscribe error: %v", err)
-		}
+		sub.Unsubscribe()
 	}
 
 	if err := b.Disconnect(); err != nil {
@@ -298,7 +292,7 @@ func TestConcurrentSubBroker(t *testing.T) {
 
 func TestConcurrentPubBroker(t *testing.T) {
 	m := newTestRegistry()
-	b := broker.NewHttpBroker(broker.Registry(m))
+	b := broker.NewBroker(broker.Registry(m))
 
 	if err := b.Init(); err != nil {
 		t.Fatalf("Unexpected init error: %v", err)
@@ -342,9 +336,7 @@ func TestConcurrentPubBroker(t *testing.T) {
 
 	wg.Wait()
 
-	if err := sub.Unsubscribe(); err != nil {
-		t.Fatalf("Unexpected unsubscribe error: %v", err)
-	}
+	sub.Unsubscribe()
 
 	if err := b.Disconnect(); err != nil {
 		t.Fatalf("Unexpected disconnect error: %v", err)
@@ -362,6 +354,14 @@ func BenchmarkSub32(b *testing.B) {
 	sub(b, 32)
 }
 
+func BenchmarkSub64(b *testing.B) {
+	sub(b, 64)
+}
+
+func BenchmarkSub128(b *testing.B) {
+	sub(b, 128)
+}
+
 func BenchmarkPub1(b *testing.B) {
 	pub(b, 1)
 }
@@ -373,3 +373,11 @@ func BenchmarkPub8(b *testing.B) {
 func BenchmarkPub32(b *testing.B) {
 	pub(b, 32)
 }
+
+func BenchmarkPub64(b *testing.B) {
+	pub(b, 64)
+}
+
+func BenchmarkPub128(b *testing.B) {
+	pub(b, 128)
+}

broker/nats/options.go

@@ -1,37 +0,0 @@
-package nats
-
-import (
-	"time"
-
-	natsp "github.com/nats-io/nats.go"
-	"go-micro.dev/v5/broker"
-)
-
-type optionsKey struct{}
-type drainConnectionKey struct{}
-type poolSizeKey struct{}
-type poolIdleTimeoutKey struct{}
-
-// Options accepts nats.Options.
-func Options(opts natsp.Options) broker.Option {
-	return setBrokerOption(optionsKey{}, opts)
-}
-
-// DrainConnection will drain subscription on close.
-func DrainConnection() broker.Option {
-	return setBrokerOption(drainConnectionKey{}, struct{}{})
-}
-
-// PoolSize sets the size of the connection pool.
-// If set to a value > 1, the broker will use a connection pool.
-// Default is 1 (no pooling).
-func PoolSize(size int) broker.Option {
-	return setBrokerOption(poolSizeKey{}, size)
-}
-
-// PoolIdleTimeout sets the timeout for idle connections in the pool.
-// Connections idle for longer than this duration will be closed.
-// Default is 5 minutes. Set to 0 to disable idle timeout.
-func PoolIdleTimeout(timeout time.Duration) broker.Option {
-	return setBrokerOption(poolIdleTimeoutKey{}, timeout)
-}

broker/nats/pool.go

@@ -1,188 +0,0 @@
-package nats
-
-import (
-	"errors"
-	"sync"
-	"time"
-
-	natsp "github.com/nats-io/nats.go"
-)
-
-var (
-	// ErrPoolExhausted is returned when no connections are available in the pool
-	ErrPoolExhausted = errors.New("connection pool exhausted")
-	// ErrPoolClosed is returned when trying to use a closed pool
-	ErrPoolClosed = errors.New("connection pool is closed")
-)
-
-// connectionPool manages a pool of NATS connections
-type connectionPool struct {
-	mu          sync.RWMutex
-	connections chan *pooledConnection
-	factory     func() (*natsp.Conn, error)
-	size        int
-	idleTimeout time.Duration
-	closed      bool
-}
-
-// pooledConnection wraps a NATS connection with metadata
-type pooledConnection struct {
-	conn      *natsp.Conn
-	createdAt time.Time
-	lastUsed  time.Time
-	mu        sync.Mutex
-}
-
-// newConnectionPool creates a new connection pool
-func newConnectionPool(size int, factory func() (*natsp.Conn, error)) (*connectionPool, error) {
-	if size <= 0 {
-		size = 1
-	}
-
-	pool := &connectionPool{
-		connections: make(chan *pooledConnection, size),
-		factory:     factory,
-		size:        size,
-		idleTimeout: 5 * time.Minute,
-		closed:      false,
-	}
-
-	return pool, nil
-}
-
-// Get retrieves a connection from the pool or creates a new one
-func (p *connectionPool) Get() (*pooledConnection, error) {
-	p.mu.RLock()
-	if p.closed {
-		p.mu.RUnlock()
-		return nil, ErrPoolClosed
-	}
-	p.mu.RUnlock()
-
-	// Try to get an existing connection from the pool
-	select {
-	case conn := <-p.connections:
-		// Check if connection is still valid and not idle for too long
-		if conn.isValid() && !conn.isExpired(p.idleTimeout) {
-			conn.updateLastUsed()
-			return conn, nil
-		}
-		// Connection is invalid or expired, close it and create a new one
-		conn.close()
-		return p.createConnection()
-	default:
-		// No connection available, create a new one
-		return p.createConnection()
-	}
-}
-
-// Put returns a connection to the pool
-func (p *connectionPool) Put(conn *pooledConnection) error {
-	p.mu.RLock()
-	defer p.mu.RUnlock()
-
-	if p.closed {
-		return conn.close()
-	}
-
-	// Check if connection is still valid
-	if !conn.isValid() {
-		return conn.close()
-	}
-
-	conn.updateLastUsed()
-
-	// Try to return connection to pool
-	select {
-	case p.connections <- conn:
-		return nil
-	default:
-		// Pool is full, close the connection
-		return conn.close()
-	}
-}
-
-// Close closes all connections in the pool
-func (p *connectionPool) Close() error {
-	p.mu.Lock()
-	defer p.mu.Unlock()
-
-	if p.closed {
-		return nil
-	}
-
-	p.closed = true
-	close(p.connections)
-
-	// Close all connections in the pool
-	for conn := range p.connections {
-		conn.close()
-	}
-
-	return nil
-}
-
-// createConnection creates a new pooled connection
-func (p *connectionPool) createConnection() (*pooledConnection, error) {
-	conn, err := p.factory()
-	if err != nil {
-		return nil, err
-	}
-
-	return &pooledConnection{
-		conn:      conn,
-		createdAt: time.Now(),
-		lastUsed:  time.Now(),
-	}, nil
-}
-
-// isValid checks if the underlying NATS connection is valid
-func (pc *pooledConnection) isValid() bool {
-	pc.mu.Lock()
-	defer pc.mu.Unlock()
-
-	if pc.conn == nil {
-		return false
-	}
-
-	status := pc.conn.Status()
-	return status == natsp.CONNECTED || status == natsp.RECONNECTING
-}
-
-// isExpired checks if the connection has been idle for too long
-func (pc *pooledConnection) isExpired(timeout time.Duration) bool {
-	pc.mu.Lock()
-	defer pc.mu.Unlock()
-
-	if timeout <= 0 {
-		return false
-	}
-
-	return time.Since(pc.lastUsed) > timeout
-}
-
-// close closes the underlying NATS connection
-func (pc *pooledConnection) close() error {
-	pc.mu.Lock()
-	defer pc.mu.Unlock()
-
-	if pc.conn != nil {
-		pc.conn.Close()
-		pc.conn = nil
-	}
-	return nil
-}
-
-// Conn returns the underlying NATS connection
-func (pc *pooledConnection) Conn() *natsp.Conn {
-	pc.mu.Lock()
-	defer pc.mu.Unlock()
-	return pc.conn
-}
-
-// updateLastUsed updates the last used timestamp in a thread-safe manner
-func (pc *pooledConnection) updateLastUsed() {
-	pc.mu.Lock()
-	defer pc.mu.Unlock()
-	pc.lastUsed = time.Now()
-}

broker/nats/pool_test.go

@@ -1,204 +0,0 @@
-package nats
-
-import (
-	"sync"
-	"testing"
-	"time"
-
-	natsp "github.com/nats-io/nats.go"
-)
-
-func TestConnectionPool_GetPut(t *testing.T) {
-	// Mock factory that creates connections
-	connCount := 0
-	factory := func() (*natsp.Conn, error) {
-		connCount++
-		// Return a mock connection (we can't create real NATS connections in tests without a server)
-		// This test is more about the pool logic
-		return nil, nil
-	}
-
-	pool, err := newConnectionPool(3, factory)
-	if err != nil {
-		t.Fatalf("Failed to create pool: %v", err)
-	}
-	defer pool.Close()
-
-	// Get a connection (should create one)
-	conn1, err := pool.Get()
-	if err != nil {
-		t.Fatalf("Failed to get connection: %v", err)
-	}
-	if conn1 == nil {
-		t.Fatal("Expected connection, got nil")
-	}
-
-	// Put it back
-	if err := pool.Put(conn1); err != nil {
-		t.Fatalf("Failed to put connection: %v", err)
-	}
-
-	// Get it again (should reuse the same one)
-	conn2, err := pool.Get()
-	if err != nil {
-		t.Fatalf("Failed to get connection: %v", err)
-	}
-
-	// Since we can't compare actual connections easily, just verify we got one
-	if conn2 == nil {
-		t.Fatal("Expected connection, got nil")
-	}
-}
-
-func TestConnectionPool_Concurrent(t *testing.T) {
-	connCount := 0
-	mu := sync.Mutex{}
-	factory := func() (*natsp.Conn, error) {
-		mu.Lock()
-		connCount++
-		mu.Unlock()
-		return nil, nil
-	}
-
-	pool, err := newConnectionPool(5, factory)
-	if err != nil {
-		t.Fatalf("Failed to create pool: %v", err)
-	}
-	defer pool.Close()
-
-	// Simulate concurrent access
-	var wg sync.WaitGroup
-	for i := 0; i < 10; i++ {
-		wg.Add(1)
-		go func() {
-			defer wg.Done()
-			conn, err := pool.Get()
-			if err != nil {
-				t.Errorf("Failed to get connection: %v", err)
-				return
-			}
-			// Simulate some work
-			time.Sleep(10 * time.Millisecond)
-			if err := pool.Put(conn); err != nil {
-				t.Errorf("Failed to put connection: %v", err)
-			}
-		}()
-	}
-
-	wg.Wait()
-
-	// We should have created some connections
-	mu.Lock()
-	if connCount == 0 {
-		t.Error("Expected at least one connection to be created")
-	}
-	mu.Unlock()
-}
-
-func TestConnectionPool_Close(t *testing.T) {
-	factory := func() (*natsp.Conn, error) {
-		return nil, nil
-	}
-
-	pool, err := newConnectionPool(3, factory)
-	if err != nil {
-		t.Fatalf("Failed to create pool: %v", err)
-	}
-
-	// Get a connection
-	conn, err := pool.Get()
-	if err != nil {
-		t.Fatalf("Failed to get connection: %v", err)
-	}
-
-	// Close the pool
-	if err := pool.Close(); err != nil {
-		t.Fatalf("Failed to close pool: %v", err)
-	}
-
-	// Put connection back to closed pool should not panic
-	// The connection will be closed instead of returned to pool
-	_ = pool.Put(conn)
-
-	// Try to get from closed pool
-	_, err = pool.Get()
-	if err != ErrPoolClosed {
-		t.Errorf("Expected ErrPoolClosed, got: %v", err)
-	}
-}
-
-func TestPooledConnection_IsValid(t *testing.T) {
-	pc := &pooledConnection{
-		conn:      nil, // nil connection should be invalid
-		createdAt: time.Now(),
-		lastUsed:  time.Now(),
-	}
-
-	if pc.isValid() {
-		t.Error("Expected nil connection to be invalid")
-	}
-}
-
-func TestPooledConnection_IsExpired(t *testing.T) {
-	pc := &pooledConnection{
-		conn:      nil,
-		createdAt: time.Now(),
-		lastUsed:  time.Now().Add(-10 * time.Minute), // 10 minutes ago
-	}
-
-	// With 5 minute timeout, should be expired
-	if !pc.isExpired(5 * time.Minute) {
-		t.Error("Expected connection to be expired")
-	}
-
-	// With 0 timeout, should never expire
-	if pc.isExpired(0) {
-		t.Error("Expected connection not to expire with 0 timeout")
-	}
-
-	// With 20 minute timeout, should not be expired
-	if pc.isExpired(20 * time.Minute) {
-		t.Error("Expected connection not to be expired")
-	}
-}
-
-func TestNatsBroker_PoolConfiguration(t *testing.T) {
-	// Test that pool size is set correctly
-	br := NewNatsBroker(PoolSize(5))
-	nb, ok := br.(*natsBroker)
-	if !ok {
-		t.Fatal("Expected broker to be of type *natsBroker")
-	}
-
-	if nb.poolSize != 5 {
-		t.Errorf("Expected pool size 5, got %d", nb.poolSize)
-	}
-
-	// Test with custom idle timeout
-	br2 := NewNatsBroker(PoolSize(3), PoolIdleTimeout(10*time.Minute))
-	nb2, ok := br2.(*natsBroker)
-	if !ok {
-		t.Fatal("Expected broker to be of type *natsBroker")
-	}
-
-	if nb2.poolSize != 3 {
-		t.Errorf("Expected pool size 3, got %d", nb2.poolSize)
-	}
-
-	if nb2.poolIdleTimeout != 10*time.Minute {
-		t.Errorf("Expected idle timeout 10m, got %v", nb2.poolIdleTimeout)
-	}
-}
-
-func TestNatsBroker_DefaultSingleConnection(t *testing.T) {
-	// Test that default behavior is single connection (pool size 1)
-	br := NewNatsBroker()
-	nb, ok := br.(*natsBroker)
-	if !ok {
-		t.Fatal("Expected broker to be of type *natsBroker")
-	}
-
-	if nb.poolSize != 1 {
-		t.Errorf("Expected default pool size 1, got %d", nb.poolSize)
-	}
-}

broker/options.go

@@ -4,30 +4,25 @@ import (
 	"context"
 	"crypto/tls"
 
-	"go-micro.dev/v5/codec"
-	"go-micro.dev/v5/logger"
-	"go-micro.dev/v5/registry"
+	"github.com/asim/go-micro/v3/codec"
+	"github.com/asim/go-micro/v3/registry"
 )
 
 type Options struct {
-	Codec codec.Marshaler
-
-	// Logger is the underlying logger
-	Logger logger.Logger
-
-	// Registry used for clustering
-	Registry registry.Registry
-	// Other options for implementations of the interface
-	// can be stored in a context
-	Context context.Context
+	Addrs  []string
+	Secure bool
+	Codec  codec.Marshaler
 
 	// Handler executed when error happens in broker mesage
 	// processing
 	ErrorHandler Handler
 
 	TLSConfig *tls.Config
-	Addrs     []string
-	Secure    bool
+	// Registry used for clustering
+	Registry registry.Registry
+	// Other options for implementations of the interface
+	// can be stored in a context
+	Context context.Context
 }
 
 type PublishOptions struct {
@@ -37,25 +32,24 @@ type PublishOptions struct {
 }
 
 type SubscribeOptions struct {
-
-	// Other options for implementations of the interface
-	// can be stored in a context
-	Context context.Context
+	// AutoAck defaults to true. When a handler returns
+	// with a nil error the message is acked.
+	AutoAck bool
 	// Subscribers with the same queue name
 	// will create a shared subscription where each
 	// receives a subset of messages.
 	Queue string
 
-	// AutoAck defaults to true. When a handler returns
-	// with a nil error the message is acked.
-	AutoAck bool
+	// Other options for implementations of the interface
+	// can be stored in a context
+	Context context.Context
 }
 
 type Option func(*Options)
 
 type PublishOption func(*PublishOptions)
 
-// PublishContext set context.
+// PublishContext set context
 func PublishContext(ctx context.Context) PublishOption {
 	return func(o *PublishOptions) {
 		o.Context = ctx
@@ -64,19 +58,6 @@ func PublishContext(ctx context.Context) PublishOption {
 
 type SubscribeOption func(*SubscribeOptions)
 
-func NewOptions(opts ...Option) *Options {
-	options := Options{
-		Context: context.Background(),
-		Logger:  logger.DefaultLogger,
-	}
-
-	for _, o := range opts {
-		o(&options)
-	}
-
-	return &options
-}
-
 func NewSubscribeOptions(opts ...SubscribeOption) SubscribeOptions {
 	opt := SubscribeOptions{
 		AutoAck: true,
@@ -89,7 +70,7 @@ func NewSubscribeOptions(opts ...SubscribeOption) SubscribeOptions {
 	return opt
 }
 
-// Addrs sets the host addresses to be used by the broker.
+// Addrs sets the host addresses to be used by the broker
 func Addrs(addrs ...string) Option {
 	return func(o *Options) {
 		o.Addrs = addrs
@@ -97,7 +78,7 @@ func Addrs(addrs ...string) Option {
 }
 
 // Codec sets the codec used for encoding/decoding used where
-// a broker does not support headers.
+// a broker does not support headers
 func Codec(c codec.Marshaler) Option {
 	return func(o *Options) {
 		o.Codec = c
@@ -113,14 +94,14 @@ func DisableAutoAck() SubscribeOption {
 }
 
 // ErrorHandler will catch all broker errors that cant be handled
-// in normal way, for example Codec errors.
+// in normal way, for example Codec errors
 func ErrorHandler(h Handler) Option {
 	return func(o *Options) {
 		o.ErrorHandler = h
 	}
 }
 
-// Queue sets the name of the queue to share messages on.
+// Queue sets the name of the queue to share messages on
 func Queue(name string) SubscribeOption {
 	return func(o *SubscribeOptions) {
 		o.Queue = name
@@ -133,28 +114,21 @@ func Registry(r registry.Registry) Option {
 	}
 }
 
-// Secure communication with the broker.
+// Secure communication with the broker
 func Secure(b bool) Option {
 	return func(o *Options) {
 		o.Secure = b
 	}
 }
 
-// Specify TLS Config.
+// Specify TLS Config
 func TLSConfig(t *tls.Config) Option {
 	return func(o *Options) {
 		o.TLSConfig = t
 	}
 }
 
-// Logger sets the underline logger.
-func Logger(l logger.Logger) Option {
-	return func(o *Options) {
-		o.Logger = l
-	}
-}
-
-// SubscribeContext set context.
+// SubscribeContext set context
 func SubscribeContext(ctx context.Context) SubscribeOption {
 	return func(o *SubscribeOptions) {
 		o.Context = ctx

broker/rabbitmq/rabbitmq_test.go

@@ -1,305 +0,0 @@
-package rabbitmq_test
-
-import (
-	"context"
-	"encoding/json"
-	"os"
-	"testing"
-	"time"
-
-	"go-micro.dev/v5/logger"
-
-	micro "go-micro.dev/v5"
-	broker "go-micro.dev/v5/broker"
-	rabbitmq "go-micro.dev/v5/broker/rabbitmq"
-	server "go-micro.dev/v5/server"
-)
-
-type Example struct{}
-
-func init() {
-	rabbitmq.DefaultRabbitURL = "amqp://rabbitmq:rabbitmq@127.0.0.1:5672"
-}
-
-type TestEvent struct {
-	Name string    `json:"name"`
-	Age  int       `json:"age"`
-	Time time.Time `json:"time"`
-}
-
-func (e *Example) Handler(ctx context.Context, r interface{}) error {
-	return nil
-}
-
-func TestDurable(t *testing.T) {
-	if tr := os.Getenv("TRAVIS"); len(tr) > 0 {
-		t.Skip()
-	}
-	brkrSub := broker.NewSubscribeOptions(
-		broker.Queue("queue.default"),
-		broker.DisableAutoAck(),
-		rabbitmq.DurableQueue(),
-	)
-
-	b := rabbitmq.NewBroker()
-	b.Init()
-	if err := b.Connect(); err != nil {
-		t.Logf("cant conect to broker, skip: %v", err)
-		t.Skip()
-	}
-
-	s := server.NewServer(server.Broker(b))
-
-	service := micro.NewService(
-		micro.Server(s),
-		micro.Broker(b),
-	)
-	h := &Example{}
-	// Register a subscriber
-	micro.RegisterSubscriber(
-		"topic",
-		service.Server(),
-		h.Handler,
-		server.SubscriberContext(brkrSub.Context),
-		server.SubscriberQueue("queue.default"),
-	)
-
-	// service.Init()
-
-	if err := service.Run(); err != nil {
-		t.Fatal(err)
-	}
-}
-
-func TestWithoutExchange(t *testing.T) {
-
-	b := rabbitmq.NewBroker(rabbitmq.WithoutExchange())
-	b.Init()
-	if err := b.Connect(); err != nil {
-		t.Logf("cant conect to broker, skip: %v", err)
-		t.Skip()
-	}
-
-	s := server.NewServer(server.Broker(b))
-
-	service := micro.NewService(
-		micro.Server(s),
-		micro.Broker(b),
-	)
-	brkrSub := broker.NewSubscribeOptions(
-		broker.Queue("direct.queue"),
-		broker.DisableAutoAck(),
-		rabbitmq.DurableQueue(),
-	)
-	// Register a subscriber
-	err := micro.RegisterSubscriber(
-		"direct.queue",
-		service.Server(),
-		func(ctx context.Context, evt *TestEvent) error {
-			logger.Logf(logger.InfoLevel, "receive event: %+v", evt)
-			return nil
-		},
-		server.SubscriberContext(brkrSub.Context),
-		server.SubscriberQueue("direct.queue"),
-	)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	go func() {
-		time.Sleep(5 * time.Second)
-		logger.Logf(logger.InfoLevel, "pub event")
-		jsonData, _ := json.Marshal(&TestEvent{
-			Name: "test",
-			Age:  16,
-		})
-		err := b.Publish("direct.queue", &broker.Message{
-			Body: jsonData,
-		},
-			rabbitmq.DeliveryMode(2),
-			rabbitmq.ContentType("application/json"))
-		if err != nil {
-			t.Fatal(err)
-		}
-	}()
-
-	// service.Init()
-
-	if err := service.Run(); err != nil {
-		t.Fatal(err)
-	}
-}
-
-func TestFanoutExchange(t *testing.T) {
-	b := rabbitmq.NewBroker(rabbitmq.ExchangeType(rabbitmq.ExchangeTypeFanout), rabbitmq.ExchangeName("fanout.test"))
-	b.Init()
-	if err := b.Connect(); err != nil {
-		t.Logf("cant conect to broker, skip: %v", err)
-		t.Skip()
-	}
-
-	s := server.NewServer(server.Broker(b))
-
-	service := micro.NewService(
-		micro.Server(s),
-		micro.Broker(b),
-	)
-	brkrSub := broker.NewSubscribeOptions(
-		broker.Queue("fanout.queue"),
-		broker.DisableAutoAck(),
-		rabbitmq.DurableQueue(),
-	)
-	// Register a subscriber
-	err := micro.RegisterSubscriber(
-		"fanout.queue",
-		service.Server(),
-		func(ctx context.Context, evt *TestEvent) error {
-			logger.Logf(logger.InfoLevel, "receive event: %+v", evt)
-			return nil
-		},
-		server.SubscriberContext(brkrSub.Context),
-		server.SubscriberQueue("fanout.queue"),
-	)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	go func() {
-		time.Sleep(5 * time.Second)
-		logger.Logf(logger.InfoLevel, "pub event")
-		jsonData, _ := json.Marshal(&TestEvent{
-			Name: "test",
-			Age:  16,
-		})
-		err := b.Publish("fanout.queue", &broker.Message{
-			Body: jsonData,
-		},
-			rabbitmq.DeliveryMode(2),
-			rabbitmq.ContentType("application/json"))
-		if err != nil {
-			t.Fatal(err)
-		}
-	}()
-
-	// service.Init()
-
-	if err := service.Run(); err != nil {
-		t.Fatal(err)
-	}
-}
-
-func TestDirectExchange(t *testing.T) {
-	b := rabbitmq.NewBroker(rabbitmq.ExchangeType(rabbitmq.ExchangeTypeDirect), rabbitmq.ExchangeName("direct.test"))
-	b.Init()
-	if err := b.Connect(); err != nil {
-		t.Logf("cant conect to broker, skip: %v", err)
-		t.Skip()
-	}
-
-	s := server.NewServer(server.Broker(b))
-
-	service := micro.NewService(
-		micro.Server(s),
-		micro.Broker(b),
-	)
-	brkrSub := broker.NewSubscribeOptions(
-		broker.Queue("direct.exchange.queue"),
-		broker.DisableAutoAck(),
-		rabbitmq.DurableQueue(),
-	)
-	// Register a subscriber
-	err := micro.RegisterSubscriber(
-		"direct.exchange.queue",
-		service.Server(),
-		func(ctx context.Context, evt *TestEvent) error {
-			logger.Logf(logger.InfoLevel, "receive event: %+v", evt)
-			return nil
-		},
-		server.SubscriberContext(brkrSub.Context),
-		server.SubscriberQueue("direct.exchange.queue"),
-	)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	go func() {
-		time.Sleep(5 * time.Second)
-		logger.Logf(logger.InfoLevel, "pub event")
-		jsonData, _ := json.Marshal(&TestEvent{
-			Name: "test",
-			Age:  16,
-		})
-		err := b.Publish("direct.exchange.queue", &broker.Message{
-			Body: jsonData,
-		},
-			rabbitmq.DeliveryMode(2),
-			rabbitmq.ContentType("application/json"))
-		if err != nil {
-			t.Fatal(err)
-		}
-	}()
-
-	// service.Init()
-
-	if err := service.Run(); err != nil {
-		t.Fatal(err)
-	}
-}
-
-func TestTopicExchange(t *testing.T) {
-	b := rabbitmq.NewBroker()
-	b.Init()
-	if err := b.Connect(); err != nil {
-		t.Logf("cant conect to broker, skip: %v", err)
-		t.Skip()
-	}
-
-	s := server.NewServer(server.Broker(b))
-
-	service := micro.NewService(
-		micro.Server(s),
-		micro.Broker(b),
-	)
-	brkrSub := broker.NewSubscribeOptions(
-		broker.Queue("topic.exchange.queue"),
-		broker.DisableAutoAck(),
-		rabbitmq.DurableQueue(),
-	)
-	// Register a subscriber
-	err := micro.RegisterSubscriber(
-		"my-test-topic",
-		service.Server(),
-		func(ctx context.Context, evt *TestEvent) error {
-			logger.Logf(logger.InfoLevel, "receive event: %+v", evt)
-			return nil
-		},
-		server.SubscriberContext(brkrSub.Context),
-		server.SubscriberQueue("topic.exchange.queue"),
-	)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	go func() {
-		time.Sleep(5 * time.Second)
-		logger.Logf(logger.InfoLevel, "pub event")
-		jsonData, _ := json.Marshal(&TestEvent{
-			Name: "test",
-			Age:  16,
-		})
-		err := b.Publish("my-test-topic", &broker.Message{
-			Body: jsonData,
-		},
-			rabbitmq.DeliveryMode(2),
-			rabbitmq.ContentType("application/json"))
-		if err != nil {
-			t.Fatal(err)
-		}
-	}()
-
-	// service.Init()
-
-	if err := service.Run(); err != nil {
-		t.Fatal(err)
-	}
-}

cache/cache.go

@@ -22,15 +22,16 @@ var (
 )
 
 // Cache is the interface that wraps the cache.
+//
+// Context specifies the context for the cache.
+// Get gets a cached value by key.
+// Put stores a key-value pair into cache.
+// Delete removes a key from cache.
 type Cache interface {
-	// Get gets a cached value by key.
-	Get(ctx context.Context, key string) (interface{}, time.Time, error)
-	// Put stores a key-value pair into cache.
-	Put(ctx context.Context, key string, val interface{}, d time.Duration) error
-	// Delete removes a key from cache.
-	Delete(ctx context.Context, key string) error
-	// String returns the name of the implementation.
-	String() string
+	Context(ctx context.Context) Cache
+	Get(key string) (interface{}, time.Time, error)
+	Put(key string, val interface{}, d time.Duration) error
+	Delete(key string) error
 }
 
 // Item represents an item stored in the cache.

cache/cache_test.go

@@ -7,15 +7,15 @@ import (
 )
 
 var (
-	ctx             = context.TODO()
-	key string      = "test"
-	val interface{} = "hello go-micro"
+	ctx context.Context = context.TODO()
+	key string          = "test"
+	val interface{}     = "hello go-micro"
 )
 
 // TestMemCache tests the in-memory cache implementation.
 func TestCache(t *testing.T) {
 	t.Run("CacheGetMiss", func(t *testing.T) {
-		if _, _, err := NewCache().Get(ctx, key); err == nil {
+		if _, _, err := NewCache().Context(ctx).Get(key); err == nil {
 			t.Error("expected to get no value from cache")
 		}
 	})
@@ -23,11 +23,11 @@ func TestCache(t *testing.T) {
 	t.Run("CacheGetHit", func(t *testing.T) {
 		c := NewCache()
 
-		if err := c.Put(ctx, key, val, 0); err != nil {
+		if err := c.Context(ctx).Put(key, val, 0); err != nil {
 			t.Error(err)
 		}
 
-		if a, _, err := c.Get(ctx, key); err != nil {
+		if a, _, err := c.Context(ctx).Get(key); err != nil {
 			t.Errorf("Expected a value, got err: %s", err)
 		} else if a != val {
 			t.Errorf("Expected '%v', got '%v'", val, a)
@@ -38,12 +38,12 @@ func TestCache(t *testing.T) {
 		c := NewCache()
 		e := 20 * time.Millisecond
 
-		if err := c.Put(ctx, key, val, e); err != nil {
+		if err := c.Context(ctx).Put(key, val, e); err != nil {
 			t.Error(err)
 		}
 
 		<-time.After(25 * time.Millisecond)
-		if _, _, err := c.Get(ctx, key); err == nil {
+		if _, _, err := c.Context(ctx).Get(key); err == nil {
 			t.Error("expected to get no value from cache")
 		}
 	})
@@ -52,18 +52,18 @@ func TestCache(t *testing.T) {
 		c := NewCache()
 		e := 25 * time.Millisecond
 
-		if err := c.Put(ctx, key, val, e); err != nil {
+		if err := c.Context(ctx).Put(key, val, e); err != nil {
 			t.Error(err)
 		}
 
 		<-time.After(20 * time.Millisecond)
-		if _, _, err := c.Get(ctx, key); err != nil {
+		if _, _, err := c.Context(ctx).Get(key); err != nil {
 			t.Errorf("expected a value, got err: %s", err)
 		}
 	})
 
 	t.Run("CacheDeleteMiss", func(t *testing.T) {
-		if err := NewCache().Delete(ctx, key); err == nil {
+		if err := NewCache().Context(ctx).Delete(key); err == nil {
 			t.Error("expected to delete no value from cache")
 		}
 	})
@@ -71,15 +71,15 @@ func TestCache(t *testing.T) {
 	t.Run("CacheDeleteHit", func(t *testing.T) {
 		c := NewCache()
 
-		if err := c.Put(ctx, key, val, 0); err != nil {
+		if err := c.Context(ctx).Put(key, val, 0); err != nil {
 			t.Error(err)
 		}
 
-		if err := c.Delete(ctx, key); err != nil {
+		if err := c.Context(ctx).Delete(key); err != nil {
 			t.Errorf("Expected to delete an item, got err: %s", err)
 		}
 
-		if _, _, err := c.Get(ctx, key); err == nil {
+		if _, _, err := c.Context(ctx).Get(key); err == nil {
 			t.Errorf("Expected error")
 		}
 	})
@@ -89,12 +89,12 @@ func TestCacheWithOptions(t *testing.T) {
 	t.Run("CacheWithExpiration", func(t *testing.T) {
 		c := NewCache(Expiration(20 * time.Millisecond))
 
-		if err := c.Put(ctx, key, val, 0); err != nil {
+		if err := c.Context(ctx).Put(key, val, 0); err != nil {
 			t.Error(err)
 		}
 
 		<-time.After(25 * time.Millisecond)
-		if _, _, err := c.Get(ctx, key); err == nil {
+		if _, _, err := c.Context(ctx).Get(key); err == nil {
 			t.Error("expected to get no value from cache")
 		}
 	})
@@ -102,7 +102,7 @@ func TestCacheWithOptions(t *testing.T) {
 	t.Run("CacheWithItems", func(t *testing.T) {
 		c := NewCache(Items(map[string]Item{key: {val, 0}}))
 
-		if a, _, err := c.Get(ctx, key); err != nil {
+		if a, _, err := c.Context(ctx).Get(key); err != nil {
 			t.Errorf("Expected a value, got err: %s", err)
 		} else if a != val {
 			t.Errorf("Expected '%v', got '%v'", val, a)

cache/default.go

@@ -8,14 +8,20 @@ import (
 
 type memCache struct {
 	opts Options
+	sync.RWMutex
+	ctx context.Context
 
 	items map[string]Item
-	sync.RWMutex
 }
 
-func (c *memCache) Get(ctx context.Context, key string) (interface{}, time.Time, error) {
-	c.RWMutex.RLock()
-	defer c.RWMutex.RUnlock()
+func (c *memCache) Context(ctx context.Context) Cache {
+	c.ctx = ctx
+	return c
+}
+
+func (c *memCache) Get(key string) (interface{}, time.Time, error) {
+	c.RWMutex.Lock()
+	defer c.RWMutex.Unlock()
 
 	item, found := c.items[key]
 	if !found {
@@ -28,7 +34,7 @@ func (c *memCache) Get(ctx context.Context, key string) (interface{}, time.Time,
 	return item.Value, time.Unix(0, item.Expiration), nil
 }
 
-func (c *memCache) Put(ctx context.Context, key string, val interface{}, d time.Duration) error {
+func (c *memCache) Put(key string, val interface{}, d time.Duration) error {
 	var e int64
 	if d == DefaultExpiration {
 		d = c.opts.Expiration
@@ -48,7 +54,7 @@ func (c *memCache) Put(ctx context.Context, key string, val interface{}, d time.
 	return nil
 }
 
-func (c *memCache) Delete(ctx context.Context, key string) error {
+func (c *memCache) Delete(key string) error {
 	c.RWMutex.Lock()
 	defer c.RWMutex.Unlock()
 
@@ -60,7 +66,3 @@ func (c *memCache) Delete(ctx context.Context, key string) error {
 	delete(c.items, key)
 	return nil
 }
-
-func (m *memCache) String() string {
-	return "memory"
-}

cache/options.go

@@ -1,22 +1,11 @@
 package cache
 
-import (
-	"context"
-	"time"
-
-	"go-micro.dev/v5/logger"
-)
+import "time"
 
 // Options represents the options for the cache.
 type Options struct {
-	// Context should contain all implementation specific options, using context.WithValue.
-	Context context.Context
-	// Logger is the be used logger
-	Logger logger.Logger
-	Items  map[string]Item
-	// Address represents the address or other connection information of the cache service.
-	Address    string
 	Expiration time.Duration
+	Items      map[string]Item
 }
 
 // Option manipulates the Options passed.
@@ -36,33 +25,11 @@ func Items(i map[string]Item) Option {
 	}
 }
 
-// WithAddress sets the cache service address or connection information.
-func WithAddress(addr string) Option {
-	return func(o *Options) {
-		o.Address = addr
-	}
-}
-
-// WithContext sets the cache context, for any extra configuration.
-func WithContext(c context.Context) Option {
-	return func(o *Options) {
-		o.Context = c
-	}
-}
-
-// WithLogger sets underline logger.
-func WithLogger(l logger.Logger) Option {
-	return func(o *Options) {
-		o.Logger = l
-	}
-}
-
 // NewOptions returns a new options struct.
 func NewOptions(opts ...Option) Options {
 	options := Options{
 		Expiration: DefaultExpiration,
 		Items:      make(map[string]Item),
-		Logger:     logger.DefaultLogger,
 	}
 
 	for _, o := range opts {

cache/redis/options.go

@@ -1,48 +0,0 @@
-package redis
-
-import (
-	"context"
-
-	rclient "github.com/go-redis/redis/v8"
-	"go-micro.dev/v5/cache"
-)
-
-type redisOptionsContextKey struct{}
-
-// WithRedisOptions sets advanced options for redis.
-func WithRedisOptions(options rclient.UniversalOptions) cache.Option {
-	return func(o *cache.Options) {
-		if o.Context == nil {
-			o.Context = context.Background()
-		}
-
-		o.Context = context.WithValue(o.Context, redisOptionsContextKey{}, options)
-	}
-}
-
-func newUniversalClient(options cache.Options) rclient.UniversalClient {
-	if options.Context == nil {
-		options.Context = context.Background()
-	}
-
-	opts, ok := options.Context.Value(redisOptionsContextKey{}).(rclient.UniversalOptions)
-	if !ok {
-		addr := "redis://127.0.0.1:6379"
-		if len(options.Address) > 0 {
-			addr = options.Address
-		}
-
-		redisOptions, err := rclient.ParseURL(addr)
-		if err != nil {
-			redisOptions = &rclient.Options{Addr: addr}
-		}
-
-		return rclient.NewClient(redisOptions)
-	}
-
-	if len(opts.Addrs) == 0 && len(options.Address) > 0 {
-		opts.Addrs = []string{options.Address}
-	}
-
-	return rclient.NewUniversalClient(&opts)
-}

cache/redis/options_test.go

@@ -1,139 +0,0 @@
-package redis
-
-import (
-	"context"
-	"reflect"
-	"testing"
-
-	rclient "github.com/go-redis/redis/v8"
-	"go-micro.dev/v5/cache"
-)
-
-func Test_newUniversalClient(t *testing.T) {
-	type fields struct {
-		options cache.Options
-	}
-	type wantValues struct {
-		username string
-		password string
-		address  string
-	}
-
-	tests := []struct {
-		name   string
-		fields fields
-		want   wantValues
-	}{
-		{name: "No Url", fields: fields{options: cache.Options{}},
-			want: wantValues{
-				username: "",
-				password: "",
-				address:  "127.0.0.1:6379",
-			}},
-		{name: "legacy Url", fields: fields{options: cache.Options{Address: "127.0.0.1:6379"}},
-			want: wantValues{
-				username: "",
-				password: "",
-				address:  "127.0.0.1:6379",
-			}},
-		{name: "New Url", fields: fields{options: cache.Options{Address: "redis://127.0.0.1:6379"}},
-			want: wantValues{
-				username: "",
-				password: "",
-				address:  "127.0.0.1:6379",
-			}},
-		{name: "Url with Pwd", fields: fields{options: cache.Options{Address: "redis://:password@redis:6379"}},
-			want: wantValues{
-				username: "",
-				password: "password",
-				address:  "redis:6379",
-			}},
-		{name: "Url with username and Pwd", fields: fields{
-			options: cache.Options{Address: "redis://username:password@redis:6379"}},
-			want: wantValues{
-				username: "username",
-				password: "password",
-				address:  "redis:6379",
-			}},
-
-		{name: "Sentinel Failover client", fields: fields{
-			options: cache.Options{
-				Context: context.WithValue(
-					context.TODO(), redisOptionsContextKey{},
-					rclient.UniversalOptions{MasterName: "master-name"}),
-			}},
-			want: wantValues{
-				username: "",
-				password: "",
-				address:  "FailoverClient", // <- Placeholder set by NewFailoverClient
-			}},
-	}
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			univClient := newUniversalClient(tt.fields.options)
-			client, ok := univClient.(*rclient.Client)
-			if !ok {
-				t.Errorf("newUniversalClient() expect a *redis.Client")
-				return
-			}
-			if client.Options().Addr != tt.want.address {
-				t.Errorf("newUniversalClient() Address = %v, want address %v", client.Options().Addr, tt.want.address)
-			}
-			if client.Options().Password != tt.want.password {
-				t.Errorf("newUniversalClient() password = %v, want password %v", client.Options().Password, tt.want.password)
-			}
-			if client.Options().Username != tt.want.username {
-				t.Errorf("newUniversalClient() username = %v, want username %v", client.Options().Username, tt.want.username)
-			}
-		})
-	}
-}
-
-func Test_newUniversalClientCluster(t *testing.T) {
-	type fields struct {
-		options cache.Options
-	}
-	type wantValues struct {
-		username string
-		password string
-		addrs    []string
-	}
-
-	tests := []struct {
-		name   string
-		fields fields
-		want   wantValues
-	}{
-		{name: "Addrs in redis options", fields: fields{
-			options: cache.Options{
-				Address: "127.0.0.1:6379", // <- ignored
-				Context: context.WithValue(
-					context.TODO(), redisOptionsContextKey{},
-					rclient.UniversalOptions{Addrs: []string{"127.0.0.1:6381", "127.0.0.1:6382"}}),
-			}},
-			want: wantValues{
-				username: "",
-				password: "",
-				addrs:    []string{"127.0.0.1:6381", "127.0.0.1:6382"},
-			}},
-	}
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			univClient := newUniversalClient(tt.fields.options)
-			client, ok := univClient.(*rclient.ClusterClient)
-			if !ok {
-				t.Errorf("newUniversalClient() expect a *redis.ClusterClient")
-				return
-			}
-			if !reflect.DeepEqual(client.Options().Addrs, tt.want.addrs) {
-				t.Errorf("newUniversalClient() Addrs = %v, want addrs %v", client.Options().Addrs, tt.want.addrs)
-			}
-			if client.Options().Password != tt.want.password {
-				t.Errorf("newUniversalClient() password = %v, want password %v", client.Options().Password, tt.want.password)
-			}
-			if client.Options().Username != tt.want.username {
-				t.Errorf("newUniversalClient() username = %v, want username %v", client.Options().Username, tt.want.username)
-			}
-		})
-	}
-}

cache/redis/redis.go

@@ -1,57 +0,0 @@
-package redis
-
-import (
-	"context"
-	"time"
-
-	rclient "github.com/go-redis/redis/v8"
-	"go-micro.dev/v5/cache"
-)
-
-// NewRedisCache returns a new redis cache.
-func NewRedisCache(opts ...cache.Option) cache.Cache {
-	options := cache.NewOptions(opts...)
-	return &redisCache{
-		opts:   options,
-		client: newUniversalClient(options),
-	}
-}
-
-type redisCache struct {
-	opts   cache.Options
-	client rclient.UniversalClient
-}
-
-func (c *redisCache) Get(ctx context.Context, key string) (interface{}, time.Time, error) {
-	val, err := c.client.Get(ctx, key).Bytes()
-	if err != nil && err == rclient.Nil {
-		return nil, time.Time{}, cache.ErrKeyNotFound
-	} else if err != nil {
-		return nil, time.Time{}, err
-	}
-
-	dur, err := c.client.TTL(ctx, key).Result()
-	if err != nil {
-		return nil, time.Time{}, err
-	}
-	if dur == -1 {
-		return val, time.Unix(1<<63-1, 0), nil
-	}
-	if dur == -2 {
-		return val, time.Time{}, cache.ErrItemExpired
-	}
-
-	return val, time.Now().Add(dur), nil
-}
-
-func (c *redisCache) Put(ctx context.Context, key string, val interface{}, dur time.Duration) error {
-	return c.client.Set(ctx, key, val, dur).Err()
-}
-
-func (c *redisCache) Delete(ctx context.Context, key string) error {
-	return c.client.Del(ctx, key).Err()
-}
-
-func (m *redisCache) String() string {
-	return "redis"
-}

cache/redis/redis_test.go

@@ -1,88 +0,0 @@
-package redis
-
-import (
-	"context"
-	"os"
-	"testing"
-	"time"
-
-	"go-micro.dev/v5/cache"
-)
-
-var (
-	ctx              = context.TODO()
-	key  string      = "redistestkey"
-	val  interface{} = "hello go-micro"
-	addr             = cache.WithAddress("redis://127.0.0.1:6379")
-)
-
-// TestMemCache tests the in-memory cache implementation.
-func TestCache(t *testing.T) {
-	if len(os.Getenv("LOCAL")) == 0 {
-		t.Skip()
-	}
-
-	t.Run("CacheGetMiss", func(t *testing.T) {
-		if _, _, err := NewRedisCache(addr).Get(ctx, key); err == nil {
-			t.Error("expected to get no value from cache")
-		}
-	})
-
-	t.Run("CacheGetHit", func(t *testing.T) {
-		c := NewRedisCache(addr)
-
-		if err := c.Put(ctx, key, val, 0); err != nil {
-			t.Error(err)
-		}
-
-		if a, _, err := c.Get(ctx, key); err != nil {
-			t.Errorf("Expected a value, got err: %s", err)
-		} else if string(a.([]byte)) != val {
-			t.Errorf("Expected '%v', got '%v'", val, a)
-		}
-	})
-
-	t.Run("CacheGetExpired", func(t *testing.T) {
-		c := NewRedisCache(addr)
-		d := 20 * time.Millisecond
-
-		if err := c.Put(ctx, key, val, d); err != nil {
-			t.Error(err)
-		}
-
-		<-time.After(25 * time.Millisecond)
-		if _, _, err := c.Get(ctx, key); err == nil {
-			t.Error("expected to get no value from cache")
-		}
-	})
-
-	t.Run("CacheGetValid", func(t *testing.T) {
-		c := NewRedisCache(addr)
-		e := 25 * time.Millisecond
-
-		if err := c.Put(ctx, key, val, e); err != nil {
-			t.Error(err)
-		}
-
-		<-time.After(20 * time.Millisecond)
-		if _, _, err := c.Get(ctx, key); err != nil {
-			t.Errorf("expected a value, got err: %s", err)
-		}
-	})
-
-	t.Run("CacheDeleteHit", func(t *testing.T) {
-		c := NewRedisCache(addr)
-
-		if err := c.Put(ctx, key, val, 0); err != nil {
-			t.Error(err)
-		}
-
-		if err := c.Delete(ctx, key); err != nil {
-			t.Errorf("Expected to delete an item, got err: %s", err)
-		}
-
-		if _, _, err := c.Get(ctx, key); err == nil {
-			t.Errorf("Expected error")
-		}
-	})
-}

client/backoff.go

@@ -4,7 +4,7 @@ import (
 	"context"
 	"time"
 
-	"go-micro.dev/v5/util/backoff"
+	"github.com/asim/go-micro/v3/util/backoff"
 )
 
 type BackoffFunc func(ctx context.Context, req Request, attempts int) (time.Duration, error)

client/cache.go

@@ -7,40 +7,37 @@ import (
 	"hash/fnv"
 	"time"
 
+	"github.com/asim/go-micro/v3/metadata"
 	cache "github.com/patrickmn/go-cache"
-
-	"go-micro.dev/v5/metadata"
-	"go-micro.dev/v5/transport/headers"
 )
 
-// NewCache returns an initialized cache.
+// NewCache returns an initialised cache.
 func NewCache() *Cache {
 	return &Cache{
 		cache: cache.New(cache.NoExpiration, 30*time.Second),
 	}
 }
 
-// Cache for responses.
+// Cache for responses
 type Cache struct {
 	cache *cache.Cache
 }
 
-// Get a response from the cache.
+// Get a response from the cache
 func (c *Cache) Get(ctx context.Context, req *Request) (interface{}, bool) {
 	return c.cache.Get(key(ctx, req))
 }
 
-// Set a response in the cache.
+// Set a response in the cache
 func (c *Cache) Set(ctx context.Context, req *Request, rsp interface{}, expiry time.Duration) {
 	c.cache.Set(key(ctx, req), rsp, expiry)
 }
 
-// List the key value pairs in the cache.
+// List the key value pairs in the cache
 func (c *Cache) List() map[string]string {
 	items := c.cache.Items()
 
 	rsp := make(map[string]string, len(items))
-
 	for k, v := range items {
 		bytes, _ := json.Marshal(v.Object)
 		rsp[k] = string(bytes)
@@ -49,9 +46,9 @@ func (c *Cache) List() map[string]string {
 	return rsp
 }
 
-// key returns a hash for the context and request.
+// key returns a hash for the context and request
 func key(ctx context.Context, req *Request) string {
-	ns, _ := metadata.Get(ctx, headers.Namespace)
+	ns, _ := metadata.Get(ctx, "Micro-Namespace")
 
 	bytes, _ := json.Marshal(map[string]interface{}{
 		"namespace": ns,
@@ -65,6 +62,5 @@ func key(ctx context.Context, req *Request) string {
 
 	h := fnv.New64()
 	h.Write(bytes)
-
 	return fmt.Sprintf("%x", h.Sum(nil))
 }

client/cache_test.go

@@ -5,8 +5,7 @@ import (
 	"testing"
 	"time"
 
-	"go-micro.dev/v5/metadata"
-	"go-micro.dev/v5/transport/headers"
+	"github.com/asim/go-micro/v3/metadata"
 )
 
 func TestCache(t *testing.T) {
@@ -66,7 +65,7 @@ func TestCacheKey(t *testing.T) {
 	})
 
 	t.Run("DifferentMetadata", func(t *testing.T) {
-		mdCtx := metadata.Set(context.TODO(), headers.Namespace, "bar")
+		mdCtx := metadata.Set(context.TODO(), "Micro-Namespace", "bar")
 		key1 := key(mdCtx, &req1)
 		key2 := key(ctx, &req1)
 

client/client.go

@@ -3,15 +3,9 @@ package client
 
 import (
 	"context"
+	"time"
 
-	"go-micro.dev/v5/codec"
-)
-
-var (
-	// NewClient returns a new client.
-	NewClient func(...Option) Client = newRPCClient
-	// DefaultClient is a default client to use out of the box.
-	DefaultClient Client = newRPCClient()
+	"github.com/asim/go-micro/v3/codec"
 )
 
 // Client is the interface used to make requests to services.
@@ -28,19 +22,19 @@ type Client interface {
 	String() string
 }
 
-// Router manages request routing.
+// Router manages request routing
 type Router interface {
 	SendRequest(context.Context, Request) (Response, error)
 }
 
-// Message is the interface for publishing asynchronously.
+// Message is the interface for publishing asynchronously
 type Message interface {
 	Topic() string
 	Payload() interface{}
 	ContentType() string
 }
 
-// Request is the interface for a synchronous request used by Call or Stream.
+// Request is the interface for a synchronous request used by Call or Stream
 type Request interface {
 	// The service to call
 	Service() string
@@ -58,7 +52,7 @@ type Request interface {
 	Stream() bool
 }
 
-// Response is the response received from a service.
+// Response is the response received from a service
 type Response interface {
 	// Read the response
 	Codec() codec.Reader
@@ -68,9 +62,8 @@ type Response interface {
 	Read() ([]byte, error)
 }
 
-// Stream is the inteface for a bidirectional synchronous stream.
+// Stream is the inteface for a bidirectional synchronous stream
 type Stream interface {
-	Closer
 	// Context for the stream
 	Context() context.Context
 	// The request made
@@ -87,28 +80,42 @@ type Stream interface {
 	Close() error
 }
 
-// Closer handle client close.
-type Closer interface {
-	// CloseSend closes the send direction of the stream.
-	CloseSend() error
-}
-
-// Option used by the Client.
+// Option used by the Client
 type Option func(*Options)
 
-// CallOption used by Call or Stream.
+// CallOption used by Call or Stream
 type CallOption func(*CallOptions)
 
-// PublishOption used by Publish.
+// PublishOption used by Publish
 type PublishOption func(*PublishOptions)
 
-// MessageOption used by NewMessage.
+// MessageOption used by NewMessage
 type MessageOption func(*MessageOptions)
 
-// RequestOption used by NewRequest.
+// RequestOption used by NewRequest
 type RequestOption func(*RequestOptions)
 
-// Makes a synchronous call to a service using the default client.
+var (
+	// DefaultClient is a default client to use out of the box
+	DefaultClient Client = newRpcClient()
+	// DefaultBackoff is the default backoff function for retries
+	DefaultBackoff = exponentialBackoff
+	// DefaultRetry is the default check-for-retry function for retries
+	DefaultRetry = RetryOnError
+	// DefaultRetries is the default number of times a request is tried
+	DefaultRetries = 1
+	// DefaultRequestTimeout is the default request timeout
+	DefaultRequestTimeout = time.Second * 5
+	// DefaultPoolSize sets the connection pool size
+	DefaultPoolSize = 100
+	// DefaultPoolTTL sets the connection pool ttl
+	DefaultPoolTTL = time.Minute
+
+	// NewClient returns a new client
+	NewClient func(...Option) Client = newRpcClient
+)
+
+// Makes a synchronous call to a service using the default client
 func Call(ctx context.Context, request Request, response interface{}, opts ...CallOption) error {
 	return DefaultClient.Call(ctx, request, response, opts...)
 }
@@ -119,13 +126,13 @@ func Publish(ctx context.Context, msg Message, opts ...PublishOption) error {
 	return DefaultClient.Publish(ctx, msg, opts...)
 }
 
-// Creates a new message using the default client.
+// Creates a new message using the default client
 func NewMessage(topic string, payload interface{}, opts ...MessageOption) Message {
 	return DefaultClient.NewMessage(topic, payload, opts...)
 }
 
 // Creates a new request using the default client. Content Type will
-// be set to the default within options and use the appropriate codec.
+// be set to the default within options and use the appropriate codec
 func NewRequest(service, endpoint string, request interface{}, reqOpts ...RequestOption) Request {
 	return DefaultClient.NewRequest(service, endpoint, request, reqOpts...)
 }

client/common_test.go

@@ -1,11 +1,11 @@
 package client
 
 import (
-	"go-micro.dev/v5/registry"
+	"github.com/asim/go-micro/v3/registry"
 )
 
 var (
-	// mock data.
+	// mock data
 	testData = map[string][]*registry.Service{
 		"foo": {
 			{

client/options.go

@@ -4,115 +4,81 @@ import (
 	"context"
 	"time"
 
-	"go-micro.dev/v5/broker"
-	"go-micro.dev/v5/codec"
-	"go-micro.dev/v5/logger"
-	"go-micro.dev/v5/registry"
-	"go-micro.dev/v5/selector"
-	"go-micro.dev/v5/transport"
+	"github.com/asim/go-micro/v3/broker"
+	"github.com/asim/go-micro/v3/codec"
+	"github.com/asim/go-micro/v3/registry"
+	"github.com/asim/go-micro/v3/selector"
+	"github.com/asim/go-micro/v3/transport"
 )
 
-var (
-	// DefaultBackoff is the default backoff function for retries.
-	DefaultBackoff = exponentialBackoff
-	// DefaultRetry is the default check-for-retry function for retries.
-	DefaultRetry = RetryOnError
-	// DefaultRetries is the default number of times a request is tried.
-	DefaultRetries = 5
-	// DefaultRequestTimeout is the default request timeout.
-	DefaultRequestTimeout = time.Second * 30
-	// DefaultConnectionTimeout is the default connection timeout.
-	DefaultConnectionTimeout = time.Second * 5
-	// DefaultPoolSize sets the connection pool size.
-	DefaultPoolSize = 100
-	// DefaultPoolTTL sets the connection pool ttl.
-	DefaultPoolTTL = time.Minute
-	// DefaultPoolCloseTimeout sets the connection pool colse timeout.
-	DefaultPoolCloseTimeout = time.Second
-)
-
-// Options are the Client options.
 type Options struct {
+	// Used to select codec
+	ContentType string
 
-	// Default Call Options
-	CallOptions CallOptions
-
-	// Router sets the router
-	Router Router
-
+	// Plugged interfaces
+	Broker    broker.Broker
+	Codecs    map[string]codec.NewCodec
 	Registry  registry.Registry
 	Selector  selector.Selector
 	Transport transport.Transport
 
-	// Plugged interfaces
-	Broker broker.Broker
+	// Router sets the router
+	Router Router
 
-	// Logger is the underline logger
-	Logger logger.Logger
-
-	// Other options for implementations of the interface
-	// can be stored in a context
-	Context context.Context
-	Codecs  map[string]codec.NewCodec
+	// Connection Pool
+	PoolSize int
+	PoolTTL  time.Duration
 
 	// Response cache
 	Cache *Cache
 
-	// Used to select codec
-	ContentType string
-
 	// Middleware for client
 	Wrappers []Wrapper
 
-	// Connection Pool
-	PoolSize         int
-	PoolTTL          time.Duration
-	PoolCloseTimeout time.Duration
-}
-
-// CallOptions are options used to make calls to a server.
-type CallOptions struct {
+	// Default Call Options
+	CallOptions CallOptions
 
 	// Other options for implementations of the interface
 	// can be stored in a context
 	Context context.Context
-	// Backoff func
-	Backoff BackoffFunc
-	// Check if retriable func
-	Retry         RetryFunc
+}
+
+type CallOptions struct {
 	SelectOptions []selector.SelectOption
 
 	// Address of remote hosts
 	Address []string
+	// Backoff func
+	Backoff BackoffFunc
+	// Check if retriable func
+	Retry RetryFunc
+	// Transport Dial Timeout
+	DialTimeout time.Duration
+	// Number of Call attempts
+	Retries int
+	// Request/Response timeout
+	RequestTimeout time.Duration
+	// Stream timeout for the stream
+	StreamTimeout time.Duration
+	// Use the services own auth token
+	ServiceToken bool
+	// Duration to cache the response for
+	CacheExpiry time.Duration
 
 	// Middleware for low level call func
 	CallWrappers []CallWrapper
 
-	// ConnectionTimeout of one request to the server.
-	// Set this lower than the RequestTimeout to enable retries on connection timeout.
-	ConnectionTimeout time.Duration
-	// Request/Response timeout of entire srv.Call, for single request timeout set ConnectionTimeout.
-	RequestTimeout time.Duration
-	// Stream timeout for the stream
-	StreamTimeout time.Duration
-	// Duration to cache the response for
-	CacheExpiry time.Duration
-	// Transport Dial Timeout. Used for initial dial to establish a connection.
-	DialTimeout time.Duration
-	// Number of Call attempts
-	Retries int
-	// Use the services own auth token
-	ServiceToken bool
-	// ConnClose sets the Connection: close header.
-	ConnClose bool
-}
-
-type PublishOptions struct {
 	// Other options for implementations of the interface
 	// can be stored in a context
 	Context context.Context
+}
+
+type PublishOptions struct {
 	// Exchange is the routing exchange for the message
 	Exchange string
+	// Other options for implementations of the interface
+	// can be stored in a context
+	Context context.Context
 }
 
 type MessageOptions struct {
@@ -120,15 +86,14 @@ type MessageOptions struct {
 }
 
 type RequestOptions struct {
+	ContentType string
+	Stream      bool
 
 	// Other options for implementations of the interface
 	// can be stored in a context
-	Context     context.Context
-	ContentType string
-	Stream      bool
+	Context context.Context
 }
 
-// NewOptions creates new Client options.
 func NewOptions(options ...Option) Options {
 	opts := Options{
 		Cache:       NewCache(),
@@ -136,21 +101,18 @@ func NewOptions(options ...Option) Options {
 		ContentType: DefaultContentType,
 		Codecs:      make(map[string]codec.NewCodec),
 		CallOptions: CallOptions{
-			Backoff:           DefaultBackoff,
-			Retry:             DefaultRetry,
-			Retries:           DefaultRetries,
-			RequestTimeout:    DefaultRequestTimeout,
-			ConnectionTimeout: DefaultConnectionTimeout,
-			DialTimeout:       transport.DefaultDialTimeout,
+			Backoff:        DefaultBackoff,
+			Retry:          DefaultRetry,
+			Retries:        DefaultRetries,
+			RequestTimeout: DefaultRequestTimeout,
+			DialTimeout:    transport.DefaultDialTimeout,
 		},
-		PoolSize:         DefaultPoolSize,
-		PoolTTL:          DefaultPoolTTL,
-		PoolCloseTimeout: DefaultPoolCloseTimeout,
-		Broker:           broker.DefaultBroker,
-		Selector:         selector.DefaultSelector,
-		Registry:         registry.DefaultRegistry,
-		Transport:        transport.DefaultTransport,
-		Logger:           logger.DefaultLogger,
+		PoolSize:  DefaultPoolSize,
+		PoolTTL:   DefaultPoolTTL,
+		Broker:    broker.DefaultBroker,
+		Selector:  selector.DefaultSelector,
+		Registry:  registry.DefaultRegistry,
+		Transport: transport.DefaultTransport,
 	}
 
 	for _, o := range options {
@@ -160,49 +122,42 @@ func NewOptions(options ...Option) Options {
 	return opts
 }
 
-// Broker to be used for pub/sub.
+// Broker to be used for pub/sub
 func Broker(b broker.Broker) Option {
 	return func(o *Options) {
 		o.Broker = b
 	}
 }
 
-// Codec to be used to encode/decode requests for a given content type.
+// Codec to be used to encode/decode requests for a given content type
 func Codec(contentType string, c codec.NewCodec) Option {
 	return func(o *Options) {
 		o.Codecs[contentType] = c
 	}
 }
 
-// ContentType sets the default content type of the client.
+// Default content type of the client
 func ContentType(ct string) Option {
 	return func(o *Options) {
 		o.ContentType = ct
 	}
 }
 
-// PoolSize sets the connection pool size.
+// PoolSize sets the connection pool size
 func PoolSize(d int) Option {
 	return func(o *Options) {
 		o.PoolSize = d
 	}
 }
 
-// PoolTTL sets the connection pool ttl.
+// PoolTTL sets the connection pool ttl
 func PoolTTL(d time.Duration) Option {
 	return func(o *Options) {
 		o.PoolTTL = d
 	}
 }
 
-// PoolCloseTimeout sets the connection pool close timeout.
-func PoolCloseTimeout(d time.Duration) Option {
-	return func(o *Options) {
-		o.PoolCloseTimeout = d
-	}
-}
-
-// Registry to find nodes for a given service.
+// Registry to find nodes for a given service
 func Registry(r registry.Registry) Option {
 	return func(o *Options) {
 		o.Registry = r
@@ -211,28 +166,28 @@ func Registry(r registry.Registry) Option {
 	}
 }
 
-// Transport to use for communication e.g http, rabbitmq, etc.
+// Transport to use for communication e.g http, rabbitmq, etc
 func Transport(t transport.Transport) Option {
 	return func(o *Options) {
 		o.Transport = t
 	}
 }
 
-// Select is used to select a node to route a request to.
+// Select is used to select a node to route a request to
 func Selector(s selector.Selector) Option {
 	return func(o *Options) {
 		o.Selector = s
 	}
 }
 
-// Adds a Wrapper to a list of options passed into the client.
+// Adds a Wrapper to a list of options passed into the client
 func Wrap(w Wrapper) Option {
 	return func(o *Options) {
 		o.Wrappers = append(o.Wrappers, w)
 	}
 }
 
-// Adds a Wrapper to the list of CallFunc wrappers.
+// 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...)
@@ -240,14 +195,15 @@ func WrapCall(cw ...CallWrapper) Option {
 }
 
 // Backoff is used to set the backoff function used
-// when retrying Calls.
+// when retrying Calls
 func Backoff(fn BackoffFunc) Option {
 	return func(o *Options) {
 		o.CallOptions.Backoff = fn
 	}
 }
 
-// Retries set the number of retries when making the request.
+// Number of retries when making the request.
+// Should this be a Call Option?
 func Retries(i int) Option {
 	return func(o *Options) {
 		o.CallOptions.Retries = i
@@ -261,28 +217,22 @@ func Retry(fn RetryFunc) Option {
 	}
 }
 
-// ConnectionTimeout sets the connection timeout
-func ConnectionTimeout(t time.Duration) Option {
-	return func(o *Options) {
-		o.CallOptions.ConnectionTimeout = t
-	}
-}
-
-// RequestTimeout set the request timeout.
+// The request timeout.
+// Should this be a Call Option?
 func RequestTimeout(d time.Duration) Option {
 	return func(o *Options) {
 		o.CallOptions.RequestTimeout = d
 	}
 }
 
-// StreamTimeout sets the stream timeout.
+// StreamTimeout sets the stream timeout
 func StreamTimeout(d time.Duration) Option {
 	return func(o *Options) {
 		o.CallOptions.StreamTimeout = d
 	}
 }
 
-// DialTimeout sets the transport dial timeout.
+// Transport dial timeout
 func DialTimeout(d time.Duration) Option {
 	return func(o *Options) {
 		o.CallOptions.DialTimeout = d
@@ -291,21 +241,21 @@ func DialTimeout(d time.Duration) Option {
 
 // Call Options
 
-// WithExchange sets the exchange to route a message through.
+// WithExchange sets the exchange to route a message through
 func WithExchange(e string) PublishOption {
 	return func(o *PublishOptions) {
 		o.Exchange = e
 	}
 }
 
-// PublishContext sets the context in publish options.
+// PublishContext sets the context in publish options
 func PublishContext(ctx context.Context) PublishOption {
 	return func(o *PublishOptions) {
 		o.Context = ctx
 	}
 }
 
-// WithAddress sets the remote addresses to use rather than using service discovery.
+// WithAddress sets the remote addresses to use rather than using service discovery
 func WithAddress(a ...string) CallOption {
 	return func(o *CallOptions) {
 		o.Address = a
@@ -318,7 +268,7 @@ func WithSelectOption(so ...selector.SelectOption) CallOption {
 	}
 }
 
-// WithCallWrapper is a CallOption which adds to the existing CallFunc wrappers.
+// 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...)
@@ -326,7 +276,7 @@ func WithCallWrapper(cw ...CallWrapper) CallOption {
 }
 
 // WithBackoff is a CallOption which overrides that which
-// set in Options.CallOptions.
+// set in Options.CallOptions
 func WithBackoff(fn BackoffFunc) CallOption {
 	return func(o *CallOptions) {
 		o.Backoff = fn
@@ -334,15 +284,15 @@ func WithBackoff(fn BackoffFunc) CallOption {
 }
 
 // WithRetry is a CallOption which overrides that which
-// set in Options.CallOptions.
+// set in Options.CallOptions
 func WithRetry(fn RetryFunc) CallOption {
 	return func(o *CallOptions) {
 		o.Retry = fn
 	}
 }
 
-// WithRetries sets the number of tries for a call.
-// This CallOption overrides Options.CallOptions.
+// WithRetries is a CallOption which overrides that which
+// set in Options.CallOptions
 func WithRetries(i int) CallOption {
 	return func(o *CallOptions) {
 		o.Retries = i
@@ -350,21 +300,14 @@ func WithRetries(i int) CallOption {
 }
 
 // WithRequestTimeout is a CallOption which overrides that which
-// set in Options.CallOptions.
+// set in Options.CallOptions
 func WithRequestTimeout(d time.Duration) CallOption {
 	return func(o *CallOptions) {
 		o.RequestTimeout = d
 	}
 }
 
-// WithConnClose sets the Connection header to close.
-func WithConnClose() CallOption {
-	return func(o *CallOptions) {
-		o.ConnClose = true
-	}
-}
-
-// WithStreamTimeout sets the stream timeout.
+// WithStreamTimeout sets the stream timeout
 func WithStreamTimeout(d time.Duration) CallOption {
 	return func(o *CallOptions) {
 		o.StreamTimeout = d
@@ -372,7 +315,7 @@ func WithStreamTimeout(d time.Duration) CallOption {
 }
 
 // WithDialTimeout is a CallOption which overrides that which
-// set in Options.CallOptions.
+// set in Options.CallOptions
 func WithDialTimeout(d time.Duration) CallOption {
 	return func(o *CallOptions) {
 		o.DialTimeout = d
@@ -380,7 +323,7 @@ func WithDialTimeout(d time.Duration) CallOption {
 }
 
 // WithServiceToken is a CallOption which overrides the
-// authorization header with the services own auth token.
+// authorization header with the services own auth token
 func WithServiceToken() CallOption {
 	return func(o *CallOptions) {
 		o.ServiceToken = true
@@ -388,7 +331,7 @@ func WithServiceToken() CallOption {
 }
 
 // WithCache is a CallOption which sets the duration the response
-// shoull be cached for.
+// shoull be cached for
 func WithCache(c time.Duration) CallOption {
 	return func(o *CallOptions) {
 		o.CacheExpiry = c
@@ -415,16 +358,9 @@ func StreamingRequest() RequestOption {
 	}
 }
 
-// WithRouter sets the client router.
+// WithRouter sets the client router
 func WithRouter(r Router) Option {
 	return func(o *Options) {
 		o.Router = r
 	}
 }
-
-// WithLogger sets the underline logger.
-func WithLogger(l logger.Logger) Option {
-	return func(o *Options) {
-		o.Logger = l
-	}
-}

client/options_test.go

@@ -4,7 +4,7 @@ import (
 	"testing"
 	"time"
 
-	"go-micro.dev/v5/transport"
+	"github.com/asim/go-micro/v3/transport"
 )
 
 func TestCallOptions(t *testing.T) {
@@ -78,6 +78,8 @@ func TestCallOptions(t *testing.T) {
 			if e := o.CallOptions.DialTimeout * (time.Second * 10); callOpts.DialTimeout != e {
 				t.Fatalf("Expected %v got %v", e, callOpts.DialTimeout)
 			}
+
 		}
+
 	}
 }

client/retry.go

@@ -3,18 +3,18 @@ package client
 import (
 	"context"
 
-	"go-micro.dev/v5/errors"
+	"github.com/asim/go-micro/v3/errors"
 )
 
-// note that returning either false or a non-nil error will result in the call not being retried.
+// note that returning either false or a non-nil error will result in the call not being retried
 type RetryFunc func(ctx context.Context, req Request, retryCount int, err error) (bool, error)
 
-// RetryAlways always retry on error.
+// RetryAlways always retry on error
 func RetryAlways(ctx context.Context, req Request, retryCount int, err error) (bool, error) {
 	return true, nil
 }
 
-// RetryOnError retries a request on a 500 or timeout error.
+// RetryOnError retries a request on a 500 or timeout error
 func RetryOnError(ctx context.Context, req Request, retryCount int, err error) (bool, error) {
 	if err == nil {
 		return false, nil
@@ -26,9 +26,8 @@ func RetryOnError(ctx context.Context, req Request, retryCount int, err error) (
 	}
 
 	switch e.Code {
-	// Retry on timeout, not on 500 internal server error, as that is a business
-	// logic error that should be handled by the user.
-	case 408:
+	// retry on timeout or internal server error
+	case 408, 500:
 		return true, nil
 	default:
 		return false, nil

client/rpc_client.go

@@ -3,48 +3,37 @@ package client
 import (
 	"context"
 	"fmt"
-	"sync"
 	"sync/atomic"
 	"time"
 
+	"github.com/asim/go-micro/v3/broker"
+	"github.com/asim/go-micro/v3/codec"
+	raw "github.com/asim/go-micro/v3/codec/bytes"
+	"github.com/asim/go-micro/v3/errors"
+	"github.com/asim/go-micro/v3/metadata"
+	"github.com/asim/go-micro/v3/registry"
+	"github.com/asim/go-micro/v3/selector"
+	"github.com/asim/go-micro/v3/transport"
+	"github.com/asim/go-micro/v3/util/buf"
+	"github.com/asim/go-micro/v3/util/net"
+	"github.com/asim/go-micro/v3/util/pool"
 	"github.com/google/uuid"
-	"github.com/pkg/errors"
-
-	"go-micro.dev/v5/broker"
-	"go-micro.dev/v5/codec"
-	raw "go-micro.dev/v5/codec/bytes"
-	merrors "go-micro.dev/v5/errors"
-	log "go-micro.dev/v5/logger"
-	"go-micro.dev/v5/metadata"
-	"go-micro.dev/v5/registry"
-	"go-micro.dev/v5/selector"
-	"go-micro.dev/v5/transport"
-	"go-micro.dev/v5/transport/headers"
-	"go-micro.dev/v5/util/buf"
-	"go-micro.dev/v5/util/net"
-	"go-micro.dev/v5/util/pool"
-)
-
-const (
-	packageID = "go.micro.client"
 )
 
 type rpcClient struct {
 	seq  uint64
-	opts Options
 	once atomic.Value
+	opts Options
 	pool pool.Pool
-	mu   sync.RWMutex
 }
 
-func newRPCClient(opt ...Option) Client {
+func newRpcClient(opt ...Option) Client {
 	opts := NewOptions(opt...)
 
 	p := pool.NewPool(
 		pool.Size(opts.PoolSize),
 		pool.TTL(opts.PoolTTL),
 		pool.Transport(opts.Transport),
-		pool.CloseTimeout(opts.PoolCloseTimeout),
 	)
 
 	rc := &rpcClient{
@@ -68,23 +57,14 @@ func (r *rpcClient) newCodec(contentType string) (codec.NewCodec, error) {
 	if c, ok := r.opts.Codecs[contentType]; ok {
 		return c, nil
 	}
-
 	if cf, ok := DefaultCodecs[contentType]; ok {
 		return cf, nil
 	}
-
-	return nil, fmt.Errorf("unsupported Content-Type: %s", contentType)
+	return nil, fmt.Errorf("Unsupported Content-Type: %s", contentType)
 }
 
-func (r *rpcClient) call(
-	ctx context.Context,
-	node *registry.Node,
-	req Request,
-	resp interface{},
-	opts CallOptions,
-) error {
+func (r *rpcClient) call(ctx context.Context, node *registry.Node, req Request, resp interface{}, opts CallOptions) error {
 	address := node.Address
-	logger := r.Options().Logger
 
 	msg := &transport.Message{
 		Header: make(map[string]string),
@@ -93,43 +73,31 @@ func (r *rpcClient) call(
 	md, ok := metadata.FromContext(ctx)
 	if ok {
 		for k, v := range md {
-			// Don't copy Micro-Topic header, that is used for pub/sub
-			// this is fixes the case when the client uses the same context that
-			// is received in the subscriber.
-			if k == headers.Message {
+			// don't copy Micro-Topic header, that used for pub/sub
+			// this fix case then client uses the same context that received in subscriber
+			if k == "Micro-Topic" {
 				continue
 			}
-
 			msg.Header[k] = v
 		}
 	}
 
-	// Set connection timeout for single requests to the server. Should be > 0
-	// as otherwise requests can't be made.
-	cTimeout := opts.ConnectionTimeout
-	if cTimeout == 0 {
-		logger.Log(log.DebugLevel, "connection timeout was set to 0, overridng to default connection timeout")
-
-		cTimeout = DefaultConnectionTimeout
-	}
-
 	// set timeout in nanoseconds
-	msg.Header["Timeout"] = fmt.Sprintf("%d", cTimeout)
+	msg.Header["Timeout"] = fmt.Sprintf("%d", opts.RequestTimeout)
 	// set the content type for the request
 	msg.Header["Content-Type"] = req.ContentType()
 	// set the accept header
 	msg.Header["Accept"] = req.ContentType()
 
 	// setup old protocol
-	reqCodec := setupProtocol(msg, node)
+	cf := setupProtocol(msg, node)
 
 	// no codec specified
-	if reqCodec == nil {
+	if cf == nil {
 		var err error
-		reqCodec, err = r.newCodec(req.ContentType())
-
+		cf, err = r.newCodec(req.ContentType())
 		if err != nil {
-			return merrors.InternalServerError("go.micro.client", err.Error())
+			return errors.InternalServerError("go.micro.client", err.Error())
 		}
 	}
 
@@ -141,32 +109,19 @@ func (r *rpcClient) call(
 		dOpts = append(dOpts, transport.WithTimeout(opts.DialTimeout))
 	}
 
-	if opts.ConnClose {
-		dOpts = append(dOpts, transport.WithConnClose())
-	}
-
 	c, err := r.pool.Get(address, dOpts...)
 	if err != nil {
-		if c == nil {
-			return merrors.InternalServerError("go.micro.client", "connection error: %v", err)
-		}
-		logger.Log(log.ErrorLevel, "failed to close pool", err)
+		return errors.InternalServerError("go.micro.client", "connection error: %v", err)
 	}
 
 	seq := atomic.AddUint64(&r.seq, 1) - 1
-	codec := newRPCCodec(msg, c, reqCodec, "")
+	codec := newRpcCodec(msg, c, cf, "")
 
 	rsp := &rpcResponse{
 		socket: c,
 		codec:  codec,
 	}
 
-	releaseFunc := func(err error) {
-		if err = r.pool.Release(c, err); err != nil {
-			logger.Log(log.ErrorLevel, "failed to release pool", err)
-		}
-	}
-
 	stream := &rpcStream{
 		id:       fmt.Sprintf("%v", seq),
 		context:  ctx,
@@ -174,17 +129,11 @@ func (r *rpcClient) call(
 		response: rsp,
 		codec:    codec,
 		closed:   make(chan bool),
-		close:    opts.ConnClose,
-		release:  releaseFunc,
+		release:  func(err error) { r.pool.Release(c, err) },
 		sendEOS:  false,
 	}
-
 	// close the stream on exiting this function
-	defer func() {
-		if err := stream.Close(); err != nil {
-			logger.Log(log.ErrorLevel, "failed to close stream", err)
-		}
-	}()
+	defer stream.Close()
 
 	// wait for error response
 	ch := make(chan error, 1)
@@ -192,7 +141,7 @@ func (r *rpcClient) call(
 	go func() {
 		defer func() {
 			if r := recover(); r != nil {
-				ch <- merrors.InternalServerError("go.micro.client", "panic recovered: %v", r)
+				ch <- errors.InternalServerError("go.micro.client", "panic recovered: %v", r)
 			}
 		}()
 
@@ -202,7 +151,7 @@ func (r *rpcClient) call(
 			return
 		}
 
-		// recv response
+		// recv request
 		if err := stream.Recv(resp); err != nil {
 			ch <- err
 			return
@@ -217,8 +166,8 @@ func (r *rpcClient) call(
 	select {
 	case err := <-ch:
 		return err
-	case <-time.After(cTimeout):
-		grr = merrors.Timeout("go.micro.client", fmt.Sprintf("%v", ctx.Err()))
+	case <-ctx.Done():
+		grr = errors.Timeout("go.micro.client", fmt.Sprintf("%v", ctx.Err()))
 	}
 
 	// set the stream error
@@ -235,7 +184,6 @@ func (r *rpcClient) call(
 
 func (r *rpcClient) stream(ctx context.Context, node *registry.Node, req Request, opts CallOptions) (Stream, error) {
 	address := node.Address
-	logger := r.Options().Logger
 
 	msg := &transport.Message{
 		Header: make(map[string]string),
@@ -258,15 +206,14 @@ func (r *rpcClient) stream(ctx context.Context, node *registry.Node, req Request
 	msg.Header["Accept"] = req.ContentType()
 
 	// set old codecs
-	nCodec := setupProtocol(msg, node)
+	cf := setupProtocol(msg, node)
 
 	// no codec specified
-	if nCodec == nil {
+	if cf == nil {
 		var err error
-
-		nCodec, err = r.newCodec(req.ContentType())
+		cf, err = r.newCodec(req.ContentType())
 		if err != nil {
-			return nil, merrors.InternalServerError("go.micro.client", err.Error())
+			return nil, errors.InternalServerError("go.micro.client", err.Error())
 		}
 	}
 
@@ -280,7 +227,7 @@ func (r *rpcClient) stream(ctx context.Context, node *registry.Node, req Request
 
 	c, err := r.opts.Transport.Dial(address, dOpts...)
 	if err != nil {
-		return nil, merrors.InternalServerError("go.micro.client", "connection error: %v", err)
+		return nil, errors.InternalServerError("go.micro.client", "connection error: %v", err)
 	}
 
 	// increment the sequence number
@@ -288,7 +235,7 @@ func (r *rpcClient) stream(ctx context.Context, node *registry.Node, req Request
 	id := fmt.Sprintf("%v", seq)
 
 	// create codec with stream id
-	codec := newRPCCodec(msg, c, nCodec, id)
+	codec := newRpcCodec(msg, c, cf, id)
 
 	rsp := &rpcResponse{
 		socket: c,
@@ -310,7 +257,8 @@ func (r *rpcClient) stream(ctx context.Context, node *registry.Node, req Request
 		closed: make(chan bool),
 		// signal the end of stream,
 		sendEOS: true,
-		release: func(_ error) {},
+		// release func
+		release: func(err error) { c.Close() },
 	}
 
 	// wait for error response
@@ -327,7 +275,7 @@ func (r *rpcClient) stream(ctx context.Context, node *registry.Node, req Request
 	case err := <-ch:
 		grr = err
 	case <-ctx.Done():
-		grr = merrors.Timeout("go.micro.client", fmt.Sprintf("%v", ctx.Err()))
+		grr = errors.Timeout("go.micro.client", fmt.Sprintf("%v", ctx.Err()))
 	}
 
 	if grr != nil {
@@ -337,10 +285,7 @@ func (r *rpcClient) stream(ctx context.Context, node *registry.Node, req Request
 		stream.Unlock()
 
 		// close the stream
-		if err := stream.Close(); err != nil {
-			logger.Logf(log.ErrorLevel, "failed to close stream: %v", err)
-		}
-
+		stream.Close()
 		return nil, grr
 	}
 
@@ -348,9 +293,6 @@ func (r *rpcClient) stream(ctx context.Context, node *registry.Node, req Request
 }
 
 func (r *rpcClient) Init(opts ...Option) error {
-	r.mu.Lock()
-	defer r.mu.Unlock()
-
 	size := r.opts.PoolSize
 	ttl := r.opts.PoolTTL
 	tr := r.opts.Transport
@@ -362,31 +304,23 @@ func (r *rpcClient) Init(opts ...Option) error {
 	// update pool configuration if the options changed
 	if size != r.opts.PoolSize || ttl != r.opts.PoolTTL || tr != r.opts.Transport {
 		// close existing pool
-		if err := r.pool.Close(); err != nil {
-			return errors.Wrap(err, "failed to close pool")
-		}
-
+		r.pool.Close()
 		// create new pool
 		r.pool = pool.NewPool(
 			pool.Size(r.opts.PoolSize),
 			pool.TTL(r.opts.PoolTTL),
 			pool.Transport(r.opts.Transport),
-			pool.CloseTimeout(r.opts.PoolCloseTimeout),
 		)
 	}
 
 	return nil
 }
 
-// Options retrives the options.
 func (r *rpcClient) Options() Options {
-	r.mu.RLock()
-	defer r.mu.RUnlock()
-
 	return r.opts
 }
 
-// next returns an iterator for the next nodes to call.
+// next returns an iterator for the next nodes to call
 func (r *rpcClient) next(request Request, opts CallOptions) (selector.Next, error) {
 	// try get the proxy
 	service, address, _ := net.Proxy(request.Service(), opts.Address)
@@ -414,22 +348,16 @@ func (r *rpcClient) next(request Request, opts CallOptions) (selector.Next, erro
 	// get next nodes from the selector
 	next, err := r.opts.Selector.Select(service, opts.SelectOptions...)
 	if err != nil {
-		if errors.Is(err, selector.ErrNotFound) {
-			return nil, merrors.InternalServerError("go.micro.client", "service %s: %s", service, err.Error())
+		if err == selector.ErrNotFound {
+			return nil, errors.InternalServerError("go.micro.client", "service %s: %s", service, err.Error())
 		}
-
-		return nil, merrors.InternalServerError("go.micro.client", "error selecting %s node: %s", service, err.Error())
+		return nil, errors.InternalServerError("go.micro.client", "error selecting %s node: %s", service, err.Error())
 	}
 
 	return next, nil
 }
 
 func (r *rpcClient) Call(ctx context.Context, request Request, response interface{}, opts ...CallOption) error {
-	// TODO: further validate these mutex locks. full lock would prevent
-	// parallel calls. Maybe we can set individual locks for secctions.
-	r.mu.RLock()
-	defer r.mu.RUnlock()
-
 	// make a copy of call opts
 	callOpts := r.opts.CallOptions
 	for _, opt := range opts {
@@ -447,7 +375,6 @@ func (r *rpcClient) Call(ctx context.Context, request Request, response interfac
 		// no deadline so we create a new one
 		var cancel context.CancelFunc
 		ctx, cancel = context.WithTimeout(ctx, callOpts.RequestTimeout)
-
 		defer cancel()
 	} else {
 		// got a deadline so no need to setup context
@@ -459,7 +386,7 @@ func (r *rpcClient) Call(ctx context.Context, request Request, response interfac
 	// should we noop right here?
 	select {
 	case <-ctx.Done():
-		return merrors.Timeout("go.micro.client", fmt.Sprintf("%v", ctx.Err()))
+		return errors.Timeout("go.micro.client", fmt.Sprintf("%v", ctx.Err()))
 	default:
 	}
 
@@ -476,7 +403,7 @@ func (r *rpcClient) Call(ctx context.Context, request Request, response interfac
 		// call backoff first. Someone may want an initial start delay
 		t, err := callOpts.Backoff(ctx, request, i)
 		if err != nil {
-			return merrors.InternalServerError("go.micro.client", "backoff error: %v", err.Error())
+			return errors.InternalServerError("go.micro.client", "backoff error: %v", err.Error())
 		}
 
 		// only sleep if greater than 0
@@ -487,22 +414,16 @@ func (r *rpcClient) Call(ctx context.Context, request Request, response interfac
 		// select next node
 		node, err := next()
 		service := request.Service()
-
 		if err != nil {
-			if errors.Is(err, selector.ErrNotFound) {
-				return merrors.InternalServerError("go.micro.client", "service %s: %s", service, err.Error())
+			if err == selector.ErrNotFound {
+				return errors.InternalServerError("go.micro.client", "service %s: %s", service, err.Error())
 			}
-
-			return merrors.InternalServerError("go.micro.client",
-				"error getting next %s node: %s",
-				service,
-				err.Error())
+			return errors.InternalServerError("go.micro.client", "error getting next %s node: %s", service, err.Error())
 		}
 
 		// make the call
 		err = rcall(ctx, node, request, response, callOpts)
 		r.opts.Selector.Mark(service, node, err)
-
 		return err
 	}
 
@@ -510,13 +431,11 @@ func (r *rpcClient) Call(ctx context.Context, request Request, response interfac
 	retries := callOpts.Retries
 
 	// disable retries when using a proxy
-	// Note: I don't see why we should disable retries for proxies, so commenting out.
-	// if _, _, ok := net.Proxy(request.Service(), callOpts.Address); ok {
-	// 	retries = 0
-	// }
+	if _, _, ok := net.Proxy(request.Service(), callOpts.Address); ok {
+		retries = 0
+	}
 
 	ch := make(chan error, retries+1)
-
 	var gerr error
 
 	for i := 0; i <= retries; i++ {
@@ -526,7 +445,7 @@ func (r *rpcClient) Call(ctx context.Context, request Request, response interfac
 
 		select {
 		case <-ctx.Done():
-			return merrors.Timeout("go.micro.client", fmt.Sprintf("call timeout: %v", ctx.Err()))
+			return errors.Timeout("go.micro.client", fmt.Sprintf("call timeout: %v", ctx.Err()))
 		case err := <-ch:
 			// if the call succeeded lets bail early
 			if err == nil {
@@ -542,8 +461,6 @@ func (r *rpcClient) Call(ctx context.Context, request Request, response interfac
 				return err
 			}
 
-			r.opts.Logger.Logf(log.DebugLevel, "Retrying request. Previous attempt failed with: %v", err)
-
 			gerr = err
 		}
 	}
@@ -552,9 +469,6 @@ func (r *rpcClient) Call(ctx context.Context, request Request, response interfac
 }
 
 func (r *rpcClient) Stream(ctx context.Context, request Request, opts ...CallOption) (Stream, error) {
-	r.mu.RLock()
-	defer r.mu.RUnlock()
-
 	// make a copy of call opts
 	callOpts := r.opts.CallOptions
 	for _, opt := range opts {
@@ -566,9 +480,10 @@ func (r *rpcClient) Stream(ctx context.Context, request Request, opts ...CallOpt
 		return nil, err
 	}
 
+	// should we noop right here?
 	select {
 	case <-ctx.Done():
-		return nil, merrors.Timeout("go.micro.client", fmt.Sprintf("%v", ctx.Err()))
+		return nil, errors.Timeout("go.micro.client", fmt.Sprintf("%v", ctx.Err()))
 	default:
 	}
 
@@ -576,7 +491,7 @@ func (r *rpcClient) Stream(ctx context.Context, request Request, opts ...CallOpt
 		// call backoff first. Someone may want an initial start delay
 		t, err := callOpts.Backoff(ctx, request, i)
 		if err != nil {
-			return nil, merrors.InternalServerError("go.micro.client", "backoff error: %v", err.Error())
+			return nil, errors.InternalServerError("go.micro.client", "backoff error: %v", err.Error())
 		}
 
 		// only sleep if greater than 0
@@ -586,21 +501,15 @@ func (r *rpcClient) Stream(ctx context.Context, request Request, opts ...CallOpt
 
 		node, err := next()
 		service := request.Service()
-
 		if err != nil {
-			if errors.Is(err, selector.ErrNotFound) {
-				return nil, merrors.InternalServerError("go.micro.client", "service %s: %s", service, err.Error())
+			if err == selector.ErrNotFound {
+				return nil, errors.InternalServerError("go.micro.client", "service %s: %s", service, err.Error())
 			}
-
-			return nil, merrors.InternalServerError("go.micro.client",
-				"error getting next %s node: %s",
-				service,
-				err.Error())
+			return nil, errors.InternalServerError("go.micro.client", "error getting next %s node: %s", service, err.Error())
 		}
 
 		stream, err := r.stream(ctx, node, request, callOpts)
 		r.opts.Selector.Mark(service, node, err)
-
 		return stream, err
 	}
 
@@ -618,7 +527,6 @@ func (r *rpcClient) Stream(ctx context.Context, request Request, opts ...CallOpt
 	}
 
 	ch := make(chan response, retries+1)
-
 	var grr error
 
 	for i := 0; i <= retries; i++ {
@@ -629,7 +537,7 @@ func (r *rpcClient) Stream(ctx context.Context, request Request, opts ...CallOpt
 
 		select {
 		case <-ctx.Done():
-			return nil, merrors.Timeout("go.micro.client", fmt.Sprintf("call timeout: %v", ctx.Err()))
+			return nil, errors.Timeout("go.micro.client", fmt.Sprintf("call timeout: %v", ctx.Err()))
 		case rsp := <-ch:
 			// if the call succeeded lets bail early
 			if rsp.err == nil {
@@ -660,15 +568,15 @@ func (r *rpcClient) Publish(ctx context.Context, msg Message, opts ...PublishOpt
 		o(&options)
 	}
 
-	metadata, ok := metadata.FromContext(ctx)
+	md, ok := metadata.FromContext(ctx)
 	if !ok {
-		metadata = make(map[string]string)
+		md = make(map[string]string)
 	}
 
 	id := uuid.New().String()
-	metadata["Content-Type"] = msg.ContentType()
-	metadata[headers.Message] = msg.Topic()
-	metadata[headers.ID] = id
+	md["Content-Type"] = msg.ContentType()
+	md["Micro-Topic"] = msg.Topic()
+	md["Micro-Id"] = id
 
 	// set the topic
 	topic := msg.Topic()
@@ -681,7 +589,7 @@ func (r *rpcClient) Publish(ctx context.Context, msg Message, opts ...PublishOpt
 	// encode message body
 	cf, err := r.newCodec(msg.ContentType())
 	if err != nil {
-		return merrors.InternalServerError(packageID, err.Error())
+		return errors.InternalServerError("go.micro.client", err.Error())
 	}
 
 	var body []byte
@@ -690,38 +598,33 @@ func (r *rpcClient) Publish(ctx context.Context, msg Message, opts ...PublishOpt
 	if d, ok := msg.Payload().(*raw.Frame); ok {
 		body = d.Data
 	} else {
+		// new buffer
 		b := buf.New(nil)
 
-		if err = cf(b).Write(&codec.Message{
+		if err := cf(b).Write(&codec.Message{
 			Target: topic,
 			Type:   codec.Event,
 			Header: map[string]string{
-				headers.ID:      id,
-				headers.Message: msg.Topic(),
+				"Micro-Id":    id,
+				"Micro-Topic": msg.Topic(),
 			},
 		}, msg.Payload()); err != nil {
-			return merrors.InternalServerError(packageID, err.Error())
+			return errors.InternalServerError("go.micro.client", err.Error())
 		}
 
 		// set the body
 		body = b.Bytes()
 	}
 
-	l, ok := r.once.Load().(bool)
-	if !ok {
-		return fmt.Errorf("failed to cast to bool")
-	}
-
-	if !l {
+	if !r.once.Load().(bool) {
 		if err = r.opts.Broker.Connect(); err != nil {
-			return merrors.InternalServerError(packageID, err.Error())
+			return errors.InternalServerError("go.micro.client", err.Error())
 		}
-
 		r.once.Store(true)
 	}
 
 	return r.opts.Broker.Publish(topic, &broker.Message{
-		Header: metadata,
+		Header: md,
 		Body:   body,
 	}, broker.PublishContext(options.Context))
 }

client/rpc_client_test.go

@@ -5,14 +5,9 @@ import (
 	"fmt"
 	"testing"
 
-	"go-micro.dev/v5/errors"
-	"go-micro.dev/v5/registry"
-	"go-micro.dev/v5/selector"
-)
-
-const (
-	serviceName     = "test.service"
-	serviceEndpoint = "Test.Endpoint"
+	"github.com/asim/go-micro/v3/errors"
+	"github.com/asim/go-micro/v3/registry"
+	"github.com/asim/go-micro/v3/selector"
 )
 
 func newTestRegistry() registry.Registry {
@@ -21,12 +16,12 @@ func newTestRegistry() registry.Registry {
 
 func TestCallAddress(t *testing.T) {
 	var called bool
-	service := serviceName
-	endpoint := serviceEndpoint
+	service := "test.service"
+	endpoint := "Test.Endpoint"
 	address := "10.1.10.1:8080"
 
 	wrap := func(cf CallFunc) CallFunc {
-		return func(_ context.Context, node *registry.Node, req Request, _ interface{}, _ CallOptions) error {
+		return func(ctx context.Context, node *registry.Node, req Request, rsp interface{}, opts CallOptions) error {
 			called = true
 
 			if req.Service() != service {
@@ -51,10 +46,7 @@ func TestCallAddress(t *testing.T) {
 		Registry(r),
 		WrapCall(wrap),
 	)
-
-	if err := c.Options().Selector.Init(selector.Registry(r)); err != nil {
-		t.Fatal("failed to initialize selector", err)
-	}
+	c.Options().Selector.Init(selector.Registry(r))
 
 	req := c.NewRequest(service, endpoint, nil)
 
@@ -66,6 +58,7 @@ func TestCallAddress(t *testing.T) {
 	if !called {
 		t.Fatal("wrapper not called")
 	}
+
 }
 
 func TestCallRetry(t *testing.T) {
@@ -76,11 +69,12 @@ func TestCallRetry(t *testing.T) {
 	var called int
 
 	wrap := func(cf CallFunc) CallFunc {
-		return func(_ context.Context, _ *registry.Node, _ Request, _ interface{}, _ CallOptions) error {
+		return func(ctx context.Context, node *registry.Node, req Request, rsp interface{}, opts CallOptions) error {
 			called++
 			if called == 1 {
 				return errors.InternalServerError("test.error", "retry request")
 			}
+
 			// don't do the call
 			return nil
 		}
@@ -90,13 +84,8 @@ func TestCallRetry(t *testing.T) {
 	c := NewClient(
 		Registry(r),
 		WrapCall(wrap),
-		Retry(RetryAlways),
-		Retries(1),
 	)
-
-	if err := c.Options().Selector.Init(selector.Registry(r)); err != nil {
-		t.Fatal("failed to initialize selector", err)
-	}
+	c.Options().Selector.Init(selector.Registry(r))
 
 	req := c.NewRequest(service, endpoint, nil)
 
@@ -119,7 +108,7 @@ func TestCallWrapper(t *testing.T) {
 	address := "10.1.10.1:8080"
 
 	wrap := func(cf CallFunc) CallFunc {
-		return func(_ context.Context, node *registry.Node, req Request, _ interface{}, _ CallOptions) error {
+		return func(ctx context.Context, node *registry.Node, req Request, rsp interface{}, opts CallOptions) error {
 			called = true
 
 			if req.Service() != service {
@@ -144,12 +133,9 @@ func TestCallWrapper(t *testing.T) {
 		Registry(r),
 		WrapCall(wrap),
 	)
+	c.Options().Selector.Init(selector.Registry(r))
 
-	if err := c.Options().Selector.Init(selector.Registry(r)); err != nil {
-		t.Fatal("failed to initialize selector", err)
-	}
-
-	err := r.Register(&registry.Service{
+	r.Register(&registry.Service{
 		Name:    service,
 		Version: "latest",
 		Nodes: []*registry.Node{
@@ -162,9 +148,6 @@ func TestCallWrapper(t *testing.T) {
 			},
 		},
 	})
-	if err != nil {
-		t.Fatal("failed to register service", err)
-	}
 
 	req := c.NewRequest(service, endpoint, nil)
 	if err := c.Call(context.Background(), req, nil); err != nil {

client/rpc_codec.go

@@ -4,17 +4,16 @@ import (
 	"bytes"
 	errs "errors"
 
-	"go-micro.dev/v5/codec"
-	raw "go-micro.dev/v5/codec/bytes"
-	"go-micro.dev/v5/codec/grpc"
-	"go-micro.dev/v5/codec/json"
-	"go-micro.dev/v5/codec/jsonrpc"
-	"go-micro.dev/v5/codec/proto"
-	"go-micro.dev/v5/codec/protorpc"
-	"go-micro.dev/v5/errors"
-	"go-micro.dev/v5/registry"
-	"go-micro.dev/v5/transport"
-	"go-micro.dev/v5/transport/headers"
+	"github.com/asim/go-micro/v3/codec"
+	raw "github.com/asim/go-micro/v3/codec/bytes"
+	"github.com/asim/go-micro/v3/codec/grpc"
+	"github.com/asim/go-micro/v3/codec/json"
+	"github.com/asim/go-micro/v3/codec/jsonrpc"
+	"github.com/asim/go-micro/v3/codec/proto"
+	"github.com/asim/go-micro/v3/codec/protorpc"
+	"github.com/asim/go-micro/v3/errors"
+	"github.com/asim/go-micro/v3/registry"
+	"github.com/asim/go-micro/v3/transport"
 )
 
 const (
@@ -29,7 +28,7 @@ func (e serverError) Error() string {
 	return string(e)
 }
 
-// errShutdown holds the specific error for closing/closed connections.
+// errShutdown holds the specific error for closing/closed connections
 var (
 	errShutdown = errs.New("connection is shut down")
 )
@@ -51,10 +50,8 @@ type readWriteCloser struct {
 }
 
 var (
-	// DefaultContentType header.
-	DefaultContentType = "application/json"
+	DefaultContentType = "application/protobuf"
 
-	// DefaultCodecs map.
 	DefaultCodecs = map[string]codec.NewCodec{
 		"application/grpc":         grpc.NewCodec,
 		"application/grpc+json":    grpc.NewCodec,
@@ -66,7 +63,7 @@ var (
 		"application/octet-stream": raw.NewCodec,
 	}
 
-	// TODO: remove legacy codec list.
+	// TODO: remove legacy codec list
 	defaultCodecs = map[string]codec.NewCodec{
 		"application/json":         jsonrpc.NewCodec,
 		"application/json-rpc":     jsonrpc.NewCodec,
@@ -87,7 +84,6 @@ func (rwc *readWriteCloser) Write(p []byte) (n int, err error) {
 func (rwc *readWriteCloser) Close() error {
 	rwc.rbuf.Reset()
 	rwc.wbuf.Reset()
-
 	return nil
 }
 
@@ -96,21 +92,20 @@ func getHeaders(m *codec.Message) {
 		if len(v) > 0 {
 			return v
 		}
-
 		return m.Header[hdr]
 	}
 
 	// check error in header
-	m.Error = set(m.Error, headers.Error)
+	m.Error = set(m.Error, "Micro-Error")
 
 	// check endpoint in header
-	m.Endpoint = set(m.Endpoint, headers.Endpoint)
+	m.Endpoint = set(m.Endpoint, "Micro-Endpoint")
 
 	// check method in header
-	m.Method = set(m.Method, headers.Method)
+	m.Method = set(m.Method, "Micro-Method")
 
 	// set the request id
-	m.Id = set(m.Id, headers.ID)
+	m.Id = set(m.Id, "Micro-Id")
 }
 
 func setHeaders(m *codec.Message, stream string) {
@@ -118,22 +113,21 @@ func setHeaders(m *codec.Message, stream string) {
 		if len(v) == 0 {
 			return
 		}
-
 		m.Header[hdr] = v
 	}
 
-	set(headers.ID, m.Id)
-	set(headers.Request, m.Target)
-	set(headers.Method, m.Method)
-	set(headers.Endpoint, m.Endpoint)
-	set(headers.Error, m.Error)
+	set("Micro-Id", m.Id)
+	set("Micro-Service", m.Target)
+	set("Micro-Method", m.Method)
+	set("Micro-Endpoint", m.Endpoint)
+	set("Micro-Error", m.Error)
 
 	if len(stream) > 0 {
-		set(headers.Stream, stream)
+		set("Micro-Stream", stream)
 	}
 }
 
-// setupProtocol sets up the old protocol.
+// setupProtocol sets up the old protocol
 func setupProtocol(msg *transport.Message, node *registry.Node) codec.NewCodec {
 	protocol := node.Metadata["protocol"]
 
@@ -143,7 +137,7 @@ func setupProtocol(msg *transport.Message, node *registry.Node) codec.NewCodec {
 	}
 
 	// processing topic publishing
-	if len(msg.Header[headers.Message]) > 0 {
+	if len(msg.Header["Micro-Topic"]) > 0 {
 		return nil
 	}
 
@@ -155,59 +149,60 @@ func setupProtocol(msg *transport.Message, node *registry.Node) codec.NewCodec {
 		msg.Header["Content-Type"] = "application/proto-rpc"
 	}
 
+	// now return codec
 	return defaultCodecs[msg.Header["Content-Type"]]
 }
 
-func newRPCCodec(req *transport.Message, client transport.Client, c codec.NewCodec, stream string) codec.Codec {
+func newRpcCodec(req *transport.Message, client transport.Client, c codec.NewCodec, stream string) codec.Codec {
 	rwc := &readWriteCloser{
 		wbuf: bytes.NewBuffer(nil),
 		rbuf: bytes.NewBuffer(nil),
 	}
-
-	return &rpcCodec{
+	r := &rpcCodec{
 		buf:    rwc,
 		client: client,
 		codec:  c(rwc),
 		req:    req,
 		stream: stream,
 	}
+	return r
 }
 
-func (c *rpcCodec) Write(message *codec.Message, body interface{}) error {
+func (c *rpcCodec) Write(m *codec.Message, body interface{}) error {
 	c.buf.wbuf.Reset()
 
 	// create header
-	if message.Header == nil {
-		message.Header = map[string]string{}
+	if m.Header == nil {
+		m.Header = map[string]string{}
 	}
 
 	// copy original header
 	for k, v := range c.req.Header {
-		message.Header[k] = v
+		m.Header[k] = v
 	}
 
 	// set the mucp headers
-	setHeaders(message, c.stream)
+	setHeaders(m, c.stream)
 
 	// if body is bytes Frame don't encode
 	if body != nil {
 		if b, ok := body.(*raw.Frame); ok {
 			// set body
-			message.Body = b.Data
+			m.Body = b.Data
 		} else {
 			// write to codec
-			if err := c.codec.Write(message, body); err != nil {
+			if err := c.codec.Write(m, body); err != nil {
 				return errors.InternalServerError("go.micro.client.codec", err.Error())
 			}
 			// set body
-			message.Body = c.buf.wbuf.Bytes()
+			m.Body = c.buf.wbuf.Bytes()
 		}
 	}
 
 	// create new transport message
 	msg := transport.Message{
-		Header: message.Header,
-		Body:   message.Body,
+		Header: m.Header,
+		Body:   m.Body,
 	}
 
 	// send the request
@@ -218,7 +213,7 @@ func (c *rpcCodec) Write(message *codec.Message, body interface{}) error {
 	return nil
 }
 
-func (c *rpcCodec) ReadHeader(msg *codec.Message, r codec.MessageType) error {
+func (c *rpcCodec) ReadHeader(m *codec.Message, r codec.MessageType) error {
 	var tm transport.Message
 
 	// read message from transport
@@ -230,13 +225,13 @@ func (c *rpcCodec) ReadHeader(msg *codec.Message, r codec.MessageType) error {
 	c.buf.rbuf.Write(tm.Body)
 
 	// set headers from transport
-	msg.Header = tm.Header
+	m.Header = tm.Header
 
 	// read header
-	err := c.codec.ReadHeader(msg, r)
+	err := c.codec.ReadHeader(m, r)
 
 	// get headers
-	getHeaders(msg)
+	getHeaders(m)
 
 	// return header error
 	if err != nil {
@@ -257,23 +252,15 @@ func (c *rpcCodec) ReadBody(b interface{}) error {
 	if err := c.codec.ReadBody(b); err != nil {
 		return errors.InternalServerError("go.micro.client.codec", err.Error())
 	}
-
 	return nil
 }
 
 func (c *rpcCodec) Close() error {
-	if err := c.buf.Close(); err != nil {
-		return err
-	}
-
-	if err := c.codec.Close(); err != nil {
-		return err
-	}
-
+	c.buf.Close()
+	c.codec.Close()
 	if err := c.client.Close(); err != nil {
 		return errors.InternalServerError("go.micro.client.transport", err.Error())
 	}
-
 	return nil
 }