fix conflicting port range test

* Add grpc plugin

* remove stale readmes

.github/FUNDING.yml

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

.github/ISSUE_TEMPLATE/bug_report.md

@@ -2,23 +2,24 @@
 name: Bug report
 about: For reporting bugs in go-micro
 title: "[BUG]"
-labels: ''
-assignees: ''
-
+labels: ""
+assignees: ""
 ---
 
-**Describe the bug**
+## 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:**
+## How to reproduce the bug
 
 If possible, please include a minimal code snippet here.
 
-**Environment:**
+## Environment
+
 Go Version: please paste `go version` output here
-```
+
+```go
 please paste `go env` output here
 ```

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

@@ -2,9 +2,8 @@
 name: Feature request / Enhancement
 about: If you have a need not served by go-micro
 title: "[FEATURE]"
-labels: ''
-assignees: ''
-
+labels: ""
+assignees: ""
 ---
 
 **Is your feature request related to a problem? Please describe.**

.github/ISSUE_TEMPLATE/question.md

@@ -1,13 +1,12 @@
 ---
 name: Question
 about: Ask a question about go-micro
-title: ''
-labels: ''
-assignees: ''
-
+title: ""
+labels: ""
+assignees: ""
 ---
 
-Before asking, please check if your question has already been answered: 
+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

.github/PULL_REQUEST_TEMPLATE.md

@@ -1,10 +1,11 @@
-## Pull Request template
+# 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. 
+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**
+## PLEASE REMOVE THIS TEMPLATE BEFORE SUBMITTING

.github/generate.sh

@@ -1,15 +0,0 @@
-#!/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

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

@@ -0,0 +1,33 @@
+name: Run Tests
+on:
+  push:
+    branches:
+      - "**"
+  pull_request:
+    types:
+      - opened
+      - reopened
+    branches:
+      - "**"
+jobs:
+  unittests:
+    name: Unit Tests
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+      - name: Set up Go
+        uses: actions/setup-go@v3
+        with:
+          go-version: 1.24
+          check-latest: true
+          cache: true
+      - name: Get dependencies
+        run: |
+          go install github.com/kyoh86/richgo@latest
+          go get -v -t -d ./...
+      - name: Run tests
+        id: tests
+        run: richgo test -v -race -cover -bench=. ./...
+        env:
+          IN_TRAVIS_CI: yes
+          RICHGO_FORCE_COLOR: 1

.github/workflows/tests.yml

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

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

.golangci.yaml

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

.richstyle.yaml

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

CHANGELOG.md

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

LICENSE

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

README.md

@@ -1,5 +1,4 @@
-# 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 [![Go.Dev reference](https://img.shields.io/badge/go.dev-reference-007d9c?logo=go&logoColor=white&style=flat-square)](https://pkg.go.dev/go-micro.dev/v5?tab=doc) [![Go Report Card](https://goreportcard.com/badge/github.com/go-micro/go-micro)](https://goreportcard.com/report/github.com/go-micro/go-micro) [![Discord](https://img.shields.io/badge/discord-chat-800080?style=flat-square)](https://discord.gg/UmFkPbu32m)
 
 Go Micro is a framework for distributed systems development.
 
@@ -20,8 +19,8 @@ Go Micro abstracts away the details of distributed systems. Here are the main fe
 - **Dynamic Config** - Load and hot reload dynamic config from anywhere. The config interface provides a way to load application
   level config from any source such as env vars, file, etcd. You can merge the sources and even define fallbacks.
 
-- **Data Storage** - A simple data store interface to read, write and delete records. It includes support for memory, file and
-  CockroachDB by default. State and persistence becomes a core requirement beyond prototyping and Micro looks to build that into the framework.
+- **Data Storage** - A simple data store interface to read, write and delete records. It includes support for many storage backends
+in the plugins repo. State and persistence becomes a core requirement beyond prototyping and Micro looks to build that into the framework.
 
 - **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
@@ -41,58 +40,68 @@ Go Micro abstracts away the details of distributed systems. Here are the main fe
 - **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.
 
-- **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.
-
-- **Synchronization** - Distributed systems are often built in an eventually consistent manner. Support for distributed locking and
-  leadership are built in as a Sync interface. When using an eventually consistent database or scheduling use the Sync interface.
-
 - **Pluggable Interfaces** - Go Micro makes use of Go interfaces for each distributed system abstraction. Because of this these interfaces
   are pluggable and allows Go Micro to be runtime agnostic. You can plugin any underlying technology.
 
 ## Getting Started
 
-To make use of Go Micro
+To make use of Go Micro import it 
 
 ```golang
