feat: update out of date docs (#2520)

* feat: redis implementation of cache

* Revert "feat: redis implementation of cache"

This reverts commit 4b3f25c1fc494d934613992d8a762024fafad7b6.

* feat: update out of date docs

.github/FUNDING.yml

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

.github/ISSUE_TEMPLATE/bug_report.md

@@ -0,0 +1,24 @@
+---
+name: Bug report
+about: For reporting bugs in go-micro
+title: "[BUG]"
+labels: ''
+assignees: ''
+
+---
+
+**Describe the bug**
+
+1. What are you trying to do?
+2. What did you expect to happen?
+3. What happens instead?
+
+**How to reproduce the bug:**
+
+If possible, please include a minimal code snippet here.
+
+**Environment:**
+Go Version: please paste `go version` output here
+```
+please paste `go env` output here
+```

.github/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/question.md

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

.github/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.17
+      uses: actions/setup-go@v1
+      with:
+        go-version: 1.17
+      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.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.17
+      uses: actions/setup-go@v1
+      with:
+        go-version: 1.17
+      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 ./...
+

.gitignore

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

.travis.yml

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

CHANGELOG.md

@@ -0,0 +1,774 @@
+# 4.7.0 (2022/05/19)
+
+### Features
+
+- remove unused variable in loop (#2495)
+- option to disable file watcher (#2485)
+- Support direct generation of grpc method (#2474)
+- remove cli
+- remove dashboard
+- Remove examples
+- Add header suppor for Kafka broker plugin; (#2470)
+- Fix codec/bytes (#2466)
+- Add Wait option support for sync/etcd plugins (#2459)
+- #2453 Fix with associated test update (#2454)
+- style:arrays pre-allocation (#2449)
+- Bump github.com/nats-io/nats-server/v2 in /plugins/events/natsjs (#2447)
+- add NATS JetStream events plugin (#2433)
+- add tls option for sync etcd plugin (#2440)
+- add new services
+
+### Bug Fixes
+
+- fix: consume and publish blocked after rabbitmq reconnecting (#2492)
+- typo fix; (#2480)
+- fix https://github.com/asim/go-micro/issues/2344 (#2462)
+- fix natsjs syntax error, remove TODOs and enable tests (#2446)
+- http transport deadlock (#2441)
+- Support for `-micro_out=module=<module_prefix>` for protoc-gen-micro (#2435)
+
+# 4.6.0 (2022/02/08)
+
+### Features
+
+- add service updates (#2418)
+- Add files via upload
+- default the content type to json (#2412)
+- Add Kafka asynchronous send support (#2409)
+- use read lock and unlock instead of write ones (#2410)
+- move the api client
+- Update client_test.go
+- switch services client
+- remove the client
+- add service interfaces
+- [FEATURE] add changelog (#2400)
+- nats config plugin (#2397)
+- Update and rename m3o.go to services.go
+- Update services/ (#2392)
+
+### Bug Fixes
+
+- fix client
+- fix context value nil (#2391)
+
+# 4.5.0 (2021/12/19)
+
+### Bug Fixes
+
+- nats deregister issue (#2384)
+- fixing f.IsExported undefined issue (#2382)
+- fix http_transport Recv and Close race condition on buff (#2374)
+- update protoc-gen-micro install doc
+- zookeeper registry delete event (#2372)
+- delete redundant lines (#2364)
+- modify the dependencies urls (#2363)
+- ignore unexported field (#2354)
+- Fix Micro CLI's proto comments (#2353)
+
+### Features
+
+- Extend client mock with ability to test publish, and a few useful method like SetResponse and SetSubscriber (#2375)
+- go micro dashboard (#2361)
+
+# 4.4.0 (2021/11/11)
+
+### Bug Fixes
+
+- fix(#2333): etcd grpc marshal issue (#2334)
+
+### Features
+
+- upgrade to go 1.17 (#2346)
+- add nats and redis events plugins
+- add events package (#2341)
+
+# 4.3.0 (2021/11/01)
+
+### Bug Fixes
+
+- flatten cli (#2332)
+- m3o client changed
+- use vanity url for cli command
+- fix broker nsq plugin nil pointer error (#2329)
+- fix config json slice parsing (#2330)
+- replace ioutil with io and os (#2327)
+- fixing #2308 (#2326)
+- Fix Micro CLI by removing replace line in go.mod
+- remove unnecessary dependencies between plugins
+- 1. use default memory registry in grpc plugins (#2317)
+- Add update rule to Makefile (#2315)
+- Plugins (#2311)
+
+### Features
+
+- Rename gomu to micro (#2325)
+- stream CloseSend (#2323)
+- strip protoc-gen-micro go mod
+
+### BREAKING CHANGES
+
+- go install go-micro.dev/v4/cmd/micro@v4
+- go install go-micro.dev/v4/cmd/protoc-gen-micro@v4
+- upgrade go micro to support stream.CloseSend
+
+# 4.2.1 (2021/10/14)
+
+### Bug Fixes
+
+- fix gomu.
+
+# 4.2.0 (2021/10/13)
+
+### Bug Fixes
+
+- fix examples go mod.
+- update go sums.
+- move to go-micro.dev.
+- upgrade protoc-gen-micro to v4.
+
+# 4.1.0 (2021/10/12)
+
+- v4.1.0.
+
+# 4.0.0 (2021/10/12)
+
+### Features
+
+- Vanity URL go-micro.dev([#2271](https://github.com/asim/go-micro/issues/2271)).
+
+### BREAKING CHANGES
+
+- upgrade github.com/asim/go-micro/v3 to go-micro.dev/v4.
+
+# 3.7.0 (2021/10/11)
+
+- Add latest version (#2303).
+
+# 3.6.0 (2021/08/23)
+
+- Minor fixes https://github.com/asim/go-micro/compare/v3.5.2...c7195aae9817db4eaf5483990fcb8706f86d3002.
+
+# 3.5.2 (2021/07/06)
+
+- Tag it and bag it.
+
+# 3.5.1 (2021/04/20)
+
+- Minor bug fixes.
+
+# 3.5.0 (2021/01/29)
+
+- kill the bugs.
+
+# 3.0.1 (2021/01/20)
+
+- Tag with protoc changes.
+
+# 3.0.0 (2021/01/20)
+
+- V3.
+
+### BREAKING CHANGES
+
+- upgrade github.com/micro/go-micro/v2 to github.com/asim/go-micro/v3.
+- change default transport from gRPC to mucp, using grpc server/client plugins.
+
+# 3.0.0-beta.3 (2020/09/29)
+
+- Secret implementation of config. Supporting config merge (#2027)
+- remove transport options
+- read service package (#2026)
+- env config implementation (#2024)
+- runtime: remove builder package (moved to micro) (#2023)
+- Fix branch names support for k8s runtime (#2020)
+- fix config bug (#2021)
+- runtime: minor fixes for local runtime (#2019)
+- remove memcache and update gomod
+- Add errors to config methods (#2015)
+- store/file: fix segmentation violation bug (#2013)
+- Config interface change (#2010)
+- proxy/grpc: fix client streaming bug (EOF not sent to the server) (#2011)
+- client/grpc: fix stream closed bug (#2009)
+- store/file: don't keep connection to boltdb open (#2006)
+- runtime/builder with golang implementation (#2003)
+- store: implement s3 blob store (#2005)
+- store: add blob interface with file implementation (#2004)
+- auth: remove micro specific code (#1999)
+- Fix running subfolders (#1998)
+- api: fix request body re-sequencing bug (#1996)
+- add Name to auth.Account as a user friendly alias (#1992)
+- Fixing top level run outside repo (#1993)
+- runtime: normalised service statuses (#1994)
+- Add 'Namespace' header to allowed CORS headers (#1990)
+- Remove all the external plugins except grpc (#1988)
+- util/kubernetes: fix TCPSocketAction bug (#1987)
+- Fixing the metric tagging issue here (#1986).
+
+# 3.0.0-beta.2 (2020/09/05)
+
+- Cut a v3 beta 2.
+
+# 3.0.0-beta (2020/08/12)
+
+- write nil when expiry is zero.
+
+# 3.0.0-alpha (2020/07/27)
+
+- v3 refactor (#1868).
+
+# 2.9.1 (2020/07/03)
+
+- push tags to docker hub (#1766).
+
+# 2.9.0 (2020/06/12)
+
+- Fix regex detection. Fixes #1663 (#1696).
+
+# 2.9.0-rc5 (2020/06/11)
+
+- Merge branch 'master' into release-2.9.0.
+
+# 2.9.0-rc4 (2020/06/11)
+
+- Merge branch 'master' into release-2.9.0.
+
+# 2.9.0-rc1 (2020/06/11)
+
+- Merge branch 'master' into release-2.9.0.
+
+# 2.8.0 (2020/05/31)
+
+- Rewrite Auth interface to use Rules
+- Add Cache interface into the Client for request caching
+- Fix atomic sequence updates in Client
+- Update go mod deps
+- Fix ipv6 parsing in mdns registry
+- Add namespacing to the default runtime
+- Replace go-git with v5
+- Increase register ttl to 90 seconds.
+
+# 2.7.0 (2020/05/18)
+
+- Fix the rpc handler json rpc body parsing
+- Use caddyserver/certmagic instead of mholt
+- Add HasRole to Account
+- Add jwt refresh token generation
+- Fix rpc stream close locking race
+- Add auth namespace env var
+- Strip the router penalty code
+- Add file upload util
+- Fix killing processes in runtime
+- Pass namespace to runtime commands
+- Generate account on start
+- Check errors in cockroachdb.
+
+# 2.6.0 (2020/05/04)
+
+- Fix discord bot authentication header
+- Improve api rpc regexp matching
+- Change auth account access via context
+- Create a jwt implementation of auth
+- Fix grpc content-type encoding bug
+- Consolidate proxy/network env var logic
+- Change secrets interface naming
+- Log file path in the logger
+- Change location of network resolver
+- Add Store to service options
+- Fix default runtime log parsing
+- Add namespace checks to k8s runtime
+- Add proper git checkout in local runtime
+- Add database/table options for store
+- Add pki implementation
+- Import qson.
+
+# 2.5.0 (2020/04/15)
+
+- api/router/registry: extract path based parameters from url to req (#1530).
+
+# 2.4.0 (2020/03/31)
+
+- There can be only one! (#1445).
+
+# 2.3.0 (2020/03/17)
+
+- grpc client/server fixes (#1355).
+
+# 2.2.0 (2020/02/28)
+
+- Rename Auth Validate to Verify
+- Replaces noop auth with base32 generated tokens
+- Change Excludes to Exclude
+- Add token option to auth
+- Add profile option and flags for debug
+- Add config loading for auth token
+- Move before start to before listening.
+
+# 2.1.2 (2020/02/24)
+
+- fix router panic (#1254).
+
+# 2.1.1 (2020/02/23)
+
+- update go modules (#1240).
+
+# 2.1.0 (2020/02/13)
+
+- Exclude Stats & Trace from Auth (#1192).
+
+# 2.0.0 (2020/01/30)
+
+- v2 release.
+
+# 1.18.0 (2019/12/08)
+
+- Add golang ci linter
+- Add race detection to travis
+- Please the linter
+- Do some perf optimisations on slice alloc
+- Move http broker to use single entry in registry
+- Strip the grpc metadata filtering
+- Strip the old codec usage
+- Disable retries in client when MICRO_PROXY is enabled
+- Strip old X-Micro headers
+- Add debug/log streaming implementations
+- Add first debug/log interface
+- Huge network/tunnel refactor to fix bugs
+- Fix proxy slice allocation bug
+- Splay out some of the network events
+- Default to AdvertiseLocal for router
+- Add runtime filtering with Type
+- Remove SIGKILL processing.
+
+# 1.17.1 (2019/11/27)
+
+- fix rpc server go routine leak
+- add a psuedo socket pool
+- update debug buffer to return entries.
+
+# 1.17.0 (2019/11/27)
+
+- Add github related issue templates
+- Add Dockerfile for predownloaded go-micro source
+- Regenerate all the protos to move to \*.pb.micro.go
+- Fix api handler to parse text/plain as default content type
+- Fix event handler to allow GET requests
+- Change http broker ids to go.micro.http.broker-uuid
+- Require protocol field in metadata to query services via client
+- Process raw frames in call to Publish
+- Complete proxy support for processing messages
+- Proxy support for publishing of messages
+- Fix grpc connection leak by always closing the connection
+- Add a debug ring buffer
+- Add broker to tunnel and network
+- Force network dns resolver to use cloudflare 1.0.0.1
+- Add option to specify whether server should handle signalling
+- Change mdns request timeout to 10ms rather than 100ms
+- Add router AdvertiseNone and AdvertiseLocal strategies
+- Rename runtime packager to builder
+- Add full support for a kubernetes runtime.
+
+# 1.16.0 (2019/11/09)
+
+- Pre-make slices for perf optimisation
+- Add runtime flag and k8s runtime
+- Add debug/profile for pprof profiling
+- Reduce go routines in mdns registry and registry cache
+- Optimise the router flap detection.
+
+# 1.15.1 (2019/11/03)
+
+- Router recovery penalty should be below 500.
+
+# 1.15.0 (2019/11/03)
+
+- go fmt -s
+- web generate service on registration
+- downgrade some network messages to trace
+- fix tunnel panic on deleting link
+- add postgres store
+- change grpc recover logging
+- add runtime service
+- add kubernetes runtime
+- add runtime notifier
+- proxy add header based routing for Micro-{Gateway, Router, Network}
+- network hash address based on service + node id
+- metadata add mergecontext function.
+
+# 1.14.0 (2019/10/25)
+
+- Remove consul registry
+- Change store Sync endpoint to List
+- Remove cloudflare-go usage in store
+- Add non-backwards compatible link changes.
+
+# 1.13.2 (2019/10/22)
+
+- Fix proxy selection to use round robin strategy.
+
+# 1.13.1 (2019/10/19)
+
+- Fix divide by zero bug in broker.
+
+# 1.13.0 (2019/10/18)
+
+- Fix network recursive read lock bug
+- Add certmagic random pull time
+- Strip http broker topic: prefix.
+
+# 1.12.0 (2019/10/17)
+
+- Add ACME Provider interface
+- Implement certmagic ACME Provider
+- Add certmagic Store implementation
+- Add broker service implementation
+- Add ability to set grpc dial and call options
+- Add etcd registry and other plugins
+- Add Network.Connect rpc endpoint
+- Resolve network node dns names
+- Support Network.Routes querying
+- Fix caching registry bugs
+- Move gossip registry to go-plugins
+- Add router advertise strategy
+- Add Cloudflare store implementation
+- Add store service implementation.
+
+# 1.11.3 (2019/10/12)
+
+- Fix the quic-go checksum mismatch by updating to 0.12.1.
+
+# 1.11.2 (2019/10/12)
+
+- Fix cache error check.
+
+# 1.11.1 (2019/10/07)
+
+- Fix cache registry deadlocking bug.
+
+# 1.11.0 (2019/10/01)
+
+- This is likely the last release of v1.
+
+# 1.10.0 (2019/09/11)
+
+- Add grpc client code application/grpc content-type
+- Move client to use stream dialer
+- Add network implementation
+- Add dynamic plugin loading
+- Add multilink usage in proxy
+- Add registry implementation
+- Scope mdns to .micro domain
+- Support grpc server processing by default
+- Add tunnel broker.
+
+# 1.9.1 (2019/08/19)
+
+- Fix waitgroup race condition.
+
+# 1.9.0 (2019/08/19)
+
+- Fix grpc codec for broker publishing
+- Use the connection pool for streaming
+- Send EOS from client when closing stream
+- Add stream header to mucp protocol
+- Add stream multiplexing in the server
+- Fix watcher bug in file config source
+- Fix monitoring watcher to only look at mucp services
+- Only check router status on lookup failure
+- Fix proxy streaming and client request processing
+- Fix host:port processing for messaging systems
+- Add start method to the router
+- Fix router race condition for default values
+- Add loopback detection to the tunnel
+- Add connection retry logic to tunnel
+- Make log levels accessible for the logger
+- Add proxy muxer for internal calls.
+
+# 1.8.3 (2019/08/12)
+
+- Fix nats draining
+- More verbose selector errors to return service name
+- Move handler debug package
+- Add a monitoring package
+- Fix consul address parsing
+- Fix server extraction code
+- Add tunnel implementation
+- Add util log level
+- Add util io package to wrap transport socket.
+
+# 1.8.2 (2019/08/06)
+
+- Point release for micro
+- Adds travis caching
+- Removes unused network code
+- Adds tunnel interface
+- Consul agent check
+- Router handler interface
+- Non host:port fixes.
+
+# 1.8.1 (2019/07/31)
+
+- Use mdns 0.2.0 release tag.
+
+# 1.8.0 (2019/07/29)
+
+- Move the selector into client
+- Change broker.Publication to broker.Event
+- Move cmd into config
+- Enable default json processing in api
+- Remove port from registry
+- Memory broker/transport race fixes
+- GRPC codec fix
+- Client pool interface
+- Router interface/service implementations
+- Config decoding fixes
+- Memory store expiration fix
+- Network link/tunnel/resolver packages
+- Proxy router caching
+- Registry util functions.
+
+# 1.7.0 (2019/06/21)
+
+- Update go mod
+- Move mock data out of memory registry
+- wrap the grpc codecs to support framing
+- change grpc resolution to use service.method
+- support full proxying via grpc
+- add text codec
+- move data/store
+- add network interface
+- add router package and implementation
+- move options to config/options
+- send gossip updates on register/deregister
+- fix node add/del bug
+- add handler wrapper back into core router.
+
+# 1.6.0 (2019/06/07)
+
+- Massive go.mod dependency cleanup _ Moved etcd, memcache, redis sync things to go-plugins _ uuid to google uuid \* blew away go.mod
+- Add better proxy interface and features
+- Add new options interface.
+
+# 1.5.0 (2019/06/05)
+
+- Fix go mod issues.
+
+# 1.4.0 (2019/06/04)
+
+- Final consolidation of all libraries.
+
+# 1.3.1 (2019/06/03)
+
+- Fix broken pipe bug. Don't send message when client closed connection..
+
+# 1.3.0 (2019/05/31)
+
+- The great rewrite.
+
+# 1.2.0 (2019/05/22)
+
+- Update go mod
+- Fix mock client
+- Fix retries logic
+- Fix consul api change
+- Use consul client for watcher
+- Fix gossip data races
+- Add registry check function.
+
+# 1.1.0 (2019/03/28)
+
+- Update go mod
+- Fix endpoint extractor generation.
+
+# 1.0.0 (2019/03/05)
+
+- 1.0.0 release.
+
+# 0.27.1 (2019/03/05)
+
+- Fix nil consul client.
+
+# 0.27.0 (2019/02/23)
+
+- Remove buff check in http transport
+- Change default version to latest
+- Add exchange routing
+- Update go modules.
+
+# 0.26.1 (2019/02/13)
+
+- Fix gossip registry
+- Update go modules for rcache.
+
+# 0.26.0 (2019/02/13)
+
+- Update go modules
+- Add gossip registry rejoin
+- Move selector to rcache.
+
+# 0.25.0 (2019/02/04)
+
+- Add server request body.
+
+# 0.24.1 (2019/02/01)
+
+- Various bug fixes
+- Backwards compatible with 0.14 and older
+- Fix mdns and gossip race conditions
+- Use official h2c server
+- Enable support for MICRO_PROXY.
+
+# 0.24.0 (2019/01/30)
+
+- Add go mod.
+
+# 0.23.0 (2019/01/29)
+
+- Move headers from X-Micro to Micro
+- Remove Register/Deregister methods from server
+- Move register_interval to be internal
+- Add subscriber context option.
+
+# 0.22.1 (2019/01/22)
+
+- Fix broken error handling
+- now returns error from ServeRequest router.
+
+# 0.22.0 (2019/01/18)
+
+- Address backwards compatibility.
+
+# 0.21.0 (2019/01/17)
+
+- Make MDNS the default registry
+- Move mocks to be memory implementations
+- Add metadata.Copy function.
+
+# 0.20.0 (2019/01/14)
+
+- BREAKING CHANGES.
+
+# 0.17.0 (2019/01/03)
+
+- Offline inbox for http broker
+- JSON/Proto/GRPC codecs
+- HTTP proxy from environment.
+
+# 0.16.0 (2018/12/29)
+
+- Fix cache/gossip data race
+- Rename cache selector to registry.
+
+# 0.15.1 (2018/12/18)
+
+- Selector cache lookup optimization.
+
+# 0.15.0 (2018/12/13)
+
+- Public NewSubscribeOptions
+- http2 broker support
+- Timeout error function
+- Consul Query Options
+- Gossip registry
+- RPC Codec renaming.
+
+# 0.14.1 (2018/11/22)
+
+- bug fix socket headers.
+
+# 0.14.0 (2018/11/21)
+
+- use google uuid
+- add http handler option.
+
+# 0.13.0 (2018/11/15)
+
+- add local/remote ip methods
+- various linting things
+- get checks on 0 ttl
+- accept loop.
+
+# 0.12.0 (2018/10/09)
+
+- reorder server flag
+- atomic increment sequence
+- new error method.
+
+# 0.11.0 (2018/08/24)
+
+- Support Consul Connect registration
+- Add/Use Init for initialisation from cmd.
+
+# 0.10.0 (2018/07/26)
+
+- Fix broker locking
+- Add RetryOnError as default retry policy
+- Fix mock client reflection
+- Support dialtimeout only above 0
+- Add verbose client errors
+- Allow client retries to be 0.
+
+# 0.9.0 (2018/06/09)
+
+- Reset server address on shutdown
+- Set default pool size to 1
+- Support reinitialising connection pool
+- Set retries to 1 by default
+- Return error for subscribers.
+
+# 0.8.0 (2018/04/20)
+
+- Rework of interfaces.
+
+# 0.7.0 (2018/04/10)
+
+- Move misc to util package
+- Add register ttl and interval flags
+- Fix protoc-gen-micro example.
+
+# 0.6.0 (2018/04/05)
+
+- Add consul TCP check
+- Atomic increment rpc stream sequence.
+
+# 0.5.0 (2018/03/04)
+
+- Support consul services without version
+- Switch to stdlib context.
+
+# 0.4.0 (2018/02/19)
+
+- Add WatchOption which allows filtering by service
+- Add Options method to registry
+- Add Conflict error
+- Only watch selected services in cache.
+
+# 0.3.0 (2018/01/02)
+
+- https support for consul
+- subscriber deadlock fix
+- selector top level option.
+
+# 0.2.0 (2017/10/29)
+
+- Performance improvements.
+
+# 0.1.4 (2017/09/04)
+
+- sort handler/subscriber endpoints
+- pass options to new subscriber.
+
+# 0.1.3 (2017/08/15)
+
+- Bug fix nil consul http client.
+
+# 0.1.2 (2017/07/20)
+
+- respond when codec errors out.
+
+# 0.1.1 (2017/06/12)
+
+- Fix potential panic/waitgroup bug.
+
+# 0.1.0 (2017/06/12)
+
+- Initial release.

README.md

@@ -1,459 +1,98 @@
-# Go Micro [![License](https://img.shields.io/:license-apache-blue.svg)](https://opensource.org/licenses/Apache-2.0) [![GoDoc](https://godoc.org/github.com/micro/go-micro?status.svg)](https://godoc.org/github.com/micro/go-micro) [![Travis CI](https://api.travis-ci.org/micro/go-micro.svg?branch=master)](https://travis-ci.org/micro/go-micro) [![Go Report Card](https://goreportcard.com/badge/micro/go-micro)](https://goreportcard.com/report/github.com/micro/go-micro)
+# Go Micro [![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/go-micro.dev/v4?tab=doc) [![Community](https://img.shields.io/:community-projects-orange.svg)](https://github.com/go-micro)
 
-Go Micro is a pluggable RPC framework for distributed systems development.
 
-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. It comes with built in support for {json,proto}-rpc encoding, consul or multicast dns for service discovery, http for communication and random hashed client side load balancing.
+Go Micro is a framework for distributed systems development.
 
-Plugins are available at [github.com/micro/go-plugins](https://github.com/micro/go-plugins).
+## Overview
 
-Follow us on [Twitter](https://twitter.com/microhq) or join the [Slack](http://slack.micro.mu/) community.
+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.
 
 ## Features
 
 Go Micro abstracts away the details of distributed systems. Here are the main features.
 
-- **Service Discovery** - Automatic service registration and name resolution
-- **Load Balancing** - Client side load balancing built on discovery
-- **Message Encoding** - Dynamic encoding based on content-type with protobuf and json support
-- **Sync Streaming** - RPC based communication with support for bidirectional streaming
-- **Async Messaging** - Native PubSub messaging built in for event driven architectures
+- **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.
 
-Go Micro supports both the Service and Function programming models. Read on to learn more.
+- **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.
 
-## Docs
+- **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.
 
-For more detailed information on the architecture, installation and use of go-micro checkout the [docs](https://micro.mu/docs).
+- **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.
 
-## Learn By Example
+- **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.
 
-An example service can be found in [**examples/service**](https://github.com/micro/examples/tree/master/service) and function in [**examples/function**](https://github.com/micro/examples/tree/master/function). 
+- **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.
 
-The [**examples**](https://github.com/micro/examples) directory contains examples for using things such as middleware/wrappers, selector filters, pub/sub, grpc, plugins and much more. For the complete greeter example look at [**examples/greeter**](https://github.com/micro/examples/tree/master/greeter). Other examples can be found throughout the GitHub repository.
+- **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.
 
-Watch the [Golang UK Conf 2016](https://www.youtube.com/watch?v=xspaDovwk34) video for a high level overview.
+- **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.
 
-## Getting started
+- **Event Streaming** - PubSub is great for async notifications but for more advanced use cases event streaming is preferred. Offering
+  persistent storage, consuming from offsets and acking. Go Micro includes support for NATS Jetstream and Redis streams.
 
-- [Install Protobuf](#install-protobuf)
-- [Service Discovery](#service-discovery)
-- [Writing a Service](#writing-a-service)
-- [Writing a Function](#writing-a-function)
-- [Publish & Subscribe](#publish--subscribe)
-- [Plugins](#plugins)
-- [Wrappers](#wrappers)
+- **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.
 
-## Install Protobuf
+- **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.
 
-Protobuf is required for code generation
+## Getting Started
 
-You'll need to install:
+To make use of Go Micro
 
-- [protoc-gen-micro](https://github.com/micro/protoc-gen-micro)
+```golang
+import "go-micro.dev/v4"
 
-## Service Discovery
-
-Service discovery is used to resolve service names to addresses. 
-
-### Consul
-
-[Consul](https://www.consul.io/) is used as the default service discovery system. 
-
-Discovery is pluggable. Find plugins for etcd, kubernetes, zookeeper and more in the [micro/go-plugins](https://github.com/micro/go-plugins) repo.
-
-[Install guide](https://www.consul.io/intro/getting-started/install.html)
-
-### Multicast DNS
-
-[Multicast DNS](https://en.wikipedia.org/wiki/Multicast_DNS) is a built in service discovery plugin for a zero dependency configuration. 
-
-Pass `--registry=mdns` to any command or the enviroment variable `MICRO_REGISTRY=mdns`
-
-```
-MICRO_REGISTRY=mdns go run main.go
-```
-
-## Writing a service
-
-This is a simple greeter RPC service example
-
-Find this example at [examples/service](https://github.com/micro/examples/tree/master/service).
-
-### Create service proto
-
-One of the key requirements of microservices is strongly defined interfaces. Micro uses protobuf to achieve this.
-
-Here we define the Greeter handler with the method Hello. It takes a HelloRequest and HelloResponse both with one string arguments.
-
-```proto
-syntax = "proto3";
-
-service Greeter {
-	rpc Hello(HelloRequest) returns (HelloResponse) {}
-}
-
-message HelloRequest {
-	string name = 1;
-}
-
-message HelloResponse {
-	string greeting = 2;
-}
-```
-
-### Generate the proto
-
-After writing the proto definition we must compile it using protoc with the micro plugin.
-
-```shell
-protoc --proto_path=$GOPATH/src:. --micro_out=. --go_out=. path/to/greeter.proto
-```
-
-### Write the service
-
-Below is the code for the greeter service. 
-
-It does the following:
-
-1. Implements the interface defined for the Greeter handler
-2. Initialises a micro.Service
-3. Registers the Greeter handler
-4. Runs the service
-
-```go
-package main
-
-import (
-	"context"
-	"fmt"
-
-	micro "github.com/micro/go-micro"
-	proto "github.com/micro/examples/service/proto"
-)
-
-type Greeter struct{}
-
-func (g *Greeter) Hello(ctx context.Context, req *proto.HelloRequest, rsp *proto.HelloResponse) error {
-	rsp.Greeting = "Hello " + req.Name
-	return nil
-}
-
-func main() {
-	// Create a new service. Optionally include some options here.
-	service := micro.NewService(
-		micro.Name("greeter"),
-	)
-
-	// Init will parse the command line flags.
-	service.Init()
-
-	// Register handler
-	proto.RegisterGreeterHandler(service.Server(), new(Greeter))
-
-	// Run the server
-	if err := service.Run(); err != nil {
-		fmt.Println(err)
-	}
-}
-```
-
-### Run service
-```
-go run examples/service/main.go
-```
-
-Output
-```
-2016/03/14 10:59:14 Listening on [::]:50137
-2016/03/14 10:59:14 Broker Listening on [::]:50138
-2016/03/14 10:59:14 Registering node: greeter-ca62b017-e9d3-11e5-9bbb-68a86d0d36b6
-```
-
-### Define a client
-
-Below is the client code to query the greeter service. 
-
-The generated proto includes a greeter client to reduce boilerplate code.
-
-```go
-package main
-
-import (
-	"context"
-	"fmt"
-
-	micro "github.com/micro/go-micro"
-	proto "github.com/micro/examples/service/proto"
-)
-
-
-func main() {
-	// Create a new service. Optionally include some options here.
-	service := micro.NewService(micro.Name("greeter.client"))
-	service.Init()
-
-	// Create new greeter client
-	greeter := proto.NewGreeterService("greeter", service.Client())
-
-	// Call the greeter
-	rsp, err := greeter.Hello(context.TODO(), &proto.HelloRequest{Name: "John"})
-	if err != nil {
-		fmt.Println(err)
-	}
-
-	// Print response
-	fmt.Println(rsp.Greeting)
-}
-```
-
-### Run the client
-
-```shell
-go run client.go
-```
-
-Output
-```
-Hello John
-```
-
-## Writing a Function
-
-Go Micro includes the Function programming model. 
-
-A Function is a one time executing Service which exits after completing a request. 
-
-### Defining a Function
-
-```go
-package main
-
-import (
-	"context"
-
-	proto "github.com/micro/examples/function/proto"
-	"github.com/micro/go-micro"
-)
-
-type Greeter struct{}
-
-func (g *Greeter) Hello(ctx context.Context, req *proto.HelloRequest, rsp *proto.HelloResponse) error {
-	rsp.Greeting = "Hello " + req.Name
-	return nil
-}
-
-func main() {
-	// create a new function
-	fnc := micro.NewFunction(
-		micro.Name("greeter"),
-	)
-
-	// init the command line
-	fnc.Init()
-
-	// register a handler
-	fnc.Handle(new(Greeter))
-
-	// run the function
-	fnc.Run()
-}
-```
-
-It's that simple.
-
-## Publish & Subscribe
-
-Go-micro has a built in message broker interface for event driven architectures.
-
-PubSub operates on the same protobuf generated messages as RPC. They are encoded/decoded automatically and sent via the broker. 
-By default go-micro includes a point-to-point http broker but this can be swapped out via go-plugins.
-
-### Publish
-
-
-Create a new publisher with a `topic` name and service client
-
-```go
-p := micro.NewPublisher("events", service.Client())
-```
-
-Publish a proto message
-
-```go
-p.Publish(context.TODO(), &proto.Event{Name: "event"})
-```
-
-### Subscribe
-
-Create a message handler. It's signature should be `func(context.Context, v interface{}) error`.
-
-```go
-func ProcessEvent(ctx context.Context, event *proto.Event) error {
-	fmt.Printf("Got event %+v\n", event)
-	return nil
-}
-```
-
-Register the message handler with a `topic`
-
-```go
-micro.RegisterSubscriber("events", ProcessEvent)
-```
-
-See [examples/pubsub](https://github.com/micro/examples/tree/master/pubsub) for a complete example.
-
-## Plugins
-
-By default go-micro only provides a few implementation of each interface at the core but it's completely pluggable. There's already dozens of plugins which are available at [github.com/micro/go-plugins](https://github.com/micro/go-plugins). Contributions are welcome!
-
-### Build with plugins
-
-If you want to integrate plugins simply link them in a separate file and rebuild
-
-Create a plugins.go file
-
-```go
-import (
-        // etcd v3 registry
-        _ "github.com/micro/go-plugins/registry/etcdv3"
-        // nats transport
-        _ "github.com/micro/go-plugins/transport/nats"
-        // kafka broker
-        _ "github.com/micro/go-plugins/broker/kafka"
-)
-```
-
-Build binary
-
-```shell
-// For local use
-go build -i -o service ./main.go ./plugins.go
-```
-
-Flag usage of plugins
-```shell
-service --registry=etcdv3 --transport=nats --broker=kafka
-```
-
-### Plugin as option
-
-Alternatively you can set the plugin as an option to a service
-
-```go
-
-import (
-        "github.com/micro/go-micro" 
-        // etcd v3 registry
-        "github.com/micro/go-plugins/registry/etcdv3"
-        // nats transport
-        "github.com/micro/go-plugins/transport/nats"
-        // kafka broker
-        "github.com/micro/go-plugins/broker/kafka"
-)
-
-func main() {
-	registry := etcdv3.NewRegistry()
-	broker := kafka.NewBroker()
-	transport := nats.NewTransport()
-
-        service := micro.NewService(
-                micro.Name("greeter"),
-                micro.Registry(registry),
-                micro.Broker(broker),
-                micro.Transport(transport),
-        )
-
-	service.Init()
-	service.Run()
-}
-```
-
-### Write plugins
-
-Plugins are a concept built on Go's interface. Each package maintains a high level interface abstraction. 
-Simply implement the interface and pass it in as an option to the service.
-
-The service discovery interface is called [Registry](https://godoc.org/github.com/micro/go-micro/registry#Registry). 
-Anything which implements this interface can be used as a registry. The same applies to the other packages.
-
-```go
-type Registry interface {
-    Register(*Service, ...RegisterOption) error
-    Deregister(*Service) error
-    GetService(string) ([]*Service, error)
-    ListServices() ([]*Service, error)
-    Watch() (Watcher, error)
-    String() string
-}
-```
-
-Browse [go-plugins](https://github.com/micro/go-plugins) to get a better idea of implementation details.
-
-## Wrappers
-
-Go-micro includes the notion of middleware as wrappers. The client or handlers can be wrapped using the decorator pattern.
-
-### Handler
-
-Here's an example service handler wrapper which logs the incoming request
-
-```go
-// implements the server.HandlerWrapper
-func logWrapper(fn server.HandlerFunc) server.HandlerFunc {
-	return func(ctx context.Context, req server.Request, rsp interface{}) error {
-		fmt.Printf("[%v] server request: %s", time.Now(), req.Method())
-		return fn(ctx, req, rsp)
-	}
-}
-```
-
-It can be initialised when creating the service
-
-```go
+// create a new service
 service := micro.NewService(
-	micro.Name("greeter"),
-	// wrap the handler
-	micro.WrapHandler(logWrapper),
+    micro.Name("helloworld"),
 )
+
+// initialise flags
+service.Init()
+
+// start the service
+service.Run()
 ```
 
-### Client
+See the [examples](https://github.com/go-micro/examples) for detailed information on usage.
 
-Here's an example of a client wrapper which logs requests made
+## Code Generation
 
-```go
-type logWrapper struct {
-	client.Client
-}
+See [cmd/protoc-gen-micro](https://github.com/micro/go-micro/tree/master/cmd/protoc-gen-micro) for protobuf code generation.
 
-func (l *logWrapper) Call(ctx context.Context, req client.Request, rsp interface{}, opts ...client.CallOption) error {
-	fmt.Printf("[wrapper] client request to service: %s method: %s\n", req.Service(), req.Method())
-	return l.Client.Call(ctx, req, rsp)
-}
+## Community
 
-// implements client.Wrapper as logWrapper
-func logWrap(c client.Client) client.Client {
-	return &logWrapper{c}
-}
-```
+See [github.com/go-micro](https://github.com/go-micro) for community led projects.
 
-It can be initialised when creating the service
+- [Demo](https://github.com/go-micro/demo)
+- [Plugins](https://github.com/go-micro/plugins)
+- [Examples](https://github.com/go-micro/examples)
+- [Dashboard](https://github.com/go-micro/dashboard)
+- [CLI](https://github.com/go-micro/cli)
 
-```go
-service := micro.NewService(
-	micro.Name("greeter"),
-	// wrap the client
-	micro.WrapClient(logWrap),
-)
-```
+## Changelog
 
-## Other Languages
+See [CHANGELOG.md](https://github.com/micro/go-micro/tree/master/CHANGELOG.md) for release history.
 
-Check out [ja-micro](https://github.com/Sixt/ja-micro) to write services in Java
+## Evolution
 
-## Sponsors
+Go Micro started in 2015. It's since evolved into a platform called [Micro](https://micro.dev) and a service called [M3O](https://m3o.com).
 
-Sixt is an Enterprise Sponsor of Micro
+## License
 
-<a href="https://micro.mu/blog/2016/04/25/announcing-sixt-sponsorship.html"><img src="https://micro.mu/sixt_logo.png" width=150px height="auto" /></a>
-
-Become a sponsor by backing micro on [Patreon](https://www.patreon.com/microhq)
+Go Micro is Apache 2.0 licensed.

_config.yml

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

api/api.go

@@ -0,0 +1,187 @@
+package api
+
+import (
+	"errors"
+	"regexp"
+	"strings"
+
+	"go-micro.dev/v4/registry"
+	"go-micro.dev/v4/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/client/client.go

@@ -0,0 +1,219 @@
+// Package client provides an api client
+package client
+
+import (
+	"bytes"
+	"encoding/json"
+	"errors"
+	"io/ioutil"
+	"net/http"
+	"net/url"
+	"strings"
+	"time"
+
+	"github.com/gorilla/websocket"
+)
+
+const (
+	// local address for api
+	localAddress = "http://localhost:8080"
+)
+
+// Options of the Client
+type Options struct {
+	// Token for authentication
+	Token string
+	// Address of the micro platform.
+	// By default it connects to live. Change it or use the local flag
+	// to connect to your local installation.
+	Address string
+	// Helper flag to help users connect to the default local address
+	Local bool
+	// set a timeout
+	Timeout time.Duration
+}
+
+// Request is the request of the generic `api-client` call
+type Request struct {
+	// eg. "go.micro.srv.greeter"
+	Service string `json:"service"`
+	// eg. "Say.Hello"
+	Endpoint string `json:"endpoint"`
+	// json and then base64 encoded body
+	Body string `json:"body"`
+}
+
+// Response is the response of the generic `api-client` call.
+type Response struct {
+	// json and base64 encoded response body
+	Body string `json:"body"`
+	// error fields. Error json example
+	// {"id":"go.micro.client","code":500,"detail":"malformed method name: \"\"","status":"Internal Server Error"}
+	Code   int    `json:"code"`
+	ID     string `json:"id"`
+	Detail string `json:"detail"`
+	Status string `json:"status"`
+}
+
+// Client enables generic calls to micro
+type Client struct {
+	options Options
+}
+
+type Stream struct {
+	conn              *websocket.Conn
+	service, endpoint string
+}
+
+// NewClient returns a generic micro client that connects to live by default
+func NewClient(options *Options) *Client {
+	ret := new(Client)
+	ret.options = Options{
+		Address: localAddress,
+	}
+
+	// no options provided
+	if options == nil {
+		return ret
+	}
+
+	if options.Token != "" {
+		ret.options.Token = options.Token
+	}
+
+	if options.Local {
+		ret.options.Address = localAddress
+		ret.options.Local = true
+	}
+
+	if options.Timeout > 0 {
+		ret.options.Timeout = options.Timeout
+	}
+
+	return ret
+}
+
+// SetToken sets the api auth token
+func (client *Client) SetToken(t string) {
+	client.options.Token = t
+}
+
+// SetTimeout sets the http client's timeout
+func (client *Client) SetTimeout(d time.Duration) {
+	client.options.Timeout = d
+}
+
+// Call enables you to access any endpoint of any service on Micro
+func (client *Client) Call(service, endpoint string, request, response interface{}) error {
+	// example curl: curl -XPOST -d '{"service": "go.micro.srv.greeter", "endpoint": "Say.Hello"}'
+	//  -H 'Content-Type: application/json' http://localhost:8080/client {"body":"eyJtc2ciOiJIZWxsbyAifQ=="}
+	uri, err := url.Parse(client.options.Address)
+	if err != nil {
+		return err
+	}
+
+	// set the url to go through the v1 api
+	uri.Path = "/" + service + "/" + endpoint
+
+	b, err := marshalRequest(service, endpoint, request)
+	if err != nil {
+		return err
+	}
+
+	req, err := http.NewRequest("POST", uri.String(), bytes.NewBuffer(b))
+	if err != nil {
+		return err
+	}
+
+	// set the token if it exists
+	if len(client.options.Token) > 0 {
+		req.Header.Set("Authorization", "Bearer "+client.options.Token)
+	}
+
+	req.Header.Set("Content-Type", "application/json")
+
+	// if user didn't specify Timeout the default is 0 i.e no timeout
+	httpClient := &http.Client{
+		Timeout: client.options.Timeout,
+	}
+
+	resp, err := httpClient.Do(req)
+	if err != nil {
+		return err
+	}
+	defer resp.Body.Close()
+
+	body, err := ioutil.ReadAll(resp.Body)
+	if err != nil {
+		return err
+	}
+	if !(resp.StatusCode >= 200 && resp.StatusCode < 300) {
+		return errors.New(string(body))
+	}
+	return unmarshalResponse(body, response)
+}
+
+// Stream enables the ability to stream via websockets
+func (client *Client) Stream(service, endpoint string, request interface{}) (*Stream, error) {
+	b, err := marshalRequest(service, endpoint, request)
+	if err != nil {
+		return nil, err
+	}
+
+	uri, err := url.Parse(client.options.Address)
+	if err != nil {
+		return nil, err
+	}
+
+	// set the url to go through the v1 api
+	uri.Path = "/" + service + "/" + endpoint
+
+	// replace http with websocket
+	uri.Scheme = strings.Replace(uri.Scheme, "http", "ws", 1)
+
+	// create the headers
+	header := make(http.Header)
+	// set the token if it exists
+	if len(client.options.Token) > 0 {
+		header.Set("Authorization", "Bearer "+client.options.Token)
+	}
+	header.Set("Content-Type", "application/json")
+
+	// dial the connection
+	conn, _, err := websocket.DefaultDialer.Dial(uri.String(), header)
+	if err != nil {
+		return nil, err
+	}
+
+	// send the first request
+	if err := conn.WriteMessage(websocket.TextMessage, b); err != nil {
+		return nil, err
+	}
+
+	return &Stream{conn, service, endpoint}, nil
+}
+
+func (s *Stream) Recv(v interface{}) error {
+	// read response
+	_, message, err := s.conn.ReadMessage()
+	if err != nil {
+		return err
+	}
+	return unmarshalResponse(message, v)
+}
+
+func (s *Stream) Send(v interface{}) error {
+	b, err := marshalRequest(s.service, s.endpoint, v)
+	if err != nil {
+		return err
+	}
+	return s.conn.WriteMessage(websocket.TextMessage, b)
+}
+
+func marshalRequest(service, endpoint string, v interface{}) ([]byte, error) {
+	return json.Marshal(v)
+}
+
+func unmarshalResponse(body []byte, v interface{}) error {
+	return json.Unmarshal(body, &v)
+}

api/client/client_test.go

@@ -0,0 +1,24 @@
+package client
+
+import (
+	"os"
+	"testing"
+)
+
+func TestBasicCall(t *testing.T) {
+	if v := os.Getenv("IN_TRAVIS_CI"); v == "yes" {
+		return
+	}
+
+	response := map[string]interface{}{}
+	if err := NewClient(&Options{
+		Token: os.Getenv("TOKEN"),
+	}).Call("groups", "list", map[string]interface{}{
+		"memberId": "random",
+	}, &response); err != nil {
+		t.Fatal(err)
+	}
+	if len(response) > 0 {
+		t.Fatal(len(response))
+	}
+}

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

api/handler/handler.go

@@ -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"
+
+	"go-micro.dev/v4/api"
+	"go-micro.dev/v4/api/handler"
+	"go-micro.dev/v4/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"
+
+	"go-micro.dev/v4/api/handler"
+	"go-micro.dev/v4/api/resolver"
+	"go-micro.dev/v4/api/resolver/vpath"
+	"go-micro.dev/v4/api/router"
+	regRouter "go-micro.dev/v4/api/router/registry"
+	"go-micro.dev/v4/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 (
+	"go-micro.dev/v4/api/router"
+	"go-micro.dev/v4/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"
+
+	jsonpatch "github.com/evanphx/json-patch/v5"
+	"github.com/oxtoacart/bpool"
+	"go-micro.dev/v4/api"
+	"go-micro.dev/v4/api/handler"
+	"go-micro.dev/v4/api/internal/proto"
+	"go-micro.dev/v4/client"
+	"go-micro.dev/v4/codec"
+	"go-micro.dev/v4/codec/jsonrpc"
+	"go-micro.dev/v4/codec/protorpc"
+	"go-micro.dev/v4/errors"
+	"go-micro.dev/v4/logger"
+	"go-micro.dev/v4/metadata"
+	"go-micro.dev/v4/registry"
+	"go-micro.dev/v4/selector"
+	"go-micro.dev/v4/util/ctx"
+	"go-micro.dev/v4/util/qson"
+)
+
+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"
+
+	"github.com/golang/protobuf/proto"
+	go_api "go-micro.dev/v4/api/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/gobwas/httphead"
+	"github.com/gobwas/ws"
+	"github.com/gobwas/ws/wsutil"
+	"go-micro.dev/v4/api"
+	"go-micro.dev/v4/client"
+	raw "go-micro.dev/v4/codec/bytes"
+	"go-micro.dev/v4/logger"
+	"go-micro.dev/v4/selector"
+)
+
+// 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"
+
+	"go-micro.dev/v4/api"
+	"go-micro.dev/v4/api/handler"
+	"go-micro.dev/v4/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"
+
+	"go-micro.dev/v4/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"
+
+	"go-micro.dev/v4/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"
+
+	"go-micro.dev/v4/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"
+
+	"go-micro.dev/v4/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 (
+	"go-micro.dev/v4/api/resolver"
+	"go-micro.dev/v4/api/resolver/vpath"
+	"go-micro.dev/v4/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"
+
+	"go-micro.dev/v4/api"
+	"go-micro.dev/v4/api/router"
+	"go-micro.dev/v4/api/router/util"
+	"go-micro.dev/v4/logger"
+	"go-micro.dev/v4/metadata"
+	"go-micro.dev/v4/registry"
+	"go-micro.dev/v4/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/stretchr/testify/assert"
+	"go-micro.dev/v4/registry"
+)
+
+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"
+
+	"go-micro.dev/v4/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"
+
+	"go-micro.dev/v4/api"
+	"go-micro.dev/v4/api/router"
+	"go-micro.dev/v4/api/router/util"
+	"go-micro.dev/v4/logger"
+	"go-micro.dev/v4/metadata"
+	"go-micro.dev/v4/registry"
+	rutil "go-micro.dev/v4/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"
+
+	"go-micro.dev/v4/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"
+
+	"go-micro.dev/v4/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"
+
+	"go-micro.dev/v4/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"
+
+	"go-micro.dev/v4/api/server/acme"
+	"go-micro.dev/v4/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/gorilla/handlers"
+	"go-micro.dev/v4/api/server"
+	"go-micro.dev/v4/api/server/cors"
+	"go-micro.dev/v4/logger"
+)
+
+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"
+	"go-micro.dev/v4/api/server"
+	"go-micro.dev/v4/api/server/cors"
+	"io"
+	"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 := io.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 := io.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"
+	"go-micro.dev/v4/api/server/cors"
+	"net/http"
+
+	"go-micro.dev/v4/api/resolver"
+	"go-micro.dev/v4/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

@@ -0,0 +1,137 @@
+// Package auth provides authentication and authorization capability
+package auth
+
+import (
+	"context"
+	"errors"
+	"time"
+)
+
+const (
+	// BearerScheme used for Authorization header
+	BearerScheme = "Bearer "
+	// ScopePublic is the scope applied to a rule to allow access to the public
+	ScopePublic = ""
+	// ScopeAccount is the scope applied to a rule to limit to users with any valid account
+	ScopeAccount = "*"
+)
+
+var (
+	// ErrInvalidToken is when the token provided is not valid
+	ErrInvalidToken = errors.New("invalid token provided")
+	// ErrForbidden is when a user does not have the necessary scope to access a resource
+	ErrForbidden = errors.New("resource forbidden")
+)
+
+// Auth provides authentication and authorization
+type Auth interface {
+	// Init the auth
+	Init(opts ...Option)
+	// Options set for auth
+	Options() Options
+	// Generate a new account
+	Generate(id string, opts ...GenerateOption) (*Account, error)
+	// Inspect a token
+	Inspect(token string) (*Account, error)
+	// Token generated using refresh token or credentials
+	Token(opts ...TokenOption) (*Token, error)
+	// String returns the name of the implementation
+	String() string
+}
+
+// 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
+	// Grant access to a resource
+	Grant(rule *Rule) error
+	// Revoke access to a resource
+	Revoke(rule *Rule) error
+	// List returns all the rules used to verify requests
+	List(...ListOption) ([]*Rule, error)
+}
+
+// Account provided by an auth provider
+type Account struct {
+	// ID of the account e.g. email
+	ID string `json:"id"`
+	// Type of the account, e.g. service
+	Type string `json:"type"`
+	// Issuer of the account
+	Issuer string `json:"issuer"`
+	// Any other associated metadata
+	Metadata 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
+type Token struct {
+	// The token to be used for accessing resources
+	AccessToken string `json:"access_token"`
+	// RefreshToken to be used to generate a new token
+	RefreshToken string `json:"refresh_token"`
+	// Time of token creation
+	Created time.Time `json:"created"`
+	// Time of token expiry
+	Expiry time.Time `json:"expiry"`
+}
+
+// Expired returns a boolean indicating if the token needs to be refreshed
+func (t *Token) Expired() bool {
+	return t.Expiry.Unix() < time.Now().Unix()
+}
+
+// Resource is an entity such as a user or
+type Resource struct {
+	// Name of the resource, e.g. go.micro.service.notes
+	Name string `json:"name"`
+	// Type of resource, e.g. service
+	Type string `json:"type"`
+	// Endpoint resource e.g NotesService.Create
+	Endpoint string `json:"endpoint"`
+}
+
+// Access defines the type of access a rule grants
+type Access int
+
+const (
+	// AccessGranted to a resource
+	AccessGranted Access = iota
+	// AccessDenied to a resource
+	AccessDenied
+)
+
+// Rule is used to verify access to a resource
+type Rule struct {
+	// ID of the rule, e.g. "public"
+	ID string
+	// Scope the rule requires, a blank scope indicates open to the public and * indicates the rule
+	// applies to any valid account
+	Scope string
+	// Resource the rule applies to
+	Resource *Resource
+	// Access determines if the rule grants or denies access to the resource
+	Access Access
+	// Priority the rule should take when verifying a request, the higher the value the sooner the
+	// rule will be applied
+	Priority int32
+}
+
+type accountKey struct{}
+
+// AccountFromContext gets the account from the context, which
+// is set by the auth wrapper at the start of a call. If the account
+// is not set, a nil account will be returned. The error is only returned
+// when there was a problem retrieving an account
+func AccountFromContext(ctx context.Context) (*Account, bool) {
+	acc, ok := ctx.Value(accountKey{}).(*Account)
+	return acc, ok
+}
+
+// ContextWithAccount sets the account in the context
+func ContextWithAccount(ctx context.Context, account *Account) context.Context {
+	return context.WithValue(ctx, accountKey{}, account)
+}

auth/noop.go

@@ -0,0 +1,91 @@
+package auth
+
+import (
+	"github.com/google/uuid"
+)
+
+var (
+	DefaultAuth = NewAuth()
+)
+
+func NewAuth(opts ...Option) Auth {
+	options := Options{}
+
+	for _, o := range opts {
+		o(&options)
+	}
+
+	return &noop{
+		opts: options,
+	}
+}
+
+func NewRules() Rules {
+	return new(noopRules)
+}
+
+type noop struct {
+	opts Options
+}
+
+type noopRules struct{}
+
+// String returns the name of the implementation
+func (n *noop) String() string {
+	return "noop"
+}
+
+// Init the auth
+func (n *noop) Init(opts ...Option) {
+	for _, o := range opts {
+		o(&n.opts)
+	}
+}
+
+// Options set for auth
+func (n *noop) Options() Options {
+	return n.opts
+}
+
+// Generate a new account
+func (n *noop) Generate(id string, opts ...GenerateOption) (*Account, error) {
+	options := NewGenerateOptions(opts...)
+
+	return &Account{
+		ID:       id,
+		Secret:   options.Secret,
+		Metadata: options.Metadata,
+		Scopes:   options.Scopes,
+		Issuer:   n.Options().Namespace,
+	}, nil
+}
+
+// Grant access to a resource
+func (n *noopRules) Grant(rule *Rule) error {
+	return nil
+}
+
+// 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
+func (n *noopRules) Verify(acc *Account, res *Resource, opts ...VerifyOption) error {
+	return nil
+}
+
+func (n *noopRules) List(opts ...ListOption) ([]*Rule, error) {
+	return []*Rule{}, nil
+}
+
+// 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
+func (n *noop) Token(opts ...TokenOption) (*Token, error) {
+	return &Token{}, nil
+}

auth/options.go

@@ -0,0 +1,207 @@
+package auth
+
+import (
+	"context"
+	"time"
+)
+
+func NewOptions(opts ...Option) Options {
+	var options Options
+	for _, o := range opts {
+		o(&options)
+	}
+	return options
+}
+
+type Options struct {
+	// 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
+	PrivateKey string
+	// Addrs sets the addresses of auth
+	Addrs []string
+}
+
+type Option func(o *Options)
+
+// Addrs is the auth addresses to use
+func Addrs(addrs ...string) Option {
+	return func(o *Options) {
+		o.Addrs = addrs
+	}
+}
+
+// Namespace the service belongs to
+func Namespace(n string) Option {
+	return func(o *Options) {
+		o.Namespace = n
+	}
+}
+
+// PublicKey is the JWT public key
+func PublicKey(key string) Option {
+	return func(o *Options) {
+		o.PublicKey = key
+	}
+}
+
+// PrivateKey is the JWT private key
+func PrivateKey(key string) Option {
+	return func(o *Options) {
+		o.PrivateKey = key
+	}
+}
+
+// Credentials sets the auth credentials
+func Credentials(id, secret string) Option {
+	return func(o *Options) {
+		o.ID = id
+		o.Secret = secret
+	}
+}
+
+// ClientToken sets the auth token to use when making requests
+func ClientToken(token *Token) Option {
+	return func(o *Options) {
+		o.Token = token
+	}
+}
+
+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
+}
+
+type GenerateOption func(o *GenerateOptions)
+
+// WithSecret for the generated account
+func WithSecret(s string) GenerateOption {
+	return func(o *GenerateOptions) {
+		o.Secret = s
+	}
+}
+
+// WithType for the generated account
+func WithType(t string) GenerateOption {
+	return func(o *GenerateOptions) {
+		o.Type = t
+	}
+}
+
+// WithMetadata for the generated account
+func WithMetadata(md map[string]string) GenerateOption {
+	return func(o *GenerateOptions) {
+		o.Metadata = md
+	}
+}
+
+// WithProvider for the generated account
+func WithProvider(p string) GenerateOption {
+	return func(o *GenerateOptions) {
+		o.Provider = p
+	}
+}
+
+// WithScopes for the generated account
+func WithScopes(s ...string) GenerateOption {
+	return func(o *GenerateOptions) {
+		o.Scopes = s
+	}
+}
+
+// NewGenerateOptions from a slice of options
+func NewGenerateOptions(opts ...GenerateOption) GenerateOptions {
+	var options GenerateOptions
+	for _, o := range opts {
+		o(&options)
+	}
+	return options
+}
+
+type TokenOptions struct {
+	// ID for the account
+	ID string
+	// Secret for the account
+	Secret string
+	// RefreshToken is used to refesh a token
+	RefreshToken string
+	// Expiry is the time the token should live for
+	Expiry time.Duration
+}
+
+type TokenOption func(o *TokenOptions)
+
+// WithExpiry for the token
+func WithExpiry(ex time.Duration) TokenOption {
+	return func(o *TokenOptions) {
+		o.Expiry = ex
+	}
+}
+
+func WithCredentials(id, secret string) TokenOption {
+	return func(o *TokenOptions) {
+		o.ID = id
+		o.Secret = secret
+	}
+}
+
+func WithToken(rt string) TokenOption {
+	return func(o *TokenOptions) {
+		o.RefreshToken = rt
+	}
+}
+
+// NewTokenOptions from a slice of options
+func NewTokenOptions(opts ...TokenOption) TokenOptions {
+	var options TokenOptions
+	for _, o := range opts {
+		o(&options)
+	}
+
+	// set defualt expiry of token
+	if options.Expiry == 0 {
+		options.Expiry = time.Minute
+	}
+
+	return options
+}
+
+type VerifyOptions struct {
+	Context context.Context
+}
+
+type VerifyOption func(o *VerifyOptions)
+
+func VerifyContext(ctx context.Context) VerifyOption {
+	return func(o *VerifyOptions) {
+		o.Context = ctx
+	}
+}
+
+type ListOptions struct {
+	Context context.Context
+}
+
+type ListOption func(o *ListOptions)
+
+func RulesContext(ctx context.Context) ListOption {
+	return func(o *ListOptions) {
+		o.Context = ctx
+	}
+}

auth/rules.go

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

auth/rules_test.go

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

broker/broker.go

@@ -3,31 +3,32 @@ package broker
 
 // Broker is an interface used for asynchronous messaging.
 type Broker interface {
+	Init(...Option) error
 	Options() Options
 	Address() string
 	Connect() error
 	Disconnect() error
-	Init(...Option) error
-	Publish(string, *Message, ...PublishOption) error
-	Subscribe(string, Handler, ...SubscribeOption) (Subscriber, error)
+	Publish(topic string, m *Message, opts ...PublishOption) error
+	Subscribe(topic string, h Handler, opts ...SubscribeOption) (Subscriber, error)
 	String() string
 }
 
 // Handler is used to process messages via a subscription of a topic.
 // The handler is passed a publication interface which contains the
 // message and optional Ack method to acknowledge receipt of the message.
-type Handler func(Publication) error
+type Handler func(Event) error
 
 type Message struct {
 	Header map[string]string
 	Body   []byte
 }
 
-// Publication is given to a subscription handler for processing
-type Publication interface {
+// Event is given to a subscription handler for processing
+type Event interface {
 	Topic() string
 	Message() *Message
 	Ack() error
+	Error() error
 }
 
 // Subscriber is a convenience return type for the Subscribe method
@@ -38,13 +39,9 @@ type Subscriber interface {
 }
 
 var (
-	DefaultBroker Broker = newHttpBroker()
+	DefaultBroker Broker = NewBroker()
 )
 
-func NewBroker(opts ...Option) Broker {
-	return newHttpBroker(opts...)
-}
-
 func Init(opts ...Option) error {
 	return DefaultBroker.Init(opts...)
 }

broker/codec/codec.go

@@ -1,10 +0,0 @@
-package codec
-
-// Codec is used for encoding where the broker doesn't natively support
-// headers in the message type. In this case the entire message is
-// encoded as the payload
-type Codec interface {
-	Marshal(interface{}) ([]byte, error)
-	Unmarshal([]byte, interface{}) error
-	String() string
-}

broker/codec/json/json.go

@@ -1,25 +0,0 @@
-package json
-
-import (
-	"encoding/json"
-
-	"github.com/micro/go-micro/broker/codec"
-)
-
-type jsonCodec struct{}
-
-func (j jsonCodec) Marshal(v interface{}) ([]byte, error) {
-	return json.Marshal(v)
-}
-
-func (j jsonCodec) Unmarshal(d []byte, v interface{}) error {
-	return json.Unmarshal(d, v)
-}
-
-func (j jsonCodec) String() string {
-	return "json"
-}
-
-func NewCodec() codec.Codec {
-	return jsonCodec{}
-}

broker/codec/noop/noop.go

@@ -1,35 +0,0 @@
-package noop
-
-import (
-	"errors"
-
-	"github.com/micro/go-micro/broker"
-	"github.com/micro/go-micro/broker/codec"
-)
-
-type noopCodec struct{}
-
-func (n noopCodec) Marshal(v interface{}) ([]byte, error) {
-	msg, ok := v.(*broker.Message)
-	if !ok {
-		return nil, errors.New("invalid message")
-	}
-	return msg.Body, nil
-}
-
-func (n noopCodec) Unmarshal(d []byte, v interface{}) error {
-	msg, ok := v.(*broker.Message)
-	if !ok {
-		return errors.New("invalid message")
-	}
-	msg.Body = d
-	return nil
-}
-
-func (n noopCodec) String() string {
-	return "noop"
-}
-
-func NewCodec() codec.Codec {
-	return noopCodec{}
-}

broker/http.go

@@ -1,3 +1,4 @@
+// Package http provides a http based message broker
 package broker
 
 import (
@@ -7,26 +8,23 @@ import (
 	"errors"
 	"fmt"
 	"io"
-	"io/ioutil"
 	"math/rand"
 	"net"
 	"net/http"
 	"net/url"
 	"runtime"
-	"strconv"
-	"strings"
 	"sync"
 	"time"
 
-	"github.com/micro/go-log"
-	"github.com/micro/go-micro/broker/codec/json"
-	merr "github.com/micro/go-micro/errors"
-	"github.com/micro/go-micro/registry"
-	"github.com/micro/go-rcache"
-	maddr "github.com/micro/util/go/lib/addr"
-	mnet "github.com/micro/util/go/lib/net"
-	mls "github.com/micro/util/go/lib/tls"
-	"github.com/pborman/uuid"
+	"github.com/google/uuid"
+	"go-micro.dev/v4/codec/json"
+	merr "go-micro.dev/v4/errors"
+	"go-micro.dev/v4/registry"
+	"go-micro.dev/v4/registry/cache"
+	maddr "go-micro.dev/v4/util/addr"
+	mnet "go-micro.dev/v4/util/net"
+	mls "go-micro.dev/v4/util/tls"
+	"golang.org/x/net/http2"
 )
 
 // HTTP Broker is a point to point async broker
@@ -44,6 +42,10 @@ type httpBroker struct {
 	subscribers map[string][]*httpSubscriber
 	running     bool
 	exit        chan chan error
+
+	// offline message inbox
+	mtx   sync.RWMutex
+	inbox map[string][][]byte
 }
 
 type httpSubscriber struct {
@@ -55,13 +57,16 @@ type httpSubscriber struct {
 	hb    *httpBroker
 }
 
-type httpPublication struct {
-	m *Message
-	t string
+type httpEvent struct {
+	m   *Message
+	t   string
+	err error
 }
 
 var (
-	DefaultSubPath   = "/_sub"
+	DefaultPath      = "/"
+	DefaultAddress   = "127.0.0.1:0"
+	serviceName      = "micro.http.broker"
 	broadcastVersion = "ff.http.broadcast"
 	registerTTL      = time.Minute
 	registerInterval = time.Second * 30
@@ -78,6 +83,10 @@ func newTransport(config *tls.Config) *http.Transport {
 		}
 	}
 
+	dialTLS := func(network string, addr string) (net.Conn, error) {
+		return tls.Dial(network, addr, config)
+	}
+
 	t := &http.Transport{
 		Proxy: http.ProxyFromEnvironment,
 		Dial: (&net.Dialer{
@@ -85,18 +94,23 @@ func newTransport(config *tls.Config) *http.Transport {
 			KeepAlive: 30 * time.Second,
 		}).Dial,
 		TLSHandshakeTimeout: 10 * time.Second,
-		TLSClientConfig:     config,
+		DialTLS:             dialTLS,
 	}
 	runtime.SetFinalizer(&t, func(tr **http.Transport) {
 		(*tr).CloseIdleConnections()
 	})
+
+	// setup http2
+	http2.ConfigureTransport(t)
+
 	return t
 }
 
 func newHttpBroker(opts ...Option) Broker {
 	options := Options{
-		Codec:   json.NewCodec(),
-		Context: context.TODO(),
+		Codec:    json.Marshaler{},
+		Context:  context.TODO(),
+		Registry: registry.DefaultRegistry,
 	}
 
 	for _, o := range opts {
@@ -104,41 +118,53 @@ func newHttpBroker(opts ...Option) Broker {
 	}
 
 	// set address
-	addr := ":0"
+	addr := DefaultAddress
+
 	if len(options.Addrs) > 0 && len(options.Addrs[0]) > 0 {
 		addr = options.Addrs[0]
 	}
 
-	// get registry
-	reg, ok := options.Context.Value(registryKey).(registry.Registry)
-	if !ok {
-		reg = registry.DefaultRegistry
-	}
-
 	h := &httpBroker{
-		id:          "broker-" + uuid.NewUUID().String(),
+		id:          uuid.New().String(),
 		address:     addr,
 		opts:        options,
-		r:           reg,
+		r:           options.Registry,
 		c:           &http.Client{Transport: newTransport(options.TLSConfig)},
 		subscribers: make(map[string][]*httpSubscriber),
 		exit:        make(chan chan error),
 		mux:         http.NewServeMux(),
+		inbox:       make(map[string][][]byte),
+	}
+
+	// specify the message handler
+	h.mux.Handle(DefaultPath, h)
+
+	// get optional handlers
+	if h.opts.Context != nil {
+		handlers, ok := h.opts.Context.Value("http_handlers").(map[string]http.Handler)
+		if ok {
+			for pattern, handler := range handlers {
+				h.mux.Handle(pattern, handler)
+			}
+		}
 	}
 
-	h.mux.Handle(DefaultSubPath, h)
 	return h
 }
 
-func (h *httpPublication) Ack() error {
+func (h *httpEvent) Ack() error {
 	return nil
 }
 
-func (h *httpPublication) Message() *Message {
+func (h *httpEvent) Error() error {
+	return h.err
+}
+
+func (h *httpEvent) Message() *Message {
 	return h.m
 }
 
-func (h *httpPublication) Topic() string {
+func (h *httpEvent) Topic() string {
 	return h.t
 }
 
@@ -154,6 +180,49 @@ func (h *httpSubscriber) Unsubscribe() error {
 	return h.hb.unsubscribe(h)
 }
 
+func (h *httpBroker) saveMessage(topic string, msg []byte) {
+	h.mtx.Lock()
+	defer h.mtx.Unlock()
+
+	// get messages
+	c := h.inbox[topic]
+
+	// save message
+	c = append(c, msg)
+
+	// max length 64
+	if len(c) > 64 {
+		c = c[:64]
+	}
+
+	// save inbox
+	h.inbox[topic] = c
+}
+
+func (h *httpBroker) getMessage(topic string, num int) [][]byte {
+	h.mtx.Lock()
+	defer h.mtx.Unlock()
+
+	// get messages
+	c, ok := h.inbox[topic]
+	if !ok {
+		return nil
+	}
+
+	// more message than requests
+	if len(c) >= num {
+		msg := c[:num]
+		h.inbox[topic] = c[num:]
+		return msg
+	}
+
+	// reset inbox
+	h.inbox[topic] = nil
+
+	// return all messages
+	return c
+}
+
 func (h *httpBroker) subscribe(s *httpSubscriber) error {
 	h.Lock()
 	defer h.Unlock()
@@ -170,13 +239,14 @@ func (h *httpBroker) unsubscribe(s *httpSubscriber) error {
 	h.Lock()
 	defer h.Unlock()
 
+	//nolint:prealloc
 	var subscribers []*httpSubscriber
 
 	// look for subscriber
 	for _, sub := range h.subscribers[s.topic] {
 		// deregister and skip forward
-		if sub.id == s.id {
-			h.r.Deregister(sub.svc)
+		if sub == s {
+			_ = h.r.Deregister(sub.svc)
 			continue
 		}
 		// keep subscriber
@@ -200,7 +270,7 @@ func (h *httpBroker) run(l net.Listener) {
 			h.RLock()
 			for _, subs := range h.subscribers {
 				for _, sub := range subs {
-					h.r.Register(sub.svc, registry.RegisterTTL(registerTTL))
+					_ = h.r.Register(sub.svc, registry.RegisterTTL(registerTTL))
 				}
 			}
 			h.RUnlock()
@@ -210,7 +280,7 @@ func (h *httpBroker) run(l net.Listener) {
 			h.RLock()
 			for _, subs := range h.subscribers {
 				for _, sub := range subs {
-					h.r.Deregister(sub.svc)
+					_ = h.r.Deregister(sub.svc)
 				}
 			}
 			h.RUnlock()
@@ -229,7 +299,7 @@ func (h *httpBroker) ServeHTTP(w http.ResponseWriter, req *http.Request) {
 
 	req.ParseForm()
 
-	b, err := ioutil.ReadAll(req.Body)
+	b, err := io.ReadAll(req.Body)
 	if err != nil {
 		errr := merr.InternalServerError("go.micro.broker", "Error reading request body: %v", err)
 		w.WriteHeader(500)
@@ -245,8 +315,8 @@ func (h *httpBroker) ServeHTTP(w http.ResponseWriter, req *http.Request) {
 		return
 	}
 
-	topic := m.Header[":topic"]
-	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")
@@ -255,18 +325,25 @@ func (h *httpBroker) ServeHTTP(w http.ResponseWriter, req *http.Request) {
 		return
 	}
 
-	p := &httpPublication{m: m, t: topic}
+	p := &httpEvent{m: m, t: topic}
 	id := req.Form.Get("id")
 
+	//nolint:prealloc
+	var subs []Handler
+
 	h.RLock()
 	for _, subscriber := range h.subscribers[topic] {
-		if id == subscriber.id {
-			// sub is sync; crufty rate limiting
-			// so we don't hose the cpu
-			subscriber.fn(p)
+		if id != subscriber.id {
+			continue
 		}
+		subs = append(subs, subscriber.fn)
 	}
 	h.RUnlock()
+
+	// execute the handler
+	for _, fn := range subs {
+		p.err = fn(p)
+	}
 }
 
 func (h *httpBroker) Address() string {
@@ -276,12 +353,15 @@ func (h *httpBroker) Address() string {
 }
 
 func (h *httpBroker) Connect() error {
-	h.Lock()
-	defer h.Unlock()
-
+	h.RLock()
 	if h.running {
+		h.RUnlock()
 		return nil
 	}
+	h.RUnlock()
+
+	h.Lock()
+	defer h.Unlock()
 
 	var l net.Listener
 	var err error
@@ -325,7 +405,6 @@ func (h *httpBroker) Connect() error {
 		return err
 	}
 
-	log.Logf("Broker Listening on %s", l.Addr().String())
 	addr := h.address
 	h.address = l.Addr().String()
 
@@ -333,17 +412,18 @@ func (h *httpBroker) Connect() error {
 	go func() {
 		h.run(l)
 		h.Lock()
+		h.opts.Addrs = []string{addr}
 		h.address = addr
 		h.Unlock()
 	}()
 
 	// get registry
-	reg, ok := h.opts.Context.Value(registryKey).(registry.Registry)
-	if !ok {
+	reg := h.opts.Registry
+	if reg == nil {
 		reg = registry.DefaultRegistry
 	}
-	// set rcache
-	h.r = rcache.New(reg)
+	// set cache
+	h.r = cache.New(reg)
 
 	// set running
 	h.running = true
@@ -351,15 +431,18 @@ func (h *httpBroker) Connect() error {
 }
 
 func (h *httpBroker) Disconnect() error {
+	h.RLock()
+	if !h.running {
+		h.RUnlock()
+		return nil
+	}
+	h.RUnlock()
+
 	h.Lock()
 	defer h.Unlock()
 
-	if !h.running {
-		return nil
-	}
-
-	// stop rcache
-	rc, ok := h.r.(rcache.Cache)
+	// stop cache
+	rc, ok := h.r.(cache.Cache)
 	if ok {
 		rc.Stop()
 	}
@@ -375,34 +458,48 @@ func (h *httpBroker) Disconnect() error {
 }
 
 func (h *httpBroker) Init(opts ...Option) error {
-	h.Lock()
-	defer h.Unlock()
-
+	h.RLock()
 	if h.running {
+		h.RUnlock()
 		return errors.New("cannot init while connected")
 	}
+	h.RUnlock()
+
+	h.Lock()
+	defer h.Unlock()
 
 	for _, o := range opts {
 		o(&h.opts)
 	}
 
+	if len(h.opts.Addrs) > 0 && len(h.opts.Addrs[0]) > 0 {
+		h.address = h.opts.Addrs[0]
+	}
+
 	if len(h.id) == 0 {
-		h.id = "broker-" + uuid.NewUUID().String()
+		h.id = "go.micro.http.broker-" + uuid.New().String()
 	}
 
 	// get registry
-	reg, ok := h.opts.Context.Value(registryKey).(registry.Registry)
-	if !ok {
+	reg := h.opts.Registry
+	if reg == nil {
 		reg = registry.DefaultRegistry
 	}
 
-	// get rcache
-	if rc, ok := h.r.(rcache.Cache); ok {
+	// get cache
+	if rc, ok := h.r.(cache.Cache); ok {
 		rc.Stop()
 	}
 
 	// set registry
-	h.r = rcache.New(reg)
+	h.r = cache.New(reg)
+
+	// reconfigure tls config
+	if c := h.opts.TLSConfig; c != nil {
+		h.c = &http.Client{
+			Transport: newTransport(c),
+		}
+	}
 
 	return nil
 }
@@ -412,14 +509,7 @@ func (h *httpBroker) Options() Options {
 }
 
 func (h *httpBroker) Publish(topic string, msg *Message, opts ...PublishOption) error {
-	h.RLock()
-	s, err := h.r.GetService("topic:" + topic)
-	if err != nil {
-		h.RUnlock()
-		return err
-	}
-	h.RUnlock()
-
+	// create the message first
 	m := &Message{
 		Header: make(map[string]string),
 		Body:   msg.Body,
@@ -429,14 +519,27 @@ func (h *httpBroker) Publish(topic string, msg *Message, opts ...PublishOption)
 		m.Header[k] = v
 	}
 
-	m.Header[":topic"] = topic
+	m.Header["Micro-Topic"] = topic
 
+	// encode the message
 	b, err := h.opts.Codec.Marshal(m)
 	if err != nil {
 		return err
 	}
 
-	pub := func(node *registry.Node, b []byte) {
+	// save the message
+	h.saveMessage(topic, b)
+
+	// now attempt to get the service
+	h.RLock()
+	s, err := h.r.GetService(serviceName)
+	if err != nil {
+		h.RUnlock()
+		return err
+	}
+	h.RUnlock()
+
+	pub := func(node *registry.Node, t string, b []byte) error {
 		scheme := "http"
 
 		// check if secure is added in metadata
@@ -447,55 +550,108 @@ func (h *httpBroker) Publish(topic string, msg *Message, opts ...PublishOption)
 		vals := url.Values{}
 		vals.Add("id", node.Id)
 
-		uri := fmt.Sprintf("%s://%s:%d%s?%s", scheme, node.Address, node.Port, DefaultSubPath, vals.Encode())
+		uri := fmt.Sprintf("%s://%s%s?%s", scheme, node.Address, DefaultPath, vals.Encode())
 		r, err := h.c.Post(uri, "application/json", bytes.NewReader(b))
-		if err == nil {
-			io.Copy(ioutil.Discard, r.Body)
-			r.Body.Close()
+		if err != nil {
+			return err
 		}
+
+		// discard response body
+		io.Copy(io.Discard, r.Body)
+		r.Body.Close()
+		return nil
 	}
 
-	for _, service := range s {
-		// only process if we have nodes
-		if len(service.Nodes) == 0 {
-			continue
-		}
+	srv := func(s []*registry.Service, b []byte) {
+		for _, service := range s {
+			var nodes []*registry.Node
 
-		switch service.Version {
-		// broadcast version means broadcast to all nodes
-		case broadcastVersion:
 			for _, node := range service.Nodes {
-				// publish async
-				go pub(node, b)
-			}
-		default:
-			// select node to publish to
-			node := service.Nodes[rand.Int()%len(service.Nodes)]
+				// only use nodes tagged with broker http
+				if node.Metadata["broker"] != "http" {
+					continue
+				}
 
-			// publish async
-			go pub(node, b)
+				// look for nodes for the topic
+				if node.Metadata["topic"] != topic {
+					continue
+				}
+
+				nodes = append(nodes, node)
+			}
+
+			// only process if we have nodes
+			if len(nodes) == 0 {
+				continue
+			}
+
+			switch service.Version {
+			// broadcast version means broadcast to all nodes
+			case broadcastVersion:
+				var success bool
+
+				// publish to all nodes
+				for _, node := range nodes {
+					// publish async
+					if err := pub(node, topic, b); err == nil {
+						success = true
+					}
+				}
+
+				// save if it failed to publish at least once
+				if !success {
+					h.saveMessage(topic, b)
+				}
+			default:
+				// select node to publish to
+				node := nodes[rand.Int()%len(nodes)]
+
+				// publish async to one node
+				if err := pub(node, topic, b); err != nil {
+					// if failed save it
+					h.saveMessage(topic, b)
+				}
+			}
 		}
 	}
 
+	// do the rest async
+	go func() {
+		// get a third of the backlog
+		messages := h.getMessage(topic, 8)
+		delay := (len(messages) > 1)
+
+		// publish all the messages
+		for _, msg := range messages {
+			// serialize here
+			srv(s, msg)
+
+			// sending a backlog of messages
+			if delay {
+				time.Sleep(time.Millisecond * 100)
+			}
+		}
+	}()
+
 	return nil
 }
 
 func (h *httpBroker) Subscribe(topic string, handler Handler, opts ...SubscribeOption) (Subscriber, error) {
-	options := newSubscribeOptions(opts...)
+	var err error
+	var host, port string
+	options := NewSubscribeOptions(opts...)
 
 	// parse address for host, port
-	parts := strings.Split(h.Address(), ":")
-	host := strings.Join(parts[:len(parts)-1], ":")
-	port, _ := strconv.Atoi(parts[len(parts)-1])
+	host, port, err = net.SplitHostPort(h.Address())
+	if err != nil {
+		return nil, err
+	}
 
 	addr, err := maddr.Extract(host)
 	if err != nil {
 		return nil, err
 	}
 
-	// create unique id
-	id := h.id + "." + uuid.NewUUID().String()
-
 	var secure bool
 
 	if h.opts.Secure || h.opts.TLSConfig != nil {
@@ -504,11 +660,12 @@ func (h *httpBroker) Subscribe(topic string, handler Handler, opts ...SubscribeO
 
 	// register service
 	node := &registry.Node{
-		Id:      id,
-		Address: addr,
-		Port:    port,
+		Id:      topic + "-" + h.id,
+		Address: mnet.HostPort(addr, port),
 		Metadata: map[string]string{
 			"secure": fmt.Sprintf("%t", secure),
+			"broker": "http",
+			"topic":  topic,
 		},
 	}
 
@@ -519,7 +676,7 @@ func (h *httpBroker) Subscribe(topic string, handler Handler, opts ...SubscribeO
 	}
 
 	service := &registry.Service{
-		Name:    "topic:" + topic,
+		Name:    serviceName,
 		Version: version,
 		Nodes:   []*registry.Node{node},
 	}
@@ -528,7 +685,7 @@ func (h *httpBroker) Subscribe(topic string, handler Handler, opts ...SubscribeO
 	subscriber := &httpSubscriber{
 		opts:  options,
 		hb:    h,
-		id:    id,
+		id:    node.Id,
 		topic: topic,
 		fn:    handler,
 		svc:   service,
@@ -546,3 +703,8 @@ func (h *httpBroker) Subscribe(topic string, handler Handler, opts ...SubscribeO
 func (h *httpBroker) String() string {
 	return "http"
 }
+
+// NewBroker returns a new http broker
+func NewBroker(opts ...Option) Broker {
+	return newHttpBroker(opts...)
+}

broker/http/http.go

@@ -1,9 +0,0 @@
-package http
-
-import (
-	"github.com/micro/go-micro/broker"
-)
-
-func NewBroker(opts ...broker.Option) broker.Broker {
-	return broker.NewBroker(opts...)
-}

broker/http_test.go

@@ -0,0 +1,383 @@
+package broker_test
+
+import (
+	"sync"
+	"testing"
+	"time"
+
+	"github.com/google/uuid"
+	"go-micro.dev/v4/broker"
+	"go-micro.dev/v4/registry"
+)
+
+var (
+	// mock data
+	testData = map[string][]*registry.Service{
+		"foo": {
+			{
+				Name:    "foo",
+				Version: "1.0.0",
+				Nodes: []*registry.Node{
+					{
+						Id:      "foo-1.0.0-123",
+						Address: "localhost:9999",
+					},
+					{
+						Id:      "foo-1.0.0-321",
+						Address: "localhost:9999",
+					},
+				},
+			},
+			{
+				Name:    "foo",
+				Version: "1.0.1",
+				Nodes: []*registry.Node{
+					{
+						Id:      "foo-1.0.1-321",
+						Address: "localhost:6666",
+					},
+				},
+			},
+			{
+				Name:    "foo",
+				Version: "1.0.3",
+				Nodes: []*registry.Node{
+					{
+						Id:      "foo-1.0.3-345",
+						Address: "localhost:8888",
+					},
+				},
+			},
+		},
+	}
+)
+
+func newTestRegistry() registry.Registry {
+	return registry.NewMemoryRegistry(registry.Services(testData))
+}
+
+func sub(be *testing.B, c int) {
+	be.StopTimer()
+	m := newTestRegistry()
+
+	b := broker.NewBroker(broker.Registry(m))
+	topic := uuid.New().String()
+
+	if err := b.Init(); err != nil {
+		be.Fatalf("Unexpected init error: %v", err)
+	}
+
+	if err := b.Connect(); err != nil {
+		be.Fatalf("Unexpected connect error: %v", err)
+	}
+
+	msg := &broker.Message{
+		Header: map[string]string{
+			"Content-Type": "application/json",
+		},
+		Body: []byte(`{"message": "Hello World"}`),
+	}
+
+	var subs []broker.Subscriber
+	done := make(chan bool, c)
+
+	for i := 0; i < c; i++ {
+		sub, err := b.Subscribe(topic, func(p broker.Event) error {
+			done <- true
+			m := p.Message()
+
+			if string(m.Body) != string(msg.Body) {
+				be.Fatalf("Unexpected msg %s, expected %s", string(m.Body), string(msg.Body))
+			}
+
+			return nil
+		}, broker.Queue("shared"))
+		if err != nil {
+			be.Fatalf("Unexpected subscribe error: %v", err)
+		}
+		subs = append(subs, sub)
+	}
+
+	for i := 0; i < be.N; i++ {
+		be.StartTimer()
+		if err := b.Publish(topic, msg); err != nil {
+			be.Fatalf("Unexpected publish error: %v", err)
+		}
+		<-done
+		be.StopTimer()
+	}
+
+	for _, sub := range subs {
+		sub.Unsubscribe()
+	}
+
+	if err := b.Disconnect(); err != nil {
+		be.Fatalf("Unexpected disconnect error: %v", err)
+	}
+}
+
+func pub(be *testing.B, c int) {
+	be.StopTimer()
+	m := newTestRegistry()
+	b := broker.NewBroker(broker.Registry(m))
+	topic := uuid.New().String()
+
+	if err := b.Init(); err != nil {
+		be.Fatalf("Unexpected init error: %v", err)
+	}
+
+	if err := b.Connect(); err != nil {
+		be.Fatalf("Unexpected connect error: %v", err)
+	}
+
+	msg := &broker.Message{
+		Header: map[string]string{
+			"Content-Type": "application/json",
+		},
+		Body: []byte(`{"message": "Hello World"}`),
+	}
+
+	done := make(chan bool, c*4)
+
+	sub, err := b.Subscribe(topic, func(p broker.Event) error {
+		done <- true
+		m := p.Message()
+		if string(m.Body) != string(msg.Body) {
+			be.Fatalf("Unexpected msg %s, expected %s", string(m.Body), string(msg.Body))
+		}
+		return nil
+	}, broker.Queue("shared"))
+	if err != nil {
+		be.Fatalf("Unexpected subscribe error: %v", err)
+	}
+
+	var wg sync.WaitGroup
+	ch := make(chan int, c*4)
+	be.StartTimer()
+
+	for i := 0; i < c; i++ {
+		go func() {
+			for range ch {
+				if err := b.Publish(topic, msg); err != nil {
+					be.Fatalf("Unexpected publish error: %v", err)
+				}
+				select {
+				case <-done:
+				case <-time.After(time.Second):
+				}
+				wg.Done()
+			}
+		}()
+	}
+
+	for i := 0; i < be.N; i++ {
+		wg.Add(1)
+		ch <- i
+	}
+
+	wg.Wait()
+	be.StopTimer()
+	sub.Unsubscribe()
+	close(ch)
+	close(done)
+
+	if err := b.Disconnect(); err != nil {
+		be.Fatalf("Unexpected disconnect error: %v", err)
+	}
+}
+
+func TestBroker(t *testing.T) {
+	m := newTestRegistry()
+	b := broker.NewBroker(broker.Registry(m))
+
+	if err := b.Init(); err != nil {
+		t.Fatalf("Unexpected init error: %v", err)
+	}
+
+	if err := b.Connect(); err != nil {
+		t.Fatalf("Unexpected connect error: %v", err)
+	}
+
+	msg := &broker.Message{
+		Header: map[string]string{
+			"Content-Type": "application/json",
+		},
+		Body: []byte(`{"message": "Hello World"}`),
+	}
+
+	done := make(chan bool)
+
+	sub, err := b.Subscribe("test", func(p broker.Event) error {
+		m := p.Message()
+
+		if string(m.Body) != string(msg.Body) {
+			t.Fatalf("Unexpected msg %s, expected %s", string(m.Body), string(msg.Body))
+		}
+
+		close(done)
+		return nil
+	})
+	if err != nil {
+		t.Fatalf("Unexpected subscribe error: %v", err)
+	}
+
+	if err := b.Publish("test", msg); err != nil {
+		t.Fatalf("Unexpected publish error: %v", err)
+	}
+
+	<-done
+	sub.Unsubscribe()
+
+	if err := b.Disconnect(); err != nil {
+		t.Fatalf("Unexpected disconnect error: %v", err)
+	}
+}
+
+func TestConcurrentSubBroker(t *testing.T) {
+	m := newTestRegistry()
+	b := broker.NewBroker(broker.Registry(m))
+
+	if err := b.Init(); err != nil {
+		t.Fatalf("Unexpected init error: %v", err)
+	}
+
+	if err := b.Connect(); err != nil {
+		t.Fatalf("Unexpected connect error: %v", err)
+	}
+
+	msg := &broker.Message{
+		Header: map[string]string{
+			"Content-Type": "application/json",
+		},
+		Body: []byte(`{"message": "Hello World"}`),
+	}
+
+	var subs []broker.Subscriber
+	var wg sync.WaitGroup
+
+	for i := 0; i < 10; i++ {
+		sub, err := b.Subscribe("test", func(p broker.Event) error {
+			defer wg.Done()
+
+			m := p.Message()
+
+			if string(m.Body) != string(msg.Body) {
+				t.Fatalf("Unexpected msg %s, expected %s", string(m.Body), string(msg.Body))
+			}
+
+			return nil
+		})
+		if err != nil {
+			t.Fatalf("Unexpected subscribe error: %v", err)
+		}
+
+		wg.Add(1)
+		subs = append(subs, sub)
+	}
+
+	if err := b.Publish("test", msg); err != nil {
+		t.Fatalf("Unexpected publish error: %v", err)
+	}
+
+	wg.Wait()
+
+	for _, sub := range subs {
+		sub.Unsubscribe()
+	}
+
+	if err := b.Disconnect(); err != nil {
+		t.Fatalf("Unexpected disconnect error: %v", err)
+	}
+}
+
+func TestConcurrentPubBroker(t *testing.T) {
+	m := newTestRegistry()
+	b := broker.NewBroker(broker.Registry(m))
+
+	if err := b.Init(); err != nil {
+		t.Fatalf("Unexpected init error: %v", err)
+	}
+
+	if err := b.Connect(); err != nil {
+		t.Fatalf("Unexpected connect error: %v", err)
+	}
+
+	msg := &broker.Message{
+		Header: map[string]string{
+			"Content-Type": "application/json",
+		},
+		Body: []byte(`{"message": "Hello World"}`),
+	}
+
+	var wg sync.WaitGroup
+
+	sub, err := b.Subscribe("test", func(p broker.Event) error {
+		defer wg.Done()
+
+		m := p.Message()
+
+		if string(m.Body) != string(msg.Body) {
+			t.Fatalf("Unexpected msg %s, expected %s", string(m.Body), string(msg.Body))
+		}
+
+		return nil
+	})
+	if err != nil {
+		t.Fatalf("Unexpected subscribe error: %v", err)
+	}
+
+	for i := 0; i < 10; i++ {
+		wg.Add(1)
+
+		if err := b.Publish("test", msg); err != nil {
+			t.Fatalf("Unexpected publish error: %v", err)
+		}
+	}
+
+	wg.Wait()
+
+	sub.Unsubscribe()
+
+	if err := b.Disconnect(); err != nil {
+		t.Fatalf("Unexpected disconnect error: %v", err)
+	}
+}
+
+func BenchmarkSub1(b *testing.B) {
+	sub(b, 1)
+}
+func BenchmarkSub8(b *testing.B) {
+	sub(b, 8)
+}
+
+func BenchmarkSub32(b *testing.B) {
+	sub(b, 32)
+}
+
+func BenchmarkSub64(b *testing.B) {
+	sub(b, 64)
+}
+
+func BenchmarkSub128(b *testing.B) {
+	sub(b, 128)
+}
+
+func BenchmarkPub1(b *testing.B) {
+	pub(b, 1)
+}
+
+func BenchmarkPub8(b *testing.B) {
+	pub(b, 8)
+}
+
+func BenchmarkPub32(b *testing.B) {
+	pub(b, 32)
+}
+
+func BenchmarkPub64(b *testing.B) {
+	pub(b, 64)
+}
+
+func BenchmarkPub128(b *testing.B) {
+	pub(b, 128)
+}

broker/memory.go

@@ -0,0 +1,239 @@
+// Package memory provides a memory broker
+package broker
+
+import (
+	"context"
+	"errors"
+	"math/rand"
+	"sync"
+	"time"
+
+	"github.com/google/uuid"
+	"go-micro.dev/v4/logger"
+	maddr "go-micro.dev/v4/util/addr"
+	mnet "go-micro.dev/v4/util/net"
+)
+
+type memoryBroker struct {
+	opts Options
+
+	addr string
+	sync.RWMutex
+	connected   bool
+	Subscribers map[string][]*memorySubscriber
+}
+
+type memoryEvent struct {
+	opts    Options
+	topic   string
+	err     error
+	message interface{}
+}
+
+type memorySubscriber struct {
+	id      string
+	topic   string
+	exit    chan bool
+	handler Handler
+	opts    SubscribeOptions
+}
+
+func (m *memoryBroker) Options() Options {
+	return m.opts
+}
+
+func (m *memoryBroker) Address() string {
+	return m.addr
+}
+
+func (m *memoryBroker) Connect() error {
+	m.Lock()
+	defer m.Unlock()
+
+	if m.connected {
+		return nil
+	}
+
+	// use 127.0.0.1 to avoid scan of all network interfaces
+	addr, err := maddr.Extract("127.0.0.1")
+	if err != nil {
+		return err
+	}
+	i := rand.Intn(20000)
+	// set addr with port
+	addr = mnet.HostPort(addr, 10000+i)
+
+	m.addr = addr
+	m.connected = true
+
+	return nil
+}
+
+func (m *memoryBroker) Disconnect() error {
+	m.Lock()
+	defer m.Unlock()
+
+	if !m.connected {
+		return nil
+	}
+
+	m.connected = false
+
+	return nil
+}
+
+func (m *memoryBroker) Init(opts ...Option) error {
+	for _, o := range opts {
+		o(&m.opts)
+	}
+	return nil
+}
+
+func (m *memoryBroker) Publish(topic string, msg *Message, opts ...PublishOption) error {
+	m.RLock()
+	if !m.connected {
+		m.RUnlock()
+		return errors.New("not connected")
+	}
+
+	subs, ok := m.Subscribers[topic]
+	m.RUnlock()
+	if !ok {
+		return nil
+	}
+
+	var v interface{}
+	if m.opts.Codec != nil {
+		buf, err := m.opts.Codec.Marshal(msg)
+		if err != nil {
+			return err
+		}
+		v = buf
+	} else {
+		v = msg
+	}
+
+	p := &memoryEvent{
+		topic:   topic,
+		message: v,
+		opts:    m.opts,
+	}
+
+	for _, sub := range subs {
+		if err := sub.handler(p); err != nil {
+			p.err = err
+			if eh := m.opts.ErrorHandler; eh != nil {
+				eh(p)
+				continue
+			}
+			return err
+		}
+	}
+
+	return nil
+}
+
+func (m *memoryBroker) Subscribe(topic string, handler Handler, opts ...SubscribeOption) (Subscriber, error) {
+	m.RLock()
+	if !m.connected {
+		m.RUnlock()
+		return nil, errors.New("not connected")
+	}
+	m.RUnlock()
+
+	var options SubscribeOptions
+	for _, o := range opts {
+		o(&options)
+	}
+
+	sub := &memorySubscriber{
+		exit:    make(chan bool, 1),
+		id:      uuid.New().String(),
+		topic:   topic,
+		handler: handler,
+		opts:    options,
+	}
+
+	m.Lock()
+	m.Subscribers[topic] = append(m.Subscribers[topic], sub)
+	m.Unlock()
+
+	go func() {
+		<-sub.exit
+		m.Lock()
+		var newSubscribers []*memorySubscriber
+		for _, sb := range m.Subscribers[topic] {
+			if sb.id == sub.id {
+				continue
+			}
+			newSubscribers = append(newSubscribers, sb)
+		}
+		m.Subscribers[topic] = newSubscribers
+		m.Unlock()
+	}()
+
+	return sub, nil
+}
+
+func (m *memoryBroker) String() string {
+	return "memory"
+}
+
+func (m *memoryEvent) Topic() string {
+	return m.topic
+}
+
+func (m *memoryEvent) Message() *Message {
+	switch v := m.message.(type) {
+	case *Message:
+		return v
+	case []byte:
+		msg := &Message{}
+		if err := m.opts.Codec.Unmarshal(v, msg); err != nil {
+			if logger.V(logger.ErrorLevel, logger.DefaultLogger) {
+				logger.Errorf("[memory]: failed to unmarshal: %v\n", err)
+			}
+			return nil
+		}
+		return msg
+	}
+
+	return nil
+}
+
+func (m *memoryEvent) Ack() error {
+	return nil
+}
+
+func (m *memoryEvent) Error() error {
+	return m.err
+}
+
+func (m *memorySubscriber) Options() SubscribeOptions {
+	return m.opts
+}
+
+func (m *memorySubscriber) Topic() string {
+	return m.topic
+}
+
+func (m *memorySubscriber) Unsubscribe() error {
+	m.exit <- true
+	return nil
+}
+
+func NewMemoryBroker(opts ...Option) Broker {
+	options := Options{
+		Context: context.Background(),
+	}
+
+	rand.Seed(time.Now().UnixNano())
+	for _, o := range opts {
+		o(&options)
+	}
+
+	return &memoryBroker{
+		opts:        options,
+		Subscribers: make(map[string][]*memorySubscriber),
+	}
+}

broker/memory_test.go

@@ -0,0 +1,50 @@
+package broker_test
+
+import (
+	"fmt"
+	"testing"
+
+	"go-micro.dev/v4/broker"
+)
+
+func TestMemoryBroker(t *testing.T) {
+	b := broker.NewMemoryBroker()
+
+	if err := b.Connect(); err != nil {
+		t.Fatalf("Unexpected connect error %v", err)
+	}
+
+	topic := "test"
+	count := 10
+
+	fn := func(p broker.Event) error {
+		return nil
+	}
+
+	sub, err := b.Subscribe(topic, fn)
+	if err != nil {
+		t.Fatalf("Unexpected error subscribing %v", err)
+	}
+
+	for i := 0; i < count; i++ {
+		message := &broker.Message{
+			Header: map[string]string{
+				"foo": "bar",
+				"id":  fmt.Sprintf("%d", i),
+			},
+			Body: []byte(`hello world`),
+		}
+
+		if err := b.Publish(topic, message); err != nil {
+			t.Fatalf("Unexpected error publishing %d", i)
+		}
+	}
+
+	if err := sub.Unsubscribe(); err != nil {
+		t.Fatalf("Unexpected error unsubscribing from %s: %v", topic, err)
+	}
+
+	if err := b.Disconnect(); err != nil {
+		t.Fatalf("Unexpected connect error %v", err)
+	}
+}

broker/mock/mock.go

@@ -1,179 +0,0 @@
-package mock
-
-import (
-	"errors"
-	"sync"
-
-	"github.com/micro/go-micro/broker"
-	"github.com/pborman/uuid"
-)
-
-type mockBroker struct {
-	opts broker.Options
-
-	sync.RWMutex
-	connected   bool
-	Subscribers map[string][]*mockSubscriber
-}
-
-type mockPublication struct {
-	topic   string
-	message *broker.Message
-}
-
-type mockSubscriber struct {
-	id      string
-	topic   string
-	exit    chan bool
-	handler broker.Handler
-	opts    broker.SubscribeOptions
-}
-
-func (m *mockBroker) Options() broker.Options {
-	return m.opts
-}
-
-func (m *mockBroker) Address() string {
-	return ""
-}
-
-func (m *mockBroker) Connect() error {
-	m.Lock()
-	defer m.Unlock()
-
-	if m.connected {
-		return nil
-	}
-
-	m.connected = true
-
-	return nil
-}
-
-func (m *mockBroker) Disconnect() error {
-	m.Lock()
-	defer m.Unlock()
-
-	if !m.connected {
-		return nil
-	}
-
-	m.connected = false
-
-	return nil
-}
-
-func (m *mockBroker) Init(opts ...broker.Option) error {
-	for _, o := range opts {
-		o(&m.opts)
-	}
-	return nil
-}
-
-func (m *mockBroker) Publish(topic string, message *broker.Message, opts ...broker.PublishOption) error {
-	m.Lock()
-	defer m.Unlock()
-
-	if !m.connected {
-		return errors.New("not connected")
-	}
-
-	subs, ok := m.Subscribers[topic]
-	if !ok {
-		return nil
-	}
-
-	p := &mockPublication{
-		topic:   topic,
-		message: message,
-	}
-
-	for _, sub := range subs {
-		if err := sub.handler(p); err != nil {
-			return err
-		}
-	}
-
-	return nil
-}
-
-func (m *mockBroker) Subscribe(topic string, handler broker.Handler, opts ...broker.SubscribeOption) (broker.Subscriber, error) {
-	m.Lock()
-	defer m.Unlock()
-
-	if !m.connected {
-		return nil, errors.New("not connected")
-	}
-
-	var options broker.SubscribeOptions
-	for _, o := range opts {
-		o(&options)
-	}
-
-	sub := &mockSubscriber{
-		exit:    make(chan bool, 1),
-		id:      uuid.NewUUID().String(),
-		topic:   topic,
-		handler: handler,
-		opts:    options,
-	}
-
-	m.Subscribers[topic] = append(m.Subscribers[topic], sub)
-
-	go func() {
-		<-sub.exit
-		m.Lock()
-		var newSubscribers []*mockSubscriber
-		for _, sb := range m.Subscribers[topic] {
-			if sb.id == sub.id {
-				continue
-			}
-			newSubscribers = append(newSubscribers, sb)
-		}
-		m.Subscribers[topic] = newSubscribers
-		m.Unlock()
-	}()
-
-	return sub, nil
-}
-
-func (m *mockBroker) String() string {
-	return "mock"
-}
-
-func (m *mockPublication) Topic() string {
-	return m.topic
-}
-
-func (m *mockPublication) Message() *broker.Message {
-	return m.message
-}
-
-func (m *mockPublication) Ack() error {
-	return nil
-}
-
-func (m *mockSubscriber) Options() broker.SubscribeOptions {
-	return m.opts
-}
-
-func (m *mockSubscriber) Topic() string {
-	return m.topic
-}
-
-func (m *mockSubscriber) Unsubscribe() error {
-	m.exit <- true
-	return nil
-}
-
-func NewBroker(opts ...broker.Option) broker.Broker {
-	var options broker.Options
-	for _, o := range opts {
-		o(&options)
-	}
-
-	return &mockBroker{
-		opts:        options,
-		Subscribers: make(map[string][]*mockSubscriber),
-	}
-}

broker/options.go

@@ -4,15 +4,22 @@ import (
 	"context"
 	"crypto/tls"
 
-	"github.com/micro/go-micro/broker/codec"
-	"github.com/micro/go-micro/registry"
+	"go-micro.dev/v4/codec"
+	"go-micro.dev/v4/registry"
 )
 
 type Options struct {
-	Addrs     []string
-	Secure    bool
-	Codec     codec.Codec
+	Addrs  []string
+	Secure bool
+	Codec  codec.Marshaler
+
+	// Handler executed when error happens in broker mesage
+	// processing
+	ErrorHandler Handler
+
 	TLSConfig *tls.Config
+	// Registry used for clustering
+	Registry registry.Registry
 	// Other options for implementations of the interface
 	// can be stored in a context
 	Context context.Context
@@ -42,15 +49,16 @@ type Option func(*Options)
 
 type PublishOption func(*PublishOptions)
 
+// PublishContext set context
+func PublishContext(ctx context.Context) PublishOption {
+	return func(o *PublishOptions) {
+		o.Context = ctx
+	}
+}
+
 type SubscribeOption func(*SubscribeOptions)
 
-type contextKeyT string
-
-var (
-	registryKey = contextKeyT("github.com/micro/go-micro/registry")
-)
-
-func newSubscribeOptions(opts ...SubscribeOption) SubscribeOptions {
+func NewSubscribeOptions(opts ...SubscribeOption) SubscribeOptions {
 	opt := SubscribeOptions{
 		AutoAck: true,
 	}
@@ -71,7 +79,7 @@ func Addrs(addrs ...string) Option {
 
 // Codec sets the codec used for encoding/decoding used where
 // a broker does not support headers
-func Codec(c codec.Codec) Option {
+func Codec(c codec.Marshaler) Option {
 	return func(o *Options) {
 		o.Codec = c
 	}
@@ -85,6 +93,14 @@ func DisableAutoAck() SubscribeOption {
 	}
 }
 
+// ErrorHandler will catch all broker errors that cant be handled
+// in normal way, for example Codec errors
+func ErrorHandler(h Handler) Option {
+	return func(o *Options) {
+		o.ErrorHandler = h
+	}
+}
+
 // Queue sets the name of the queue to share messages on
 func Queue(name string) SubscribeOption {
 	return func(o *SubscribeOptions) {
@@ -94,7 +110,7 @@ func Queue(name string) SubscribeOption {
 
 func Registry(r registry.Registry) Option {
 	return func(o *Options) {
-		o.Context = context.WithValue(o.Context, registryKey, r)
+		o.Registry = r
 	}
 }
 
@@ -111,3 +127,10 @@ func TLSConfig(t *tls.Config) Option {
 		o.TLSConfig = t
 	}
 }
+
+// SubscribeContext set context
+func SubscribeContext(ctx context.Context) SubscribeOption {
+	return func(o *SubscribeOptions) {
+		o.Context = ctx
+	}
+}

cache/cache.go

@@ -0,0 +1,65 @@
+package cache
+
+import (
+	"context"
+	"errors"
+	"time"
+)
+
+var (
+	// DefaultCache is the default cache.
+	DefaultCache Cache = NewCache()
+	// DefaultExpiration is the default duration for items stored in
+	// the cache to expire.
+	DefaultExpiration time.Duration = 0
+
+	// ErrItemExpired is returned in Cache.Get when the item found in the cache
+	// has expired.
+	ErrItemExpired error = errors.New("item has expired")
+	// ErrKeyNotFound is returned in Cache.Get and Cache.Delete when the
+	// provided key could not be found in cache.
+	ErrKeyNotFound error = errors.New("key not found in cache")
+)
+
+// Cache is the interface that wraps the 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
+}
+
+// Item represents an item stored in the cache.
+type Item struct {
+	Value      interface{}
+	Expiration int64
+}
+
+// Expired returns true if the item has expired.
+func (i *Item) Expired() bool {
+	if i.Expiration == 0 {
+		return false
+	}
+
+	return time.Now().UnixNano() > i.Expiration
+}
+
+// NewCache returns a new cache.
+func NewCache(opts ...Option) Cache {
+	options := NewOptions(opts...)
+	items := make(map[string]Item)
+
+	if len(options.Items) > 0 {
+		items = options.Items
+	}
+
+	return &memCache{
+		opts:  options,
+		items: items,
+	}
+}

cache/memory.go

@@ -0,0 +1,66 @@
+package cache
+
+import (
+	"context"
+	"sync"
+	"time"
+)
+
+type memCache struct {
+	opts Options
+	sync.RWMutex
+
+	items map[string]Item
+}
+
+func (c *memCache) Get(ctx context.Context, key string) (interface{}, time.Time, error) {
+	c.RWMutex.RLock()
+	defer c.RWMutex.RUnlock()
+
+	item, found := c.items[key]
+	if !found {
+		return nil, time.Time{}, ErrKeyNotFound
+	}
+	if item.Expired() {
+		return nil, time.Time{}, ErrItemExpired
+	}
+
+	return item.Value, time.Unix(0, item.Expiration), nil
+}
+
+func (c *memCache) Put(ctx context.Context, key string, val interface{}, d time.Duration) error {
+	var e int64
+	if d == DefaultExpiration {
+		d = c.opts.Expiration
+	}
+	if d > 0 {
+		e = time.Now().Add(d).UnixNano()
+	}
+
+	c.RWMutex.Lock()
+	defer c.RWMutex.Unlock()
+
+	c.items[key] = Item{
+		Value:      val,
+		Expiration: e,
+	}
+
+	return nil
+}
+
+func (c *memCache) Delete(ctx context.Context, key string) error {
+	c.RWMutex.Lock()
+	defer c.RWMutex.Unlock()
+
+	_, found := c.items[key]
+	if !found {
+		return ErrKeyNotFound
+	}
+
+	delete(c.items, key)
+	return nil
+}
+
+func (m *memCache) String() string {
+	return "memory"
+}

cache/memory_test.go

@@ -0,0 +1,111 @@
+package cache
+
+import (
+	"context"
+	"testing"
+	"time"
+)
+
+var (
+	ctx             = 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 {
+			t.Error("expected to get no value from cache")
+		}
+	})
+
+	t.Run("CacheGetHit", func(t *testing.T) {
+		c := NewCache()
+
+		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 a != val {
+			t.Errorf("Expected '%v', got '%v'", val, a)
+		}
+	})
+
+	t.Run("CacheGetExpired", func(t *testing.T) {
+		c := NewCache()
+		e := 20 * time.Millisecond
+
+		if err := c.Put(ctx, key, val, e); 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 := NewCache()
+		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("CacheDeleteMiss", func(t *testing.T) {
+		if err := NewCache().Delete(ctx, key); err == nil {
+			t.Error("expected to delete no value from cache")
+		}
+	})
+
+	t.Run("CacheDeleteHit", func(t *testing.T) {
+		c := NewCache()
+
+		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")
+		}
+	})
+}
+
+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 {
+			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("CacheWithItems", func(t *testing.T) {
+		c := NewCache(Items(map[string]Item{key: {val, 0}}))
+
+		if a, _, err := c.Get(ctx, 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/options.go

@@ -0,0 +1,61 @@
+package cache
+
+import (
+	"context"
+	"time"
+)
+
+// Options represents the options for the cache.
+type Options struct {
+	Expiration time.Duration
+	Items      map[string]Item
+	// Address represents the address or other connection information of the cache service.
+	Address string
+	// Context should contain all implementation specific options, using context.WithValue.
+	Context context.Context
+}
+
+// Option manipulates the Options passed.
+type Option func(o *Options)
+
+// Expiration sets the duration for items stored in the cache to expire.
+func Expiration(d time.Duration) Option {
+	return func(o *Options) {
+		o.Expiration = d
+	}
+}
+
+// Items initializes the cache with preconfigured items.
+func Items(i map[string]Item) Option {
+	return func(o *Options) {
+		o.Items = i
+	}
+}
+
+// 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
+	}
+}
+
+// NewOptions returns a new options struct.
+func NewOptions(opts ...Option) Options {
+	options := Options{
+		Expiration: DefaultExpiration,
+		Items:      make(map[string]Item),
+	}
+
+	for _, o := range opts {
+		o(&options)
+	}
+
+	return options
+}

cache/options_test.go

@@ -0,0 +1,43 @@
+package cache
+
+import (
+	"testing"
+	"time"
+)
+
+func TestOptions(t *testing.T) {
+	testData := map[string]struct {
+		set        bool
+		expiration time.Duration
+		items      map[string]Item
+	}{
+		"DefaultOptions":  {false, DefaultExpiration, map[string]Item{}},
+		"ModifiedOptions": {true, time.Second, map[string]Item{"test": {"hello go-micro", 0}}},
+	}
+
+	for k, d := range testData {
+		t.Run(k, func(t *testing.T) {
+			var opts Options
+
+			if d.set {
+				opts = NewOptions(
+					Expiration(d.expiration),
+					Items(d.items),
+				)
+			} else {
+				opts = NewOptions()
+			}
+
+			// test options
+			for _, o := range []Options{opts} {
+				if o.Expiration != d.expiration {
+					t.Fatalf("Expected expiration '%v', got '%v'", d.expiration, o.Expiration)
+				}
+
+				if o.Items["test"] != d.items["test"] {
+					t.Fatalf("Expected items %#v, got %#v", d.items, o.Items)
+				}
+			}
+		})
+	}
+}

client/backoff.go

@@ -2,16 +2,13 @@ package client
 
 import (
 	"context"
-	"math"
 	"time"
+
+	"go-micro.dev/v4/util/backoff"
 )
 
 type BackoffFunc func(ctx context.Context, req Request, attempts int) (time.Duration, error)
 
-// exponential backoff
 func exponentialBackoff(ctx context.Context, req Request, attempts int) (time.Duration, error) {
-	if attempts == 0 {
-		return time.Duration(0), nil
-	}
-	return time.Duration(math.Pow(10, float64(attempts))) * time.Millisecond, nil
+	return backoff.Do(attempts), nil
 }

client/backoff_test.go

@@ -2,13 +2,19 @@ package client
 
 import (
 	"context"
-	"math"
 	"testing"
 	"time"
 )
 
 func TestBackoff(t *testing.T) {
-	delta := time.Duration(0)
+	results := []time.Duration{
+		0 * time.Second,
+		100 * time.Millisecond,
+		600 * time.Millisecond,
+		1900 * time.Millisecond,
+		4300 * time.Millisecond,
+		7900 * time.Millisecond,
+	}
 
 	c := NewClient()
 
@@ -18,10 +24,8 @@ func TestBackoff(t *testing.T) {
 			t.Fatal(err)
 		}
 
-		if d < delta {
-			t.Fatalf("Expected greater than %v, got %v", delta, d)
+		if d != results[i] {
+			t.Fatalf("Expected equal than %v, got %v", results[i], d)
 		}
-
-		delta = time.Millisecond * time.Duration(math.Pow(10, float64(i+1)))
 	}
 }

client/cache.go

@@ -0,0 +1,66 @@
+package client
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"hash/fnv"
+	"time"
+
+	cache "github.com/patrickmn/go-cache"
+	"go-micro.dev/v4/metadata"
+)
+
+// NewCache returns an initialised cache.
+func NewCache() *Cache {
+	return &Cache{
+		cache: cache.New(cache.NoExpiration, 30*time.Second),
+	}
+}
+
+// Cache for responses
+type Cache struct {
+	cache *cache.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
+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
+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)
+	}
+
+	return rsp
+}
+
+// key returns a hash for the context and request
+func key(ctx context.Context, req *Request) string {
+	ns, _ := metadata.Get(ctx, "Micro-Namespace")
+
+	bytes, _ := json.Marshal(map[string]interface{}{
+		"namespace": ns,
+		"request": map[string]interface{}{
+			"service":  (*req).Service(),
+			"endpoint": (*req).Endpoint(),
+			"method":   (*req).Method(),
+			"body":     (*req).Body(),
+		},
+	})
+
+	h := fnv.New64()
+	h.Write(bytes)
+	return fmt.Sprintf("%x", h.Sum(nil))
+}

client/cache_test.go

@@ -0,0 +1,76 @@
+package client
+
+import (
+	"context"
+	"testing"
+	"time"
+
+	"go-micro.dev/v4/metadata"
+)
+
+func TestCache(t *testing.T) {
+	ctx := context.TODO()
+	req := NewRequest("go.micro.service.foo", "Foo.Bar", nil)
+
+	t.Run("CacheMiss", func(t *testing.T) {
+		if _, ok := NewCache().Get(ctx, &req); ok {
+			t.Errorf("Expected to get no result from Get")
+		}
+	})
+
+	t.Run("CacheHit", func(t *testing.T) {
+		c := NewCache()
+
+		rsp := "theresponse"
+		c.Set(ctx, &req, rsp, time.Minute)
+
+		if res, ok := c.Get(ctx, &req); !ok {
+			t.Errorf("Expected a result, got nothing")
+		} else if res != rsp {
+			t.Errorf("Expected '%v' result, got '%v'", rsp, res)
+		}
+	})
+}
+
+func TestCacheKey(t *testing.T) {
+	ctx := context.TODO()
+	req1 := NewRequest("go.micro.service.foo", "Foo.Bar", nil)
+	req2 := NewRequest("go.micro.service.foo", "Foo.Baz", nil)
+	req3 := NewRequest("go.micro.service.foo", "Foo.Baz", "customquery")
+
+	t.Run("IdenticalRequests", func(t *testing.T) {
+		key1 := key(ctx, &req1)
+		key2 := key(ctx, &req1)
+		if key1 != key2 {
+			t.Errorf("Expected the keys to match for identical requests and context")
+		}
+	})
+
+	t.Run("DifferentRequestEndpoints", func(t *testing.T) {
+		key1 := key(ctx, &req1)
+		key2 := key(ctx, &req2)
+
+		if key1 == key2 {
+			t.Errorf("Expected the keys to differ for different request endpoints")
+		}
+	})
+
+	t.Run("DifferentRequestBody", func(t *testing.T) {
+		key1 := key(ctx, &req2)
+		key2 := key(ctx, &req3)
+
+		if key1 == key2 {
+			t.Errorf("Expected the keys to differ for different request bodies")
+		}
+	})
+
+	t.Run("DifferentMetadata", func(t *testing.T) {
+		mdCtx := metadata.Set(context.TODO(), "Micro-Namespace", "bar")
+		key1 := key(mdCtx, &req1)
+		key2 := key(ctx, &req1)
+
+		if key1 == key2 {
+			t.Errorf("Expected the keys to differ for different metadata")
+		}
+	})
+}

client/client.go

@@ -4,22 +4,29 @@ package client
 import (
 	"context"
 	"time"
+
+	"go-micro.dev/v4/codec"
 )
 
 // Client is the interface used to make requests to services.
 // It supports Request/Response via Transport and Publishing via the Broker.
-// It also supports bidiectional streaming of requests.
+// It also supports bidirectional streaming of requests.
 type Client interface {
 	Init(...Option) error
 	Options() Options
 	NewMessage(topic string, msg interface{}, opts ...MessageOption) Message
-	NewRequest(service, method string, req interface{}, reqOpts ...RequestOption) Request
+	NewRequest(service, endpoint string, req interface{}, reqOpts ...RequestOption) Request
 	Call(ctx context.Context, req Request, rsp interface{}, opts ...CallOption) error
 	Stream(ctx context.Context, req Request, opts ...CallOption) (Stream, error)
 	Publish(ctx context.Context, msg Message, opts ...PublishOption) error
 	String() string
 }
 
+// Router manages request routing
+type Router interface {
+	SendRequest(context.Context, Request) (Response, error)
+}
+
 // Message is the interface for publishing asynchronously
 type Message interface {
 	Topic() string
@@ -29,24 +36,57 @@ type Message interface {
 
 // Request is the interface for a synchronous request used by Call or Stream
 type Request interface {
+	// The service to call
 	Service() string
+	// The action to take
 	Method() string
+	// The endpoint to invoke
+	Endpoint() string
+	// The content type
 	ContentType() string
-	Request() interface{}
+	// The unencoded request body
+	Body() interface{}
+	// Write to the encoded request writer. This is nil before a call is made
+	Codec() codec.Writer
 	// indicates whether the request will be a streaming one rather than unary
 	Stream() bool
 }
 
+// Response is the response received from a service
+type Response interface {
+	// Read the response
+	Codec() codec.Reader
+	// read the header
+	Header() map[string]string
+	// Read the undecoded response
+	Read() ([]byte, error)
+}
+
 // Stream is the inteface for a bidirectional synchronous stream
 type Stream interface {
+	Closer
+	// Context for the stream
 	Context() context.Context
+	// The request made
 	Request() Request
+	// The response read
+	Response() Response
+	// Send will encode and send a request
 	Send(interface{}) error
+	// Recv will decode and read a response
 	Recv(interface{}) error
+	// Error returns the stream error
 	Error() error
+	// Close closes the stream
 	Close() error
 }
 
+// Closer handle client close
+type Closer interface {
+	// CloseSend closes the send direction of the stream.
+	CloseSend() error
+}
+
 // Option used by the Client
 type Option func(*Options)
 
@@ -68,15 +108,18 @@ var (
 	// DefaultBackoff is the default backoff function for retries
 	DefaultBackoff = exponentialBackoff
 	// DefaultRetry is the default check-for-retry function for retries
-	DefaultRetry = alwaysRetry
+	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 = 1
+	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
@@ -95,15 +138,10 @@ func NewMessage(topic string, payload interface{}, opts ...MessageOption) Messag
 	return DefaultClient.NewMessage(topic, payload, opts...)
 }
 
-// Creates a new client with the options passed in
-func NewClient(opt ...Option) Client {
-	return newRpcClient(opt...)
-}
-
 // Creates a new request using the default client. Content Type will
 // be set to the default within options and use the appropriate codec
-func NewRequest(service, method string, request interface{}, reqOpts ...RequestOption) Request {
-	return DefaultClient.NewRequest(service, method, request, reqOpts...)
+func NewRequest(service, endpoint string, request interface{}, reqOpts ...RequestOption) Request {
+	return DefaultClient.NewRequest(service, endpoint, request, reqOpts...)
 }
 
 // Creates a streaming connection with a service and returns responses on the

client/common_test.go

@@ -0,0 +1,59 @@
+package client
+
+import (
+	"go-micro.dev/v4/registry"
+)
+
+var (
+	// mock data
+	testData = map[string][]*registry.Service{
+		"foo": {
+			{
+				Name:    "foo",
+				Version: "1.0.0",
+				Nodes: []*registry.Node{
+					{
+						Id:      "foo-1.0.0-123",
+						Address: "localhost:9999",
+						Metadata: map[string]string{
+							"protocol": "mucp",
+						},
+					},
+					{
+						Id:      "foo-1.0.0-321",
+						Address: "localhost:9999",
+						Metadata: map[string]string{
+							"protocol": "mucp",
+						},
+					},
+				},
+			},
+			{
+				Name:    "foo",
+				Version: "1.0.1",
+				Nodes: []*registry.Node{
+					{
+						Id:      "foo-1.0.1-321",
+						Address: "localhost:6666",
+						Metadata: map[string]string{
+							"protocol": "mucp",
+						},
+					},
+				},
+			},
+			{
+				Name:    "foo",
+				Version: "1.0.3",
+				Nodes: []*registry.Node{
+					{
+						Id:      "foo-1.0.3-345",
+						Address: "localhost:8888",
+						Metadata: map[string]string{
+							"protocol": "mucp",
+						},
+					},
+				},
+			},
+		},
+	}
+)

client/mock/context.go

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

client/mock/mock.go

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

client/mock/mock_test.go

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

client/mock/options.go

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

client/options.go

@@ -4,11 +4,11 @@ import (
 	"context"
 	"time"
 
-	"github.com/micro/go-micro/broker"
-	"github.com/micro/go-micro/codec"
-	"github.com/micro/go-micro/registry"
-	"github.com/micro/go-micro/selector"
-	"github.com/micro/go-micro/transport"
+	"go-micro.dev/v4/broker"
+	"go-micro.dev/v4/codec"
+	"go-micro.dev/v4/registry"
+	"go-micro.dev/v4/selector"
+	"go-micro.dev/v4/transport"
 )
 
 type Options struct {
@@ -22,10 +22,16 @@ type Options struct {
 	Selector  selector.Selector
 	Transport transport.Transport
 
+	// Router sets the router
+	Router Router
+
 	// Connection Pool
 	PoolSize int
 	PoolTTL  time.Duration
 
+	// Response cache
+	Cache *Cache
+
 	// Middleware for client
 	Wrappers []Wrapper
 
@@ -40,8 +46,8 @@ type Options struct {
 type CallOptions struct {
 	SelectOptions []selector.SelectOption
 
-	// Address of remote host
-	Address string
+	// Address of remote hosts
+	Address []string
 	// Backoff func
 	Backoff BackoffFunc
 	// Check if retriable func
@@ -52,6 +58,12 @@ type CallOptions struct {
 	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
@@ -62,6 +74,8 @@ type CallOptions struct {
 }
 
 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
@@ -80,9 +94,12 @@ type RequestOptions struct {
 	Context context.Context
 }
 
-func newOptions(options ...Option) Options {
+func NewOptions(options ...Option) Options {
 	opts := Options{
-		Codecs: make(map[string]codec.NewCodec),
+		Cache:       NewCache(),
+		Context:     context.Background(),
+		ContentType: DefaultContentType,
+		Codecs:      make(map[string]codec.NewCodec),
 		CallOptions: CallOptions{
 			Backoff:        DefaultBackoff,
 			Retry:          DefaultRetry,
@@ -90,36 +107,18 @@ func newOptions(options ...Option) Options {
 			RequestTimeout: DefaultRequestTimeout,
 			DialTimeout:    transport.DefaultDialTimeout,
 		},
-		PoolSize: DefaultPoolSize,
-		PoolTTL:  DefaultPoolTTL,
+		PoolSize:  DefaultPoolSize,
+		PoolTTL:   DefaultPoolTTL,
+		Broker:    broker.DefaultBroker,
+		Selector:  selector.DefaultSelector,
+		Registry:  registry.DefaultRegistry,
+		Transport: transport.DefaultTransport,
 	}
 
 	for _, o := range options {
 		o(&opts)
 	}
 
-	if len(opts.ContentType) == 0 {
-		opts.ContentType = defaultContentType
-	}
-
-	if opts.Broker == nil {
-		opts.Broker = broker.DefaultBroker
-	}
-
-	if opts.Registry == nil {
-		opts.Registry = registry.DefaultRegistry
-	}
-
-	if opts.Selector == nil {
-		opts.Selector = selector.NewSelector(
-			selector.Registry(opts.Registry),
-		)
-	}
-
-	if opts.Transport == nil {
-		opts.Transport = transport.DefaultTransport
-	}
-
 	return opts
 }
 
@@ -151,7 +150,7 @@ func PoolSize(d int) Option {
 	}
 }
 
-// PoolSize sets the connection pool size
+// PoolTTL sets the connection pool ttl
 func PoolTTL(d time.Duration) Option {
 	return func(o *Options) {
 		o.PoolTTL = d
@@ -162,6 +161,8 @@ func PoolTTL(d time.Duration) Option {
 func Registry(r registry.Registry) Option {
 	return func(o *Options) {
 		o.Registry = r
+		// set in the selector
+		o.Selector.Init(selector.Registry(r))
 	}
 }
 
@@ -224,6 +225,13 @@ func RequestTimeout(d time.Duration) Option {
 	}
 }
 
+// StreamTimeout sets the stream timeout
+func StreamTimeout(d time.Duration) Option {
+	return func(o *Options) {
+		o.CallOptions.StreamTimeout = d
+	}
+}
+
 // Transport dial timeout
 func DialTimeout(d time.Duration) Option {
 	return func(o *Options) {
@@ -233,8 +241,22 @@ func DialTimeout(d time.Duration) Option {
 
 // Call Options
 
-// WithAddress sets the remote address to use rather than using service discovery
-func WithAddress(a string) CallOption {
+// 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
+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
+func WithAddress(a ...string) CallOption {
 	return func(o *CallOptions) {
 		o.Address = a
 	}
@@ -285,6 +307,13 @@ func WithRequestTimeout(d time.Duration) CallOption {
 	}
 }
 
+// WithStreamTimeout sets the stream timeout
+func WithStreamTimeout(d time.Duration) CallOption {
+	return func(o *CallOptions) {
+		o.StreamTimeout = d
+	}
+}
+
 // WithDialTimeout is a CallOption which overrides that which
 // set in Options.CallOptions
 func WithDialTimeout(d time.Duration) CallOption {
@@ -293,6 +322,28 @@ func WithDialTimeout(d time.Duration) CallOption {
 	}
 }
 
+// WithServiceToken is a CallOption which overrides the
+// authorization header with the services own auth token
+func WithServiceToken() CallOption {
+	return func(o *CallOptions) {
+		o.ServiceToken = true
+	}
+}
+
+// WithCache is a CallOption which sets the duration the response
+// shoull be cached for
+func WithCache(c time.Duration) CallOption {
+	return func(o *CallOptions) {
+		o.CacheExpiry = c
+	}
+}
+
+func WithMessageContentType(ct string) MessageOption {
+	return func(o *MessageOptions) {
+		o.ContentType = ct
+	}
+}
+
 // Request Options
 
 func WithContentType(ct string) RequestOption {
@@ -306,3 +357,10 @@ func StreamingRequest() RequestOption {
 		o.Stream = true
 	}
 }
+
+// WithRouter sets the client router
+func WithRouter(r Router) Option {
+	return func(o *Options) {
+		o.Router = r
+	}
+}

client/options_test.go

@@ -4,7 +4,7 @@ import (
 	"testing"
 	"time"
 
-	"github.com/micro/go-micro/transport"
+	"go-micro.dev/v4/transport"
 )
 
 func TestCallOptions(t *testing.T) {
@@ -23,7 +23,7 @@ func TestCallOptions(t *testing.T) {
 		var cl Client
 
 		if d.set {
-			opts = newOptions(
+			opts = NewOptions(
 				Retries(d.retries),
 				RequestTimeout(d.rtimeout),
 				DialTimeout(d.dtimeout),
@@ -35,7 +35,7 @@ func TestCallOptions(t *testing.T) {
 				DialTimeout(d.dtimeout),
 			)
 		} else {
-			opts = newOptions()
+			opts = NewOptions()
 			cl = NewClient()
 		}
 

client/retry.go

@@ -2,12 +2,34 @@ package client
 
 import (
 	"context"
+
+	"go-micro.dev/v4/errors"
 )
 
 // 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)
 
-// always retry on error
-func alwaysRetry(ctx context.Context, req Request, retryCount int, err error) (bool, 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
+func RetryOnError(ctx context.Context, req Request, retryCount int, err error) (bool, error) {
+	if err == nil {
+		return false, nil
+	}
+
+	e := errors.Parse(err.Error())
+	if e == nil {
+		return false, nil
+	}
+
+	switch e.Code {
+	// retry on timeout or internal server error
+	case 408, 500:
+		return true, nil
+	default:
+		return false, nil
+	}
+}

client/rpc/rpc.go

@@ -1,9 +0,0 @@
-package rpc
-
-import (
-	"github.com/micro/go-micro/client"
-)
-
-func NewClient(opts ...client.Option) client.Client {
-	return client.NewClient(opts...)
-}

client/rpc_client.go

@@ -1,38 +1,47 @@
 package client
 
 import (
-	"bytes"
 	"context"
 	"fmt"
-	"sync"
+	"sync/atomic"
 	"time"
 
-	"github.com/micro/go-micro/broker"
-	"github.com/micro/go-micro/codec"
-	"github.com/micro/go-micro/errors"
-	"github.com/micro/go-micro/metadata"
-	"github.com/micro/go-micro/registry"
-	"github.com/micro/go-micro/selector"
-	"github.com/micro/go-micro/transport"
-	"sync/atomic"
+	"github.com/google/uuid"
+	"go-micro.dev/v4/broker"
+	"go-micro.dev/v4/codec"
+	raw "go-micro.dev/v4/codec/bytes"
+	"go-micro.dev/v4/errors"
+	"go-micro.dev/v4/metadata"
+	"go-micro.dev/v4/registry"
+	"go-micro.dev/v4/selector"
+	"go-micro.dev/v4/transport"
+	"go-micro.dev/v4/util/buf"
+	"go-micro.dev/v4/util/net"
+	"go-micro.dev/v4/util/pool"
 )
 
 type rpcClient struct {
-	once sync.Once
-	opts Options
-	pool *pool
 	seq  uint64
+	once atomic.Value
+	opts Options
+	pool pool.Pool
 }
 
 func newRpcClient(opt ...Option) Client {
-	opts := newOptions(opt...)
+	opts := NewOptions(opt...)
+
+	p := pool.NewPool(
+		pool.Size(opts.PoolSize),
+		pool.TTL(opts.PoolTTL),
+		pool.Transport(opts.Transport),
+	)
 
 	rc := &rpcClient{
-		once: sync.Once{},
 		opts: opts,
-		pool: newPool(opts.PoolSize, opts.PoolTTL),
+		pool: p,
 		seq:  0,
 	}
+	rc.once.Store(false)
 
 	c := Client(rc)
 
@@ -48,13 +57,15 @@ 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 {
+	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, address string, 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
+
 	msg := &transport.Message{
 		Header: make(map[string]string),
 	}
@@ -62,6 +73,11 @@ func (r *rpcClient) call(ctx context.Context, address string, req Request, resp
 	md, ok := metadata.FromContext(ctx)
 	if ok {
 		for k, v := range md {
+			// 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
 		}
 	}
@@ -73,33 +89,53 @@ func (r *rpcClient) call(ctx context.Context, address string, req Request, resp
 	// set the accept header
 	msg.Header["Accept"] = req.ContentType()
 
-	cf, err := r.newCodec(req.ContentType())
-	if err != nil {
-		return errors.InternalServerError("go.micro.client", err.Error())
+	// setup old protocol
+	cf := setupProtocol(msg, node)
+
+	// no codec specified
+	if cf == nil {
+		var err error
+		cf, err = r.newCodec(req.ContentType())
+		if err != nil {
+			return errors.InternalServerError("go.micro.client", err.Error())
+		}
 	}
 
-	var grr error
-	c, err := r.pool.getConn(address, r.opts.Transport, transport.WithTimeout(opts.DialTimeout))
+	dOpts := []transport.DialOption{
+		transport.WithStream(),
+	}
+
+	if opts.DialTimeout >= 0 {
+		dOpts = append(dOpts, transport.WithTimeout(opts.DialTimeout))
+	}
+
+	c, err := r.pool.Get(address, dOpts...)
 	if err != nil {
 		return errors.InternalServerError("go.micro.client", "connection error: %v", err)
 	}
-	defer func() {
-		// defer execution of release
-		r.pool.release(address, c, grr)
-	}()
 
-	seq := r.seq
-	atomic.AddUint64(&r.seq, 1)
+	seq := atomic.AddUint64(&r.seq, 1) - 1
+	codec := newRpcCodec(msg, c, cf, "")
+
+	rsp := &rpcResponse{
+		socket: c,
+		codec:  codec,
+	}
 
 	stream := &rpcStream{
-		context: ctx,
-		request: req,
-		closed:  make(chan bool),
-		codec:   newRpcPlusCodec(msg, c, cf),
-		seq:     seq,
+		id:       fmt.Sprintf("%v", seq),
+		context:  ctx,
+		request:  req,
+		response: rsp,
+		codec:    codec,
+		closed:   make(chan bool),
+		release:  func(err error) { r.pool.Release(c, err) },
+		sendEOS:  false,
 	}
+	// close the stream on exiting this function
 	defer stream.Close()
 
+	// wait for error response
 	ch := make(chan error, 1)
 
 	go func() {
@@ -110,7 +146,7 @@ func (r *rpcClient) call(ctx context.Context, address string, req Request, resp
 		}()
 
 		// send request
-		if err := stream.Send(req.Request()); err != nil {
+		if err := stream.Send(req.Body()); err != nil {
 			ch <- err
 			return
 		}
@@ -125,17 +161,30 @@ func (r *rpcClient) call(ctx context.Context, address string, req Request, resp
 		ch <- nil
 	}()
 
+	var grr error
+
 	select {
 	case err := <-ch:
-		grr = err
 		return err
 	case <-ctx.Done():
-		grr = ctx.Err()
-		return errors.New("go.micro.client", fmt.Sprintf("request timeout: %v", ctx.Err()), 408)
+		grr = errors.Timeout("go.micro.client", fmt.Sprintf("%v", ctx.Err()))
 	}
+
+	// set the stream error
+	if grr != nil {
+		stream.Lock()
+		stream.err = grr
+		stream.Unlock()
+
+		return grr
+	}
+
+	return nil
 }
 
-func (r *rpcClient) stream(ctx context.Context, address string, req Request, opts CallOptions) (Stream, error) {
+func (r *rpcClient) stream(ctx context.Context, node *registry.Node, req Request, opts CallOptions) (Stream, error) {
+	address := node.Address
+
 	msg := &transport.Message{
 		Header: make(map[string]string),
 	}
@@ -148,33 +197,76 @@ func (r *rpcClient) stream(ctx context.Context, address string, req Request, opt
 	}
 
 	// set timeout in nanoseconds
-	msg.Header["Timeout"] = fmt.Sprintf("%d", opts.RequestTimeout)
+	if opts.StreamTimeout > time.Duration(0) {
+		msg.Header["Timeout"] = fmt.Sprintf("%d", opts.StreamTimeout)
+	}
 	// set the content type for the request
 	msg.Header["Content-Type"] = req.ContentType()
 	// set the accept header
 	msg.Header["Accept"] = req.ContentType()
 
-	cf, err := r.newCodec(req.ContentType())
-	if err != nil {
-		return nil, errors.InternalServerError("go.micro.client", err.Error())
+	// set old codecs
+	cf := setupProtocol(msg, node)
+
+	// no codec specified
+	if cf == nil {
+		var err error
+		cf, err = r.newCodec(req.ContentType())
+		if err != nil {
+			return nil, errors.InternalServerError("go.micro.client", err.Error())
+		}
 	}
 
-	c, err := r.opts.Transport.Dial(address, transport.WithStream(), transport.WithTimeout(opts.DialTimeout))
+	dOpts := []transport.DialOption{
+		transport.WithStream(),
+	}
+
+	if opts.DialTimeout >= 0 {
+		dOpts = append(dOpts, transport.WithTimeout(opts.DialTimeout))
+	}
+
+	c, err := r.opts.Transport.Dial(address, dOpts...)
 	if err != nil {
 		return nil, errors.InternalServerError("go.micro.client", "connection error: %v", err)
 	}
 
-	stream := &rpcStream{
-		context: ctx,
-		request: req,
-		closed:  make(chan bool),
-		codec:   newRpcPlusCodec(msg, c, cf),
+	// increment the sequence number
+	seq := atomic.AddUint64(&r.seq, 1) - 1
+	id := fmt.Sprintf("%v", seq)
+
+	// create codec with stream id
+	codec := newRpcCodec(msg, c, cf, id)
+
+	rsp := &rpcResponse{
+		socket: c,
+		codec:  codec,
 	}
 
+	// set request codec
+	if r, ok := req.(*rpcRequest); ok {
+		r.codec = codec
+	}
+
+	stream := &rpcStream{
+		id:       id,
+		context:  ctx,
+		request:  req,
+		response: rsp,
+		codec:    codec,
+		// used to close the stream
+		closed: make(chan bool),
+		// signal the end of stream,
+		sendEOS: true,
+		// release func
+		release: func(err error) { c.Close() },
+	}
+
+	// wait for error response
 	ch := make(chan error, 1)
 
 	go func() {
-		ch <- stream.Send(req.Request())
+		// send the first message
+		ch <- stream.Send(req.Body())
 	}()
 
 	var grr error
@@ -183,10 +275,16 @@ func (r *rpcClient) stream(ctx context.Context, address string, req Request, opt
 	case err := <-ch:
 		grr = err
 	case <-ctx.Done():
-		grr = errors.New("go.micro.client", fmt.Sprintf("request timeout: %v", ctx.Err()), 408)
+		grr = errors.Timeout("go.micro.client", fmt.Sprintf("%v", ctx.Err()))
 	}
 
 	if grr != nil {
+		// set the error
+		stream.Lock()
+		stream.err = grr
+		stream.Unlock()
+
+		// close the stream
 		stream.Close()
 		return nil, grr
 	}
@@ -197,17 +295,22 @@ func (r *rpcClient) stream(ctx context.Context, address string, req Request, opt
 func (r *rpcClient) Init(opts ...Option) error {
 	size := r.opts.PoolSize
 	ttl := r.opts.PoolTTL
+	tr := r.opts.Transport
 
 	for _, o := range opts {
 		o(&r.opts)
 	}
 
 	// update pool configuration if the options changed
-	if size != r.opts.PoolSize || ttl != r.opts.PoolTTL {
-		r.pool.Lock()
-		r.pool.size = r.opts.PoolSize
-		r.pool.ttl = int64(r.opts.PoolTTL.Seconds())
-		r.pool.Unlock()
+	if size != r.opts.PoolSize || ttl != r.opts.PoolTTL || tr != r.opts.Transport {
+		// close existing 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),
+		)
 	}
 
 	return nil
@@ -217,22 +320,38 @@ func (r *rpcClient) Options() Options {
 	return r.opts
 }
 
+// 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)
+
 	// return remote address
-	if len(opts.Address) > 0 {
+	if len(address) > 0 {
+		nodes := make([]*registry.Node, len(address))
+
+		for i, addr := range address {
+			nodes[i] = &registry.Node{
+				Address: addr,
+				// Set the protocol
+				Metadata: map[string]string{
+					"protocol": "mucp",
+				},
+			}
+		}
+
+		// crude return method
 		return func() (*registry.Node, error) {
-			return &registry.Node{
-				Address: opts.Address,
-			}, nil
+			return nodes[time.Now().Unix()%int64(len(nodes))], nil
 		}, nil
 	}
 
 	// get next nodes from the selector
-	next, err := r.opts.Selector.Select(request.Service(), opts.SelectOptions...)
-	if err != nil && err == selector.ErrNotFound {
-		return nil, errors.NotFound("go.micro.client", err.Error())
-	} else if err != nil {
-		return nil, errors.InternalServerError("go.micro.client", err.Error())
+	next, err := r.opts.Selector.Select(service, opts.SelectOptions...)
+	if err != nil {
+		if err == selector.ErrNotFound {
+			return nil, errors.InternalServerError("go.micro.client", "service %s: %s", service, err.Error())
+		}
+		return nil, errors.InternalServerError("go.micro.client", "error selecting %s node: %s", service, err.Error())
 	}
 
 	return next, nil
@@ -254,18 +373,20 @@ func (r *rpcClient) Call(ctx context.Context, request Request, response interfac
 	d, ok := ctx.Deadline()
 	if !ok {
 		// no deadline so we create a new one
-		ctx, _ = context.WithTimeout(ctx, callOpts.RequestTimeout)
+		var cancel context.CancelFunc
+		ctx, cancel = context.WithTimeout(ctx, callOpts.RequestTimeout)
+		defer cancel()
 	} else {
 		// got a deadline so no need to setup context
 		// but we need to set the timeout we pass along
-		opt := WithRequestTimeout(d.Sub(time.Now()))
+		opt := WithRequestTimeout(time.Until(d))
 		opt(&callOpts)
 	}
 
 	// should we noop right here?
 	select {
 	case <-ctx.Done():
-		return errors.New("go.micro.client", fmt.Sprintf("%v", ctx.Err()), 408)
+		return errors.Timeout("go.micro.client", fmt.Sprintf("%v", ctx.Err()))
 	default:
 	}
 
@@ -282,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 errors.InternalServerError("go.micro.client", err.Error())
+			return errors.InternalServerError("go.micro.client", "backoff error: %v", err.Error())
 		}
 
 		// only sleep if greater than 0
@@ -292,35 +413,39 @@ func (r *rpcClient) Call(ctx context.Context, request Request, response interfac
 
 		// select next node
 		node, err := next()
-		if err != nil && err == selector.ErrNotFound {
-			return errors.NotFound("go.micro.client", err.Error())
-		} else if err != nil {
-			return errors.InternalServerError("go.micro.client", err.Error())
-		}
-
-		// set the address
-		address := node.Address
-		if node.Port > 0 {
-			address = fmt.Sprintf("%s:%d", address, node.Port)
+		service := request.Service()
+		if err != nil {
+			if err == selector.ErrNotFound {
+				return errors.InternalServerError("go.micro.client", "service %s: %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, address, request, response, callOpts)
-		r.opts.Selector.Mark(request.Service(), node, err)
+		err = rcall(ctx, node, request, response, callOpts)
+		r.opts.Selector.Mark(service, node, err)
 		return err
 	}
 
-	ch := make(chan error, callOpts.Retries)
+	// get the retries
+	retries := callOpts.Retries
+
+	// disable retries when using a proxy
+	if _, _, ok := net.Proxy(request.Service(), callOpts.Address); ok {
+		retries = 0
+	}
+
+	ch := make(chan error, retries+1)
 	var gerr error
 
-	for i := 0; i <= callOpts.Retries; i++ {
-		go func() {
+	for i := 0; i <= retries; i++ {
+		go func(i int) {
 			ch <- call(i)
-		}()
+		}(i)
 
 		select {
 		case <-ctx.Done():
-			return errors.New("go.micro.client", fmt.Sprintf("call timeout: %v", ctx.Err()), 408)
+			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 {
@@ -355,22 +480,10 @@ func (r *rpcClient) Stream(ctx context.Context, request Request, opts ...CallOpt
 		return nil, err
 	}
 
-	// check if we already have a deadline
-	d, ok := ctx.Deadline()
-	if !ok {
-		// no deadline so we create a new one
-		ctx, _ = context.WithTimeout(ctx, callOpts.RequestTimeout)
-	} else {
-		// got a deadline so no need to setup context
-		// but we need to set the timeout we pass along
-		opt := WithRequestTimeout(d.Sub(time.Now()))
-		opt(&callOpts)
-	}
-
 	// should we noop right here?
 	select {
 	case <-ctx.Done():
-		return nil, errors.New("go.micro.client", fmt.Sprintf("%v", ctx.Err()), 408)
+		return nil, errors.Timeout("go.micro.client", fmt.Sprintf("%v", ctx.Err()))
 	default:
 	}
 
@@ -378,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, errors.InternalServerError("go.micro.client", err.Error())
+			return nil, errors.InternalServerError("go.micro.client", "backoff error: %v", err.Error())
 		}
 
 		// only sleep if greater than 0
@@ -387,19 +500,16 @@ func (r *rpcClient) Stream(ctx context.Context, request Request, opts ...CallOpt
 		}
 
 		node, err := next()
-		if err != nil && err == selector.ErrNotFound {
-			return nil, errors.NotFound("go.micro.client", err.Error())
-		} else if err != nil {
-			return nil, errors.InternalServerError("go.micro.client", err.Error())
+		service := request.Service()
+		if err != nil {
+			if err == selector.ErrNotFound {
+				return nil, errors.InternalServerError("go.micro.client", "service %s: %s", service, err.Error())
+			}
+			return nil, errors.InternalServerError("go.micro.client", "error getting next %s node: %s", service, err.Error())
 		}
 
-		address := node.Address
-		if node.Port > 0 {
-			address = fmt.Sprintf("%s:%d", address, node.Port)
-		}
-
-		stream, err := r.stream(ctx, address, request, callOpts)
-		r.opts.Selector.Mark(request.Service(), node, err)
+		stream, err := r.stream(ctx, node, request, callOpts)
+		r.opts.Selector.Mark(service, node, err)
 		return stream, err
 	}
 
@@ -408,18 +518,26 @@ func (r *rpcClient) Stream(ctx context.Context, request Request, opts ...CallOpt
 		err    error
 	}
 
-	ch := make(chan response, callOpts.Retries)
+	// get the retries
+	retries := callOpts.Retries
+
+	// disable retries when using a proxy
+	if _, _, ok := net.Proxy(request.Service(), callOpts.Address); ok {
+		retries = 0
+	}
+
+	ch := make(chan response, retries+1)
 	var grr error
 
-	for i := 0; i <= callOpts.Retries; i++ {
-		go func() {
+	for i := 0; i <= retries; i++ {
+		go func(i int) {
 			s, err := call(i)
 			ch <- response{s, err}
-		}()
+		}(i)
 
 		select {
 		case <-ctx.Done():
-			return nil, errors.New("go.micro.client", fmt.Sprintf("call timeout: %v", ctx.Err()), 408)
+			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 {
@@ -443,29 +561,72 @@ func (r *rpcClient) Stream(ctx context.Context, request Request, opts ...CallOpt
 }
 
 func (r *rpcClient) Publish(ctx context.Context, msg Message, opts ...PublishOption) error {
+	options := PublishOptions{
+		Context: context.Background(),
+	}
+	for _, o := range opts {
+		o(&options)
+	}
+
 	md, ok := metadata.FromContext(ctx)
 	if !ok {
 		md = make(map[string]string)
 	}
+
+	id := uuid.New().String()
 	md["Content-Type"] = msg.ContentType()
+	md["Micro-Topic"] = msg.Topic()
+	md["Micro-Id"] = id
+
+	// set the topic
+	topic := msg.Topic()
+
+	// get the exchange
+	if len(options.Exchange) > 0 {
+		topic = options.Exchange
+	}
 
 	// encode message body
 	cf, err := r.newCodec(msg.ContentType())
 	if err != nil {
 		return errors.InternalServerError("go.micro.client", err.Error())
 	}
-	b := &buffer{bytes.NewBuffer(nil)}
-	if err := cf(b).Write(&codec.Message{Type: codec.Publication}, msg.Payload()); err != nil {
-		return errors.InternalServerError("go.micro.client", err.Error())
-	}
-	r.once.Do(func() {
-		r.opts.Broker.Connect()
-	})
 
-	return r.opts.Broker.Publish(msg.Topic(), &broker.Message{
+	var body []byte
+
+	// passed in raw data
+	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{
+			Target: topic,
+			Type:   codec.Event,
+			Header: map[string]string{
+				"Micro-Id":    id,
+				"Micro-Topic": msg.Topic(),
+			},
+		}, msg.Payload()); err != nil {
+			return errors.InternalServerError("go.micro.client", err.Error())
+		}
+
+		// set the body
+		body = b.Bytes()
+	}
+
+	if !r.once.Load().(bool) {
+		if err = r.opts.Broker.Connect(); err != nil {
+			return errors.InternalServerError("go.micro.client", err.Error())
+		}
+		r.once.Store(true)
+	}
+
+	return r.opts.Broker.Publish(topic, &broker.Message{
 		Header: md,
-		Body:   b.Bytes(),
-	})
+		Body:   body,
+	}, broker.PublishContext(options.Context))
 }
 
 func (r *rpcClient) NewMessage(topic string, message interface{}, opts ...MessageOption) Message {
@@ -477,5 +638,5 @@ func (r *rpcClient) NewRequest(service, method string, request interface{}, reqO
 }
 
 func (r *rpcClient) String() string {
-	return "rpc"
+	return "mucp"
 }

client/rpc_client_test.go

@@ -2,35 +2,38 @@ package client
 
 import (
 	"context"
-	"errors"
 	"fmt"
 	"testing"
 
-	"github.com/micro/go-micro/registry"
-	"github.com/micro/go-micro/registry/mock"
-	"github.com/micro/go-micro/selector"
+	"go-micro.dev/v4/errors"
+	"go-micro.dev/v4/registry"
+	"go-micro.dev/v4/selector"
 )
 
+func newTestRegistry() registry.Registry {
+	return registry.NewMemoryRegistry(registry.Services(testData))
+}
+
 func TestCallAddress(t *testing.T) {
 	var called bool
 	service := "test.service"
-	method := "Test.Method"
+	endpoint := "Test.Endpoint"
 	address := "10.1.10.1:8080"
 
 	wrap := func(cf CallFunc) CallFunc {
-		return func(ctx context.Context, addr string, req Request, rsp interface{}, opts CallOptions) error {
+		return func(ctx context.Context, node *registry.Node, req Request, rsp interface{}, opts CallOptions) error {
 			called = true
 
 			if req.Service() != service {
 				return fmt.Errorf("expected service: %s got %s", service, req.Service())
 			}
 
-			if req.Method() != method {
-				return fmt.Errorf("expected service: %s got %s", method, req.Method())
+			if req.Endpoint() != endpoint {
+				return fmt.Errorf("expected service: %s got %s", endpoint, req.Endpoint())
 			}
 
-			if addr != address {
-				return fmt.Errorf("expected address: %s got %s", address, addr)
+			if node.Address != address {
+				return fmt.Errorf("expected address: %s got %s", address, node.Address)
 			}
 
 			// don't do the call
@@ -38,14 +41,14 @@ func TestCallAddress(t *testing.T) {
 		}
 	}
 
-	r := mock.NewRegistry()
+	r := newTestRegistry()
 	c := NewClient(
 		Registry(r),
 		WrapCall(wrap),
 	)
 	c.Options().Selector.Init(selector.Registry(r))
 
-	req := c.NewRequest(service, method, nil)
+	req := c.NewRequest(service, endpoint, nil)
 
 	// test calling remote address
 	if err := c.Call(context.Background(), req, nil, WithAddress(address)); err != nil {
@@ -60,16 +63,16 @@ func TestCallAddress(t *testing.T) {
 
 func TestCallRetry(t *testing.T) {
 	service := "test.service"
-	method := "Test.Method"
-	address := "10.1.10.1:8080"
+	endpoint := "Test.Endpoint"
+	address := "10.1.10.1"
 
 	var called int
 
 	wrap := func(cf CallFunc) CallFunc {
-		return func(ctx context.Context, addr string, req Request, rsp interface{}, opts CallOptions) error {
+		return func(ctx context.Context, node *registry.Node, req Request, rsp interface{}, opts CallOptions) error {
 			called++
 			if called == 1 {
-				return errors.New("retry request")
+				return errors.InternalServerError("test.error", "retry request")
 			}
 
 			// don't do the call
@@ -77,14 +80,14 @@ func TestCallRetry(t *testing.T) {
 		}
 	}
 
-	r := mock.NewRegistry()
+	r := newTestRegistry()
 	c := NewClient(
 		Registry(r),
 		WrapCall(wrap),
 	)
 	c.Options().Selector.Init(selector.Registry(r))
 
-	req := c.NewRequest(service, method, nil)
+	req := c.NewRequest(service, endpoint, nil)
 
 	// test calling remote address
 	if err := c.Call(context.Background(), req, nil, WithAddress(address)); err != nil {
@@ -101,25 +104,23 @@ func TestCallWrapper(t *testing.T) {
 	var called bool
 	id := "test.1"
 	service := "test.service"
-	method := "Test.Method"
-	host := "10.1.10.1"
-	port := 8080
+	endpoint := "Test.Endpoint"
 	address := "10.1.10.1:8080"
 
 	wrap := func(cf CallFunc) CallFunc {
-		return func(ctx context.Context, addr string, req Request, rsp interface{}, opts CallOptions) error {
+		return func(ctx context.Context, node *registry.Node, req Request, rsp interface{}, opts CallOptions) error {
 			called = true
 
 			if req.Service() != service {
 				return fmt.Errorf("expected service: %s got %s", service, req.Service())
 			}
 
-			if req.Method() != method {
-				return fmt.Errorf("expected service: %s got %s", method, req.Method())
+			if req.Endpoint() != endpoint {
+				return fmt.Errorf("expected service: %s got %s", endpoint, req.Endpoint())
 			}
 
-			if addr != address {
-				return fmt.Errorf("expected address: %s got %s", address, addr)
+			if node.Address != address {
+				return fmt.Errorf("expected address: %s got %s", address, node.Address)
 			}
 
 			// don't do the call
@@ -127,7 +128,7 @@ func TestCallWrapper(t *testing.T) {
 		}
 	}
 
-	r := mock.NewRegistry()
+	r := newTestRegistry()
 	c := NewClient(
 		Registry(r),
 		WrapCall(wrap),
@@ -138,15 +139,17 @@ func TestCallWrapper(t *testing.T) {
 		Name:    service,
 		Version: "latest",
 		Nodes: []*registry.Node{
-			&registry.Node{
+			{
 				Id:      id,
-				Address: host,
-				Port:    port,
+				Address: address,
+				Metadata: map[string]string{
+					"protocol": "mucp",
+				},
 			},
 		},
 	})
 
-	req := c.NewRequest(service, method, nil)
+	req := c.NewRequest(service, endpoint, nil)
 	if err := c.Call(context.Background(), req, nil); err != nil {
 		t.Fatal("call wrapper error", err)
 	}