-import "go-micro.dev/v4"
-
-// create a new service
-service := micro.NewService(
-    micro.Name("helloworld"),
-)
-
-// initialise flags
-service.Init()
-
-// start the service
-service.Run()
+import "go-micro.dev/v5"
 ```
 
-See the [examples](https://github.com/go-micro/examples) for detailed information on usage.
+Create a service and register a handler
 
-## Code Generation
+```golang
+package main
 
-See [cmd/protoc-gen-micro](https://github.com/micro/go-micro/tree/master/cmd/protoc-gen-micro) for protobuf code generation.
+import (
+        "go-micro.dev/v5"
+)
 
-## Community
+type Request struct {
+        Name string `json:"name"`
+}
 
-See [github.com/go-micro](https://github.com/go-micro) for community led projects.
+type Response struct {
+        Message string `json:"message"`
+}
 
-- [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)
+type Say struct{}
 
-## Changelog
+func (h *Say) Hello(ctx context.Context, req *Request, rsp *Response) error {
+        rsp.Message = "Hello " + req.Name
+        return nil
+}
 
-See [CHANGELOG.md](https://github.com/micro/go-micro/tree/master/CHANGELOG.md) for release history.
+func main() {
+        // create the service
+        service := micro.New("helloworld")
 
-## Evolution
+        // register handler
+        service.Handle(new(Say))
 
-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).
+        // run the service
+        service.Run()
+}
+```
 
-## License
+Set a fixed address
 
-Go Micro is Apache 2.0 licensed.
+```golang
+service := micro.NewService(
+    micro.Name("helloworld"),
+    micro.Address(":8080"),
+)
+```
+
+Call it via curl
+
+```
+curl -XPOST \
+     -H 'Content-Type: application/json' \
+     -H 'Micro-Endpoint: Say.Hello' \
+     -d '{"name": "alice"}' \
+      http://localhost:8080
+```

_config.yml

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

api/api.go

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

auth/auth.go

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

auth/noop.go

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

auth/options.go

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

auth/rules.go

@@ -8,7 +8,7 @@ import (
 
 // Verify an account has access to a resource using the rules provided. If the account does not have
 // access an error will be returned. If there are no rules provided which match the resource, an error
-// will be returned
+// will be returned.
 func Verify(rules []*Rule, acc *Account, res *Resource) error {
 	// the rule is only to be applied if the type matches the resource or is catch-all (*)
 	validTypes := []string{"*", res.Type}

auth/rules_test.go

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

broker/broker.go

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

broker/http.go

@@ -1,9 +1,8 @@
-// Package http provides a http based message broker
+// Package broker provides a http based message broker
 package broker
 
 import (
 	"bytes"
-	"context"
 	"crypto/tls"
 	"errors"
 	"fmt"
@@ -17,50 +16,53 @@ import (
 	"time"
 
 	"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"
+	"go-micro.dev/v5/codec/json"
+	merr "go-micro.dev/v5/errors"
+	"go-micro.dev/v5/registry"
+	"go-micro.dev/v5/registry/cache"
+	"go-micro.dev/v5/transport/headers"
+	maddr "go-micro.dev/v5/util/addr"
+	mnet "go-micro.dev/v5/util/net"
+	mls "go-micro.dev/v5/util/tls"
 	"golang.org/x/net/http2"
 )
 
-// HTTP Broker is a point to point async broker
+// HTTP Broker is a point to point async broker.
 type httpBroker struct {
-	id      string
-	address string
-	opts    Options
+	opts Options
+
+	r registry.Registry
 
 	mux *http.ServeMux
 
-	c *http.Client
-	r registry.Registry
-
-	sync.RWMutex
+	c           *http.Client
 	subscribers map[string][]*httpSubscriber
-	running     bool
 	exit        chan chan error
 
+	inbox   map[string][][]byte
+	id      string
+	address string
+
+	sync.RWMutex
+
 	// offline message inbox
-	mtx   sync.RWMutex
-	inbox map[string][][]byte
+	mtx     sync.RWMutex
+	running bool
 }
 
 type httpSubscriber struct {
 	opts  SubscribeOptions
-	id    string
-	topic string
 	fn    Handler
 	svc   *registry.Service
 	hb    *httpBroker
+	id    string
+	topic string
 }
 
 type httpEvent struct {
+	err error
 	m   *Message
 	t   string
-	err error
 }
 
 var (
@@ -107,11 +109,10 @@ func newTransport(config *tls.Config) *http.Transport {
 }
 
 func newHttpBroker(opts ...Option) Broker {
-	options := Options{
-		Codec:    json.Marshaler{},
-		Context:  context.TODO(),
-		Registry: registry.DefaultRegistry,
-	}
+	options := *NewOptions(opts...)
+
+	options.Registry = registry.DefaultRegistry
+	options.Codec = json.Marshaler{}
 
 	for _, o := range opts {
 		o(&options)
@@ -315,8 +316,8 @@ func (h *httpBroker) ServeHTTP(w http.ResponseWriter, req *http.Request) {
 		return
 	}
 
-	topic := m.Header["Micro-Topic"]
-	//delete(m.Header, ":topic")
+	topic := m.Header[headers.Message]
+	// delete(m.Header, ":topic")
 
 	if len(topic) == 0 {
 		errr := merr.InternalServerError("go.micro.broker", "Topic not found")
@@ -519,7 +520,7 @@ func (h *httpBroker) Publish(topic string, msg *Message, opts ...PublishOption)
 		m.Header[k] = v
 	}
 
-	m.Header["Micro-Topic"] = topic
+	m.Header[headers.Message] = topic
 
 	// encode the message
 	b, err := h.opts.Codec.Marshal(m)
@@ -704,7 +705,7 @@ func (h *httpBroker) String() string {
 	return "http"
 }
 
-// NewBroker returns a new http broker
+// NewBroker returns a new http broker.
 func NewBroker(opts ...Option) Broker {
 	return newHttpBroker(opts...)
 }

broker/http_test.go

@@ -6,12 +6,12 @@ import (
 	"time"
 
 	"github.com/google/uuid"
-	"go-micro.dev/v4/broker"
-	"go-micro.dev/v4/registry"
+	"go-micro.dev/v5/broker"
+	"go-micro.dev/v5/registry"
 )
 
 var (
-	// mock data
+	// mock data.
 	testData = map[string][]*registry.Service{
 		"foo": {
 			{
@@ -56,19 +56,19 @@ func newTestRegistry() registry.Registry {
 	return registry.NewMemoryRegistry(registry.Services(testData))
 }
 
-func sub(be *testing.B, c int) {
-	be.StopTimer()
+func sub(b *testing.B, c int) {
+	b.StopTimer()
 	m := newTestRegistry()
 
-	b := broker.NewBroker(broker.Registry(m))
+	brker := broker.NewBroker(broker.Registry(m))
 	topic := uuid.New().String()
 
-	if err := b.Init(); err != nil {
-		be.Fatalf("Unexpected init error: %v", err)
+	if err := brker.Init(); err != nil {
+		b.Fatalf("Unexpected init error: %v", err)
 	}
 
-	if err := b.Connect(); err != nil {
-		be.Fatalf("Unexpected connect error: %v", err)
+	if err := brker.Connect(); err != nil {
+		b.Fatalf("Unexpected connect error: %v", err)
 	}
 
 	msg := &broker.Message{
@@ -82,52 +82,54 @@ func sub(be *testing.B, c int) {
 	done := make(chan bool, c)
 
 	for i := 0; i < c; i++ {
-		sub, err := b.Subscribe(topic, func(p broker.Event) error {
+		sub, err := brker.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))
+				b.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)
+			b.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)
+	for i := 0; i < b.N; i++ {
+		b.StartTimer()
+		if err := brker.Publish(topic, msg); err != nil {
+			b.Fatalf("Unexpected publish error: %v", err)
 		}
 		<-done
-		be.StopTimer()
+		b.StopTimer()
 	}
 
 	for _, sub := range subs {
-		sub.Unsubscribe()
+		if err := sub.Unsubscribe(); err != nil {
+			b.Fatalf("Unexpected unsubscribe error: %v", err)
+		}
 	}
 
-	if err := b.Disconnect(); err != nil {
-		be.Fatalf("Unexpected disconnect error: %v", err)
+	if err := brker.Disconnect(); err != nil {
+		b.Fatalf("Unexpected disconnect error: %v", err)
 	}
 }
 
-func pub(be *testing.B, c int) {
-	be.StopTimer()
+func pub(b *testing.B, c int) {
+	b.StopTimer()
 	m := newTestRegistry()
-	b := broker.NewBroker(broker.Registry(m))
+	brk := broker.NewBroker(broker.Registry(m))
 	topic := uuid.New().String()
 
-	if err := b.Init(); err != nil {
-		be.Fatalf("Unexpected init error: %v", err)
+	if err := brk.Init(); err != nil {
+		b.Fatalf("Unexpected init error: %v", err)
 	}
 
-	if err := b.Connect(); err != nil {
-		be.Fatalf("Unexpected connect error: %v", err)
+	if err := brk.Connect(); err != nil {
+		b.Fatalf("Unexpected connect error: %v", err)
 	}
 
 	msg := &broker.Message{
@@ -139,27 +141,27 @@ func pub(be *testing.B, c int) {
 
 	done := make(chan bool, c*4)
 
-	sub, err := b.Subscribe(topic, func(p broker.Event) error {
+	sub, err := brk.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))
+			b.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)
+		b.Fatalf("Unexpected subscribe error: %v", err)
 	}
 
 	var wg sync.WaitGroup
 	ch := make(chan int, c*4)
-	be.StartTimer()
+	b.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)
+				if err := brk.Publish(topic, msg); err != nil {
+					b.Fatalf("Unexpected publish error: %v", err)
 				}
 				select {
 				case <-done:
@@ -170,19 +172,19 @@ func pub(be *testing.B, c int) {
 		}()
 	}
 
-	for i := 0; i < be.N; i++ {
+	for i := 0; i < b.N; i++ {
 		wg.Add(1)
 		ch <- i
 	}
 
 	wg.Wait()
-	be.StopTimer()
+	b.StopTimer()
 	sub.Unsubscribe()
 	close(ch)
 	close(done)
 
-	if err := b.Disconnect(); err != nil {
-		be.Fatalf("Unexpected disconnect error: %v", err)
+	if err := brk.Disconnect(); err != nil {
+		b.Fatalf("Unexpected disconnect error: %v", err)
 	}
 }
 
@@ -226,7 +228,9 @@ func TestBroker(t *testing.T) {
 	}
 
 	<-done
-	sub.Unsubscribe()
+	if err := sub.Unsubscribe(); err != nil {
+		t.Fatalf("Unexpected unsubscribe error: %v", err)
+	}
 
 	if err := b.Disconnect(); err != nil {
 		t.Fatalf("Unexpected disconnect error: %v", err)
@@ -282,7 +286,9 @@ func TestConcurrentSubBroker(t *testing.T) {
 	wg.Wait()
 
 	for _, sub := range subs {
-		sub.Unsubscribe()
+		if err := sub.Unsubscribe(); err != nil {
+			t.Fatalf("Unexpected unsubscribe error: %v", err)
+		}
 	}
 
 	if err := b.Disconnect(); err != nil {
@@ -336,7 +342,9 @@ func TestConcurrentPubBroker(t *testing.T) {
 
 	wg.Wait()
 
-	sub.Unsubscribe()
+	if err := sub.Unsubscribe(); err != nil {
+		t.Fatalf("Unexpected unsubscribe error: %v", err)
+	}
 
 	if err := b.Disconnect(); err != nil {
 		t.Fatalf("Unexpected disconnect error: %v", err)

broker/memory.go

@@ -2,44 +2,44 @@
 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"
+	log "go-micro.dev/v5/logger"
+	maddr "go-micro.dev/v5/util/addr"
+	mnet "go-micro.dev/v5/util/net"
 )
 
 type memoryBroker struct {
-	opts Options
+	opts *Options
+
+	Subscribers map[string][]*memorySubscriber
 
 	addr string
 	sync.RWMutex
-	connected   bool
-	Subscribers map[string][]*memorySubscriber
+	connected bool
 }
 
 type memoryEvent struct {
-	opts    Options
-	topic   string
 	err     error
 	message interface{}
+	opts    *Options
+	topic   string
 }
 
 type memorySubscriber struct {
-	id      string
-	topic   string
+	opts    SubscribeOptions
 	exit    chan bool
 	handler Handler
-	opts    SubscribeOptions
+	id      string
+	topic   string
 }
 
 func (m *memoryBroker) Options() Options {
-	return m.opts
+	return *m.opts
 }
 
 func (m *memoryBroker) Address() string {
@@ -84,7 +84,7 @@ func (m *memoryBroker) Disconnect() error {
 
 func (m *memoryBroker) Init(opts ...Option) error {
 	for _, o := range opts {
-		o(&m.opts)
+		o(m.opts)
 	}
 	return nil
 }
@@ -190,9 +190,7 @@ func (m *memoryEvent) Message() *Message {
 	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)
-			}
+			m.opts.Logger.Logf(log.ErrorLevel, "[memory]: failed to unmarshal: %v\n", err)
 			return nil
 		}
 		return msg
@@ -223,14 +221,9 @@ func (m *memorySubscriber) Unsubscribe() error {
 }
 
 func NewMemoryBroker(opts ...Option) Broker {
-	options := Options{
-		Context: context.Background(),
-	}
+	options := NewOptions(opts...)
 
 	rand.Seed(time.Now().UnixNano())
-	for _, o := range opts {
-		o(&options)
-	}
 
 	return &memoryBroker{
 		opts:        options,

broker/memory_test.go

@@ -4,7 +4,7 @@ import (
 	"fmt"
 	"testing"
 
-	"go-micro.dev/v4/broker"
+	"go-micro.dev/v5/broker"
 )
 
 func TestMemoryBroker(t *testing.T) {

broker/options.go

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

cache/cache.go

@@ -22,7 +22,6 @@ var (
 )
 
 // 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)

cache/memory.go

@@ -8,9 +8,9 @@ import (
 
 type memCache struct {
 	opts Options
-	sync.RWMutex
 
 	items map[string]Item
+	sync.RWMutex
 }
 
 func (c *memCache) Get(ctx context.Context, key string) (interface{}, time.Time, error) {

cache/options.go

@@ -3,16 +3,20 @@ package cache
 import (
 	"context"
 	"time"
+
+	"go-micro.dev/v5/logger"
 )
 
 // 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
+	// Logger is the be used logger
+	Logger logger.Logger
+	Items  map[string]Item
+	// Address represents the address or other connection information of the cache service.
+	Address    string
+	Expiration time.Duration
 }
 
 // Option manipulates the Options passed.
@@ -32,25 +36,33 @@ func Items(i map[string]Item) Option {
 	}
 }
 
-// WithAddress sets the cache service address or connection information
+// 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
+// WithContext sets the cache context, for any extra configuration.
 func WithContext(c context.Context) Option {
 	return func(o *Options) {
 		o.Context = c
 	}
 }
 
+// WithLogger sets underline logger.
+func WithLogger(l logger.Logger) Option {
+	return func(o *Options) {
+		o.Logger = l
+	}
+}
+
 // NewOptions returns a new options struct.
 func NewOptions(opts ...Option) Options {
 	options := Options{
 		Expiration: DefaultExpiration,
 		Items:      make(map[string]Item),
+		Logger:     logger.DefaultLogger,
 	}
 
 	for _, o := range opts {

client/backoff.go

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

client/cache.go

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

client/cache_test.go

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

client/client.go

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

client/common_test.go

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

client/grpc/codec.go

@@ -6,8 +6,8 @@ import (
 	"fmt"
 	"strings"
 
-	"go-micro.dev/v4/codec"
-	"go-micro.dev/v4/codec/bytes"
+	"go-micro.dev/v5/codec"
+	"go-micro.dev/v5/codec/bytes"
 	"google.golang.org/grpc"
 	"google.golang.org/grpc/encoding"
 	"google.golang.org/protobuf/encoding/protojson"
@@ -36,7 +36,7 @@ var (
 	}
 )
 
-// UseNumber fix unmarshal Number(8234567890123456789) to interface(8.234567890123457e+18)
+// UseNumber fix unmarshal Number(8234567890123456789) to interface(8.234567890123457e+18).
 func UseNumber() {
 	useNumber = true
 }

client/grpc/error.go

@@ -1,10 +1,11 @@
 package grpc
 
 import (
-	"go-micro.dev/v4/errors"
+	"net/http"
+
+	"go-micro.dev/v5/errors"
 	"google.golang.org/grpc/codes"
 	"google.golang.org/grpc/status"
-	"net/http"
 )
 
 func microError(err error) error {
@@ -65,4 +66,4 @@ func microStatusFromGrpcCode(code codes.Code) int32 {
 	}
 
 	return http.StatusInternalServerError
-}
+}

client/grpc/grpc.go

@@ -11,15 +11,15 @@ import (
 	"sync/atomic"
 	"time"
 
-	"go-micro.dev/v4/broker"
-	"go-micro.dev/v4/client"
-	"go-micro.dev/v4/cmd"
-	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"
-	pnet "go-micro.dev/v4/util/net"
+	"go-micro.dev/v5/broker"
+	"go-micro.dev/v5/client"
+	"go-micro.dev/v5/cmd"
+	raw "go-micro.dev/v5/codec/bytes"
+	"go-micro.dev/v5/errors"
+	"go-micro.dev/v5/metadata"
+	"go-micro.dev/v5/registry"
+	"go-micro.dev/v5/selector"
+	pnet "go-micro.dev/v5/util/net"
 	"google.golang.org/grpc"
 	"google.golang.org/grpc/credentials"
 	"google.golang.org/grpc/encoding"
@@ -40,7 +40,7 @@ func init() {
 	encoding.RegisterCodec(wrapCodec{bytesCodec{}})
 }
 
-// secure returns the dial option for whether its a secure or insecure connection
+// secure returns the dial option for whether its a secure or insecure connection.
 func (g *grpcClient) secure(addr string) grpc.DialOption {
 	// first we check if theres'a  tls config
 	if g.opts.Context != nil {
@@ -166,7 +166,7 @@ func (g *grpcClient) call(ctx context.Context, node *registry.Node, req client.R
 		grpcCallOptions := []grpc.CallOption{
 			grpc.ForceCodec(cf),
 			grpc.CallContentSubtype(cf.Name())}
-		if opts := g.getGrpcCallOptions(); opts != nil {
+		if opts := callOpts(opts); opts != nil {
 			grpcCallOptions = append(grpcCallOptions, opts...)
 		}
 		err := cc.Invoke(ctx, methodToGRPC(req.Service(), req.Endpoint()), req.Body(), rsp, grpcCallOptions...)
@@ -205,6 +205,11 @@ func (g *grpcClient) stream(ctx context.Context, node *registry.Node, req client
 	header["x-content-type"] = req.ContentType()
 
 	md := gmetadata.New(header)
+
+	// WebSocket connection adds the `Connection: Upgrade` header.
+	// But as per the HTTP/2 spec, the `Connection` header makes the request malformed
+	delete(md, "connection")
+
 	ctx = gmetadata.NewOutgoingContext(ctx, md)
 
 	cf, err := g.newGRPCCodec(req.ContentType())
@@ -246,16 +251,16 @@ func (g *grpcClient) stream(ctx context.Context, node *registry.Node, req client
 		grpc.ForceCodec(wc),
 		grpc.CallContentSubtype(cf.Name()),
 	}
-	if opts := g.getGrpcCallOptions(); opts != nil {
+	if opts := callOpts(opts); opts != nil {
 		grpcCallOptions = append(grpcCallOptions, opts...)
 	}
 
-	// create a new cancelling context
+	// create a new canceling context
 	newCtx, cancel := context.WithCancel(ctx)
 
 	st, err := cc.NewStream(newCtx, desc, methodToGRPC(req.Service(), req.Endpoint()), grpcCallOptions...)
 	if err != nil {
-		// we need to cleanup as we dialled and created a context
+		// we need to cleanup as we dialed and created a context
 		// cancel the context
 		cancel()
 		// close the connection
@@ -673,26 +678,6 @@ func (g *grpcClient) getGrpcDialOptions() []grpc.DialOption {
 	return opts
 }
 
-func (g *grpcClient) getGrpcCallOptions() []grpc.CallOption {
-	if g.opts.CallOptions.Context == nil {
-		return nil
-	}
-
-	v := g.opts.CallOptions.Context.Value(grpcCallOptions{})
-
-	if v == nil {
-		return nil
-	}
-
-	opts, ok := v.([]grpc.CallOption)
-
-	if !ok {
-		return nil
-	}
-
-	return opts
-}
-
 func newClient(opts ...client.Option) client.Client {
 	options := client.NewOptions()
 	// default content type for grpc

client/grpc/grpc_pool_test.go

@@ -14,7 +14,7 @@ func testPool(t *testing.T, size int, ttl time.Duration, idle int, ms int) {
 	// setup server
 	l, err := net.Listen("tcp", ":0")
 	if err != nil {
-		t.Fatalf("failed to listen: %v", err)
+		t.Errorf("failed to listen: %v", err)
 	}
 	defer l.Close()
 
@@ -42,7 +42,7 @@ func testPool(t *testing.T, size int, ttl time.Duration, idle int, ms int) {
 		}
 
 		if rsp.Message != "Hello John" {
-			t.Fatalf("Got unexpected response %v", rsp.Message)
+			t.Errorf("Got unexpected response %v", rsp.Message)
 		}
 
 		// release the conn
@@ -51,7 +51,7 @@ func testPool(t *testing.T, size int, ttl time.Duration, idle int, ms int) {
 		p.Lock()
 		if i := p.conns[l.Addr().String()].count; i > size {
 			p.Unlock()
-			t.Fatalf("pool size %d is greater than expected %d", i, size)
+			t.Errorf("pool size %d is greater than expected %d", i, size)
 		}
 		p.Unlock()
 	}

client/grpc/grpc_test.go

@@ -5,10 +5,10 @@ import (
 	"net"
 	"testing"
 
-	"go-micro.dev/v4/client"
-	"go-micro.dev/v4/errors"
-	"go-micro.dev/v4/registry"
-	"go-micro.dev/v4/selector"
+	"go-micro.dev/v5/client"
+	"go-micro.dev/v5/errors"
+	"go-micro.dev/v5/registry"
+	"go-micro.dev/v5/selector"
 	pgrpc "google.golang.org/grpc"
 	pb "google.golang.org/grpc/examples/helloworld/helloworld"
 )
@@ -18,7 +18,7 @@ type greeterServer struct {
 	pb.UnimplementedGreeterServer
 }
 
-// SayHello implements helloworld.GreeterServer
+// SayHello implements helloworld.GreeterServer.
 func (g *greeterServer) SayHello(ctx context.Context, in *pb.HelloRequest) (*pb.HelloReply, error) {
 	if in.Name == "Error" {
 		return nil, &errors.Error{Id: "1", Code: 99, Detail: "detail"}
@@ -109,5 +109,4 @@ func TestGRPCClient(t *testing.T) {
 	if verr.Code != 99 && verr.Id != "1" && verr.Detail != "detail" {
 		t.Fatalf("invalid error received %#+v\n", verr)
 	}
-
 }

client/grpc/message.go

@@ -1,7 +1,7 @@
 package grpc
 
 import (
-	"go-micro.dev/v4/client"
+	"go-micro.dev/v5/client"
 )
 
 type grpcEvent struct {

client/grpc/options.go

@@ -5,18 +5,18 @@ import (
 	"context"
 	"crypto/tls"
 
-	"go-micro.dev/v4/client"
+	"go-micro.dev/v5/client"
 	"google.golang.org/grpc"
 	"google.golang.org/grpc/encoding"
 )
 
 var (
 	// DefaultPoolMaxStreams maximum streams on a connectioin
-	// (20)
+	// (20).
 	DefaultPoolMaxStreams = 20
 
 	// DefaultPoolMaxIdle maximum idle conns of a pool
-	// (50)
+	// (50).
 	DefaultPoolMaxIdle = 50
 
 	// DefaultMaxRecvMsgSize maximum message that client can receive
@@ -37,7 +37,7 @@ type maxSendMsgSizeKey struct{}
 type grpcDialOptions struct{}
 type grpcCallOptions struct{}
 
-// maximum streams on a connectioin
+// maximum streams on a connectioin.
 func PoolMaxStreams(n int) client.Option {
 	return func(o *client.Options) {
 		if o.Context == nil {
@@ -47,7 +47,7 @@ func PoolMaxStreams(n int) client.Option {
 	}
 }
 
-// maximum idle conns of a pool
+// maximum idle conns of a pool.
 func PoolMaxIdle(d int) client.Option {
 	return func(o *client.Options) {
 		if o.Context == nil {
@@ -57,7 +57,7 @@ func PoolMaxIdle(d int) client.Option {
 	}
 }
 
-// gRPC Codec to be used to encode/decode requests for a given content type
+// gRPC Codec to be used to encode/decode requests for a given content type.
 func Codec(contentType string, c encoding.Codec) client.Option {
 	return func(o *client.Options) {
 		codecs := make(map[string]encoding.Codec)
@@ -72,7 +72,7 @@ func Codec(contentType string, c encoding.Codec) client.Option {
 	}
 }
 
-// AuthTLS should be used to setup a secure authentication using TLS
+// AuthTLS should be used to setup a secure authentication using TLS.
 func AuthTLS(t *tls.Config) client.Option {
 	return func(o *client.Options) {
 		if o.Context == nil {
@@ -82,9 +82,7 @@ func AuthTLS(t *tls.Config) client.Option {
 	}
 }
 
-//
 // MaxRecvMsgSize set the maximum size of message that client can receive.
-//
 func MaxRecvMsgSize(s int) client.Option {
 	return func(o *client.Options) {
 		if o.Context == nil {
@@ -94,9 +92,7 @@ func MaxRecvMsgSize(s int) client.Option {
 	}
 }
 
-//
 // MaxSendMsgSize set the maximum size of message that client can send.
-//
 func MaxSendMsgSize(s int) client.Option {
 	return func(o *client.Options) {
 		if o.Context == nil {
@@ -106,9 +102,7 @@ func MaxSendMsgSize(s int) client.Option {
 	}
 }
 
-//
-// DialOptions to be used to configure gRPC dial options
-//
+// DialOptions to be used to configure gRPC dial options.
 func DialOptions(opts ...grpc.DialOption) client.CallOption {
 	return func(o *client.CallOptions) {
 		if o.Context == nil {
@@ -118,9 +112,7 @@ func DialOptions(opts ...grpc.DialOption) client.CallOption {
 	}
 }
 
-//
-// CallOptions to be used to configure gRPC call options
-//
+// CallOptions to be used to configure gRPC call options.
 func CallOptions(opts ...grpc.CallOption) client.CallOption {
 	return func(o *client.CallOptions) {
 		if o.Context == nil {
@@ -129,3 +121,23 @@ func CallOptions(opts ...grpc.CallOption) client.CallOption {
 		o.Context = context.WithValue(o.Context, grpcCallOptions{}, opts)
 	}
 }
+
+func callOpts(opts client.CallOptions) []grpc.CallOption {
+	if opts.Context == nil {
+		return nil
+	}
+
+	v := opts.Context.Value(grpcCallOptions{})
+
+	if v == nil {
+		return nil
+	}
+
+	options, ok := v.([]grpc.CallOption)
+
+	if !ok {
+		return nil
+	}
+
+	return options
+}

client/grpc/request.go

@@ -4,8 +4,8 @@ import (
 	"fmt"
 	"strings"
 
-	"go-micro.dev/v4/client"
-	"go-micro.dev/v4/codec"
+	"go-micro.dev/v5/client"
+	"go-micro.dev/v5/codec"
 )
 
 type grpcRequest struct {
@@ -17,7 +17,7 @@ type grpcRequest struct {
 	codec       codec.Codec
 }
 
-// service Struct.Method /service.Struct/Method
+// service Struct.Method /service.Struct/Method.
 func methodToGRPC(service, method string) string {
 	// no method or already grpc method
 	if len(method) == 0 || method[0] == '/' {

client/grpc/response.go

@@ -3,8 +3,8 @@ package grpc
 import (
 	"strings"
 
-	"go-micro.dev/v4/codec"
-	"go-micro.dev/v4/codec/bytes"
+	"go-micro.dev/v5/codec"
+	"go-micro.dev/v5/codec/bytes"
 	"google.golang.org/grpc"
 	"google.golang.org/grpc/encoding"
 )
@@ -16,12 +16,12 @@ type response struct {
 	gcodec codec.Codec
 }
 
-// Read the response
+// Read the response.
 func (r *response) Codec() codec.Reader {
 	return r.gcodec
 }
 
-// read the header
+// read the header.
 func (r *response) Header() map[string]string {
 	md, err := r.stream.Header()
 	if err != nil {
@@ -34,7 +34,7 @@ func (r *response) Header() map[string]string {
 	return hdr
 }
 
-// Read the undecoded response
+// Read the undecoded response.
 func (r *response) Read() ([]byte, error) {
 	f := &bytes.Frame{}
 	if err := r.gcodec.ReadBody(f); err != nil {

client/grpc/stream.go

@@ -5,11 +5,11 @@ import (
 	"io"
 	"sync"
 
-	"go-micro.dev/v4/client"
+	"go-micro.dev/v5/client"
 	"google.golang.org/grpc"
 )
 
-// Implements the streamer interface
+// Implements the streamer interface.
 type grpcStream struct {
 	sync.RWMutex
 	closed   bool

client/options.go

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

client/options_test.go

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

client/retry.go

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