Merge pull request #178 from unistack-org/fsm

fsm: improve and convert to interface

.github/FUNDING.yml

@@ -1,3 +0,0 @@
-# These are supported funding model platforms
-
-issuehunt: micro/development

.github/PULL_REQUEST_TEMPLATE.md

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

.github/dependabot.yml

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

.github/workflows/autoapprove.yml

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

.github/workflows/automerge.yml

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

.github/workflows/build.yml

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

.github/workflows/codecov.yml

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

.github/workflows/codeql-analysis.yml

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

.github/workflows/dependabot-automerge.yml

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

.github/workflows/docker.yml

@@ -1,19 +0,0 @@
-name: Docker
-
-on:
-  push:
-    branches:
-    - master
-
-jobs:
-  build:
-     runs-on: ubuntu-latest
-     steps:
-       - uses: actions/checkout@v2
-         name: Check out repository
-       - uses: elgohr/Publish-Docker-Github-Action@2.12
-         name: Build and Push Docker Image
-         with:
-           name: micro/go-micro
-           username: ${{ secrets.DOCKER_USERNAME }}
-           password: ${{ secrets.DOCKER_PASSWORD }}

.github/workflows/pr.yml

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

.github/workflows/tests.yml

@@ -1,51 +0,0 @@
-name: Run tests
-on: [push]
-
-jobs:
-
-  test:
-    name: Test repo
-    runs-on: ubuntu-latest
-    steps:
-
-    - name: Set up Go 1.13
-      uses: actions/setup-go@v1
-      with:
-        go-version: 1.13
-      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 ./...
-  
-    - name: Notify of test failure
-      if: failure()
-      uses: rtCamp/action-slack-notify@v2.0.0
-      env:
-        SLACK_CHANNEL: build
-        SLACK_COLOR: '#BF280A'
-        SLACK_ICON: https://github.githubassets.com/images/modules/logos_page/GitHub-Mark.png
-        SLACK_TITLE: Tests Failed
-        SLACK_USERNAME: GitHub Actions
-        SLACK_WEBHOOK: ${{ secrets.SLACK_WEBHOOK_URL }}
-        
-    - name: Notify of test success
-      if: success()
-      uses: rtCamp/action-slack-notify@v2.0.0
-      env:
-        SLACK_CHANNEL: build
-        SLACK_COLOR: '#1FAD2B'
-        SLACK_ICON: https://github.githubassets.com/images/modules/logos_page/GitHub-Mark.png
-        SLACK_TITLE: Tests Passed
-        SLACK_USERNAME: GitHub Actions
-        SLACK_WEBHOOK: ${{ secrets.SLACK_WEBHOOK_URL }}
-

.golangci.yml

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

CNAME

@@ -1 +0,0 @@
-go-micro.dev

Dockerfile

@@ -1,13 +0,0 @@
-FROM golang:1.13-alpine
-
-RUN mkdir /user && \
-    echo 'nobody:x:65534:65534:nobody:/:' > /user/passwd && \
-    echo 'nobody:x:65534:' > /user/group
-
-ENV GO111MODULE=on
-RUN apk --no-cache add make git gcc libtool musl-dev ca-certificates && \
-    rm -rf /var/cache/apk/* /tmp/*
-
-WORKDIR /
-COPY ./go.mod ./go.sum ./
-RUN go mod download && rm go.mod go.sum

LICENSE

@@ -176,7 +176,8 @@
 
    END OF TERMS AND CONDITIONS
 
-   Copyright 2015 Asim Aslam.
+   Copyright 2015-2020 Asim Aslam.
+   Copyright 2019-2020 Unistack LLC.
 
    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,26 +1,27 @@
-# Go Micro [![License](https://img.shields.io/:license-apache-blue.svg)](https://opensource.org/licenses/Apache-2.0) [![Go.Dev reference](https://img.shields.io/badge/go.dev-reference-007d9c?logo=go&logoColor=white&style=flat-square)](https://pkg.go.dev/github.com/micro/go-micro?tab=doc) [![Travis CI](https://api.travis-ci.org/micro/go-micro.svg?branch=master)](https://travis-ci.org/micro/go-micro) [![Go Report Card](https://goreportcard.com/badge/micro/go-micro)](https://goreportcard.com/report/github.com/micro/go-micro)
+# Micro [![License](https://img.shields.io/:license-apache-blue.svg)](https://opensource.org/licenses/Apache-2.0) [![Doc](https://img.shields.io/badge/go.dev-reference-007d9c?logo=go&logoColor=white&style=flat-square)](https://pkg.go.dev/github.com/unistack-org/micro/v3?tab=overview) [![Status](https://github.com/unistack-org/micro/workflows/build/badge.svg?branch=master)](https://github.com/unistack-org/micro/actions?query=workflow%3Abuild+branch%3Amaster+event%3Apush) [![Lint](https://goreportcard.com/badge/go.unistack.org/micro/v3)](https://goreportcard.com/report/go.unistack.org/micro/v3) [![Coverage](https://codecov.io/gh/unistack-org/micro/branch/v3/graph/badge.svg?token=OZPO2LP7VS)](https://codecov.io/gh/unistack-org/micro)
 
-Go Micro is a framework for microservice development.
+Micro is a standard library for microservices.
 
 ## Overview
 
-Go Micro provides the core requirements for distributed systems development including RPC and Event driven communication. 
-The **micro** philosophy is sane defaults with a pluggable architecture. We provide defaults to get you started quickly 
-but everything can be easily swapped out. 
-
-<img src="https://micro.mu/docs/images/go-micro.svg" />
-
-Plugins are available at [github.com/micro/go-plugins](https://github.com/micro/go-plugins).
-
-Follow us on [Twitter](https://twitter.com/microhq) or join the [Community](https://micro.mu/slack).
+Micro provides the core requirements for distributed systems development including RPC and Event driven communication. 
 
 ## Features
 
-Go Micro abstracts away the details of distributed systems. Here are the main features.
+Micro abstracts away the details of distributed systems. Here are the main features.
+
+- **Authentication** - Auth is built in as a first class citizen. Authentication and authorization enable secure 
+zero trust networking by providing every service an identity and certificates. This additionally includes rule 
+based access control.
+
+- **Dynamic Config** - Load and hot reload dynamic config from anywhere. The config interface provides a way to load application 
+level config from any source such as env vars, 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.
 
 - **Service Discovery** - Automatic service registration and name resolution. Service discovery is at the core of micro service 
-development. When service A needs to speak to service B it needs the location of that service. The default discovery mechanism is 
-multicast DNS (mdns), a zeroconf system.
+development. When service A needs to speak to service B it needs the location of that service.
 
 - **Load Balancing** - Client side load balancing built on service discovery. Once we have the addresses of any number of instances 
 of a service we now need a way to decide which node to route to. We use random hashed load balancing to provide even distribution 
@@ -28,21 +29,24 @@ across the services and retry a different node if there's a problem.
 
 - **Message Encoding** - Dynamic message encoding based on content-type. The client and server will use codecs along with content-type 
 to seamlessly encode and decode Go types for you. Any variety of messages could be encoded and sent from different clients. The client 
-and server handle this by default. This includes protobuf and json by default.
+and server handle this by default.
 
-- **Request/Response** - RPC based request/response with support for bidirectional streaming. We provide an abstraction for synchronous 
-communication. A request made to a service will be automatically resolved, load balanced, dialled and streamed. The default 
-transport is [gRPC](https://grpc.io/).
+- **Transport** - gRPC or http based request/response with support for bidirectional streaming. We provide an abstraction for synchronous communication. A request made to a service will be automatically resolved, load balanced, dialled and streamed.
 
-- **Async Messaging** - PubSub is built in as a first class citizen for asynchronous communication and event driven architectures. 
-Event notifications are a core pattern in micro service development. The default messaging system is an embedded [NATS](https://nats.io/) 
-server.
+- **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.
 
-- **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. Find plugins in 
-[github.com/micro/go-plugins](https://github.com/micro/go-plugins).
+- **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** - Micro makes use of Go interfaces for each system abstraction. Because of this these interfaces 
+are pluggable and allows Micro to be runtime agnostic.
 
 ## Getting Started
 
-See the [docs](https://micro.mu/docs/framework.html) for detailed information on the architecture, installation and use of go-micro.
+To be created.
+
+## License
+
+Micro is Apache 2.0 licensed.
 

README.zh-cn.md

@@ -1,36 +0,0 @@
-# Go Micro [![License](https://img.shields.io/:license-apache-blue.svg)](https://opensource.org/licenses/Apache-2.0) [![Go.Dev reference](https://img.shields.io/badge/go.dev-reference-007d9c?logo=go&logoColor=white&style=flat-square)](https://pkg.go.dev/github.com/micro/go-micro?tab=doc) [![Travis CI](https://api.travis-ci.org/micro/go-micro.svg?branch=master)](https://travis-ci.org/micro/go-micro) [![Go Report Card](https://goreportcard.com/badge/micro/go-micro)](https://goreportcard.com/report/github.com/micro/go-micro)
-
-Go Micro是基于Golang的微服务开发框架。
-
-## 概览
-
-Go Micro提供分布式系统开发的核心库，包含RPC与事件驱动的通信机制。
-
-**micro**的设计哲学是可插拔的架构理念，她提供可快速构建系统的组件，并且可以根据自身的需求剥离默认实现并自行定制。
-
-<img src="https://micro.mu/docs/images/go-micro.svg" />
-
-所有插件可在仓库[github.com/micro/go-plugins](https://github.com/micro/go-plugins)中找到。
-
-可以订阅我们的[Twitter](https://twitter.com/microhq)或者加入[Slack](http://slack.micro.mu/)论坛。
-
-## 特性
-
-Go Micro把分布式系统的各种细节抽象出来。下面是它的主要特性。
-
-- **服务发现（Service Discovery）** - 自动服务注册与名称解析。服务发现是微服务开发中的核心。当服务A要与服务B协作时，它得知道B在哪里。默认的服务发现系统是Consul，而multicast DNS (mdns，组播)机制作为本地解决方案，或者零依赖的P2P网络中的SWIM协议（gossip）。 
-
-- **负载均衡（Load Balancing）** - 在服务发现之上构建了负载均衡机制。当我们得到一个服务的任意多个的实例节点时，我们要一个机制去决定要路由到哪一个节点。我们使用随机处理过的哈希负载均衡机制来保证对服务请求颁发的均匀分布，并且在发生问题时进行重试。
-
-- **消息编码（Message Encoding）** - 支持基于内容类型（content-type）动态编码消息。客户端和服务端会一起使用content-type的格式来对Go进行无缝编/解码。各种各样的消息被编码会发送到不同的客户端，客户端服服务端默认会处理这些消息。content-type默认包含proto-rpc和json-rpc。
-
-- **Request/Response** - RPC通信基于支持双向流的请求/响应方式，我们提供有抽象的同步通信机制。请求发送到服务时，会自动解析、负载均衡、拨号、转成字节流。默认的传输协议是http/1.1，而tls下使用http2协议。
-
-- **异步消息（Async Messaging）** - 发布订阅（PubSub）头等功能内置在异步通信与事件驱动架构中。事件通知在微服务开发中处于核心位置。默认的消息传送使用点到点http/1.1，激活tls时则使用http2。
-
-- **可插拔接口（Pluggable Interfaces）** - Go Micro为每个分布式系统抽象出接口。因此，Go Micro的接口都是可插拔的，允许其在运行时不可知的情况下仍可支持。所以只要实现接口，可以在内部使用任何的技术。更多插件请参考：[github.com/micro/go-plugins](https://github.com/micro/go-plugins)。
-
-## 快速上手
-
-更多关于架构、安装的资料可以查看[文档](https://micro.mu/docs/cn/)。
-

SECURITY.md

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

_config.yml

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

agent/agent.go

@@ -1,2 +0,0 @@
-// Package agent provides an interface for building robots
-package agent

agent/command/command.go

@@ -1,54 +0,0 @@
-// Package command is an interface for defining bot commands
-package command
-
-var (
-	// Commmands keyed by golang/regexp patterns
-	// regexp.Match(key, input) is used to match
-	Commands = map[string]Command{}
-)
-
-// Command is the interface for specific named
-// commands executed via plugins or the bot.
-type Command interface {
-	// Executes the command with args passed in
-	Exec(args ...string) ([]byte, error)
-	// Usage of the command
-	Usage() string
-	// Description of the command
-	Description() string
-	// Name of the command
-	String() string
-}
-
-type cmd struct {
-	name        string
-	usage       string
-	description string
-	exec        func(args ...string) ([]byte, error)
-}
-
-func (c *cmd) Description() string {
-	return c.description
-}
-
-func (c *cmd) Exec(args ...string) ([]byte, error) {
-	return c.exec(args...)
-}
-
-func (c *cmd) Usage() string {
-	return c.usage
-}
-
-func (c *cmd) String() string {
-	return c.name
-}
-
-// NewCommand helps quickly create a new command
-func NewCommand(name, usage, description string, exec func(args ...string) ([]byte, error)) Command {
-	return &cmd{
-		name:        name,
-		usage:       usage,
-		description: description,
-		exec:        exec,
-	}
-}

agent/command/command_test.go

@@ -1,65 +0,0 @@
-package command
-
-import (
-	"testing"
-)
-
-func TestCommand(t *testing.T) {
-	c := &cmd{
-		name:        "test",
-		usage:       "test usage",
-		description: "test description",
-		exec: func(args ...string) ([]byte, error) {
-			return []byte("test"), nil
-		},
-	}
-
-	if c.String() != c.name {
-		t.Fatalf("expected name %s got %s", c.name, c.String())
-	}
-
-	if c.Usage() != c.usage {
-		t.Fatalf("expected usage %s got %s", c.usage, c.Usage())
-	}
-
-	if c.Description() != c.description {
-		t.Fatalf("expected description %s got %s", c.description, c.Description())
-	}
-
-	if r, err := c.Exec(); err != nil {
-		t.Fatal(err)
-	} else if string(r) != "test" {
-		t.Fatalf("expected exec result test got %s", string(r))
-	}
-}
-
-func TestNewCommand(t *testing.T) {
-	c := &cmd{
-		name:        "test",
-		usage:       "test usage",
-		description: "test description",
-		exec: func(args ...string) ([]byte, error) {
-			return []byte("test"), nil
-		},
-	}
-
-	nc := NewCommand(c.name, c.usage, c.description, c.exec)
-
-	if nc.String() != c.name {
-		t.Fatalf("expected name %s got %s", c.name, nc.String())
-	}
-
-	if nc.Usage() != c.usage {
-		t.Fatalf("expected usage %s got %s", c.usage, nc.Usage())
-	}
-
-	if nc.Description() != c.description {
-		t.Fatalf("expected description %s got %s", c.description, nc.Description())
-	}
-
-	if r, err := nc.Exec(); err != nil {
-		t.Fatal(err)
-	} else if string(r) != "test" {
-		t.Fatalf("expected exec result test got %s", string(r))
-	}
-}

agent/input/discord/README.md

@@ -1,22 +0,0 @@
-# Discord input for micro-bot
-[Discord](https://discordapp.com) support for micro bot based on [discordgo](github.com/bwmarrin/discordgo).
-
-This was originally written by Aleksandr Tihomirov (@zet4) and can be found at https://github.com/zet4/micro-misc/.
-
-## Options
-### discord_token
-
-You have to supply an application token via `--discord_token`.
-
-Head over to Discord's [developer introduction](https://discordapp.com/developers/docs/intro)
-to learn how to create applications and how the API works.
-
-### discord_prefix
-
-Set a command prefix with `--discord_prefix`. The default prefix is `Micro `.
-You can mention the bot or use the prefix to run a command.
-
-### discord_whitelist
-
-Pass a list of comma-separated user IDs with `--discord_whitelist`. Only allow
-these users to use the bot.

agent/input/discord/conn.go

@@ -1,94 +0,0 @@
-package discord
-
-import (
-	"errors"
-	"strings"
-	"sync"
-
-	"github.com/bwmarrin/discordgo"
-	"github.com/micro/go-micro/v2/agent/input"
-	log "github.com/micro/go-micro/v2/logger"
-)
-
-type discordConn struct {
-	master *discordInput
-	exit   chan struct{}
-	recv   chan *discordgo.Message
-
-	sync.Mutex
-}
-
-func newConn(master *discordInput) *discordConn {
-	conn := &discordConn{
-		master: master,
-		exit:   make(chan struct{}),
-		recv:   make(chan *discordgo.Message),
-	}
-
-	conn.master.session.AddHandler(func(s *discordgo.Session, m *discordgo.MessageCreate) {
-		if m.Author.ID == master.botID {
-			return
-		}
-
-		whitelisted := false
-		for _, ID := range conn.master.whitelist {
-			if m.Author.ID == ID {
-				whitelisted = true
-				break
-			}
-		}
-
-		if len(master.whitelist) > 0 && !whitelisted {
-			return
-		}
-
-		var valid bool
-		m.Message.Content, valid = conn.master.prefixfn(m.Message.Content)
-		if !valid {
-			return
-		}
-
-		conn.recv <- m.Message
-	})
-
-	return conn
-}
-
-func (dc *discordConn) Recv(event *input.Event) error {
-	for {
-		select {
-		case <-dc.exit:
-			return errors.New("connection closed")
-		case msg := <-dc.recv:
-
-			event.From = msg.ChannelID + ":" + msg.Author.ID
-			event.To = dc.master.botID
-			event.Type = input.TextEvent
-			event.Data = []byte(msg.Content)
-			return nil
-		}
-	}
-}
-
-func (dc *discordConn) Send(e *input.Event) error {
-	fields := strings.Split(e.To, ":")
-	_, err := dc.master.session.ChannelMessageSend(fields[0], string(e.Data))
-	if err != nil {
-		log.Error("[bot][loop][send]", err)
-	}
-	return nil
-}
-
-func (dc *discordConn) Close() error {
-	if err := dc.master.session.Close(); err != nil {
-		return err
-	}
-
-	select {
-	case <-dc.exit:
-		return nil
-	default:
-		close(dc.exit)
-	}
-	return nil
-}

agent/input/discord/discord.go

@@ -1,153 +0,0 @@
-package discord
-
-import (
-	"fmt"
-	"sync"
-
-	"errors"
-	"strings"
-
-	"github.com/bwmarrin/discordgo"
-	"github.com/micro/cli/v2"
-	"github.com/micro/go-micro/v2/agent/input"
-)
-
-func init() {
-	input.Inputs["discord"] = newInput()
-}
-
-func newInput() *discordInput {
-	return &discordInput{}
-}
-
-type discordInput struct {
-	token     string
-	whitelist []string
-	prefix    string
-	prefixfn  func(string) (string, bool)
-	botID     string
-
-	session *discordgo.Session
-
-	sync.Mutex
-	running bool
-	exit    chan struct{}
-}
-
-func (d *discordInput) Flags() []cli.Flag {
-	return []cli.Flag{
-		&cli.StringFlag{
-			Name:    "discord_token",
-			EnvVars: []string{"MICRO_DISCORD_TOKEN"},
-			Usage:   "Discord token (prefix with Bot if it's for bot account)",
-		},
-		&cli.StringFlag{
-			Name:    "discord_whitelist",
-			EnvVars: []string{"MICRO_DISCORD_WHITELIST"},
-			Usage:   "Discord Whitelist (seperated by ,)",
-		},
-		&cli.StringFlag{
-			Name:    "discord_prefix",
-			Usage:   "Discord Prefix",
-			EnvVars: []string{"MICRO_DISCORD_PREFIX"},
-			Value:   "Micro ",
-		},
-	}
-}
-
-func (d *discordInput) Init(ctx *cli.Context) error {
-	token := ctx.String("discord_token")
-	whitelist := ctx.String("discord_whitelist")
-	prefix := ctx.String("discord_prefix")
-
-	if len(token) == 0 {
-		return errors.New("require token")
-	}
-
-	d.token = token
-	d.prefix = prefix
-
-	if len(whitelist) > 0 {
-		d.whitelist = strings.Split(whitelist, ",")
-	}
-
-	return nil
-}
-
-func (d *discordInput) Start() error {
-	if len(d.token) == 0 {
-		return errors.New("missing discord configuration")
-	}
-
-	d.Lock()
-	defer d.Unlock()
-
-	if d.running {
-		return nil
-	}
-
-	var err error
-	d.session, err = discordgo.New(d.token)
-	if err != nil {
-		return err
-	}
-
-	u, err := d.session.User("@me")
-	if err != nil {
-		return err
-	}
-
-	d.botID = u.ID
-	d.prefixfn = CheckPrefixFactory(fmt.Sprintf("<@%s> ", d.botID), fmt.Sprintf("<@!%s> ", d.botID), d.prefix)
-
-	d.exit = make(chan struct{})
-	d.running = true
-
-	return nil
-}
-
-func (d *discordInput) Stream() (input.Conn, error) {
-	d.Lock()
-	defer d.Unlock()
-	if !d.running {
-		return nil, errors.New("not running")
-	}
-
-	//Fire-n-forget close just in case...
-	d.session.Close()
-
-	conn := newConn(d)
-	if err := d.session.Open(); err != nil {
-		return nil, err
-	}
-	return conn, nil
-}
-
-func (d *discordInput) Stop() error {
-	d.Lock()
-	defer d.Unlock()
-
-	if !d.running {
-		return nil
-	}
-
-	close(d.exit)
-	d.running = false
-	return nil
-}
-
-func (d *discordInput) String() string {
-	return "discord"
-}
-
-// CheckPrefixFactory Creates a prefix checking function and stuff.
-func CheckPrefixFactory(prefixes ...string) func(string) (string, bool) {
-	return func(content string) (string, bool) {
-		for _, prefix := range prefixes {
-			if strings.HasPrefix(content, prefix) {
-				return strings.TrimPrefix(content, prefix), true
-			}
-		}
-		return "", false
-	}
-}

agent/input/input.go

@@ -1,55 +0,0 @@
-// Package input is an interface for bot inputs
-package input
-
-import (
-	"github.com/micro/cli/v2"
-)
-
-type EventType string
-
-const (
-	TextEvent EventType = "text"
-)
-
-var (
-	// Inputs keyed by name
-	// Example slack or hipchat
-	Inputs = map[string]Input{}
-)
-
-// Event is the unit sent and received
-type Event struct {
-	Type EventType
-	From string
-	To   string
-	Data []byte
-	Meta map[string]interface{}
-}
-
-// Input is an interface for sources which
-// provide a way to communicate with the bot.
-// Slack, HipChat, XMPP, etc.
-type Input interface {
-	// Provide cli flags
-	Flags() []cli.Flag
-	// Initialise input using cli context
-	Init(*cli.Context) error
-	// Stream events from the input
-	Stream() (Conn, error)
-	// Start the input
-	Start() error
-	// Stop the input
-	Stop() error
-	// name of the input
-	String() string
-}
-
-// Conn interface provides a way to
-// send and receive events. Send and
-// Recv both block until succeeding
-// or failing.
-type Conn interface {
-	Close() error
-	Recv(*Event) error
-	Send(*Event) error
-}

agent/input/slack/conn.go

@@ -1,160 +0,0 @@
-package slack
-
-import (
-	"errors"
-	"fmt"
-	"strings"
-	"sync"
-	"time"
-
-	"github.com/micro/go-micro/v2/agent/input"
-	"github.com/nlopes/slack"
-)
-
-// Satisfies the input.Conn interface
-type slackConn struct {
-	auth *slack.AuthTestResponse
-	rtm  *slack.RTM
-	exit chan bool
-
-	sync.Mutex
-	names map[string]string
-}
-
-func (s *slackConn) run() {
-	// func retrieves user names and maps to IDs
-	setNames := func() {
-		names := make(map[string]string)
-		users, err := s.rtm.Client.GetUsers()
-		if err != nil {
-			return
-		}
-
-		for _, user := range users {
-			names[user.ID] = user.Name
-		}
-
-		s.Lock()
-		s.names = names
-		s.Unlock()
-	}
-
-	setNames()
-
-	t := time.NewTicker(time.Minute)
-	defer t.Stop()
-
-	for {
-		select {
-		case <-s.exit:
-			return
-		case <-t.C:
-			setNames()
-		}
-	}
-}
-
-func (s *slackConn) getName(id string) string {
-	s.Lock()
-	name := s.names[id]
-	s.Unlock()
-	return name
-}
-
-func (s *slackConn) Close() error {
-	select {
-	case <-s.exit:
-		return nil
-	default:
-		close(s.exit)
-	}
-	return nil
-}
-
-func (s *slackConn) Recv(event *input.Event) error {
-	if event == nil {
-		return errors.New("event cannot be nil")
-	}
-
-	for {
-		select {
-		case <-s.exit:
-			return errors.New("connection closed")
-		case e := <-s.rtm.IncomingEvents:
-			switch ev := e.Data.(type) {
-			case *slack.MessageEvent:
-				// only accept type message
-				if ev.Type != "message" {
-					continue
-				}
-
-				// only accept DMs or messages to me
-				switch {
-				case strings.HasPrefix(ev.Channel, "D"):
-				case strings.HasPrefix(ev.Text, s.auth.User):
-				case strings.HasPrefix(ev.Text, fmt.Sprintf("<@%s>", s.auth.UserID)):
-				default:
-					continue
-				}
-
-				// Strip username from text
-				switch {
-				case strings.HasPrefix(ev.Text, s.auth.User):
-					args := strings.Split(ev.Text, " ")[1:]
-					ev.Text = strings.Join(args, " ")
-					event.To = s.auth.User
-				case strings.HasPrefix(ev.Text, fmt.Sprintf("<@%s>", s.auth.UserID)):
-					args := strings.Split(ev.Text, " ")[1:]
-					ev.Text = strings.Join(args, " ")
-					event.To = s.auth.UserID
-				}
-
-				if event.Meta == nil {
-					event.Meta = make(map[string]interface{})
-				}
-
-				// fill in the blanks
-				event.From = ev.Channel + ":" + ev.User
-				event.Type = input.TextEvent
-				event.Data = []byte(ev.Text)
-				event.Meta["reply"] = ev
-				return nil
-			case *slack.InvalidAuthEvent:
-				return errors.New("invalid credentials")
-			}
-		}
-	}
-}
-
-func (s *slackConn) Send(event *input.Event) error {
-	var channel, message, name string
-
-	if len(event.To) == 0 {
-		return errors.New("require Event.To")
-	}
-
-	parts := strings.Split(event.To, ":")
-
-	if len(parts) == 2 {
-		channel = parts[0]
-		name = s.getName(parts[1])
-		// try using reply meta
-	} else if ev, ok := event.Meta["reply"]; ok {
-		channel = ev.(*slack.MessageEvent).Channel
-		name = s.getName(ev.(*slack.MessageEvent).User)
-	}
-
-	// don't know where to send the message
-	if len(channel) == 0 {
-		return errors.New("could not determine who message is to")
-	}
-
-	if len(name) == 0 || strings.HasPrefix(channel, "D") {
-		message = string(event.Data)
-	} else {
-		message = fmt.Sprintf("@%s: %s", name, string(event.Data))
-	}
-
-	s.rtm.SendMessage(s.rtm.NewOutgoingMessage(message, channel))
-	return nil
-}

agent/input/slack/slack.go

@@ -1,147 +0,0 @@
-package slack
-
-import (
-	"errors"
-	"sync"
-
-	"github.com/micro/cli/v2"
-	"github.com/micro/go-micro/v2/agent/input"
-	"github.com/nlopes/slack"
-)
-
-type slackInput struct {
-	debug bool
-	token string
-
-	sync.Mutex
-	running bool
-	exit    chan bool
-
-	api *slack.Client
-}
-
-func init() {
-	input.Inputs["slack"] = NewInput()
-}
-
-func (p *slackInput) Flags() []cli.Flag {
-	return []cli.Flag{
-		&cli.BoolFlag{
-			Name:    "slack_debug",
-			Usage:   "Slack debug output",
-			EnvVars: []string{"MICRO_SLACK_DEBUG"},
-		},
-		&cli.StringFlag{
-			Name:    "slack_token",
-			Usage:   "Slack token",
-			EnvVars: []string{"MICRO_SLACK_TOKEN"},
-		},
-	}
-}
-
-func (p *slackInput) Init(ctx *cli.Context) error {
-	debug := ctx.Bool("slack_debug")
-	token := ctx.String("slack_token")
-
-	if len(token) == 0 {
-		return errors.New("missing slack token")
-	}
-
-	p.debug = debug
-	p.token = token
-
-	return nil
-}
-
-func (p *slackInput) Stream() (input.Conn, error) {
-	p.Lock()
-	defer p.Unlock()
-
-	if !p.running {
-		return nil, errors.New("not running")
-	}
-
-	// test auth
-	auth, err := p.api.AuthTest()
-	if err != nil {
-		return nil, err
-	}
-
-	rtm := p.api.NewRTM()
-	exit := make(chan bool)
-
-	go rtm.ManageConnection()
-
-	go func() {
-		select {
-		case <-p.exit:
-			select {
-			case <-exit:
-				return
-			default:
-				close(exit)
-			}
-		case <-exit:
-		}
-
-		rtm.Disconnect()
-	}()
-
-	conn := &slackConn{
-		auth:  auth,
-		rtm:   rtm,
-		exit:  exit,
-		names: make(map[string]string),
-	}
-
-	go conn.run()
-
-	return conn, nil
-}
-
-func (p *slackInput) Start() error {
-	if len(p.token) == 0 {
-		return errors.New("missing slack token")
-	}
-
-	p.Lock()
-	defer p.Unlock()
-
-	if p.running {
-		return nil
-	}
-
-	api := slack.New(p.token, slack.OptionDebug(p.debug))
-
-	// test auth
-	_, err := api.AuthTest()
-	if err != nil {
-		return err
-	}
-
-	p.api = api
-	p.exit = make(chan bool)
-	p.running = true
-	return nil
-}
-
-func (p *slackInput) Stop() error {
-	p.Lock()
-	defer p.Unlock()
-
-	if !p.running {
-		return nil
-	}
-
-	close(p.exit)
-	p.running = false
-	return nil
-}
-
-func (p *slackInput) String() string {
-	return "slack"
-}
-
-func NewInput() input.Input {
-	return &slackInput{}
-}

agent/input/telegram/README.md

@@ -1,18 +0,0 @@
-# Telegram Messenger input for micro bot
-[Telegram](https://telegram.org) support for micro bot based on [telegram-bot-api](https://github.com/go-telegram-bot-api/telegram-bot-api).
-
-## Options
-### --telegram_token (required)
-
-Sets bot's token for interacting with API.
-
-Head over to Telegram's [API documentation](https://core.telegram.org/bots/api)
-to learn how to create bots and how the API works.
-
-### --telegram_debug
-
-Sets the debug flag to make the bot's output verbose.
-
-### --telegram_whitelist
-
-Sets a list of comma-separated nicknames (without @ symbol in the beginning) for interacting with bot. Only these users can use the bot.

agent/input/telegram/conn.go

@@ -1,113 +0,0 @@
-package telegram
-
-import (
-	"errors"
-	"strings"
-	"sync"
-
-	"github.com/forestgiant/sliceutil"
-	"github.com/micro/go-micro/v2/agent/input"
-	log "github.com/micro/go-micro/v2/logger"
-	tgbotapi "gopkg.in/telegram-bot-api.v4"
-)
-
-type telegramConn struct {
-	input *telegramInput
-
-	recv <-chan tgbotapi.Update
-	exit chan bool
-
-	syncCond *sync.Cond
-	mutex    sync.Mutex
-}
-
-func newConn(input *telegramInput) (*telegramConn, error) {
-	conn := &telegramConn{
-		input: input,
-	}
-
-	conn.syncCond = sync.NewCond(&conn.mutex)
-
-	go conn.run()
-
-	return conn, nil
-}
-
-func (tc *telegramConn) run() {
-	u := tgbotapi.NewUpdate(0)
-	u.Timeout = 60
-	updates, err := tc.input.api.GetUpdatesChan(u)
-	if err != nil {
-		return
-	}
-
-	tc.recv = updates
-	tc.syncCond.Signal()
-
-	select {
-	case <-tc.exit:
-		return
-	}
-}
-
-func (tc *telegramConn) Close() error {
-	return nil
-}
-
-func (tc *telegramConn) Recv(event *input.Event) error {
-	if event == nil {
-		return errors.New("event cannot be nil")
-	}
-
-	for {
-		if tc.recv == nil {
-			tc.mutex.Lock()
-			tc.syncCond.Wait()
-		}
-
-		update := <-tc.recv
-
-		if update.Message == nil || (len(tc.input.whitelist) > 0 && !sliceutil.Contains(tc.input.whitelist, update.Message.From.UserName)) {
-			continue
-		}
-
-		if event.Meta == nil {
-			event.Meta = make(map[string]interface{})
-		}
-
-		event.Type = input.TextEvent
-		event.From = update.Message.From.UserName
-		event.To = tc.input.api.Self.UserName
-		event.Data = []byte(update.Message.Text)
-		event.Meta["chatId"] = update.Message.Chat.ID
-		event.Meta["chatType"] = update.Message.Chat.Type
-		event.Meta["messageId"] = update.Message.MessageID
-
-		return nil
-	}
-}
-
-func (tc *telegramConn) Send(event *input.Event) error {
-	messageText := strings.TrimSpace(string(event.Data))
-
-	chatId := event.Meta["chatId"].(int64)
-	chatType := ChatType(event.Meta["chatType"].(string))
-
-	msgConfig := tgbotapi.NewMessage(chatId, messageText)
-	msgConfig.ParseMode = tgbotapi.ModeHTML
-
-	if sliceutil.Contains([]ChatType{Group, Supergroup}, chatType) {
-		msgConfig.ReplyToMessageID = event.Meta["messageId"].(int)
-	}
-
-	_, err := tc.input.api.Send(msgConfig)
-
-	if err != nil {
-		// probably it could be because of nested HTML tags -- telegram doesn't allow nested tags
-		log.Error("[telegram][Send] error:", err)
-		msgConfig.Text = "This bot couldn't send the response (Internal error)"
-		tc.input.api.Send(msgConfig)
-	}
-
-	return nil
-}

agent/input/telegram/telegram.go

@@ -1,101 +0,0 @@
-package telegram
-
-import (
-	"errors"
-	"strings"
-	"sync"
-
-	"github.com/micro/cli/v2"
-	"github.com/micro/go-micro/v2/agent/input"
-	tgbotapi "gopkg.in/telegram-bot-api.v4"
-)
-
-type telegramInput struct {
-	sync.Mutex
-
-	debug     bool
-	token     string
-	whitelist []string
-
-	api *tgbotapi.BotAPI
-}
-
-type ChatType string
-
-const (
-	Private    ChatType = "private"
-	Group      ChatType = "group"
-	Supergroup ChatType = "supergroup"
-)
-
-func init() {
-	input.Inputs["telegram"] = &telegramInput{}
-}
-
-func (ti *telegramInput) Flags() []cli.Flag {
-	return []cli.Flag{
-		&cli.BoolFlag{
-			Name:    "telegram_debug",
-			EnvVars: []string{"MICRO_TELEGRAM_DEBUG"},
-			Usage:   "Telegram debug output",
-		},
-		&cli.StringFlag{
-			Name:    "telegram_token",
-			EnvVars: []string{"MICRO_TELEGRAM_TOKEN"},
-			Usage:   "Telegram token",
-		},
-		&cli.StringFlag{
-			Name:    "telegram_whitelist",
-			EnvVars: []string{"MICRO_TELEGRAM_WHITELIST"},
-			Usage:   "Telegram bot's users (comma-separated values)",
-		},
-	}
-}
-
-func (ti *telegramInput) Init(ctx *cli.Context) error {
-	ti.debug = ctx.Bool("telegram_debug")
-	ti.token = ctx.String("telegram_token")
-
-	whitelist := ctx.String("telegram_whitelist")
-
-	if whitelist != "" {
-		ti.whitelist = strings.Split(whitelist, ",")
-	}
-
-	if len(ti.token) == 0 {
-		return errors.New("missing telegram token")
-	}
-
-	return nil
-}
-
-func (ti *telegramInput) Stream() (input.Conn, error) {
-	ti.Lock()
-	defer ti.Unlock()
-
-	return newConn(ti)
-}
-
-func (ti *telegramInput) Start() error {
-	ti.Lock()
-	defer ti.Unlock()
-
-	api, err := tgbotapi.NewBotAPI(ti.token)
-	if err != nil {
-		return err
-	}
-
-	ti.api = api
-
-	api.Debug = ti.debug
-
-	return nil
-}
-
-func (ti *telegramInput) Stop() error {
-	return nil
-}
-
-func (p *telegramInput) String() string {
-	return "telegram"
-}

agent/proto/bot.pb.go

@@ -1,216 +0,0 @@
-// Code generated by protoc-gen-go. DO NOT EDIT.
-// source: github.com/micro/go-micro/v2/agent/proto/bot.proto
-
-package go_micro_bot
-
-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 HelpRequest struct {
-	XXX_NoUnkeyedLiteral struct{} `json:"-"`
-	XXX_unrecognized     []byte   `json:"-"`
-	XXX_sizecache        int32    `json:"-"`
-}
-
-func (m *HelpRequest) Reset()         { *m = HelpRequest{} }
-func (m *HelpRequest) String() string { return proto.CompactTextString(m) }
-func (*HelpRequest) ProtoMessage()    {}
-func (*HelpRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_018e8d5b14a89d12, []int{0}
-}
-
-func (m *HelpRequest) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_HelpRequest.Unmarshal(m, b)
-}
-func (m *HelpRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_HelpRequest.Marshal(b, m, deterministic)
-}
-func (m *HelpRequest) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_HelpRequest.Merge(m, src)
-}
-func (m *HelpRequest) XXX_Size() int {
-	return xxx_messageInfo_HelpRequest.Size(m)
-}
-func (m *HelpRequest) XXX_DiscardUnknown() {
-	xxx_messageInfo_HelpRequest.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_HelpRequest proto.InternalMessageInfo
-
-type HelpResponse struct {
-	Usage                string   `protobuf:"bytes,1,opt,name=usage,proto3" json:"usage,omitempty"`
-	Description          string   `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"`
-	XXX_NoUnkeyedLiteral struct{} `json:"-"`
-	XXX_unrecognized     []byte   `json:"-"`
-	XXX_sizecache        int32    `json:"-"`
-}
-
-func (m *HelpResponse) Reset()         { *m = HelpResponse{} }
-func (m *HelpResponse) String() string { return proto.CompactTextString(m) }
-func (*HelpResponse) ProtoMessage()    {}
-func (*HelpResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_018e8d5b14a89d12, []int{1}
-}
-
-func (m *HelpResponse) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_HelpResponse.Unmarshal(m, b)
-}
-func (m *HelpResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_HelpResponse.Marshal(b, m, deterministic)
-}
-func (m *HelpResponse) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_HelpResponse.Merge(m, src)
-}
-func (m *HelpResponse) XXX_Size() int {
-	return xxx_messageInfo_HelpResponse.Size(m)
-}
-func (m *HelpResponse) XXX_DiscardUnknown() {
-	xxx_messageInfo_HelpResponse.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_HelpResponse proto.InternalMessageInfo
-
-func (m *HelpResponse) GetUsage() string {
-	if m != nil {
-		return m.Usage
-	}
-	return ""
-}
-
-func (m *HelpResponse) GetDescription() string {
-	if m != nil {
-		return m.Description
-	}
-	return ""
-}
-
-type ExecRequest struct {
-	Args                 []string `protobuf:"bytes,1,rep,name=args,proto3" json:"args,omitempty"`
-	XXX_NoUnkeyedLiteral struct{} `json:"-"`
-	XXX_unrecognized     []byte   `json:"-"`
-	XXX_sizecache        int32    `json:"-"`
-}
-
-func (m *ExecRequest) Reset()         { *m = ExecRequest{} }
-func (m *ExecRequest) String() string { return proto.CompactTextString(m) }
-func (*ExecRequest) ProtoMessage()    {}
-func (*ExecRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_018e8d5b14a89d12, []int{2}
-}
-
-func (m *ExecRequest) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_ExecRequest.Unmarshal(m, b)
-}
-func (m *ExecRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_ExecRequest.Marshal(b, m, deterministic)
-}
-func (m *ExecRequest) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_ExecRequest.Merge(m, src)
-}
-func (m *ExecRequest) XXX_Size() int {
-	return xxx_messageInfo_ExecRequest.Size(m)
-}
-func (m *ExecRequest) XXX_DiscardUnknown() {
-	xxx_messageInfo_ExecRequest.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_ExecRequest proto.InternalMessageInfo
-
-func (m *ExecRequest) GetArgs() []string {
-	if m != nil {
-		return m.Args
-	}
-	return nil
-}
-
-type ExecResponse struct {
-	Result               []byte   `protobuf:"bytes,1,opt,name=result,proto3" json:"result,omitempty"`
-	Error                string   `protobuf:"bytes,2,opt,name=error,proto3" json:"error,omitempty"`
-	XXX_NoUnkeyedLiteral struct{} `json:"-"`
-	XXX_unrecognized     []byte   `json:"-"`
-	XXX_sizecache        int32    `json:"-"`
-}
-
-func (m *ExecResponse) Reset()         { *m = ExecResponse{} }
-func (m *ExecResponse) String() string { return proto.CompactTextString(m) }
-func (*ExecResponse) ProtoMessage()    {}
-func (*ExecResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_018e8d5b14a89d12, []int{3}
-}
-
-func (m *ExecResponse) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_ExecResponse.Unmarshal(m, b)
-}
-func (m *ExecResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_ExecResponse.Marshal(b, m, deterministic)
-}
-func (m *ExecResponse) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_ExecResponse.Merge(m, src)
-}
-func (m *ExecResponse) XXX_Size() int {
-	return xxx_messageInfo_ExecResponse.Size(m)
-}
-func (m *ExecResponse) XXX_DiscardUnknown() {
-	xxx_messageInfo_ExecResponse.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_ExecResponse proto.InternalMessageInfo
-
-func (m *ExecResponse) GetResult() []byte {
-	if m != nil {
-		return m.Result
-	}
-	return nil
-}
-
-func (m *ExecResponse) GetError() string {
-	if m != nil {
-		return m.Error
-	}
-	return ""
-}
-
-func init() {
-	proto.RegisterType((*HelpRequest)(nil), "go.micro.bot.HelpRequest")
-	proto.RegisterType((*HelpResponse)(nil), "go.micro.bot.HelpResponse")
-	proto.RegisterType((*ExecRequest)(nil), "go.micro.bot.ExecRequest")
-	proto.RegisterType((*ExecResponse)(nil), "go.micro.bot.ExecResponse")
-}
-
-func init() {
-	proto.RegisterFile("github.com/micro/go-micro/v2/agent/proto/bot.proto", fileDescriptor_018e8d5b14a89d12)
-}
-
-var fileDescriptor_018e8d5b14a89d12 = []byte{
-	// 246 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x6c, 0x50, 0x4d, 0x4b, 0xc4, 0x30,
-	0x10, 0xdd, 0xea, 0xba, 0xb2, 0xd3, 0x7a, 0x09, 0x22, 0x75, 0x4f, 0x35, 0xa7, 0xbd, 0x98, 0x80,
-	0x5e, 0x05, 0x0f, 0xa2, 0x78, 0xee, 0x3f, 0x68, 0xbb, 0x43, 0x2c, 0x6c, 0x3b, 0x35, 0x99, 0x82,
-	0xff, 0xc1, 0x3f, 0x2d, 0x4d, 0x72, 0x08, 0xc5, 0xdb, 0x7b, 0x79, 0xe1, 0x7d, 0x0c, 0x68, 0xd3,
-	0xf3, 0xd7, 0xdc, 0xaa, 0x8e, 0x06, 0x3d, 0xf4, 0x9d, 0x25, 0x6d, 0xe8, 0x31, 0x80, 0xc6, 0xe0,
-	0xc8, 0x7a, 0xb2, 0xc4, 0xa4, 0x5b, 0x62, 0xe5, 0x91, 0x28, 0x0c, 0x29, 0xaf, 0xab, 0x96, 0x58,
-	0xde, 0x40, 0xfe, 0x89, 0xe7, 0xa9, 0xc6, 0xef, 0x19, 0x1d, 0xcb, 0x0f, 0x28, 0x02, 0x75, 0x13,
-	0x8d, 0x0e, 0xc5, 0x2d, 0x5c, 0xcd, 0xae, 0x31, 0x58, 0x66, 0x55, 0x76, 0xdc, 0xd7, 0x81, 0x88,
-	0x0a, 0xf2, 0x13, 0xba, 0xce, 0xf6, 0x13, 0xf7, 0x34, 0x96, 0x17, 0x5e, 0x4b, 0x9f, 0xe4, 0x03,
-	0xe4, 0xef, 0x3f, 0xd8, 0x45, 0x5b, 0x21, 0x60, 0xdb, 0x58, 0xe3, 0xca, 0xac, 0xba, 0x3c, 0xee,
-	0x6b, 0x8f, 0xe5, 0x0b, 0x14, 0xe1, 0x4b, 0x8c, 0xba, 0x83, 0x9d, 0x45, 0x37, 0x9f, 0xd9, 0x67,
-	0x15, 0x75, 0x64, 0x4b, 0x05, 0xb4, 0x96, 0x6c, 0x8c, 0x09, 0xe4, 0xe9, 0x37, 0x83, 0xeb, 0x37,
-	0x1a, 0x86, 0x66, 0x3c, 0x89, 0x57, 0xd8, 0x2e, 0xa5, 0xc5, 0xbd, 0x4a, 0xa7, 0xa9, 0x64, 0xd7,
-	0xe1, 0xf0, 0x9f, 0x14, 0x82, 0xe5, 0x66, 0x31, 0x58, 0xaa, 0xac, 0x0d, 0x92, 0x05, 0x6b, 0x83,
-	0xb4, 0xb9, 0xdc, 0xb4, 0x3b, 0x7f, 0xda, 0xe7, 0xbf, 0x00, 0x00, 0x00, 0xff, 0xff, 0x18, 0xbd,
-	0x39, 0x29, 0x8d, 0x01, 0x00, 0x00,
-}

agent/proto/bot.pb.micro.go

@@ -1,108 +0,0 @@
-// Code generated by protoc-gen-micro. DO NOT EDIT.
-// source: github.com/micro/go-micro/v2/agent/proto/bot.proto
-
-package go_micro_bot
-
-import (
-	fmt "fmt"
-	proto "github.com/golang/protobuf/proto"
-	math "math"
-)
-
-import (
-	context "context"
-	client "github.com/micro/go-micro/v2/client"
-	server "github.com/micro/go-micro/v2/server"
-)
-
-// 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
-
-// Reference imports to suppress errors if they are not otherwise used.
-var _ context.Context
-var _ client.Option
-var _ server.Option
-
-// Client API for Command service
-
-type CommandService interface {
-	Help(ctx context.Context, in *HelpRequest, opts ...client.CallOption) (*HelpResponse, error)
-	Exec(ctx context.Context, in *ExecRequest, opts ...client.CallOption) (*ExecResponse, error)
-}
-
-type commandService struct {
-	c    client.Client
-	name string
-}
-
-func NewCommandService(name string, c client.Client) CommandService {
-	if c == nil {
-		c = client.NewClient()
-	}
-	if len(name) == 0 {
-		name = "go.micro.bot"
-	}
-	return &commandService{
-		c:    c,
-		name: name,
-	}
-}
-
-func (c *commandService) Help(ctx context.Context, in *HelpRequest, opts ...client.CallOption) (*HelpResponse, error) {
-	req := c.c.NewRequest(c.name, "Command.Help", in)
-	out := new(HelpResponse)
-	err := c.c.Call(ctx, req, out, opts...)
-	if err != nil {
-		return nil, err
-	}
-	return out, nil
-}
-
-func (c *commandService) Exec(ctx context.Context, in *ExecRequest, opts ...client.CallOption) (*ExecResponse, error) {
-	req := c.c.NewRequest(c.name, "Command.Exec", in)
-	out := new(ExecResponse)
-	err := c.c.Call(ctx, req, out, opts...)
-	if err != nil {
-		return nil, err
-	}
-	return out, nil
-}
-
-// Server API for Command service
-
-type CommandHandler interface {
-	Help(context.Context, *HelpRequest, *HelpResponse) error
-	Exec(context.Context, *ExecRequest, *ExecResponse) error
-}
-
-func RegisterCommandHandler(s server.Server, hdlr CommandHandler, opts ...server.HandlerOption) error {
-	type command interface {
-		Help(ctx context.Context, in *HelpRequest, out *HelpResponse) error
-		Exec(ctx context.Context, in *ExecRequest, out *ExecResponse) error
-	}
-	type Command struct {
-		command
-	}
-	h := &commandHandler{hdlr}
-	return s.Handle(s.NewHandler(&Command{h}, opts...))
-}
-
-type commandHandler struct {
-	CommandHandler
-}
-
-func (h *commandHandler) Help(ctx context.Context, in *HelpRequest, out *HelpResponse) error {
-	return h.CommandHandler.Help(ctx, in, out)
-}
-
-func (h *commandHandler) Exec(ctx context.Context, in *ExecRequest, out *ExecResponse) error {
-	return h.CommandHandler.Exec(ctx, in, out)
-}

agent/proto/bot.proto

@@ -1,25 +0,0 @@
-syntax = "proto3";
-
-package go.micro.bot;
-
-service Command {
-	rpc Help(HelpRequest) returns (HelpResponse) {};
-	rpc Exec(ExecRequest) returns (ExecResponse) {};
-}
-
-message HelpRequest {
-}
-
-message HelpResponse {
-	string usage = 1;
-	string description = 2;
-}
-
-message ExecRequest {
-	repeated string args = 1;
-}
-
-message ExecResponse {
-	bytes result = 1;
-	string error = 2;
-}

api/api.go

@@ -1,54 +1,66 @@
-package api
+package api // import "go.unistack.org/micro/v3/api"
 
 import (
 	"errors"
 	"regexp"
 	"strings"
 
-	"github.com/micro/go-micro/v2/registry"
-	"github.com/micro/go-micro/v2/server"
+	"go.unistack.org/micro/v3/metadata"
+	"go.unistack.org/micro/v3/register"
+	"go.unistack.org/micro/v3/server"
 )
 
+// nolint: revive
+// Api interface
+type Api interface {
+	// Initialise options
+	Init(...Option) error
+	// Get the options
+	Options() Options
+	// Register a http handler
+	Register(*Endpoint) error
+	// Register a route
+	Deregister(*Endpoint) error
+	// Implementation of api
+	String() string
+}
+
+// Options holds the options
+type Options struct{}
+
+// Option func signature
+type Option func(*Options) error
+
 // Endpoint is a mapping between an RPC method and HTTP endpoint
 type Endpoint struct {
-	// RPC Method e.g. Greeter.Hello
+	// Name Greeter.Hello
 	Name string
-	// Description e.g what's this endpoint for
+	// Desciption for endpoint
 	Description string
-	// API Handler e.g rpc, proxy
+	// Handler e.g rpc, proxy
 	Handler string
-	// HTTP Host e.g example.com
+	// Body destination
+	// "*" or "" - top level message value
+	// "string" - inner message value
+	Body string
+	// Host e.g example.com
 	Host []string
-	// HTTP Methods e.g GET, POST
+	// Method e.g GET, POST
 	Method []string
-	// HTTP Path e.g /greeter. Expect POSIX regex
+	// Path e.g /greeter. Expect POSIX regex
 	Path []string
+	// Stream flag
+	Stream bool
 }
 
 // Service represents an API service
 type Service struct {
 	// Name of service
 	Name string
-	// The endpoint for this service
+	// 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
+	// Services that provides service
+	Services []*register.Service
 }
 
 // Encode encodes an endpoint to endpoint metadata
@@ -74,24 +86,30 @@ func Encode(e *Endpoint) map[string]string {
 	set("method", strings.Join(e.Method, ","))
 	set("path", strings.Join(e.Path, ","))
 	set("host", strings.Join(e.Host, ","))
+	set("body", e.Body)
 
 	return ep
 }
 
 // Decode decodes endpoint metadata into an endpoint
-func Decode(e map[string]string) *Endpoint {
+func Decode(e metadata.Metadata) *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"],
-	}
+	ep := &Endpoint{}
+	ep.Name, _ = e.Get("endpoint")
+	ep.Description, _ = e.Get("description")
+	epmethod, _ := e.Get("method")
+	ep.Method = []string{epmethod}
+	eppath, _ := e.Get("path")
+	ep.Path = []string{eppath}
+	ephost, _ := e.Get("host")
+	ep.Host = []string{ephost}
+	ep.Handler, _ = e.Get("handler")
+	ep.Body, _ = e.Get("body")
+
+	return ep
 }
 
 // Validate validates an endpoint to guarantee it won't blow up when being served
@@ -105,9 +123,18 @@ func Validate(e *Endpoint) error {
 	}
 
 	for _, p := range e.Path {
-		_, err := regexp.CompilePOSIX(p)
-		if err != nil {
-			return err
+		ps := p[0]
+		pe := p[len(p)-1]
+
+		switch {
+		case ps == '^' && pe == '$':
+			if _, err := regexp.CompilePOSIX(p); err != nil {
+				return err
+			}
+		case ps == '^' && pe != '$':
+			return errors.New("invalid path")
+		case ps != '^' && pe == '$':
+			return errors.New("invalid path")
 		}
 	}
 

api/api_test.go

@@ -3,9 +3,27 @@ package api
 import (
 	"strings"
 	"testing"
+
+	"go.unistack.org/micro/v3/metadata"
+	"go.unistack.org/micro/v3/server"
 )
 
-func TestEncoding(t *testing.T) {
+func TestDecode(t *testing.T) {
+	md := metadata.New(0)
+	md.Set("host", "localhost", "method", "GET", "path", "/")
+	ep := Decode(md)
+	if md == nil {
+		t.Fatalf("failed to decode md %#+v", md)
+	} else if len(ep.Host) != 1 || len(ep.Method) != 1 || len(ep.Path) != 1 {
+		t.Fatalf("ep invalid after decode %#+v", ep)
+	}
+	if ep.Host[0] != "localhost" || ep.Method[0] != "GET" || ep.Path[0] != "/" {
+		t.Fatalf("ep invalid after decode %#+v", ep)
+	}
+}
+
+//nolint:gocyclo
+func TestEncode(t *testing.T) {
 	testData := []*Endpoint{
 		nil,
 		{
@@ -111,3 +129,117 @@ func TestEncoding(t *testing.T) {
 		}
 	}
 }
+
+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])
+	}
+}
+
+func TestWithEndpoint(t *testing.T) {
+	ep := &Endpoint{
+		Name:        "Foo.Bar",
+		Description: "A test endpoint",
+		Handler:     "meta",
+		Host:        []string{"foo.com"},
+		Method:      []string{"GET"},
+		Path:        []string{"/test/{id}"},
+	}
+	o := WithEndpoint(ep)
+	opts := server.NewHandlerOptions(o)
+	if opts.Metadata == nil {
+		t.Fatalf("WithEndpoint not works %#+v", opts)
+	}
+	md, ok := opts.Metadata[ep.Name]
+	if !ok {
+		t.Fatalf("WithEndpoint not works %#+v", opts)
+	}
+	if v, ok := md.Get("Endpoint"); !ok || v != "Foo.Bar" {
+		t.Fatalf("WithEndpoint not works %#+v", md)
+	}
+}
+
+func TestValidateNilErr(t *testing.T) {
+	var ep *Endpoint
+	if err := Validate(ep); err == nil {
+		t.Fatalf("Validate not works")
+	}
+}
+
+func TestValidateMissingNameErr(t *testing.T) {
+	ep := &Endpoint{}
+	if err := Validate(ep); err == nil {
+		t.Fatalf("Validate not works")
+	}
+}
+
+func TestValidateMissingHandlerErr(t *testing.T) {
+	ep := &Endpoint{Name: "test"}
+	if err := Validate(ep); err == nil {
+		t.Fatalf("Validate not works")
+	}
+}
+
+func TestValidateRegexpStartErr(t *testing.T) {
+	ep := &Endpoint{Name: "test", Handler: "test"}
+	ep.Path = []string{"^/"}
+	if err := Validate(ep); err == nil {
+		t.Fatalf("Validate not works")
+	}
+}
+
+func TestValidateRegexpEndErr(t *testing.T) {
+	ep := &Endpoint{Name: "test", Handler: "test", Path: []string{""}}
+	ep.Path[0] = "/$"
+	if err := Validate(ep); err == nil {
+		t.Fatalf("Validate not works")
+	}
+}
+
+func TestValidateRegexpNonErr(t *testing.T) {
+	ep := &Endpoint{Name: "test", Handler: "test", Path: []string{""}}
+	ep.Path[0] = "^/(.*)$"
+	if err := Validate(ep); err != nil {
+		t.Fatalf("Validate not works")
+	}
+}
+
+func TestValidateRegexpErr(t *testing.T) {
+	ep := &Endpoint{Name: "test", Handler: "test", Path: []string{""}}
+	ep.Path[0] = "^/(.$"
+	if err := Validate(ep); err == nil {
+		t.Fatalf("Validate not works")
+	}
+}

api/handler/api/api.go

@@ -1,117 +0,0 @@
-// Package api provides an http-rpc handler which provides the entire http request over rpc
-package api
-
-import (
-	"net/http"
-
-	goapi "github.com/micro/go-micro/v2/api"
-	"github.com/micro/go-micro/v2/api/handler"
-	api "github.com/micro/go-micro/v2/api/proto"
-	"github.com/micro/go-micro/v2/client"
-	"github.com/micro/go-micro/v2/client/selector"
-	"github.com/micro/go-micro/v2/errors"
-	"github.com/micro/go-micro/v2/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) {
-	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.Service.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,111 +0,0 @@
-package api
-
-import (
-	"fmt"
-	"io/ioutil"
-	"mime"
-	"net"
-	"net/http"
-	"strings"
-
-	api "github.com/micro/go-micro/v2/api/proto"
-	"github.com/micro/go-micro/v2/client/selector"
-	"github.com/micro/go-micro/v2/registry"
-)
-
-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:
-
-			data, _ := ioutil.ReadAll(r.Body)
-			req.Body = string(data)
-		}
-	}
-
-	// 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/broker/broker.go

@@ -1,276 +0,0 @@
-// Package broker provides a go-micro/broker handler
-package broker
-
-import (
-	"encoding/json"
-	"io/ioutil"
-	"net/http"
-	"net/url"
-	"strings"
-	"sync"
-	"sync/atomic"
-	"time"
-
-	"github.com/gorilla/websocket"
-	"github.com/micro/go-micro/v2/api/handler"
-	"github.com/micro/go-micro/v2/broker"
-	log "github.com/micro/go-micro/v2/logger"
-)
-
-const (
-	Handler = "broker"
-
-	pingTime      = (readDeadline * 9) / 10
-	readLimit     = 16384
-	readDeadline  = 60 * time.Second
-	writeDeadline = 10 * time.Second
-)
-
-type brokerHandler struct {
-	once atomic.Value
-	opts handler.Options
-	u    websocket.Upgrader
-}
-
-type conn struct {
-	b     broker.Broker
-	cType string
-	topic string
-	queue string
-	exit  chan bool
-
-	sync.Mutex
-	ws *websocket.Conn
-}
-
-var (
-	contentType = "text/plain"
-)
-
-func checkOrigin(r *http.Request) bool {
-	origin := r.Header["Origin"]
-	if len(origin) == 0 {
-		return true
-	}
-	u, err := url.Parse(origin[0])
-	if err != nil {
-		return false
-	}
-	return u.Host == r.Host
-}
-
-func (c *conn) close() {
-	select {
-	case <-c.exit:
-		return
-	default:
-		close(c.exit)
-	}
-}
-
-func (c *conn) readLoop() {
-	defer func() {
-		c.close()
-		c.ws.Close()
-	}()
-
-	// set read limit/deadline
-	c.ws.SetReadLimit(readLimit)
-	c.ws.SetReadDeadline(time.Now().Add(readDeadline))
-
-	// set close handler
-	ch := c.ws.CloseHandler()
-	c.ws.SetCloseHandler(func(code int, text string) error {
-		err := ch(code, text)
-		c.close()
-		return err
-	})
-
-	// set pong handler
-	c.ws.SetPongHandler(func(string) error {
-		c.ws.SetReadDeadline(time.Now().Add(readDeadline))
-		return nil
-	})
-
-	for {
-		_, message, err := c.ws.ReadMessage()
-		if err != nil {
-			return
-		}
-		c.b.Publish(c.topic, &broker.Message{
-			Header: map[string]string{"Content-Type": c.cType},
-			Body:   message,
-		})
-	}
-}
-
-func (c *conn) write(mType int, data []byte) error {
-	c.Lock()
-	c.ws.SetWriteDeadline(time.Now().Add(writeDeadline))
-	err := c.ws.WriteMessage(mType, data)
-	c.Unlock()
-	return err
-}
-
-func (c *conn) writeLoop() {
-	ticker := time.NewTicker(pingTime)
-
-	var opts []broker.SubscribeOption
-
-	if len(c.queue) > 0 {
-		opts = append(opts, broker.Queue(c.queue))
-	}
-
-	subscriber, err := c.b.Subscribe(c.topic, func(p broker.Event) error {
-		b, err := json.Marshal(p.Message())
-		if err != nil {
-			return nil
-		}
-		return c.write(websocket.TextMessage, b)
-	}, opts...)
-
-	defer func() {
-		subscriber.Unsubscribe()
-		ticker.Stop()
-		c.ws.Close()
-	}()
-
-	if err != nil {
-		log.Error(err.Error())
-		return
-	}
-
-	for {
-		select {
-		case <-ticker.C:
-			if err := c.write(websocket.PingMessage, []byte{}); err != nil {
-				return
-			}
-		case <-c.exit:
-			return
-		}
-	}
-}
-
-func (b *brokerHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
-	br := b.opts.Service.Client().Options().Broker
-
-	// Setup the broker
-	if !b.once.Load().(bool) {
-		if err := br.Init(); err != nil {
-			http.Error(w, err.Error(), 500)
-		}
-		if err := br.Connect(); err != nil {
-			http.Error(w, err.Error(), 500)
-		}
-		b.once.Store(true)
-	}
-
-	// Parse
-	r.ParseForm()
-	topic := r.Form.Get("topic")
-
-	// Can't do anything without a topic
-	if len(topic) == 0 {
-		http.Error(w, "Topic not specified", 400)
-		return
-	}
-
-	// Post assumed to be Publish
-	if r.Method == "POST" {
-		// Create a broker message
-		msg := &broker.Message{
-			Header: make(map[string]string),
-		}
-
-		// Set header
-		for k, v := range r.Header {
-			msg.Header[k] = strings.Join(v, ", ")
-		}
-
-		// Read body
-		b, err := ioutil.ReadAll(r.Body)
-		if err != nil {
-			http.Error(w, err.Error(), 500)
-			return
-		}
-
-		// Set body
-		msg.Body = b
-
-		// Publish
-		br.Publish(topic, msg)
-		return
-	}
-
-	// now back to our regularly scheduled programming
-
-	if r.Method != "GET" {
-		http.Error(w, "Method not allowed", 405)
-		return
-	}
-
-	queue := r.Form.Get("queue")
-
-	ws, err := b.u.Upgrade(w, r, nil)
-	if err != nil {
-		log.Error(err.Error())
-		return
-	}
-
-	cType := r.Header.Get("Content-Type")
-	if len(cType) == 0 {
-		cType = contentType
-	}
-
-	c := &conn{
-		b:     br,
-		cType: cType,
-		topic: topic,
-		queue: queue,
-		exit:  make(chan bool),
-		ws:    ws,
-	}
-
-	go c.writeLoop()
-	c.readLoop()
-}
-
-func (b *brokerHandler) String() string {
-	return "broker"
-}
-
-func NewHandler(opts ...handler.Option) handler.Handler {
-	h := &brokerHandler{
-		u: websocket.Upgrader{
-			CheckOrigin: func(r *http.Request) bool {
-				return true
-			},
-			ReadBufferSize:  1024,
-			WriteBufferSize: 1024,
-		},
-		opts: handler.NewOptions(opts...),
-	}
-	h.once.Store(true)
-	return h
-}
-
-func WithCors(cors map[string]bool, opts ...handler.Option) handler.Handler {
-	return &brokerHandler{
-		u: websocket.Upgrader{
-			CheckOrigin: func(r *http.Request) bool {
-				if origin := r.Header.Get("Origin"); cors[origin] {
-					return true
-				} else if len(origin) > 0 && cors["*"] {
-					return true
-				} else if checkOrigin(r) {
-					return true
-				}
-				return false
-			},
-			ReadBufferSize:  1024,
-			WriteBufferSize: 1024,
-		},
-		opts: handler.NewOptions(opts...),
-	}
-}

api/handler/cloudevents/cloudevents.go

@@ -1,94 +0,0 @@
-// Package cloudevents provides a cloudevents handler publishing the event using the go-micro/client
-package cloudevents
-
-import (
-	"net/http"
-	"path"
-	"regexp"
-	"strings"
-
-	"github.com/micro/go-micro/v2/api/handler"
-	"github.com/micro/go-micro/v2/util/ctx"
-)
-
-type event struct {
-	options handler.Options
-}
-
-var (
-	Handler   = "cloudevents"
-	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) {
-	// request to topic:event
-	// create event
-	// publish to topic
-	topic, _ := evRoute(e.options.Namespace, r.URL.Path)
-
-	// create event
-	ev, err := FromRequest(r)
-	if err != nil {
-		http.Error(w, err.Error(), 500)
-		return
-	}
-
-	// get client
-	c := e.options.Service.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 "cloudevents"
-}
-
-func NewHandler(opts ...handler.Option) handler.Handler {
-	return &event{
-		options: handler.NewOptions(opts...),
-	}
-}

api/handler/cloudevents/event.go

@@ -1,282 +0,0 @@
-/*
- * From: https://github.com/serverless/event-gateway/blob/master/event/event.go
- * Modified: Strip to handler requirements
- *
- * Copyright 2017 Serverless, Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- */
-
-package cloudevents
-
-import (
-	"encoding/json"
-	"errors"
-	"fmt"
-	"io/ioutil"
-	"mime"
-	"net/http"
-	"strings"
-	"time"
-	"unicode"
-
-	"github.com/google/uuid"
-	validator "gopkg.in/go-playground/validator.v9"
-)
-
-const (
-	// TransformationVersion is indicative of the revision of how Event Gateway transforms a request into CloudEvents format.
-	TransformationVersion = "0.1"
-
-	// CloudEventsVersion currently supported by Event Gateway
-	CloudEventsVersion = "0.1"
-)
-
-// Event is a default event structure. All data that passes through the Event Gateway
-// is formatted to a format defined CloudEvents v0.1 spec.
-type Event struct {
-	EventType          string                 `json:"eventType" validate:"required"`
-	EventTypeVersion   string                 `json:"eventTypeVersion,omitempty"`
-	CloudEventsVersion string                 `json:"cloudEventsVersion" validate:"required"`
-	Source             string                 `json:"source" validate:"uri,required"`
-	EventID            string                 `json:"eventID" validate:"required"`
-	EventTime          *time.Time             `json:"eventTime,omitempty"`
-	SchemaURL          string                 `json:"schemaURL,omitempty"`
-	Extensions         map[string]interface{} `json:"extensions,omitempty"`
-	ContentType        string                 `json:"contentType,omitempty"`
-	Data               interface{}            `json:"data"`
-}
-
-// New return new instance of Event.
-func New(eventType string, mimeType string, payload interface{}) *Event {
-	now := time.Now()
-
-	event := &Event{
-		EventType:          eventType,
-		CloudEventsVersion: CloudEventsVersion,
-		Source:             "https://micro.mu",
-		EventID:            uuid.New().String(),
-		EventTime:          &now,
-		ContentType:        mimeType,
-		Data:               payload,
-		Extensions: map[string]interface{}{
-			"eventgateway": map[string]interface{}{
-				"transformed":            "true",
-				"transformation-version": TransformationVersion,
-			},
-		},
-	}
-
-	event.Data = normalizePayload(event.Data, event.ContentType)
-	return event
-}
-
-// FromRequest takes an HTTP request and returns an Event along with path. Most of the implementation
-// is based on https://github.com/cloudevents/spec/blob/master/http-transport-binding.md.
-// This function also supports legacy mode where event type is sent in Event header.
-func FromRequest(r *http.Request) (*Event, error) {
-	contentType := r.Header.Get("Content-Type")
-	mimeType, _, err := mime.ParseMediaType(contentType)
-	if err != nil {
-		if err.Error() != "mime: no media type" {
-			return nil, err
-		}
-		mimeType = "application/octet-stream"
-	}
-	// Read request body
-	body := []byte{}
-	if r.Body != nil {
-		body, err = ioutil.ReadAll(r.Body)
-		if err != nil {
-			return nil, err
-		}
-	}
-
-	var event *Event
-	if mimeType == mimeCloudEventsJSON { // CloudEvents Structured Content Mode
-		return parseAsCloudEvent(mimeType, body)
-	} else if isCloudEventsBinaryContentMode(r.Header) { // CloudEvents Binary Content Mode
-		return parseAsCloudEventBinary(r.Header, body)
-	} else if isLegacyMode(r.Header) {
-		if mimeType == mimeJSON { // CloudEvent in Legacy Mode
-			event, err = parseAsCloudEvent(mimeType, body)
-			if err != nil {
-				return New(string(r.Header.Get("event")), mimeType, body), nil
-			}
-			return event, err
-		}
-
-		return New(string(r.Header.Get("event")), mimeType, body), nil
-	}
-
-	return New("http.request", mimeJSON, newHTTPRequestData(r, body)), nil
-}
-
-// Validate Event struct
-func (e *Event) Validate() error {
-	validate := validator.New()
-	err := validate.Struct(e)
-	if err != nil {
-		return fmt.Errorf("CloudEvent not valid: %v", err)
-	}
-	return nil
-}
-
-func isLegacyMode(headers http.Header) bool {
-	if headers.Get("Event") != "" {
-		return true
-	}
-
-	return false
-}
-
-func isCloudEventsBinaryContentMode(headers http.Header) bool {
-	if headers.Get("CE-EventType") != "" &&
-		headers.Get("CE-CloudEventsVersion") != "" &&
-		headers.Get("CE-Source") != "" &&
-		headers.Get("CE-EventID") != "" {
-		return true
-	}
-
-	return false
-}
-
-func parseAsCloudEventBinary(headers http.Header, payload interface{}) (*Event, error) {
-	event := &Event{
-		EventType:          headers.Get("CE-EventType"),
-		EventTypeVersion:   headers.Get("CE-EventTypeVersion"),
-		CloudEventsVersion: headers.Get("CE-CloudEventsVersion"),
-		Source:             headers.Get("CE-Source"),
-		EventID:            headers.Get("CE-EventID"),
-		ContentType:        headers.Get("Content-Type"),
-		Data:               payload,
-	}
-
-	err := event.Validate()
-	if err != nil {
-		return nil, err
-	}
-
-	if headers.Get("CE-EventTime") != "" {
-		val, err := time.Parse(time.RFC3339, headers.Get("CE-EventTime"))
-		if err != nil {
-			return nil, err
-		}
-		event.EventTime = &val
-	}
-
-	if val := headers.Get("CE-SchemaURL"); len(val) > 0 {
-		event.SchemaURL = val
-	}
-
-	event.Extensions = map[string]interface{}{}
-	for key, val := range flatten(headers) {
-		if strings.HasPrefix(key, "Ce-X-") {
-			key = strings.TrimLeft(key, "Ce-X-")
-			// Make first character lowercase
-			runes := []rune(key)
-			runes[0] = unicode.ToLower(runes[0])
-			event.Extensions[string(runes)] = val
-		}
-	}
-
-	event.Data = normalizePayload(event.Data, event.ContentType)
-	return event, nil
-}
-
-func flatten(h http.Header) map[string]string {
-	headers := map[string]string{}
-	for key, header := range h {
-		headers[key] = header[0]
-		if len(header) > 1 {
-			headers[key] = strings.Join(header, ", ")
-		}
-	}
-	return headers
-}
-
-func parseAsCloudEvent(mime string, payload interface{}) (*Event, error) {
-	body, ok := payload.([]byte)
-	if ok {
-		event := &Event{}
-		err := json.Unmarshal(body, event)
-		if err != nil {
-			return nil, err
-		}
-
-		err = event.Validate()
-		if err != nil {
-			return nil, err
-		}
-
-		event.Data = normalizePayload(event.Data, event.ContentType)
-		return event, nil
-	}
-
-	return nil, errors.New("couldn't cast to []byte")
-}
-
-const (
-	mimeJSON            = "application/json"
-	mimeFormMultipart   = "multipart/form-data"
-	mimeFormURLEncoded  = "application/x-www-form-urlencoded"
-	mimeCloudEventsJSON = "application/cloudevents+json"
-)
-
-// normalizePayload takes anything, checks if it's []byte array and depending on provided mime
-// type converts it to either string or map[string]interface to avoid having base64 string after
-// JSON marshaling.
-func normalizePayload(payload interface{}, mime string) interface{} {
-	if bytePayload, ok := payload.([]byte); ok && len(bytePayload) > 0 {
-		switch {
-		case mime == mimeJSON || strings.HasSuffix(mime, "+json"):
-			var result map[string]interface{}
-			err := json.Unmarshal(bytePayload, &result)
-			if err != nil {
-				return payload
-			}
-			return result
-		case strings.HasPrefix(mime, mimeFormMultipart), mime == mimeFormURLEncoded:
-			return string(bytePayload)
-		}
-	}
-
-	return payload
-}
-
-// HTTPRequestData is a event schema used for sending events to HTTP subscriptions.
-type HTTPRequestData struct {
-	Headers map[string]string   `json:"headers"`
-	Query   map[string][]string `json:"query"`
-	Body    interface{}         `json:"body"`
-	Host    string              `json:"host"`
-	Path    string              `json:"path"`
-	Method  string              `json:"method"`
-	Params  map[string]string   `json:"params"`
-}
-
-// NewHTTPRequestData returns a new instance of HTTPRequestData
-func newHTTPRequestData(r *http.Request, eventData interface{}) *HTTPRequestData {
-	req := &HTTPRequestData{
-		Headers: flatten(r.Header),
-		Query:   r.URL.Query(),
-		Body:    eventData,
-		Host:    r.Host,
-		Path:    r.URL.Path,
-		Method:  r.Method,
-	}
-
-	req.Body = normalizePayload(req.Body, r.Header.Get("content-type"))
-	return req
-}

api/handler/event/event.go

@@ -1,128 +0,0 @@
-// Package event provides a handler which publishes an event
-package event
-
-import (
-	"encoding/json"
-	"fmt"
-	"io/ioutil"
-	"net/http"
-	"path"
-	"regexp"
-	"strings"
-	"time"
-
-	"github.com/google/uuid"
-	"github.com/micro/go-micro/v2/api/handler"
-	proto "github.com/micro/go-micro/v2/api/proto"
-	"github.com/micro/go-micro/v2/util/ctx"
-)
-
-type event struct {
-	options 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) {
-	// request to topic:event
-	// create event
-	// publish to topic
-
-	topic, action := evRoute(e.options.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 {
-		b, err := ioutil.ReadAll(r.Body)
-		if err != nil {
-			http.Error(w, err.Error(), 500)
-			return
-		}
-		ev.Data = string(b)
-	}
-
-	// get client
-	c := e.options.Service.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{
-		options: handler.NewOptions(opts...),
-	}
-}

api/handler/file/file.go

@@ -1,16 +0,0 @@
-// Package file serves file relative to the current directory
-package file
-
-import (
-	"net/http"
-)
-
-type Handler struct{}
-
-func (h *Handler) Serve(w http.ResponseWriter, r *http.Request) {
-	http.ServeFile(w, r, "."+r.URL.Path)
-}
-
-func (h *Handler) String() string {
-	return "file"
-}

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"
-
-	"github.com/micro/go-micro/v2/api"
-	"github.com/micro/go-micro/v2/api/handler"
-	"github.com/micro/go-micro/v2/client/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,121 +0,0 @@
-package http
-
-import (
-	"net"
-	"net/http"
-	"net/http/httptest"
-	"testing"
-
-	"github.com/micro/go-micro/v2/api/handler"
-	"github.com/micro/go-micro/v2/api/router"
-	regRouter "github.com/micro/go-micro/v2/api/router/registry"
-	"github.com/micro/go-micro/v2/registry"
-	"github.com/micro/go-micro/v2/registry/memory"
-)
-
-func testHttp(t *testing.T, path, service, ns string) {
-	r := memory.NewRegistry()
-
-	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.WithNamespace(ns),
-		router.WithRegistry(r),
-	)
-
-	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 {
-		testHttp(t, d.path, d.service, d.namespace)
-	}
-}

api/handler/options.go

@@ -1,55 +0,0 @@
-package handler
-
-import (
-	"github.com/micro/go-micro/v2"
-	"github.com/micro/go-micro/v2/api/router"
-)
-
-type Options struct {
-	Namespace string
-	Router    router.Router
-	Service   micro.Service
-}
-
-type Option func(o *Options)
-
-// NewOptions fills in the blanks
-func NewOptions(opts ...Option) Options {
-	var options Options
-	for _, o := range opts {
-		o(&options)
-	}
-
-	// create service if its blank
-	if options.Service == nil {
-		WithService(micro.NewService())(&options)
-	}
-
-	// set namespace if blank
-	if len(options.Namespace) == 0 {
-		WithNamespace("go.micro.api")(&options)
-	}
-
-	return options
-}
-
-// WithNamespace specifies the namespace for the handler
-func WithNamespace(s string) Option {
-	return func(o *Options) {
-		o.Namespace = s
-	}
-}
-
-// WithRouter specifies a router to be used by the handler
-func WithRouter(r router.Router) Option {
-	return func(o *Options) {
-		o.Router = r
-	}
-}
-
-// WithService specifies a micro.Service
-func WithService(s micro.Service) Option {
-	return func(o *Options) {
-		o.Service = s
-	}
-}

api/handler/registry/registry.go

@@ -1,211 +0,0 @@
-// Package registry is a go-micro/registry handler
-package registry
-
-import (
-	"encoding/json"
-	"io/ioutil"
-	"net/http"
-	"strconv"
-	"time"
-
-	"github.com/gorilla/websocket"
-	"github.com/micro/go-micro/v2/api/handler"
-	"github.com/micro/go-micro/v2/registry"
-)
-
-const (
-	Handler = "registry"
-
-	pingTime      = (readDeadline * 9) / 10
-	readLimit     = 16384
-	readDeadline  = 60 * time.Second
-	writeDeadline = 10 * time.Second
-)
-
-type registryHandler struct {
-	opts handler.Options
-	reg  registry.Registry
-}
-
-func (rh *registryHandler) add(w http.ResponseWriter, r *http.Request) {
-	r.ParseForm()
-	b, err := ioutil.ReadAll(r.Body)
-	if err != nil {
-		http.Error(w, err.Error(), 500)
-		return
-	}
-	defer r.Body.Close()
-
-	var opts []registry.RegisterOption
-
-	// parse ttl
-	if ttl := r.Form.Get("ttl"); len(ttl) > 0 {
-		d, err := time.ParseDuration(ttl)
-		if err == nil {
-			opts = append(opts, registry.RegisterTTL(d))
-		}
-	}
-
-	var service *registry.Service
-	err = json.Unmarshal(b, &service)
-	if err != nil {
-		http.Error(w, err.Error(), 500)
-		return
-	}
-	err = rh.reg.Register(service, opts...)
-	if err != nil {
-		http.Error(w, err.Error(), 500)
-		return
-	}
-}
-
-func (rh *registryHandler) del(w http.ResponseWriter, r *http.Request) {
-	r.ParseForm()
-	b, err := ioutil.ReadAll(r.Body)
-	if err != nil {
-		http.Error(w, err.Error(), 500)
-		return
-	}
-	defer r.Body.Close()
-
-	var service *registry.Service
-	err = json.Unmarshal(b, &service)
-	if err != nil {
-		http.Error(w, err.Error(), 500)
-		return
-	}
-	err = rh.reg.Deregister(service)
-	if err != nil {
-		http.Error(w, err.Error(), 500)
-		return
-	}
-}
-
-func (rh *registryHandler) get(w http.ResponseWriter, r *http.Request) {
-	r.ParseForm()
-	service := r.Form.Get("service")
-
-	var s []*registry.Service
-	var err error
-
-	if len(service) == 0 {
-		//
-		upgrade := r.Header.Get("Upgrade")
-		connect := r.Header.Get("Connection")
-
-		// watch if websockets
-		if upgrade == "websocket" && connect == "Upgrade" {
-			rw, err := rh.reg.Watch()
-			if err != nil {
-				http.Error(w, err.Error(), 500)
-				return
-			}
-			watch(rw, w, r)
-			return
-		}
-
-		// otherwise list services
-		s, err = rh.reg.ListServices()
-	} else {
-		s, err = rh.reg.GetService(service)
-	}
-
-	if err != nil {
-		http.Error(w, err.Error(), 500)
-		return
-	}
-
-	if s == nil || (len(service) > 0 && (len(s) == 0 || len(s[0].Name) == 0)) {
-		http.Error(w, "Service not found", 404)
-		return
-	}
-
-	b, err := json.Marshal(s)
-	if err != nil {
-		http.Error(w, err.Error(), 500)
-		return
-	}
-
-	w.Header().Set("Content-Type", "application/json")
-	w.Header().Set("Content-Length", strconv.Itoa(len(b)))
-	w.Write(b)
-}
-
-func ping(ws *websocket.Conn, exit chan bool) {
-	ticker := time.NewTicker(pingTime)
-
-	for {
-		select {
-		case <-ticker.C:
-			ws.SetWriteDeadline(time.Now().Add(writeDeadline))
-			err := ws.WriteMessage(websocket.PingMessage, []byte{})
-			if err != nil {
-				return
-			}
-		case <-exit:
-			return
-		}
-	}
-}
-
-func watch(rw registry.Watcher, w http.ResponseWriter, r *http.Request) {
-	upgrader := websocket.Upgrader{
-		ReadBufferSize:  1024,
-		WriteBufferSize: 1024,
-	}
-
-	ws, err := upgrader.Upgrade(w, r, nil)
-	if err != nil {
-		http.Error(w, err.Error(), 500)
-		return
-	}
-
-	// we need an exit chan
-	exit := make(chan bool)
-
-	defer func() {
-		close(exit)
-	}()
-
-	// ping the socket
-	go ping(ws, exit)
-
-	for {
-		// get next result
-		r, err := rw.Next()
-		if err != nil {
-			http.Error(w, err.Error(), 500)
-			return
-		}
-
-		// write to client
-		ws.SetWriteDeadline(time.Now().Add(writeDeadline))
-		if err := ws.WriteJSON(r); err != nil {
-			return
-		}
-	}
-}
-
-func (rh *registryHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
-	switch r.Method {
-	case "GET":
-		rh.get(w, r)
-	case "POST":
-		rh.add(w, r)
-	case "DELETE":
-		rh.del(w, r)
-	}
-}
-
-func (rh *registryHandler) String() string {
-	return "registry"
-}
-
-func NewHandler(opts ...handler.Option) handler.Handler {
-	options := handler.NewOptions(opts...)
-
-	return &registryHandler{
-		opts: options,
-		reg:  options.Service.Client().Options().Registry,
-	}
-}

api/handler/rpc/rpc.go

@@ -1,323 +0,0 @@
-// Package rpc is a go-micro rpc handler.
-package rpc
-
-import (
-	"encoding/json"
-	"io"
-	"io/ioutil"
-	"net/http"
-	"strconv"
-	"strings"
-
-	"github.com/joncalhoun/qson"
-	"github.com/micro/go-micro/v2/api"
-	"github.com/micro/go-micro/v2/api/handler"
-	proto "github.com/micro/go-micro/v2/api/internal/proto"
-	"github.com/micro/go-micro/v2/client"
-	"github.com/micro/go-micro/v2/client/selector"
-	"github.com/micro/go-micro/v2/codec"
-	"github.com/micro/go-micro/v2/codec/jsonrpc"
-	"github.com/micro/go-micro/v2/codec/protorpc"
-	"github.com/micro/go-micro/v2/errors"
-	"github.com/micro/go-micro/v2/registry"
-	"github.com/micro/go-micro/v2/util/ctx"
-)
-
-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",
-	}
-)
-
-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) {
-	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
-	}
-
-	// only allow post when we have the router
-	if r.Method != "GET" && (h.opts.Router != nil && r.Method != "POST") {
-		http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)
-		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.Service.Client()
-
-	// create strategy
-	so := selector.WithStrategy(strategy(service.Services))
-
-	// get payload
-	br, err := requestPayload(r)
-	if err != nil {
-		writeError(w, r, err)
-		return
-	}
-
-	// create context
-	cx := ctx.FromRequest(r)
-
-	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, _ = response.Marshal()
-	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, _ = response.MarshalJSON()
-	}
-
-	// 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) {
-	// 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
-		}
-		b, _ := raw.Marshal()
-		return b, nil
-	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
-		b, _ := json.Marshal(vals)
-		return b, nil
-		// TODO: application/grpc
-	}
-
-	// otherwise as per usual
-
-	switch r.Method {
-	case "GET":
-		if len(r.URL.RawQuery) > 0 {
-			return qson.ToJSON(r.URL.RawQuery)
-		}
-	case "PATCH", "POST":
-		return ioutil.ReadAll(r.Body)
-	}
-
-	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)
-	}
-
-	w.Write([]byte(ce.Error()))
-}
-
-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 response
-	w.Write(rsp)
-}
-
-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,95 +0,0 @@
-package rpc
-
-import (
-	"bytes"
-	"encoding/json"
-	"net/http"
-	"testing"
-
-	"github.com/golang/protobuf/proto"
-	go_api "github.com/micro/go-micro/v2/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)
-	}
-
-	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/udp/udp.go

@@ -1,25 +0,0 @@
-// Package udp reads and write from a udp connection
-package udp
-
-import (
-	"io"
-	"net"
-	"net/http"
-)
-
-type Handler struct{}
-
-func (h *Handler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
-	c, err := net.Dial("udp", r.Host)
-	if err != nil {
-		http.Error(w, err.Error(), 500)
-		return
-	}
-	go io.Copy(c, r.Body)
-	// write response
-	io.Copy(w, c)
-}
-
-func (h *Handler) String() string {
-	return "udp"
-}

api/handler/unix/unix.go

@@ -1,30 +0,0 @@
-// Package unix reads from a unix socket expecting it to be in /tmp/path
-package unix
-
-import (
-	"fmt"
-	"io"
-	"net"
-	"net/http"
-	"path/filepath"
-)
-
-type Handler struct{}
-
-func (h *Handler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
-	sock := fmt.Sprintf("%s.sock", filepath.Clean(r.URL.Path))
-	path := filepath.Join("/tmp", sock)
-
-	c, err := net.Dial("unix", path)
-	if err != nil {
-		http.Error(w, err.Error(), 500)
-		return
-	}
-	go io.Copy(c, r.Body)
-	// write response
-	io.Copy(w, c)
-}
-
-func (h *Handler) String() string {
-	return "unix"
-}

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"
-
-	"github.com/micro/go-micro/v2/api"
-	"github.com/micro/go-micro/v2/api/handler"
-	"github.com/micro/go-micro/v2/client/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,338 +0,0 @@
-// Code generated by protoc-gen-go. DO NOT EDIT.
-// source: github.com/micro/go-micro/v2/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_7b6696ef87ec1943, []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_7b6696ef87ec1943, []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_7b6696ef87ec1943, []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_7b6696ef87ec1943, []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("github.com/micro/go-micro/v2/api/proto/api.proto", fileDescriptor_7b6696ef87ec1943)
-}
-
-var fileDescriptor_7b6696ef87ec1943 = []byte{
-	// 408 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x53, 0x4d, 0x8f, 0xd3, 0x30,
-	0x10, 0x55, 0xe2, 0x24, 0xbb, 0x99, 0x22, 0x84, 0x7c, 0x40, 0x66, 0x59, 0xa1, 0x2a, 0xa7, 0x0a,
-	0xa9, 0x29, 0xec, 0x72, 0x40, 0x5c, 0xa1, 0x5a, 0x8e, 0x2b, 0xff, 0x03, 0x77, 0x63, 0x25, 0x16,
-	0x4d, 0x1c, 0x62, 0xa7, 0x52, 0x7f, 0x1c, 0x07, 0x7e, 0x06, 0xff, 0x06, 0x79, 0xec, 0x7e, 0x50,
-	0x95, 0x0b, 0xf4, 0xf6, 0x62, 0xbf, 0x79, 0xf3, 0xe6, 0x8d, 0x03, 0xf3, 0x5a, 0xd9, 0x66, 0x5c,
-	0x95, 0x4f, 0xba, 0x5d, 0xb4, 0xea, 0x69, 0xd0, 0x8b, 0x5a, 0xcf, 0x3d, 0x10, 0xbd, 0x5a, 0xf4,
-	0x83, 0xb6, 0x88, 0x4a, 0x44, 0x34, 0xab, 0x75, 0x29, 0x7a, 0x55, 0xbc, 0x83, 0xe4, 0x51, 0xa8,
-	0x81, 0xbe, 0x00, 0xf2, 0x4d, 0x6e, 0x59, 0x34, 0x8d, 0x66, 0x39, 0x77, 0x90, 0xbe, 0x84, 0x6c,
-	0x23, 0xd6, 0xa3, 0x34, 0x2c, 0x9e, 0x92, 0x59, 0xce, 0xc3, 0x57, 0xf1, 0x93, 0xc0, 0x15, 0x97,
-	0xdf, 0x47, 0x69, 0xac, 0xe3, 0xb4, 0xd2, 0x36, 0xba, 0x0a, 0x85, 0xe1, 0x8b, 0x52, 0x48, 0x7a,
-	0x61, 0x1b, 0x16, 0xe3, 0x29, 0x62, 0x7a, 0x0f, 0x59, 0x23, 0x45, 0x25, 0x07, 0x46, 0xa6, 0x64,
-	0x36, 0xb9, 0x7b, 0x5d, 0x7a, 0x0b, 0x65, 0x10, 0x2b, 0xbf, 0xe2, 0xed, 0xb2, 0xb3, 0xc3, 0x96,
-	0x07, 0x2a, 0x7d, 0x0b, 0xa4, 0x96, 0x96, 0x25, 0x58, 0xc1, 0x4e, 0x2b, 0x1e, 0xa4, 0xf5, 0x74,
-	0x47, 0xa2, 0x73, 0x48, 0x7a, 0x6d, 0x2c, 0x4b, 0x91, 0xfc, 0xea, 0x94, 0xfc, 0xa8, 0x4d, 0x60,
-	0x23, 0xcd, 0x79, 0x5c, 0xe9, 0x6a, 0xcb, 0x32, 0xef, 0xd1, 0x61, 0x97, 0xc2, 0x38, 0xac, 0xd9,
-	0x95, 0x4f, 0x61, 0x1c, 0xd6, 0x37, 0x0f, 0x30, 0x39, 0xf2, 0x75, 0x26, 0xa6, 0x02, 0x52, 0x0c,
-	0x06, 0x67, 0x9d, 0xdc, 0x3d, 0xdb, 0xb5, 0x75, 0xa9, 0x72, 0x7f, 0xf5, 0x29, 0xfe, 0x18, 0xdd,
-	0x7c, 0x81, 0xeb, 0x9d, 0xdd, 0xff, 0x50, 0x59, 0x42, 0xbe, 0x9f, 0xe3, 0xdf, 0x65, 0x8a, 0x1f,
-	0x11, 0x5c, 0x73, 0x69, 0x7a, 0xdd, 0x19, 0x49, 0xdf, 0x00, 0x18, 0x2b, 0xec, 0x68, 0x3e, 0xeb,
-	0x4a, 0xa2, 0x5a, 0xca, 0x8f, 0x4e, 0xe8, 0x87, 0xfd, 0xe2, 0x62, 0x4c, 0xf6, 0xf6, 0x90, 0xac,
-	0x57, 0x38, 0xbb, 0xb9, 0x5d, 0xbc, 0xe4, 0x10, 0xef, 0xc5, 0xc2, 0x2c, 0x7e, 0x45, 0x90, 0x2e,
-	0x37, 0xb2, 0xc3, 0x2d, 0x76, 0xa2, 0x95, 0x41, 0x04, 0x31, 0x7d, 0x0e, 0xb1, 0xaa, 0xc2, 0xdb,
-	0x8b, 0x55, 0x45, 0x6f, 0x21, 0xb7, 0xaa, 0x95, 0xc6, 0x8a, 0xb6, 0x47, 0x3f, 0x84, 0x1f, 0x0e,
-	0xe8, 0xfb, 0xfd, 0x78, 0xc9, 0x9f, 0x0f, 0x07, 0x1b, 0xfc, 0x6d, 0xb6, 0x4a, 0x58, 0xc1, 0x52,
-	0xdf, 0xd4, 0xe1, 0x8b, 0xcd, 0xb6, 0xca, 0xf0, 0x07, 0xbd, 0xff, 0x1d, 0x00, 0x00, 0xff, 0xff,
-	0x97, 0xf3, 0x59, 0x6e, 0xd1, 0x03, 0x00, 0x00,
-}

api/proto/api.pb.micro.go

@@ -1,21 +0,0 @@
-// Code generated by protoc-gen-micro. DO NOT EDIT.
-// source: github.com/micro/go-micro/v2/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"
-
-	"github.com/micro/go-micro/v2/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,27 +0,0 @@
-// Package host resolves using http host
-package host
-
-import (
-	"net/http"
-
-	"github.com/micro/go-micro/v2/api/resolver"
-)
-
-type Resolver struct{}
-
-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{}
-}

api/resolver/micro/micro.go

@@ -1,45 +0,0 @@
-// Package micro provides a micro rpc resolver which prefixes a namespace
-package micro
-
-import (
-	"net/http"
-
-	"github.com/micro/go-micro/v2/api/resolver"
-)
-
-// default resolver for legacy purposes
-// it uses proxy routing to resolve names
-// /foo becomes namespace.foo
-// /v1/foo becomes namespace.v1.foo
-type Resolver struct {
-	Options resolver.Options
-}
-
-func (r *Resolver) Resolve(req *http.Request) (*resolver.Endpoint, error) {
-	var name, method string
-
-	switch r.Options.Handler {
-	// internal handlers
-	case "meta", "api", "rpc", "micro":
-		name, method = apiRoute(req.URL.Path)
-	default:
-		method = req.Method
-		name = proxyRoute(req.URL.Path)
-	}
-
-	return &resolver.Endpoint{
-		Name:   name,
-		Method: method,
-	}, nil
-}
-
-func (r *Resolver) String() string {
-	return "micro"
-}
-
-// NewResolver creates a new micro resolver
-func NewResolver(opts ...resolver.Option) resolver.Resolver {
-	return &Resolver{
-		Options: resolver.NewOptions(opts...),
-	}
-}

api/resolver/micro/route.go

@@ -1,90 +0,0 @@
-package micro
-
-import (
-	"path"
-	"regexp"
-	"strings"
-)
-
-var (
-	proxyRe   = regexp.MustCompile("^[a-zA-Z0-9]+(-[a-zA-Z0-9]+)*$")
-	versionRe = regexp.MustCompilePOSIX("^v[0-9]+$")
-)
-
-// Translates /foo/bar/zool into api service go.micro.api.foo method Bar.Zool
-// Translates /foo/bar into api service go.micro.api.foo method Foo.Bar
-func apiRoute(p string) (string, string) {
-	p = path.Clean(p)
-	p = strings.TrimPrefix(p, "/")
-	parts := strings.Split(p, "/")
-
-	// If we've got two or less parts
-	// Use first part as service
-	// Use all parts as method
-	if len(parts) <= 2 {
-		name := parts[0]
-		return name, methodName(parts)
-	}
-
-	// Treat /v[0-9]+ as versioning where we have 3 parts
-	// /v1/foo/bar => service: v1.foo method: Foo.bar
-	if len(parts) == 3 && versionRe.Match([]byte(parts[0])) {
-		name := strings.Join(parts[:len(parts)-1], ".")
-		return name, methodName(parts[len(parts)-2:])
-	}
-
-	// Service is everything minus last two parts
-	// Method is the last two parts
-	name := strings.Join(parts[:len(parts)-2], ".")
-	return name, methodName(parts[len(parts)-2:])
-}
-
-func proxyRoute(p string) string {
-	parts := strings.Split(p, "/")
-	if len(parts) < 2 {
-		return ""
-	}
-
-	var service string
-	var alias string
-
-	// /[service]/methods
-	if len(parts) > 2 {
-		// /v1/[service]
-		if versionRe.MatchString(parts[1]) {
-			service = parts[1] + "." + parts[2]
-			alias = parts[2]
-		} else {
-			service = parts[1]
-			alias = parts[1]
-		}
-		// /[service]
-	} else {
-		service = parts[1]
-		alias = parts[1]
-	}
-
-	// check service name is valid
-	if !proxyRe.MatchString(alias) {
-		return ""
-	}
-
-	return service
-}
-
-func methodName(parts []string) string {
-	for i, part := range parts {
-		parts[i] = toCamel(part)
-	}
-
-	return strings.Join(parts, ".")
-}
-
-func toCamel(s string) string {
-	words := strings.Split(s, "-")
-	var out string
-	for _, word := range words {
-		out += strings.Title(word)
-	}
-	return out
-}

api/resolver/micro/route_test.go

@@ -1,130 +0,0 @@
-package micro
-
-import (
-	"testing"
-)
-
-func TestApiRoute(t *testing.T) {
-	testData := []struct {
-		path    string
-		service string
-		method  string
-	}{
-		{
-			"/foo/bar",
-			"foo",
-			"Foo.Bar",
-		},
-		{
-			"/foo/foo/bar",
-			"foo",
-			"Foo.Bar",
-		},
-		{
-			"/foo/bar/baz",
-			"foo",
-			"Bar.Baz",
-		},
-		{
-			"/foo/bar/baz-xyz",
-			"foo",
-			"Bar.BazXyz",
-		},
-		{
-			"/foo/bar/baz/cat",
-			"foo.bar",
-			"Baz.Cat",
-		},
-		{
-			"/foo/bar/baz/cat/car",
-			"foo.bar.baz",
-			"Cat.Car",
-		},
-		{
-			"/foo/fooBar/bazCat",
-			"foo",
-			"FooBar.BazCat",
-		},
-		{
-			"/v1/foo/bar",
-			"v1.foo",
-			"Foo.Bar",
-		},
-		{
-			"/v1/foo/bar/baz",
-			"v1.foo",
-			"Bar.Baz",
-		},
-		{
-			"/v1/foo/bar/baz/cat",
-			"v1.foo.bar",
-			"Baz.Cat",
-		},
-	}
-
-	for _, d := range testData {
-		s, m := apiRoute(d.path)
-		if d.service != s {
-			t.Fatalf("Expected service: %s for path: %s got: %s %s", d.service, d.path, s, m)
-		}
-		if d.method != m {
-			t.Fatalf("Expected service: %s for path: %s got: %s", d.method, d.path, m)
-		}
-	}
-}
-
-func TestProxyRoute(t *testing.T) {
-	testData := []struct {
-		path    string
-		service string
-	}{
-		// no namespace
-		{
-			"/f",
-			"f",
-		},
-		{
-			"/f",
-			"f",
-		},
-		{
-			"/f-b",
-			"f-b",
-		},
-		{
-			"/foo/bar",
-			"foo",
-		},
-		{
-			"/foo-bar",
-			"foo-bar",
-		},
-		{
-			"/foo-bar-baz",
-			"foo-bar-baz",
-		},
-		{
-			"/foo/bar/bar",
-			"foo",
-		},
-		{
-			"/v1/foo/bar",
-			"v1.foo",
-		},
-		{
-			"/v1/foo/bar/baz",
-			"v1.foo",
-		},
-		{
-			"/v1/foo/bar/baz/cat",
-			"v1.foo",
-		},
-	}
-
-	for _, d := range testData {
-		s := proxyRoute(d.path)
-		if d.service != s {
-			t.Fatalf("Expected service: %s for path: %s got: %s", d.service, d.path, s)
-		}
-	}
-}

api/resolver/options.go

@@ -1,24 +0,0 @@
-package resolver
-
-// NewOptions returns new initialised options
-func NewOptions(opts ...Option) Options {
-	var options Options
-	for _, o := range opts {
-		o(&options)
-	}
-	return options
-}
-
-// WithHandler sets the handler being used
-func WithHandler(h string) Option {
-	return func(o *Options) {
-		o.Handler = h
-	}
-}
-
-// WithNamespace sets the namespace being used
-func WithNamespace(n string) Option {
-	return func(o *Options) {
-		o.Namespace = n
-	}
-}

api/resolver/path/path.go

@@ -1,33 +0,0 @@
-// Package path resolves using http path
-package path
-
-import (
-	"errors"
-	"net/http"
-	"strings"
-
-	"github.com/micro/go-micro/v2/api/resolver"
-)
-
-type Resolver struct{}
-
-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:], "/")
-	return &resolver.Endpoint{
-		Name:   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{}
-}

api/resolver/resolver.go

@@ -1,31 +0,0 @@
-// Package resolver resolves a http request to an endpoint
-package resolver
-
-import (
-	"net/http"
-)
-
-// 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 string
-}
-
-type Option func(o *Options)

api/resolver/vpath/vpath.go

@@ -1,59 +0,0 @@
-// Package vpath resolves using http path and recognised versioned urls
-package vpath
-
-import (
-	"errors"
-	"net/http"
-	"regexp"
-	"strings"
-
-	"github.com/micro/go-micro/v2/api/resolver"
-)
-
-type Resolver struct{}
-
-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:   parts[0],
-			Host:   req.Host,
-			Method: req.Method,
-			Path:   req.URL.Path,
-		}, nil
-	}
-
-	// /v1/foo
-	if re.MatchString(parts[0]) {
-		return &resolver.Endpoint{
-			Name:   parts[1],
-			Host:   req.Host,
-			Method: req.Method,
-			Path:   req.URL.Path,
-		}, nil
-	}
-
-	return &resolver.Endpoint{
-		Name:   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{}
-}

api/router/options.go

@@ -1,60 +0,0 @@
-package router
-
-import (
-	"github.com/micro/go-micro/v2/api/resolver"
-	"github.com/micro/go-micro/v2/api/resolver/micro"
-	"github.com/micro/go-micro/v2/registry"
-)
-
-type Options struct {
-	Namespace string
-	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 = micro.NewResolver(
-			resolver.WithHandler(options.Handler),
-			resolver.WithNamespace(options.Namespace),
-		)
-	}
-
-	return options
-}
-
-func WithHandler(h string) Option {
-	return func(o *Options) {
-		o.Handler = h
-	}
-}
-
-func WithNamespace(ns string) Option {
-	return func(o *Options) {
-		o.Namespace = ns
-	}
-}
-
-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,393 +0,0 @@
-// Package registry provides a dynamic api service router
-package registry
-
-import (
-	"errors"
-	"fmt"
-	"log"
-	"net/http"
-	"regexp"
-	"strings"
-	"sync"
-	"time"
-
-	"github.com/micro/go-micro/v2/api"
-	"github.com/micro/go-micro/v2/api/router"
-	"github.com/micro/go-micro/v2/registry"
-	"github.com/micro/go-micro/v2/registry/cache"
-)
-
-// 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
-}
-
-func setNamespace(ns, name string) string {
-	ns = strings.TrimSpace(ns)
-	name = strings.TrimSpace(name)
-
-	// no namespace
-	if len(ns) == 0 {
-		return name
-	}
-
-	switch {
-	// has - suffix
-	case strings.HasSuffix(ns, "-"):
-		return strings.Replace(ns+name, ".", "-", -1)
-	// has . suffix
-	case strings.HasSuffix(ns, "."):
-		return ns + name
-	}
-
-	// default join .
-	return strings.Join([]string{ns, name}, ".")
-}
-
-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++
-			log.Println("Error listing endpoints", err)
-			time.Sleep(time.Duration(attempts) * time.Second)
-			continue
-		}
-
-		attempts = 0
-
-		// for each service, get service and store endpoints
-		for _, s := range services {
-			// only get services for this namespace
-			if !strings.HasPrefix(s.Name, r.opts.Namespace) {
-				continue
-			}
-			service, err := r.rc.GetService(s.Name)
-			if err != nil {
-				continue
-			}
-			r.store(service)
-		}
-
-		// refresh list in 10 minutes... cruft
-		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 || !strings.HasPrefix(res.Service.Name, r.opts.Namespace) {
-		return
-	}
-
-	// get entry from cache
-	service, err := r.rc.GetService(res.Service.Name)
-	if err != nil {
-		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 _, endpoint := range service.Endpoints {
-			// create a key service:endpoint_name
-			key := fmt.Sprintf("%s:%s", service.Name, endpoint.Name)
-			// decode endpoint
-			end := api.Decode(endpoint.Metadata)
-
-			// if we got nothing skip
-			if err := api.Validate(end); err != nil {
-				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, endpoint := range eps {
-		r.eps[name] = endpoint
-	}
-}
-
-// 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++
-			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 *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) Endpoint(req *http.Request) (*api.Service, error) {
-	if r.isClosed() {
-		return nil, errors.New("router closed")
-	}
-
-	r.RLock()
-	defer r.RUnlock()
-
-	// use the first match
-	// TODO: weighted matching
-	for _, e := range r.eps {
-		ep := e.Endpoint
-
-		// match
-		var pathMatch, hostMatch, methodMatch bool
-
-		// 1. try method GET, POST, PUT, etc
-		// 2. try host example.com, foobar.com, etc
-		// 3. try path /foo/bar, /bar/baz, etc
-
-		// 1. try match method
-		for _, m := range ep.Method {
-			if req.Method == m {
-				methodMatch = true
-				break
-			}
-		}
-
-		// no match on method pass
-		if len(ep.Method) > 0 && !methodMatch {
-			continue
-		}
-
-		// 2. try match host
-		for _, h := range ep.Host {
-			if req.Host == h {
-				hostMatch = true
-				break
-			}
-		}
-
-		// no match on host pass
-		if len(ep.Host) > 0 && !hostMatch {
-			continue
-		}
-
-		// 3. try match paths
-		for _, p := range ep.Path {
-			re, err := regexp.CompilePOSIX(p)
-			if err == nil && re.MatchString(req.URL.Path) {
-				pathMatch = true
-				break
-			}
-		}
-
-		// no match pass
-		if len(ep.Path) > 0 && !pathMatch {
-			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 := setNamespace(r.opts.Namespace, 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),
-	}
-	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,181 +0,0 @@
-package registry
-
-import (
-	"fmt"
-	"net/http"
-	"net/url"
-	"testing"
-
-	"github.com/micro/go-micro/v2/api"
-)
-
-func TestSetNamespace(t *testing.T) {
-	testCases := []struct {
-		namespace string
-		name      string
-		expected  string
-	}{
-		// default dotted path
-		{
-			"go.micro.api",
-			"foo",
-			"go.micro.api.foo",
-		},
-		// dotted end
-		{
-			"go.micro.api.",
-			"foo",
-			"go.micro.api.foo",
-		},
-		// dashed end
-		{
-			"go-micro-api-",
-			"foo",
-			"go-micro-api-foo",
-		},
-		// no namespace
-		{
-			"",
-			"foo",
-			"foo",
-		},
-		{
-			"go-micro-api-",
-			"v2.foo",
-			"go-micro-api-v2-foo",
-		},
-	}
-
-	for _, test := range testCases {
-		name := setNamespace(test.namespace, test.name)
-		if name != test.expected {
-			t.Fatalf("expected name %s got %s", test.expected, name)
-		}
-	}
-}
-
-func TestRouter(t *testing.T) {
-	r := newRouter()
-
-	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
-	}
-
-	testData := []struct {
-		e *api.Endpoint
-		r *http.Request
-		m bool
-	}{
-		{
-			e: &api.Endpoint{
-				Name:   "Foo.Bar",
-				Host:   []string{"example.com"},
-				Method: []string{"GET"},
-				Path:   []string{"/foo"},
-			},
-			r: &http.Request{
-				Host:   "example.com",
-				Method: "GET",
-				URL: &url.URL{
-					Path: "/foo",
-				},
-			},
-			m: true,
-		},
-		{
-			e: &api.Endpoint{
-				Name:   "Bar.Baz",
-				Host:   []string{"example.com", "foo.com"},
-				Method: []string{"GET", "POST"},
-				Path:   []string{"/foo/bar"},
-			},
-			r: &http.Request{
-				Host:   "foo.com",
-				Method: "POST",
-				URL: &url.URL{
-					Path: "/foo/bar",
-				},
-			},
-			m: true,
-		},
-		{
-			e: &api.Endpoint{
-				Name:   "Test.Cruft",
-				Host:   []string{"example.com", "foo.com"},
-				Method: []string{"GET", "POST"},
-				Path:   []string{"/xyz"},
-			},
-			r: &http.Request{
-				Host:   "fail.com",
-				Method: "DELETE",
-				URL: &url.URL{
-					Path: "/test/fail",
-				},
-			},
-			m: false,
-		},
-	}
-
-	for _, d := range testData {
-		key := fmt.Sprintf("%s:%s", "test.service", d.e.Name)
-		r.eps[key] = &api.Service{
-			Endpoint: d.e,
-		}
-	}
-
-	for _, d := range testData {
-		e, err := r.Endpoint(d.r)
-		if d.m && err != nil {
-			t.Fatalf("expected match, got %v", err)
-		}
-		if !d.m && err == nil {
-			t.Fatal("expected error got match")
-		}
-		// skip testing the non match
-		if !d.m {
-			continue
-		}
-
-		ep := e.Endpoint
-
-		// test the match
-		if d.e.Name != ep.Name {
-			t.Fatalf("expected %v got %v", d.e.Name, ep.Name)
-		}
-		if ok := compare(d.e.Method, ep.Method); !ok {
-			t.Fatalf("expected %v got %v", d.e.Method, ep.Method)
-		}
-		if ok := compare(d.e.Path, ep.Path); !ok {
-			t.Fatalf("expected %v got %v", d.e.Path, ep.Path)
-		}
-		if ok := compare(d.e.Host, ep.Host); !ok {
-			t.Fatalf("expected %v got %v", d.e.Host, ep.Host)
-		}
-
-	}
-
-}

api/router/router.go

@@ -1,20 +0,0 @@
-// Package router provides api service routing
-package router
-
-import (
-	"net/http"
-
-	"github.com/micro/go-micro/v2/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)
-	// Route returns an api.Service route
-	Route(r *http.Request) (*api.Service, error)
-}

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,44 +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"
-	"log"
-	"net"
-	"os"
-
-	"github.com/micro/go-micro/v2/api/server/acme"
-	"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 {
-		log.Printf("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/certmagic/certmagic.go

@@ -1,68 +0,0 @@
-// Package certmagic is the ACME provider from github.com/mholt/certmagic
-package certmagic
-
-import (
-	"crypto/tls"
-	"log"
-	"math/rand"
-	"net"
-	"time"
-
-	"github.com/mholt/certmagic"
-
-	"github.com/micro/go-micro/v2/api/server/acme"
-)
-
-type certmagicProvider struct {
-	opts acme.Options
-}
-
-// TODO: set self-contained options
-func (c *certmagicProvider) setup() {
-	certmagic.Default.CA = c.opts.CA
-	if c.opts.ChallengeProvider != nil {
-		// Enabling DNS Challenge disables the other challenges
-		certmagic.Default.DNSProvider = c.opts.ChallengeProvider
-	}
-	if c.opts.OnDemand {
-		certmagic.Default.OnDemand = new(certmagic.OnDemandConfig)
-	}
-	if c.opts.Cache != nil {
-		// already validated by new()
-		certmagic.Default.Storage = c.opts.Cache.(certmagic.Storage)
-	}
-	// If multiple instances of the provider are running, inject some
-	// randomness so they don't collide
-	rand.Seed(time.Now().UnixNano())
-	randomDuration := (7 * 24 * time.Hour) + (time.Duration(rand.Intn(504)) * time.Hour)
-	certmagic.Default.RenewDurationBefore = randomDuration
-}
-
-func (c *certmagicProvider) Listen(hosts ...string) (net.Listener, error) {
-	c.setup()
-	return certmagic.Listen(hosts)
-}
-
-func (c *certmagicProvider) TLSConfig(hosts ...string) (*tls.Config, error) {
-	c.setup()
-	return certmagic.TLS(hosts)
-}
-
-// New returns a certmagic provider
-func NewProvider(options ...acme.Option) acme.Provider {
-	opts := acme.DefaultOptions()
-
-	for _, o := range options {
-		o(&opts)
-	}
-
-	if opts.Cache != nil {
-		if _, ok := opts.Cache.(certmagic.Storage); !ok {
-			log.Fatal("ACME: cache provided doesn't implement certmagic's Storage interface")
-		}
-	}
-
-	return &certmagicProvider{
-		opts: opts,
-	}
-}

api/server/acme/certmagic/certmagic_test.go

@@ -1,228 +0,0 @@
-package certmagic
-
-import (
-	"net"
-	"net/http"
-	"os"
-	"reflect"
-	"sort"
-	"testing"
-	"time"
-
-	"github.com/go-acme/lego/v3/providers/dns/cloudflare"
-	"github.com/mholt/certmagic"
-	"github.com/micro/go-micro/v2/api/server/acme"
-	cfstore "github.com/micro/go-micro/v2/store/cloudflare"
-	"github.com/micro/go-micro/v2/sync/lock/memory"
-)
-
-func TestCertMagic(t *testing.T) {
-	if len(os.Getenv("IN_TRAVIS_CI")) != 0 {
-		t.Skip("Travis doesn't let us bind :443")
-	}
-	l, err := NewProvider().Listen()
-	if err != nil {
-		if _, ok := err.(*net.OpError); ok {
-			t.Skip("Run under non privileged user")
-		}
-		t.Fatal(err.Error())
-	}
-	l.Close()
-
-	c := cloudflare.NewDefaultConfig()
-	c.AuthEmail = ""
-	c.AuthKey = ""
-	c.AuthToken = "test"
-	c.ZoneToken = "test"
-
-	p, err := cloudflare.NewDNSProviderConfig(c)
-	if err != nil {
-		t.Fatal(err.Error())
-	}
-
-	l, err = NewProvider(acme.AcceptToS(true),
-		acme.CA(acme.LetsEncryptStagingCA),
-		acme.ChallengeProvider(p),
-	).Listen()
-
-	if err != nil {
-		t.Fatal(err.Error())
-	}
-	l.Close()
-}
-
-func TestStorageImplementation(t *testing.T) {
-	apiToken, accountID := os.Getenv("CF_API_TOKEN"), os.Getenv("CF_ACCOUNT_ID")
-	kvID := os.Getenv("KV_NAMESPACE_ID")
-	if len(apiToken) == 0 || len(accountID) == 0 || len(kvID) == 0 {
-		t.Skip("No Cloudflare API keys available, skipping test")
-	}
-
-	var s certmagic.Storage
-	st := cfstore.NewStore(
-		cfstore.Token(apiToken),
-		cfstore.Account(accountID),
-		cfstore.Namespace(kvID),
-	)
-	s = &storage{
-		lock:  memory.NewLock(),
-		store: st,
-	}
-
-	// Test Lock
-	if err := s.Lock("test"); err != nil {
-		t.Fatal(err)
-	}
-
-	// Test Unlock
-	if err := s.Unlock("test"); err != nil {
-		t.Fatal(err)
-	}
-
-	// Test data
-	testdata := []struct {
-		key   string
-		value []byte
-	}{
-		{key: "/foo/a", value: []byte("lorem")},
-		{key: "/foo/b", value: []byte("ipsum")},
-		{key: "/foo/c", value: []byte("dolor")},
-		{key: "/foo/d", value: []byte("sit")},
-		{key: "/bar/a", value: []byte("amet")},
-		{key: "/bar/b", value: []byte("consectetur")},
-		{key: "/bar/c", value: []byte("adipiscing")},
-		{key: "/bar/d", value: []byte("elit")},
-		{key: "/foo/bar/a", value: []byte("sed")},
-		{key: "/foo/bar/b", value: []byte("do")},
-		{key: "/foo/bar/c", value: []byte("eiusmod")},
-		{key: "/foo/bar/d", value: []byte("tempor")},
-		{key: "/foo/bar/baz/a", value: []byte("incididunt")},
-		{key: "/foo/bar/baz/b", value: []byte("ut")},
-		{key: "/foo/bar/baz/c", value: []byte("labore")},
-		{key: "/foo/bar/baz/d", value: []byte("et")},
-		// a duplicate just in case there's any edge cases
-		{key: "/foo/a", value: []byte("lorem")},
-	}
-
-	// Test Store
-	for _, d := range testdata {
-		if err := s.Store(d.key, d.value); err != nil {
-			t.Fatal(err.Error())
-		}
-	}
-
-	// Test Load
-	for _, d := range testdata {
-		if value, err := s.Load(d.key); err != nil {
-			t.Fatal(err.Error())
-		} else {
-			if !reflect.DeepEqual(value, d.value) {
-				t.Fatalf("Load %s: expected %v, got %v", d.key, d.value, value)
-			}
-		}
-	}
-
-	// Test Exists
-	for _, d := range testdata {
-		if !s.Exists(d.key) {
-			t.Fatalf("%s should exist, but doesn't\n", d.key)
-		}
-	}
-
-	// Test List
-	if list, err := s.List("/", true); err != nil {
-		t.Fatal(err.Error())
-	} else {
-		var expected []string
-		for i, d := range testdata {
-			if i != len(testdata)-1 {
-				// Don't store the intentionally duplicated key
-				expected = append(expected, d.key)
-			}
-		}
-		sort.Strings(expected)
-		sort.Strings(list)
-		if !reflect.DeepEqual(expected, list) {
-			t.Fatalf("List: Expected %v, got %v\n", expected, list)
-		}
-	}
-	if list, err := s.List("/foo", false); err != nil {
-		t.Fatal(err.Error())
-	} else {
-		sort.Strings(list)
-		expected := []string{"/foo/a", "/foo/b", "/foo/bar", "/foo/c", "/foo/d"}
-		if !reflect.DeepEqual(expected, list) {
-			t.Fatalf("List: expected %s, got %s\n", expected, list)
-		}
-	}
-
-	// Test Stat
-	for _, d := range testdata {
-		info, err := s.Stat(d.key)
-		if err != nil {
-			t.Fatal(err.Error())
-		} else {
-			if info.Key != d.key {
-				t.Fatalf("Stat().Key: expected %s, got %s\n", d.key, info.Key)
-			}
-			if info.Size != int64(len(d.value)) {
-				t.Fatalf("Stat().Size: expected %d, got %d\n", len(d.value), info.Size)
-			}
-			if time.Since(info.Modified) > time.Minute {
-				t.Fatalf("Stat().Modified: expected time since last modified to be < 1 minute, got %v\n", time.Since(info.Modified))
-			}
-		}
-
-	}
-
-	// Test Delete
-	for _, d := range testdata {
-		if err := s.Delete(d.key); err != nil {
-			t.Fatal(err.Error())
-		}
-	}
-
-	// New interface doesn't return an error, so call it in case any log.Fatal
-	// happens
-	NewProvider(acme.Cache(s))
-}
-
-// Full test with a real zone, with  against LE staging
-func TestE2e(t *testing.T) {
-	apiToken, accountID := os.Getenv("CF_API_TOKEN"), os.Getenv("CF_ACCOUNT_ID")
-	kvID := os.Getenv("KV_NAMESPACE_ID")
-	if len(apiToken) == 0 || len(accountID) == 0 || len(kvID) == 0 {
-		t.Skip("No Cloudflare API keys available, skipping test")
-	}
-
-	testLock := memory.NewLock()
-	testStore := cfstore.NewStore(
-		cfstore.Token(apiToken),
-		cfstore.Account(accountID),
-		cfstore.Namespace(kvID),
-	)
-	testStorage := NewStorage(testLock, testStore)
-
-	conf := cloudflare.NewDefaultConfig()
-	conf.AuthToken = apiToken
-	conf.ZoneToken = apiToken
-	testChallengeProvider, err := cloudflare.NewDNSProviderConfig(conf)
-	if err != nil {
-		t.Fatal(err.Error())
-	}
-
-	testProvider := NewProvider(
-		acme.AcceptToS(true),
-		acme.Cache(testStorage),
-		acme.CA(acme.LetsEncryptStagingCA),
-		acme.ChallengeProvider(testChallengeProvider),
-		acme.OnDemand(false),
-	)
-
-	listener, err := testProvider.Listen("*.micro.mu", "micro.mu")
-	if err != nil {
-		t.Fatal(err.Error())
-	}
-	go http.Serve(listener, http.NotFoundHandler())
-	time.Sleep(10 * time.Minute)
-}

api/server/acme/certmagic/storage.go

@@ -1,147 +0,0 @@
-package certmagic
-
-import (
-	"bytes"
-	"encoding/gob"
-	"errors"
-	"fmt"
-	"path"
-	"strings"
-	"time"
-
-	"github.com/mholt/certmagic"
-	"github.com/micro/go-micro/v2/store"
-	"github.com/micro/go-micro/v2/sync/lock"
-)
-
-// File represents a "File" that will be stored in store.Store - the contents and last modified time
-type File struct {
-	// last modified time
-	LastModified time.Time
-	// Contents
-	Contents []byte
-}
-
-// storage is an implementation of certmagic.Storage using micro's sync.Map and store.Store interfaces.
-// As certmagic storage expects a filesystem (with stat() abilities) we have to implement
-// the bare minimum of metadata.
-type storage struct {
-	lock  lock.Lock
-	store store.Store
-}
-
-func (s *storage) Lock(key string) error {
-	return s.lock.Acquire(key, lock.TTL(10*time.Minute))
-}
-
-func (s *storage) Unlock(key string) error {
-	return s.lock.Release(key)
-}
-
-func (s *storage) Store(key string, value []byte) error {
-	f := File{
-		LastModified: time.Now(),
-		Contents:     value,
-	}
-	buf := &bytes.Buffer{}
-	e := gob.NewEncoder(buf)
-	if err := e.Encode(f); err != nil {
-		return err
-	}
-	r := &store.Record{
-		Key:   key,
-		Value: buf.Bytes(),
-	}
-	return s.store.Write(r)
-}
-
-func (s *storage) Load(key string) ([]byte, error) {
-	if !s.Exists(key) {
-		return nil, certmagic.ErrNotExist(errors.New(key + " doesn't exist"))
-	}
-	records, err := s.store.Read(key)
-	if err != nil {
-		return nil, err
-	}
-	if len(records) != 1 {
-		return nil, fmt.Errorf("ACME Storage: multiple records matched key %s", key)
-	}
-	b := bytes.NewBuffer(records[0].Value)
-	d := gob.NewDecoder(b)
-	var f File
-	err = d.Decode(&f)
-	if err != nil {
-		return nil, err
-	}
-	return f.Contents, nil
-}
-
-func (s *storage) Delete(key string) error {
-	return s.store.Delete(key)
-}
-
-func (s *storage) Exists(key string) bool {
-	if _, err := s.store.Read(key); err != nil {
-		return false
-	}
-	return true
-}
-
-func (s *storage) List(prefix string, recursive bool) ([]string, error) {
-	records, err := s.store.List()
-	if err != nil {
-		return nil, err
-	}
-
-	//nolint:prealloc
-	var results []string
-	for _, r := range records {
-		if strings.HasPrefix(r.Key, prefix) {
-			results = append(results, r.Key)
-		}
-	}
-	if recursive {
-		return results, nil
-	}
-	keysMap := make(map[string]bool)
-	for _, key := range results {
-		dir := strings.Split(strings.TrimPrefix(key, prefix+"/"), "/")
-		keysMap[dir[0]] = true
-	}
-	results = make([]string, 0)
-	for k := range keysMap {
-		results = append(results, path.Join(prefix, k))
-	}
-	return results, nil
-}
-
-func (s *storage) Stat(key string) (certmagic.KeyInfo, error) {
-	records, err := s.store.Read(key)
-	if err != nil {
-		return certmagic.KeyInfo{}, err
-	}
-	if len(records) != 1 {
-		return certmagic.KeyInfo{}, fmt.Errorf("ACME Storage: multiple records matched key %s", key)
-	}
-	b := bytes.NewBuffer(records[0].Value)
-	d := gob.NewDecoder(b)
-	var f File
-	err = d.Decode(&f)
-	if err != nil {
-		return certmagic.KeyInfo{}, err
-	}
-	return certmagic.KeyInfo{
-		Key:        key,
-		Modified:   f.LastModified,
-		Size:       int64(len(f.Contents)),
-		IsTerminal: false,
-	}, nil
-}
-
-// NewStorage returns a certmagic.Storage backed by a go-micro/lock and go-micro/store
-func NewStorage(lock lock.Lock, store store.Store) certmagic.Storage {
-	return &storage{
-		lock:  lock,
-		store: store,
-	}
-}

api/server/acme/options.go

@@ -1,73 +0,0 @@
-package acme
-
-import "github.com/go-acme/lego/v3/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/http/http.go

@@ -1,97 +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"
-	"github.com/micro/go-micro/v2/api/server"
-	log "github.com/micro/go-micro/v2/logger"
-)
-
-type httpServer struct {
-	mux  *http.ServeMux
-	opts server.Options
-
-	mtx     sync.RWMutex
-	address string
-	exit    chan chan error
-}
-
-func NewServer(address string) server.Server {
-	return &httpServer{
-		opts:    server.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) {
-	s.mux.Handle(path, handlers.CombinedLoggingHandler(os.Stdout, 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
-	}
-
-	log.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
-			//log.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,41 +0,0 @@
-package http
-
-import (
-	"fmt"
-	"io/ioutil"
-	"net/http"
-	"testing"
-)
-
-func TestHTTPServer(t *testing.T) {
-	testResponse := "hello world"
-
-	s := NewServer("localhost:0")
-
-	s.Handle("/", http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		fmt.Fprint(w, testResponse)
-	}))
-
-	if err := s.Start(); err != nil {
-		t.Fatal(err)
-	}
-
-	rsp, err := http.Get(fmt.Sprintf("http://%s/", s.Address()))
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer rsp.Body.Close()
-
-	b, err := ioutil.ReadAll(rsp.Body)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	if string(b) != testResponse {
-		t.Fatalf("Unexpected response, got %s, expected %s", string(b), testResponse)
-	}
-
-	if err := s.Stop(); err != nil {
-		t.Fatal(err)
-	}
-}

api/server/options.go

@@ -1,47 +0,0 @@
-package server
-
-import (
-	"crypto/tls"
-
-	"github.com/micro/go-micro/v2/api/server/acme"
-)
-
-type Option func(o *Options)
-
-type Options struct {
-	EnableACME   bool
-	ACMEProvider acme.Provider
-	EnableTLS    bool
-	ACMEHosts    []string
-	TLSConfig    *tls.Config
-}
-
-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
-	}
-}

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

@@ -1,55 +0,0 @@
-// Package auth provides authentication and authorization capability
-package auth
-
-import (
-	"time"
-)
-
-// Auth providers authentication and authorization
-type Auth interface {
-	// Init the auth package
-	Init(opts ...Option) error
-	// Options returns the options set
-	Options() Options
-	// Generate a new auth Account
-	Generate(id string, opts ...GenerateOption) (*Account, error)
-	// Revoke an authorization Account
-	Revoke(token string) error
-	// Verify an account token
-	Verify(token string) (*Account, error)
-	// String returns the implementation
-	String() string
-}
-
-// Resource is an entity such as a user or
-type Resource struct {
-	// Name of the resource
-	Name string
-	// Type of resource, e.g.
-	Type string
-}
-
-// Role an account has
-type Role struct {
-	// Name of the role
-	Name string
-	// The resource it has access
-	// TODO: potentially remove
-	Resource *Resource
-}
-
-// Account provided by an auth provider
-type Account struct {
-	// ID of the account (UUID or email)
-	Id string `json:"id"`
-	// Token used to authenticate
-	Token string `json:"token"`
-	// Time of Account creation
-	Created time.Time `json:"created"`
-	// Time of Account expiry
-	Expiry time.Time `json:"expiry"`
-	// Roles associated with the Account
-	Roles []*Role `json:"roles"`
-	// Any other associated metadata
-	Metadata map[string]string `json:"metadata"`
-}

auth/default.go

@@ -1,122 +0,0 @@
-package auth
-
-import (
-	"encoding/base32"
-	"sync"
-	"time"
-)
-
-var (
-	DefaultAuth = NewAuth()
-)
-
-func genAccount(id string) *Account {
-	// return a pseudo account
-	return &Account{
-		Id:       id,
-		Token:    base32.StdEncoding.EncodeToString([]byte(id)),
-		Created:  time.Now(),
-		Expiry:   time.Now().Add(time.Hour * 24),
-		Metadata: make(map[string]string),
-	}
-}
-
-// NewAuth returns a new default registry which is memory
-func NewAuth(opts ...Option) Auth {
-	var options Options
-	for _, o := range opts {
-		o(&options)
-	}
-
-	return &memory{
-		accounts: make(map[string]*Account),
-		opts:     options,
-	}
-}
-
-// TODO: replace with https://github.com/nats-io/nkeys
-// We'll then register public key in registry to use
-type memory struct {
-	opts Options
-	// accounts
-	sync.RWMutex
-	accounts map[string]*Account
-}
-
-func (n *memory) Init(opts ...Option) error {
-	for _, o := range opts {
-		o(&n.opts)
-	}
-	return nil
-}
-
-func (n *memory) Options() Options {
-	return n.opts
-}
-
-func (n *memory) Generate(id string, opts ...GenerateOption) (*Account, error) {
-	var options GenerateOptions
-	for _, o := range opts {
-		o(&options)
-	}
-
-	// return a pseudo account
-	acc := genAccount(id)
-
-	// set opts
-	if len(options.Roles) > 0 {
-		acc.Roles = options.Roles
-	}
-	if options.Metadata != nil {
-		acc.Metadata = options.Metadata
-	}
-
-	// TODO: don't overwrite
-	n.Lock()
-	// maybe save by account id?
-	n.accounts[acc.Token] = acc
-	n.Unlock()
-
-	return acc, nil
-}
-
-func (n *memory) Revoke(token string) error {
-	n.Lock()
-	delete(n.accounts, token)
-	n.Unlock()
-	return nil
-}
-
-func (n *memory) Verify(token string) (*Account, error) {
-	n.RLock()
-	defer n.RUnlock()
-
-	if len(token) == 0 {
-		// pseudo account?
-		return genAccount(""), nil
-	}
-
-	// try get the local account if it exists
-	if acc, ok := n.accounts[token]; ok {
-		return acc, nil
-	}
-
-	// decode the token otherwise
-	b, err := base32.StdEncoding.DecodeString(token)
-	if err != nil {
-		return genAccount(""), nil
-	}
-
-	// return a pseudo account based on token/id
-	return &Account{
-		Id:       string(b),
-		Token:    token,
-		Created:  time.Now(),
-		Expiry:   time.Now().Add(time.Hour * 24),
-		Metadata: make(map[string]string),
-	}, nil
-}
-
-func (n *memory) String() string {
-	return "memory"
-}

auth/jwt/jwt.go

@@ -1,135 +0,0 @@
-package jwt
-
-import (
-	"encoding/base64"
-	"errors"
-	"time"
-
-	"github.com/dgrijalva/jwt-go"
-	"github.com/micro/go-micro/v2/auth"
-)
-
-var (
-	// ErrInvalidPrivateKey is returned when the service provided an invalid private key
-	ErrInvalidPrivateKey = errors.New("An invalid private key was provided")
-
-	// ErrEncodingToken is returned when the service encounters an error during encoding
-	ErrEncodingToken = errors.New("An error occured while encoding the JWT")
-
-	// ErrInvalidToken is returned when the token provided is not valid
-	ErrInvalidToken = errors.New("An invalid token was provided")
-
-	// ErrMissingToken is returned when no token is provided
-	ErrMissingToken = errors.New("A valid JWT is required")
-)
-
-// NewAuth returns a new instance of the Auth service
-func NewAuth(opts ...auth.Option) auth.Auth {
-	svc := new(svc)
-	svc.Init(opts...)
-	return svc
-}
-
-// svc is the JWT implementation of the Auth interface
-type svc struct {
-	options auth.Options
-}
-
-func (s *svc) String() string {
-	return "jwt"
-}
-
-func (s *svc) Options() auth.Options {
-	return s.options
-}
-
-func (s *svc) Init(opts ...auth.Option) error {
-	for _, o := range opts {
-		o(&s.options)
-	}
-
-	return nil
-}
-
-// AuthClaims to be encoded in the JWT
-type AuthClaims struct {
-	Id       string            `json:"id"`
-	Roles    []*auth.Role      `json:"roles"`
-	Metadata map[string]string `json:"metadata"`
-
-	jwt.StandardClaims
-}
-
-// Generate a new JWT
-func (s *svc) Generate(id string, ops ...auth.GenerateOption) (*auth.Account, error) {
-	// decode the private key
-	priv, err := base64.StdEncoding.DecodeString(s.options.PrivateKey)
-	if err != nil {
-		return nil, err
-	}
-
-	key, err := jwt.ParseRSAPrivateKeyFromPEM(priv)
-	if err != nil {
-		return nil, ErrEncodingToken
-	}
-
-	options := auth.NewGenerateOptions(ops...)
-	account := jwt.NewWithClaims(jwt.SigningMethodRS256, AuthClaims{
-		id, options.Roles, options.Metadata, jwt.StandardClaims{
-			Subject:   id,
-			ExpiresAt: time.Now().Add(time.Hour * 24).Unix(),
-		},
-	})
-
-	token, err := account.SignedString(key)
-	if err != nil {
-		return nil, err
-	}
-
-	return &auth.Account{
-		Id:       id,
-		Token:    token,
-		Roles:    options.Roles,
-		Metadata: options.Metadata,
-	}, nil
-}
-
-// Revoke an authorization account
-func (s *svc) Revoke(token string) error {
-	return nil
-}
-
-// Verify a JWT
-func (s *svc) Verify(token string) (*auth.Account, error) {
-	if token == "" {
-		return nil, ErrMissingToken
-	}
-
-	// decode the public key
-	pub, err := base64.StdEncoding.DecodeString(s.options.PublicKey)
-	if err != nil {
-		return nil, err
-	}
-
-	res, err := jwt.ParseWithClaims(token, &AuthClaims{}, func(token *jwt.Token) (interface{}, error) {
-		return jwt.ParseRSAPublicKeyFromPEM(pub)
-	})
-	if err != nil {
-		return nil, err
-	}
-
-	if !res.Valid {
-		return nil, ErrInvalidToken
-	}
-
-	claims, ok := res.Claims.(*AuthClaims)
-	if !ok {
-		return nil, ErrInvalidToken
-	}
-
-	return &auth.Account{
-		Id:       claims.Id,
-		Metadata: claims.Metadata,
-		Roles:    claims.Roles,
-	}, nil
-}

auth/options.go

@@ -1,75 +0,0 @@
-package auth
-
-type Options struct {
-	// Token is an auth token
-	Token string
-	// Public key base64 encoded
-	PublicKey string
-	// Private key base64 encoded
-	PrivateKey string
-	// Endpoints to exclude
-	Exclude []string
-}
-
-type Option func(o *Options)
-
-// Exclude ecludes a set of endpoints from authorization
-func Exclude(e ...string) Option {
-	return func(o *Options) {
-		o.Exclude = e
-	}
-}
-
-// PublicKey is the JWT public key
-func PublicKey(key string) Option {
-	return func(o *Options) {
-		o.PublicKey = key
-	}
-}
-
-// PrivateKey is the JWT private key
-func PrivateKey(key string) Option {
-	return func(o *Options) {
-		o.PrivateKey = key
-	}
-}
-
-// Token sets an auth token
-func Token(t string) Option {
-	return func(o *Options) {
-		o.Token = t
-	}
-}
-
-type GenerateOptions struct {
-	// Metadata associated with the account
-	Metadata map[string]string
-	// Roles/scopes associated with the account
-	Roles []*Role
-}
-
-type GenerateOption func(o *GenerateOptions)
-
-// Metadata for the generated account
-func Metadata(md map[string]string) func(o *GenerateOptions) {
-	return func(o *GenerateOptions) {
-		o.Metadata = md
-	}
-}
-
-// Roles for the generated account
-func Roles(rs []*Role) func(o *GenerateOptions) {
-	return func(o *GenerateOptions) {
-		o.Roles = rs
-	}
-}
-
-// NewGenerateOptions from a slice of options
-func NewGenerateOptions(opts ...GenerateOption) GenerateOptions {
-	var options GenerateOptions
-	for _, o := range opts {
-		o(&options)
-	}
-
-	return options
-}

auth/service/proto/auth.pb.go

@@ -1,468 +0,0 @@
-// Code generated by protoc-gen-go. DO NOT EDIT.
-// source: micro/go-micro/auth/service/proto/auth.proto
-
-package go_micro_auth
-
-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 Account struct {
-	Id                   string            `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
-	Token                string            `protobuf:"bytes,2,opt,name=token,proto3" json:"token,omitempty"`
-	Created              int64             `protobuf:"varint,3,opt,name=created,proto3" json:"created,omitempty"`
-	Expiry               int64             `protobuf:"varint,4,opt,name=expiry,proto3" json:"expiry,omitempty"`
-	Roles                []*Role           `protobuf:"bytes,5,rep,name=roles,proto3" json:"roles,omitempty"`
-	Metadata             map[string]string `protobuf:"bytes,6,rep,name=metadata,proto3" json:"metadata,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
-	XXX_NoUnkeyedLiteral struct{}          `json:"-"`
-	XXX_unrecognized     []byte            `json:"-"`
-	XXX_sizecache        int32             `json:"-"`
-}
-
-func (m *Account) Reset()         { *m = Account{} }
-func (m *Account) String() string { return proto.CompactTextString(m) }
-func (*Account) ProtoMessage()    {}
-func (*Account) Descriptor() ([]byte, []int) {
-	return fileDescriptor_de609d4872dacc78, []int{0}
-}
-
-func (m *Account) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_Account.Unmarshal(m, b)
-}
-func (m *Account) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_Account.Marshal(b, m, deterministic)
-}
-func (m *Account) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_Account.Merge(m, src)
-}
-func (m *Account) XXX_Size() int {
-	return xxx_messageInfo_Account.Size(m)
-}
-func (m *Account) XXX_DiscardUnknown() {
-	xxx_messageInfo_Account.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_Account proto.InternalMessageInfo
-
-func (m *Account) GetId() string {
-	if m != nil {
-		return m.Id
-	}
-	return ""
-}
-
-func (m *Account) GetToken() string {
-	if m != nil {
-		return m.Token
-	}
-	return ""
-}
-
-func (m *Account) GetCreated() int64 {
-	if m != nil {
-		return m.Created
-	}
-	return 0
-}
-
-func (m *Account) GetExpiry() int64 {
-	if m != nil {
-		return m.Expiry
-	}
-	return 0
-}
-
-func (m *Account) GetRoles() []*Role {
-	if m != nil {
-		return m.Roles
-	}
-	return nil
-}
-
-func (m *Account) GetMetadata() map[string]string {
-	if m != nil {
-		return m.Metadata
-	}
-	return nil
-}
-
-type Role struct {
-	Name                 string    `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
-	Resource             *Resource `protobuf:"bytes,2,opt,name=resource,proto3" json:"resource,omitempty"`
-	XXX_NoUnkeyedLiteral struct{}  `json:"-"`
-	XXX_unrecognized     []byte    `json:"-"`
-	XXX_sizecache        int32     `json:"-"`
-}
-
-func (m *Role) Reset()         { *m = Role{} }
-func (m *Role) String() string { return proto.CompactTextString(m) }
-func (*Role) ProtoMessage()    {}
-func (*Role) Descriptor() ([]byte, []int) {
-	return fileDescriptor_de609d4872dacc78, []int{1}
-}
-
-func (m *Role) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_Role.Unmarshal(m, b)
-}
-func (m *Role) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_Role.Marshal(b, m, deterministic)
-}
-func (m *Role) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_Role.Merge(m, src)
-}
-func (m *Role) XXX_Size() int {
-	return xxx_messageInfo_Role.Size(m)
-}
-func (m *Role) XXX_DiscardUnknown() {
-	xxx_messageInfo_Role.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_Role proto.InternalMessageInfo
-
-func (m *Role) GetName() string {
-	if m != nil {
-		return m.Name
-	}
-	return ""
-}
-
-func (m *Role) GetResource() *Resource {
-	if m != nil {
-		return m.Resource
-	}
-	return nil
-}
-
-type Resource struct {
-	Name                 string   `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
-	Type                 string   `protobuf:"bytes,2,opt,name=type,proto3" json:"type,omitempty"`
-	XXX_NoUnkeyedLiteral struct{} `json:"-"`
-	XXX_unrecognized     []byte   `json:"-"`
-	XXX_sizecache        int32    `json:"-"`
-}
-
-func (m *Resource) Reset()         { *m = Resource{} }
-func (m *Resource) String() string { return proto.CompactTextString(m) }
-func (*Resource) ProtoMessage()    {}
-func (*Resource) Descriptor() ([]byte, []int) {
-	return fileDescriptor_de609d4872dacc78, []int{2}
-}
-
-func (m *Resource) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_Resource.Unmarshal(m, b)
-}
-func (m *Resource) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_Resource.Marshal(b, m, deterministic)
-}
-func (m *Resource) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_Resource.Merge(m, src)
-}
-func (m *Resource) XXX_Size() int {
-	return xxx_messageInfo_Resource.Size(m)
-}
-func (m *Resource) XXX_DiscardUnknown() {
-	xxx_messageInfo_Resource.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_Resource proto.InternalMessageInfo
-
-func (m *Resource) GetName() string {
-	if m != nil {
-		return m.Name
-	}
-	return ""
-}
-
-func (m *Resource) GetType() string {
-	if m != nil {
-		return m.Type
-	}
-	return ""
-}
-
-type GenerateRequest struct {
-	Account              *Account `protobuf:"bytes,1,opt,name=account,proto3" json:"account,omitempty"`
-	XXX_NoUnkeyedLiteral struct{} `json:"-"`
-	XXX_unrecognized     []byte   `json:"-"`
-	XXX_sizecache        int32    `json:"-"`
-}
-
-func (m *GenerateRequest) Reset()         { *m = GenerateRequest{} }
-func (m *GenerateRequest) String() string { return proto.CompactTextString(m) }
-func (*GenerateRequest) ProtoMessage()    {}
-func (*GenerateRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_de609d4872dacc78, []int{3}
-}
-
-func (m *GenerateRequest) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_GenerateRequest.Unmarshal(m, b)
-}
-func (m *GenerateRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_GenerateRequest.Marshal(b, m, deterministic)
-}
-func (m *GenerateRequest) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_GenerateRequest.Merge(m, src)
-}
-func (m *GenerateRequest) XXX_Size() int {
-	return xxx_messageInfo_GenerateRequest.Size(m)
-}
-func (m *GenerateRequest) XXX_DiscardUnknown() {
-	xxx_messageInfo_GenerateRequest.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_GenerateRequest proto.InternalMessageInfo
-
-func (m *GenerateRequest) GetAccount() *Account {
-	if m != nil {
-		return m.Account
-	}
-	return nil
-}
-
-type GenerateResponse struct {
-	Account              *Account `protobuf:"bytes,1,opt,name=account,proto3" json:"account,omitempty"`
-	XXX_NoUnkeyedLiteral struct{} `json:"-"`
-	XXX_unrecognized     []byte   `json:"-"`
-	XXX_sizecache        int32    `json:"-"`
-}
-
-func (m *GenerateResponse) Reset()         { *m = GenerateResponse{} }
-func (m *GenerateResponse) String() string { return proto.CompactTextString(m) }
-func (*GenerateResponse) ProtoMessage()    {}
-func (*GenerateResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_de609d4872dacc78, []int{4}
-}
-
-func (m *GenerateResponse) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_GenerateResponse.Unmarshal(m, b)
-}
-func (m *GenerateResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_GenerateResponse.Marshal(b, m, deterministic)
-}
-func (m *GenerateResponse) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_GenerateResponse.Merge(m, src)
-}
-func (m *GenerateResponse) XXX_Size() int {
-	return xxx_messageInfo_GenerateResponse.Size(m)
-}
-func (m *GenerateResponse) XXX_DiscardUnknown() {
-	xxx_messageInfo_GenerateResponse.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_GenerateResponse proto.InternalMessageInfo
-
-func (m *GenerateResponse) GetAccount() *Account {
-	if m != nil {
-		return m.Account
-	}
-	return nil
-}
-
-type VerifyRequest struct {
-	Token                string   `protobuf:"bytes,1,opt,name=token,proto3" json:"token,omitempty"`
-	XXX_NoUnkeyedLiteral struct{} `json:"-"`
-	XXX_unrecognized     []byte   `json:"-"`
-	XXX_sizecache        int32    `json:"-"`
-}
-
-func (m *VerifyRequest) Reset()         { *m = VerifyRequest{} }
-func (m *VerifyRequest) String() string { return proto.CompactTextString(m) }
-func (*VerifyRequest) ProtoMessage()    {}
-func (*VerifyRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_de609d4872dacc78, []int{5}
-}
-
-func (m *VerifyRequest) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_VerifyRequest.Unmarshal(m, b)
-}
-func (m *VerifyRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_VerifyRequest.Marshal(b, m, deterministic)
-}
-func (m *VerifyRequest) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_VerifyRequest.Merge(m, src)
-}
-func (m *VerifyRequest) XXX_Size() int {
-	return xxx_messageInfo_VerifyRequest.Size(m)
-}
-func (m *VerifyRequest) XXX_DiscardUnknown() {
-	xxx_messageInfo_VerifyRequest.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_VerifyRequest proto.InternalMessageInfo
-
-func (m *VerifyRequest) GetToken() string {
-	if m != nil {
-		return m.Token
-	}
-	return ""
-}
-
-type VerifyResponse struct {
-	Account              *Account `protobuf:"bytes,1,opt,name=account,proto3" json:"account,omitempty"`
-	XXX_NoUnkeyedLiteral struct{} `json:"-"`
-	XXX_unrecognized     []byte   `json:"-"`
-	XXX_sizecache        int32    `json:"-"`
-}
-
-func (m *VerifyResponse) Reset()         { *m = VerifyResponse{} }
-func (m *VerifyResponse) String() string { return proto.CompactTextString(m) }
-func (*VerifyResponse) ProtoMessage()    {}
-func (*VerifyResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_de609d4872dacc78, []int{6}
-}
-
-func (m *VerifyResponse) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_VerifyResponse.Unmarshal(m, b)
-}
-func (m *VerifyResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_VerifyResponse.Marshal(b, m, deterministic)
-}
-func (m *VerifyResponse) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_VerifyResponse.Merge(m, src)
-}
-func (m *VerifyResponse) XXX_Size() int {
-	return xxx_messageInfo_VerifyResponse.Size(m)
-}
-func (m *VerifyResponse) XXX_DiscardUnknown() {
-	xxx_messageInfo_VerifyResponse.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_VerifyResponse proto.InternalMessageInfo
-
-func (m *VerifyResponse) GetAccount() *Account {
-	if m != nil {
-		return m.Account
-	}
-	return nil
-}
-
-type RevokeRequest struct {
-	Token                string   `protobuf:"bytes,1,opt,name=token,proto3" json:"token,omitempty"`
-	XXX_NoUnkeyedLiteral struct{} `json:"-"`
-	XXX_unrecognized     []byte   `json:"-"`
-	XXX_sizecache        int32    `json:"-"`
-}
-
-func (m *RevokeRequest) Reset()         { *m = RevokeRequest{} }
-func (m *RevokeRequest) String() string { return proto.CompactTextString(m) }
-func (*RevokeRequest) ProtoMessage()    {}
-func (*RevokeRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_de609d4872dacc78, []int{7}
-}
-
-func (m *RevokeRequest) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_RevokeRequest.Unmarshal(m, b)
-}
-func (m *RevokeRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_RevokeRequest.Marshal(b, m, deterministic)
-}
-func (m *RevokeRequest) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_RevokeRequest.Merge(m, src)
-}
-func (m *RevokeRequest) XXX_Size() int {
-	return xxx_messageInfo_RevokeRequest.Size(m)
-}
-func (m *RevokeRequest) XXX_DiscardUnknown() {
-	xxx_messageInfo_RevokeRequest.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_RevokeRequest proto.InternalMessageInfo
-
-func (m *RevokeRequest) GetToken() string {
-	if m != nil {
-		return m.Token
-	}
-	return ""
-}
-
-type RevokeResponse struct {
-	XXX_NoUnkeyedLiteral struct{} `json:"-"`
-	XXX_unrecognized     []byte   `json:"-"`
-	XXX_sizecache        int32    `json:"-"`
-}
-
-func (m *RevokeResponse) Reset()         { *m = RevokeResponse{} }
-func (m *RevokeResponse) String() string { return proto.CompactTextString(m) }
-func (*RevokeResponse) ProtoMessage()    {}
-func (*RevokeResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_de609d4872dacc78, []int{8}
-}
-
-func (m *RevokeResponse) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_RevokeResponse.Unmarshal(m, b)
-}
-func (m *RevokeResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_RevokeResponse.Marshal(b, m, deterministic)
-}
-func (m *RevokeResponse) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_RevokeResponse.Merge(m, src)
-}
-func (m *RevokeResponse) XXX_Size() int {
-	return xxx_messageInfo_RevokeResponse.Size(m)
-}
-func (m *RevokeResponse) XXX_DiscardUnknown() {
-	xxx_messageInfo_RevokeResponse.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_RevokeResponse proto.InternalMessageInfo
-
-func init() {
-	proto.RegisterType((*Account)(nil), "go.micro.auth.Account")
-	proto.RegisterMapType((map[string]string)(nil), "go.micro.auth.Account.MetadataEntry")
-	proto.RegisterType((*Role)(nil), "go.micro.auth.Role")
-	proto.RegisterType((*Resource)(nil), "go.micro.auth.Resource")
-	proto.RegisterType((*GenerateRequest)(nil), "go.micro.auth.GenerateRequest")
-	proto.RegisterType((*GenerateResponse)(nil), "go.micro.auth.GenerateResponse")
-	proto.RegisterType((*VerifyRequest)(nil), "go.micro.auth.VerifyRequest")
-	proto.RegisterType((*VerifyResponse)(nil), "go.micro.auth.VerifyResponse")
-	proto.RegisterType((*RevokeRequest)(nil), "go.micro.auth.RevokeRequest")
-	proto.RegisterType((*RevokeResponse)(nil), "go.micro.auth.RevokeResponse")
-}
-
-func init() {
-	proto.RegisterFile("micro/go-micro/auth/service/proto/auth.proto", fileDescriptor_de609d4872dacc78)
-}
-
-var fileDescriptor_de609d4872dacc78 = []byte{
-	// 432 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xa4, 0x53, 0x4b, 0x6f, 0xd3, 0x40,
-	0x10, 0xae, 0x1d, 0xe7, 0xc1, 0x44, 0x09, 0xd1, 0x80, 0x8a, 0x15, 0xf1, 0x88, 0x56, 0x20, 0x05,
-	0x09, 0x1c, 0xe4, 0x5e, 0x10, 0x5c, 0x28, 0x0f, 0xf5, 0x54, 0x21, 0xed, 0x81, 0xfb, 0xe2, 0x0c,
-	0xad, 0x95, 0xc4, 0x6b, 0xd6, 0xeb, 0x08, 0xff, 0x06, 0x7e, 0x28, 0x7f, 0x03, 0x79, 0xd7, 0x1b,
-	0x6a, 0xb7, 0xe5, 0x00, 0xb7, 0x79, 0x7c, 0xf3, 0xcd, 0xf7, 0x8d, 0x76, 0xe1, 0xc5, 0x2e, 0x4d,
-	0x94, 0x5c, 0x5d, 0xc8, 0x97, 0x36, 0x10, 0xa5, 0xbe, 0x5c, 0x15, 0xa4, 0xf6, 0x69, 0x42, 0xab,
-	0x5c, 0x49, 0x6d, 0x4b, 0x91, 0x09, 0x71, 0x72, 0x21, 0x23, 0x83, 0x8b, 0xea, 0x22, 0xfb, 0xe9,
-	0xc3, 0xf0, 0x34, 0x49, 0x64, 0x99, 0x69, 0x9c, 0x82, 0x9f, 0xae, 0x43, 0x6f, 0xe1, 0x2d, 0xef,
-	0x70, 0x3f, 0x5d, 0xe3, 0x7d, 0xe8, 0x6b, 0xb9, 0xa1, 0x2c, 0xf4, 0x4d, 0xc9, 0x26, 0x18, 0xc2,
-	0x30, 0x51, 0x24, 0x34, 0xad, 0xc3, 0xde, 0xc2, 0x5b, 0xf6, 0xb8, 0x4b, 0xf1, 0x18, 0x06, 0xf4,
-	0x23, 0x4f, 0x55, 0x15, 0x06, 0xa6, 0xd1, 0x64, 0xf8, 0x1c, 0xfa, 0x4a, 0x6e, 0xa9, 0x08, 0xfb,
-	0x8b, 0xde, 0x72, 0x1c, 0xdf, 0x8b, 0x5a, 0x12, 0x22, 0x2e, 0xb7, 0xc4, 0x2d, 0x02, 0xdf, 0xc1,
-	0x68, 0x47, 0x5a, 0xac, 0x85, 0x16, 0xe1, 0xc0, 0xa0, 0x9f, 0x76, 0xd0, 0x8d, 0xd8, 0xe8, 0xbc,
-	0x81, 0x7d, 0xca, 0xb4, 0xaa, 0xf8, 0x61, 0x6a, 0xfe, 0x16, 0x26, 0xad, 0x16, 0xce, 0xa0, 0xb7,
-	0xa1, 0xaa, 0xb1, 0x55, 0x87, 0xb5, 0xaf, 0xbd, 0xd8, 0x96, 0xe4, 0x7c, 0x99, 0xe4, 0x8d, 0xff,
-	0xda, 0x63, 0x9f, 0x21, 0xa8, 0xd5, 0x20, 0x42, 0x90, 0x89, 0x1d, 0x35, 0x43, 0x26, 0xc6, 0x13,
-	0x18, 0x29, 0x2a, 0x64, 0xa9, 0x12, 0x3b, 0x38, 0x8e, 0x1f, 0x74, 0x8d, 0x34, 0x6d, 0x7e, 0x00,
-	0xb2, 0x18, 0x46, 0xae, 0x7a, 0x23, 0x29, 0x42, 0xa0, 0xab, 0xdc, 0x29, 0x31, 0x31, 0xfb, 0x00,
-	0x77, 0xcf, 0x28, 0x23, 0x25, 0x34, 0x71, 0xfa, 0x5e, 0x52, 0xa1, 0xf1, 0x15, 0x0c, 0x85, 0xf5,
-	0x6d, 0xa6, 0xc7, 0xf1, 0xf1, 0xcd, 0x57, 0xe1, 0x0e, 0xc6, 0x3e, 0xc2, 0xec, 0x0f, 0x49, 0x91,
-	0xcb, 0xac, 0xa0, 0x7f, 0x60, 0x79, 0x06, 0x93, 0x2f, 0xa4, 0xd2, 0x6f, 0x95, 0x13, 0x72, 0x78,
-	0x12, 0xde, 0x95, 0x27, 0xc1, 0xde, 0xc3, 0xd4, 0xc1, 0xfe, 0x67, 0x15, 0xa7, 0xbd, 0xdc, 0xd0,
-	0xdf, 0x57, 0xcd, 0x60, 0xea, 0x60, 0x76, 0x55, 0xfc, 0xcb, 0x83, 0xe0, 0xb4, 0xd4, 0x97, 0x78,
-	0x0e, 0x23, 0x67, 0x19, 0x1f, 0x77, 0xd6, 0x75, 0x0e, 0x3a, 0x7f, 0x72, 0x6b, 0xdf, 0xb2, 0xb2,
-	0x23, 0x3c, 0x83, 0x81, 0x35, 0x85, 0x0f, 0x3b, 0xe0, 0xd6, 0x49, 0xe6, 0x8f, 0x6e, 0xe9, 0x5e,
-	0x25, 0xb2, 0x92, 0xaf, 0x11, 0xb5, 0x0c, 0x5f, 0x23, 0x6a, 0xfb, 0x64, 0x47, 0x5f, 0x07, 0xe6,
-	0x07, 0x9f, 0xfc, 0x0e, 0x00, 0x00, 0xff, 0xff, 0xf0, 0x34, 0xce, 0x17, 0xf1, 0x03, 0x00, 0x00,
-}

auth/service/proto/auth.pb.micro.go

@@ -1,119 +0,0 @@
-// Code generated by protoc-gen-micro. DO NOT EDIT.
-// source: micro/go-micro/auth/service/proto/auth.proto
-
-package go_micro_auth
-
-import (
-	fmt "fmt"
-	proto "github.com/golang/protobuf/proto"
-	math "math"
-)
-
-import (
-	context "context"
-	client "github.com/micro/go-micro/v2/client"
-	server "github.com/micro/go-micro/v2/server"
-)
-
-// 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
-
-// Reference imports to suppress errors if they are not otherwise used.
-var _ context.Context
-var _ client.Option
-var _ server.Option
-
-// Client API for Auth service
-
-type AuthService interface {
-	Generate(ctx context.Context, in *GenerateRequest, opts ...client.CallOption) (*GenerateResponse, error)
-	Verify(ctx context.Context, in *VerifyRequest, opts ...client.CallOption) (*VerifyResponse, error)
-	Revoke(ctx context.Context, in *RevokeRequest, opts ...client.CallOption) (*RevokeResponse, error)
-}
-
-type authService struct {
-	c    client.Client
-	name string
-}
-
-func NewAuthService(name string, c client.Client) AuthService {
-	return &authService{
-		c:    c,
-		name: name,
-	}
-}
-
-func (c *authService) Generate(ctx context.Context, in *GenerateRequest, opts ...client.CallOption) (*GenerateResponse, error) {
-	req := c.c.NewRequest(c.name, "Auth.Generate", in)
-	out := new(GenerateResponse)
-	err := c.c.Call(ctx, req, out, opts...)
-	if err != nil {
-		return nil, err
-	}
-	return out, nil
-}
-
-func (c *authService) Verify(ctx context.Context, in *VerifyRequest, opts ...client.CallOption) (*VerifyResponse, error) {
-	req := c.c.NewRequest(c.name, "Auth.Verify", in)
-	out := new(VerifyResponse)
-	err := c.c.Call(ctx, req, out, opts...)
-	if err != nil {
-		return nil, err
-	}
-	return out, nil
-}
-
-func (c *authService) Revoke(ctx context.Context, in *RevokeRequest, opts ...client.CallOption) (*RevokeResponse, error) {
-	req := c.c.NewRequest(c.name, "Auth.Revoke", in)
-	out := new(RevokeResponse)
-	err := c.c.Call(ctx, req, out, opts...)
-	if err != nil {
-		return nil, err
-	}
-	return out, nil
-}
-
-// Server API for Auth service
-
-type AuthHandler interface {
-	Generate(context.Context, *GenerateRequest, *GenerateResponse) error
-	Verify(context.Context, *VerifyRequest, *VerifyResponse) error
-	Revoke(context.Context, *RevokeRequest, *RevokeResponse) error
-}
-
-func RegisterAuthHandler(s server.Server, hdlr AuthHandler, opts ...server.HandlerOption) error {
-	type auth interface {
-		Generate(ctx context.Context, in *GenerateRequest, out *GenerateResponse) error
-		Verify(ctx context.Context, in *VerifyRequest, out *VerifyResponse) error
-		Revoke(ctx context.Context, in *RevokeRequest, out *RevokeResponse) error
-	}
-	type Auth struct {
-		auth
-	}
-	h := &authHandler{hdlr}
-	return s.Handle(s.NewHandler(&Auth{h}, opts...))
-}
-
-type authHandler struct {
-	AuthHandler
-}
-
-func (h *authHandler) Generate(ctx context.Context, in *GenerateRequest, out *GenerateResponse) error {
-	return h.AuthHandler.Generate(ctx, in, out)
-}
-
-func (h *authHandler) Verify(ctx context.Context, in *VerifyRequest, out *VerifyResponse) error {
-	return h.AuthHandler.Verify(ctx, in, out)
-}
-
-func (h *authHandler) Revoke(ctx context.Context, in *RevokeRequest, out *RevokeResponse) error {
-	return h.AuthHandler.Revoke(ctx, in, out)
-}

auth/service/proto/auth.proto

@@ -1,50 +0,0 @@
-syntax = "proto3";
-
-package go.micro.auth;
-
-service Auth {
-    rpc Generate(GenerateRequest) returns (GenerateResponse) {};
-    rpc Verify(VerifyRequest) returns (VerifyResponse) {};
-    rpc Revoke(RevokeRequest)  returns (RevokeResponse) {};
-}
-
-message Account{
-	string id = 1;
-	string token = 2;
-	int64 created = 3;
-	int64 expiry = 4;
-	repeated Role roles = 5;
-	map<string, string> metadata = 6;
-}
-
-message Role {
-	string name = 1;
-	Resource resource = 2;
-}
-
-message Resource{
-	string name = 1;
-	string type = 2;
-}
-
-message GenerateRequest {
-	Account account = 1;
-}
-
-message GenerateResponse {
-	Account account = 1;
-}
-
-message VerifyRequest {
-	string token = 1;
-}
-
-message VerifyResponse {
-	Account account = 1;
-}
-
-message RevokeRequest {
-	string token = 1;
-}
-
-message RevokeResponse {}

auth/service/service.go

@@ -1,132 +0,0 @@
-package service
-
-import (
-	"context"
-	"time"
-
-	"github.com/micro/go-micro/v2/auth"
-	pb "github.com/micro/go-micro/v2/auth/service/proto"
-	"github.com/micro/go-micro/v2/client"
-)
-
-// NewAuth returns a new instance of the Auth service
-func NewAuth(opts ...auth.Option) auth.Auth {
-	svc := new(svc)
-	svc.Init(opts...)
-	return svc
-}
-
-// svc is the service implementation of the Auth interface
-type svc struct {
-	options auth.Options
-	auth    pb.AuthService
-}
-
-func (s *svc) String() string {
-	return "service"
-}
-
-func (s *svc) Init(opts ...auth.Option) error {
-	for _, o := range opts {
-		o(&s.options)
-	}
-
-	dc := client.DefaultClient
-	s.auth = pb.NewAuthService("go.micro.auth", dc)
-
-	return nil
-}
-
-func (s *svc) Options() auth.Options {
-	return s.options
-}
-
-// Generate a new auth account
-func (s *svc) Generate(id string, opts ...auth.GenerateOption) (*auth.Account, error) {
-	// construct the request
-	options := auth.NewGenerateOptions(opts...)
-	sa := &auth.Account{
-		Id:       id,
-		Roles:    options.Roles,
-		Metadata: options.Metadata,
-	}
-	req := &pb.GenerateRequest{Account: serializeAccount(sa)}
-
-	// execute the request
-	resp, err := s.auth.Generate(context.Background(), req)
-	if err != nil {
-		return nil, err
-	}
-
-	// format the response
-	return deserializeAccount(resp.Account), nil
-}
-
-// Revoke an authorization account
-func (s *svc) Revoke(token string) error {
-	// contruct the request
-	req := &pb.RevokeRequest{Token: token}
-
-	// execute the request
-	_, err := s.auth.Revoke(context.Background(), req)
-	return err
-}
-
-// Verify an account token
-func (s *svc) Verify(token string) (*auth.Account, error) {
-	resp, err := s.auth.Verify(context.Background(), &pb.VerifyRequest{Token: token})
-	if err != nil {
-		return nil, err
-	}
-
-	return deserializeAccount(resp.Account), nil
-}
-
-func serializeAccount(sa *auth.Account) *pb.Account {
-	roles := make([]*pb.Role, len(sa.Roles))
-	for i, r := range sa.Roles {
-		roles[i] = &pb.Role{
-			Name: r.Name,
-		}
-
-		if r.Resource != nil {
-			roles[i].Resource = &pb.Resource{
-				Name: r.Resource.Name,
-				Type: r.Resource.Type,
-			}
-		}
-	}
-
-	return &pb.Account{
-		Id:       sa.Id,
-		Roles:    roles,
-		Metadata: sa.Metadata,
-	}
-}
-
-func deserializeAccount(a *pb.Account) *auth.Account {
-	// format the response
-	sa := &auth.Account{
-		Id:       a.Id,
-		Token:    a.Token,
-		Created:  time.Unix(a.Created, 0),
-		Expiry:   time.Unix(a.Expiry, 0),
-		Metadata: a.Metadata,
-	}
-
-	sa.Roles = make([]*auth.Role, len(a.Roles))
-	for i, r := range a.Roles {
-		sa.Roles[i] = &auth.Role{
-			Name: r.Name,
-		}
-
-		if r.Resource != nil {
-			sa.Roles[i].Resource = &auth.Resource{
-				Name: r.Resource.Name,
-				Type: r.Resource.Type,
-			}
-		}
-	}
-
-	return sa
-}

auth/store/store.go

@@ -1,130 +0,0 @@
-package store
-
-import (
-	"bytes"
-	"encoding/gob"
-	"time"
-
-	"github.com/google/uuid"
-	"github.com/micro/go-micro/v2/auth"
-	"github.com/micro/go-micro/v2/errors"
-	"github.com/micro/go-micro/v2/store"
-)
-
-type Auth struct {
-	store store.Store
-	opts  auth.Options
-}
-
-// NewAuth returns an instance of store auth
-func NewAuth(opts ...auth.Option) auth.Auth {
-	var options auth.Options
-
-	for _, o := range opts {
-		o(&options)
-	}
-
-	return &Auth{
-		store: store.DefaultStore,
-		opts:  options,
-	}
-}
-
-// Init the auth package
-func (a *Auth) Init(opts ...auth.Option) error {
-	for _, o := range opts {
-		o(&a.opts)
-	}
-	return nil
-}
-
-// Options returns the options set
-func (a *Auth) Options() auth.Options {
-	return a.opts
-}
-
-// Generate a new auth Account
-func (a *Auth) Generate(id string, opts ...auth.GenerateOption) (*auth.Account, error) {
-	// generate the token
-	token, err := uuid.NewUUID()
-	if err != nil {
-		return nil, err
-	}
-
-	// parse the options
-	options := auth.NewGenerateOptions(opts...)
-
-	// construct the account
-	sa := auth.Account{
-		Id:       id,
-		Token:    token.String(),
-		Created:  time.Now(),
-		Metadata: options.Metadata,
-		Roles:    options.Roles,
-	}
-
-	// encode the data to bytes
-	// TODO: replace with json
-	buf := &bytes.Buffer{}
-	e := gob.NewEncoder(buf)
-	if err := e.Encode(sa); err != nil {
-		return nil, err
-	}
-
-	// write to the store
-	err = a.store.Write(&store.Record{
-		Key:   token.String(),
-		Value: buf.Bytes(),
-	})
-	if err != nil {
-		return nil, err
-	}
-
-	// return the result
-	return &sa, nil
-}
-
-// Revoke an authorization Account
-func (a *Auth) Revoke(token string) error {
-	records, err := a.store.Read(token, store.ReadSuffix())
-	if err != nil {
-		return err
-	}
-	if len(records) == 0 {
-		return errors.BadRequest("go.micro.auth", "token not found")
-	}
-
-	for _, r := range records {
-		if err := a.store.Delete(r.Key); err != nil {
-			return errors.InternalServerError("go.micro.auth", "error deleting from store")
-		}
-	}
-
-	return nil
-}
-
-// Verify an account token
-func (a *Auth) Verify(token string) (*auth.Account, error) {
-	// lookup the record by token
-	records, err := a.store.Read(token, store.ReadSuffix())
-	if err == store.ErrNotFound || len(records) == 0 {
-		return nil, errors.Unauthorized("go.micro.auth", "invalid token")
-	} else if err != nil {
-		return nil, errors.InternalServerError("go.micro.auth", "error reading store")
-	}
-
-	// decode the result
-	// TODO: replace with json
-	b := bytes.NewBuffer(records[0].Value)
-	decoder := gob.NewDecoder(b)
-	var sa auth.Account
-	err = decoder.Decode(&sa)
-
-	// return the result
-	return &sa, err
-}
-
-// String returns the implementation
-func (a *Auth) String() string {
-	return "store"
-}

broker/broker.go

@@ -1,66 +1,132 @@
 // Package broker is an interface used for asynchronous messaging
-package broker
+package broker // import "go.unistack.org/micro/v3/broker"
+
+import (
+	"context"
+	"errors"
+
+	"go.unistack.org/micro/v3/metadata"
+)
+
+// DefaultBroker default memory broker
+var DefaultBroker = NewBroker()
+
+var (
+	// ErrNotConnected returns when broker used but not connected yet
+	ErrNotConnected = errors.New("broker not connected")
+	// ErrDisconnected returns when broker disconnected
+	ErrDisconnected = errors.New("broker disconnected")
+)
 
 // Broker is an interface used for asynchronous messaging.
 type Broker interface {
-	Init(...Option) error
+	// Name returns broker instance name
+	Name() string
+	// Init initilize broker
+	Init(opts ...Option) error
+	// Options returns broker options
 	Options() Options
+	// Address return configured address
 	Address() string
-	Connect() error
-	Disconnect() error
-	Publish(topic string, m *Message, opts ...PublishOption) error
-	Subscribe(topic string, h Handler, opts ...SubscribeOption) (Subscriber, error)
+	// Connect connects to broker
+	Connect(ctx context.Context) error
+	// Disconnect disconnect from broker
+	Disconnect(ctx context.Context) error
+	// Publish message to broker topic
+	Publish(ctx context.Context, topic string, msg *Message, opts ...PublishOption) error
+	// Subscribe subscribes to topic message via handler
+	Subscribe(ctx context.Context, topic string, h Handler, opts ...SubscribeOption) (Subscriber, error)
+	// BatchPublish messages to broker with multiple topics
+	BatchPublish(ctx context.Context, msgs []*Message, opts ...PublishOption) error
+	// BatchSubscribe subscribes to topic messages via handler
+	BatchSubscribe(ctx context.Context, topic string, h BatchHandler, opts ...SubscribeOption) (Subscriber, error)
+	// String type of broker
 	String() string
 }
 
 // Handler is used to process messages via a subscription of a topic.
-// The handler is passed a publication interface which contains the
-// message and optional Ack method to acknowledge receipt of the message.
 type Handler func(Event) error
 
-type Message struct {
-	Header map[string]string
-	Body   []byte
+// Events contains multiple events
+type Events []Event
+
+// Ack try to ack all events and return
+func (evs Events) Ack() error {
+	var err error
+	for _, ev := range evs {
+		if err = ev.Ack(); err != nil {
+			return err
+		}
+	}
+	return nil
 }
 
+// SetError sets error on event
+func (evs Events) SetError(err error) {
+	for _, ev := range evs {
+		ev.SetError(err)
+	}
+}
+
+// BatchHandler is used to process messages in batches via a subscription of a topic.
+type BatchHandler func(Events) error
+
 // Event is given to a subscription handler for processing
 type Event interface {
+	// Topic returns event topic
 	Topic() string
+	// Message returns broker message
 	Message() *Message
+	// Ack acknowledge message
 	Ack() error
+	// Error returns message error (like decoding errors or some other)
+	Error() error
+	// SetError set event processing error
+	SetError(err error)
+}
+
+// RawMessage is a raw encoded JSON value.
+// It implements Marshaler and Unmarshaler and can be used to delay decoding or precompute a encoding.
+type RawMessage []byte
+
+// MarshalJSON returns m as the JSON encoding of m.
+func (m *RawMessage) MarshalJSON() ([]byte, error) {
+	if m == nil {
+		return []byte("null"), nil
+	}
+	return *m, nil
+}
+
+// UnmarshalJSON sets *m to a copy of data.
+func (m *RawMessage) UnmarshalJSON(data []byte) error {
+	if m == nil {
+		return errors.New("RawMessage UnmarshalJSON on nil pointer")
+	}
+	*m = append((*m)[0:0], data...)
+	return nil
+}
+
+// Message is used to transfer data
+type Message struct {
+	// Header contains message metadata
+	Header metadata.Metadata
+	// Body contains message body
+	Body RawMessage
+}
+
+// NewMessage create broker message with topic filled
+func NewMessage(topic string) *Message {
+	m := &Message{Header: metadata.New(2)}
+	m.Header.Set(metadata.HeaderTopic, topic)
+	return m
 }
 
 // Subscriber is a convenience return type for the Subscribe method
 type Subscriber interface {
+	// Options returns subscriber options
 	Options() SubscribeOptions
+	// Topic returns topic for subscription
 	Topic() string
-	Unsubscribe() error
-}
-
-var (
-	DefaultBroker Broker = NewBroker()
-)
-
-func Init(opts ...Option) error {
-	return DefaultBroker.Init(opts...)
-}
-
-func Connect() error {
-	return DefaultBroker.Connect()
-}
-
-func Disconnect() error {
-	return DefaultBroker.Disconnect()
-}
-
-func Publish(topic string, msg *Message, opts ...PublishOption) error {
-	return DefaultBroker.Publish(topic, msg, opts...)
-}
-
-func Subscribe(topic string, handler Handler, opts ...SubscribeOption) (Subscriber, error) {
-	return DefaultBroker.Subscribe(topic, handler, opts...)
-}
-
-func String() string {
-	return DefaultBroker.String()
+	// Unsubscribe from topic
+	Unsubscribe(ctx context.Context) error
 }

broker/context.go

@@ -0,0 +1,54 @@
+package broker
+
+import (
+	"context"
+)
+
+type brokerKey struct{}
+
+// FromContext returns broker from passed context
+func FromContext(ctx context.Context) (Broker, bool) {
+	if ctx == nil {
+		return nil, false
+	}
+	c, ok := ctx.Value(brokerKey{}).(Broker)
+	return c, ok
+}
+
+// NewContext savess broker in context
+func NewContext(ctx context.Context, s Broker) context.Context {
+	if ctx == nil {
+		ctx = context.Background()
+	}
+	return context.WithValue(ctx, brokerKey{}, s)
+}
+
+// SetSubscribeOption returns a function to setup a context with given value
+func SetSubscribeOption(k, v interface{}) SubscribeOption {
+	return func(o *SubscribeOptions) {
+		if o.Context == nil {
+			o.Context = context.Background()
+		}
+		o.Context = context.WithValue(o.Context, k, v)
+	}
+}
+
+// SetOption returns a function to setup a context with given value
+func SetOption(k, v interface{}) Option {
+	return func(o *Options) {
+		if o.Context == nil {
+			o.Context = context.Background()
+		}
+		o.Context = context.WithValue(o.Context, k, v)
+	}
+}
+
+// SetPublishOption returns a function to setup a context with given value
+func SetPublishOption(k, v interface{}) PublishOption {
+	return func(o *PublishOptions) {
+		if o.Context == nil {
+			o.Context = context.Background()
+		}
+		o.Context = context.WithValue(o.Context, k, v)
+	}
+}

broker/context_test.go

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

broker/default.go

@@ -1,475 +0,0 @@
-package broker
-
-import (
-	"context"
-	"errors"
-	"net"
-	"net/url"
-	"strconv"
-	"strings"
-	"sync"
-	"time"
-
-	"github.com/micro/go-micro/v2/codec/json"
-	log "github.com/micro/go-micro/v2/logger"
-	"github.com/micro/go-micro/v2/registry"
-	"github.com/micro/go-micro/v2/util/addr"
-	"github.com/nats-io/nats-server/v2/server"
-	nats "github.com/nats-io/nats.go"
-)
-
-type natsBroker struct {
-	sync.Once
-	sync.RWMutex
-
-	// indicate if we're connected
-	connected bool
-
-	// address to bind routes to
-	addrs []string
-	// servers for the client
-	servers []string
-
-	// client connection and nats opts
-	conn  *nats.Conn
-	opts  Options
-	nopts nats.Options
-
-	// should we drain the connection
-	drain   bool
-	closeCh chan (error)
-
-	// embedded server
-	server *server.Server
-	// configure to use local server
-	local bool
-	// server exit channel
-	exit chan bool
-}
-
-type subscriber struct {
-	s    *nats.Subscription
-	opts SubscribeOptions
-}
-
-type publication struct {
-	t string
-	m *Message
-}
-
-func (p *publication) Topic() string {
-	return p.t
-}
-
-func (p *publication) Message() *Message {
-	return p.m
-}
-
-func (p *publication) Ack() error {
-	// nats does not support acking
-	return nil
-}
-
-func (s *subscriber) Options() SubscribeOptions {
-	return s.opts
-}
-
-func (s *subscriber) Topic() string {
-	return s.s.Subject
-}
-
-func (s *subscriber) Unsubscribe() error {
-	return s.s.Unsubscribe()
-}
-
-func (n *natsBroker) Address() string {
-	n.RLock()
-	defer n.RUnlock()
-
-	if n.server != nil {
-		return n.server.ClusterAddr().String()
-	}
-
-	if n.conn != nil && n.conn.IsConnected() {
-		return n.conn.ConnectedUrl()
-	}
-
-	if len(n.addrs) > 0 {
-		return n.addrs[0]
-	}
-
-	return "127.0.0.1:-1"
-}
-
-func (n *natsBroker) setAddrs(addrs []string) []string {
-	//nolint:prealloc
-	var cAddrs []string
-	for _, addr := range addrs {
-		if len(addr) == 0 {
-			continue
-		}
-		if !strings.HasPrefix(addr, "nats://") {
-			addr = "nats://" + addr
-		}
-		cAddrs = append(cAddrs, addr)
-	}
-	// if there's no address and we weren't told to
-	// embed a local server then use the default url
-	if len(cAddrs) == 0 && !n.local {
-		cAddrs = []string{nats.DefaultURL}
-	}
-	return cAddrs
-}
-
-// serve stats a local nats server if needed
-func (n *natsBroker) serve(exit chan bool) error {
-	// local server address
-	host := "127.0.0.1"
-	port := -1
-
-	// cluster address
-	caddr := "0.0.0.0"
-	cport := -1
-
-	// with no address we just default it
-	// this is a local client address
-	if len(n.addrs) > 0 {
-		address := n.addrs[0]
-		if strings.HasPrefix(address, "nats://") {
-			address = strings.TrimPrefix(address, "nats://")
-		}
-
-		// parse out the address
-		h, p, err := net.SplitHostPort(address)
-		if err == nil {
-			caddr = h
-			cport, _ = strconv.Atoi(p)
-		}
-	}
-
-	// 1. create new server
-	// 2. register the server
-	// 3. connect to other servers
-
-	// set cluster opts
-	cOpts := server.ClusterOpts{
-		Host: caddr,
-		Port: cport,
-	}
-
-	// get the routes for other nodes
-	var routes []*url.URL
-
-	// get existing nats servers to connect to
-	services, err := n.opts.Registry.GetService("go.micro.nats.broker")
-	if err == nil {
-		for _, service := range services {
-			for _, node := range service.Nodes {
-				u, err := url.Parse("nats://" + node.Address)
-				if err != nil {
-					log.Info(err)
-					continue
-				}
-				// append to the cluster routes
-				routes = append(routes, u)
-			}
-		}
-	}
-
-	// try get existing server
-	s := n.server
-
-	if s != nil {
-		// stop the existing server
-		s.Shutdown()
-	}
-
-	s, err = server.NewServer(&server.Options{
-		// Specify the host
-		Host: host,
-		// Use a random port
-		Port: port,
-		// Set the cluster ops
-		Cluster: cOpts,
-		// Set the routes
-		Routes:         routes,
-		NoLog:          true,
-		NoSigs:         true,
-		MaxControlLine: 2048,
-		TLSConfig:      n.opts.TLSConfig,
-	})
-	if err != nil {
-		return err
-	}
-
-	// save the server
-	n.server = s
-
-	// start the server
-	go s.Start()
-
-	var ready bool
-
-	// wait till its ready for connections
-	for i := 0; i < 3; i++ {
-		if s.ReadyForConnections(time.Second) {
-			ready = true
-			break
-		}
-	}
-
-	if !ready {
-		return errors.New("server not ready")
-	}
-
-	// set the client address
-	n.servers = []string{s.ClientURL()}
-
-	go func() {
-		var advertise string
-
-		// parse out the address
-		_, port, err := net.SplitHostPort(s.ClusterAddr().String())
-		if err == nil {
-			addr, _ := addr.Extract("")
-			advertise = net.JoinHostPort(addr, port)
-		} else {
-			s.ClusterAddr().String()
-		}
-
-		// register the cluster address
-		for {
-			select {
-			case err := <-n.closeCh:
-				if err != nil {
-					log.Info(err)
-				}
-			case <-exit:
-				// deregister on exit
-				n.opts.Registry.Deregister(&registry.Service{
-					Name:    "go.micro.nats.broker",
-					Version: "v2",
-					Nodes: []*registry.Node{
-						{Id: s.ID(), Address: advertise},
-					},
-				})
-				s.Shutdown()
-				return
-			default:
-				// register the broker
-				n.opts.Registry.Register(&registry.Service{
-					Name:    "go.micro.nats.broker",
-					Version: "v2",
-					Nodes: []*registry.Node{
-						{Id: s.ID(), Address: advertise},
-					},
-				}, registry.RegisterTTL(time.Minute))
-				time.Sleep(time.Minute)
-			}
-		}
-	}()
-
-	return nil
-}
-
-func (n *natsBroker) Connect() error {
-	n.Lock()
-	defer n.Unlock()
-
-	if !n.connected {
-		// create exit chan
-		n.exit = make(chan bool)
-
-		// start the local server
-		if err := n.serve(n.exit); err != nil {
-			return err
-		}
-
-		// set to connected
-	}
-
-	status := nats.CLOSED
-	if n.conn != nil {
-		status = n.conn.Status()
-	}
-
-	switch status {
-	case nats.CONNECTED, nats.RECONNECTING, nats.CONNECTING:
-		return nil
-	default: // DISCONNECTED or CLOSED or DRAINING
-		opts := n.nopts
-		opts.DrainTimeout = 1 * time.Second
-		opts.AsyncErrorCB = n.onAsyncError
-		opts.DisconnectedErrCB = n.onDisconnectedError
-		opts.ClosedCB = n.onClose
-		opts.Servers = n.servers
-		opts.Secure = n.opts.Secure
-		opts.TLSConfig = n.opts.TLSConfig
-
-		// secure might not be set
-		if n.opts.TLSConfig != nil {
-			opts.Secure = true
-		}
-
-		c, err := opts.Connect()
-		if err != nil {
-			return err
-		}
-		n.conn = c
-
-		n.connected = true
-
-		return nil
-	}
-}
-
-func (n *natsBroker) Disconnect() error {
-	n.RLock()
-	defer n.RUnlock()
-
-	if !n.connected {
-		return nil
-	}
-
-	// drain the connection if specified
-	if n.drain {
-		n.conn.Drain()
-	}
-
-	// close the client connection
-	n.conn.Close()
-
-	// shutdown the local server
-	// and deregister
-	if n.server != nil {
-		select {
-		case <-n.exit:
-		default:
-			close(n.exit)
-		}
-	}
-
-	// set not connected
-	n.connected = false
-
-	return nil
-}
-
-func (n *natsBroker) Init(opts ...Option) error {
-	n.setOption(opts...)
-	return nil
-}
-
-func (n *natsBroker) Options() Options {
-	return n.opts
-}
-
-func (n *natsBroker) Publish(topic string, msg *Message, opts ...PublishOption) error {
-	b, err := n.opts.Codec.Marshal(msg)
-	if err != nil {
-		return err
-	}
-	n.RLock()
-	defer n.RUnlock()
-	return n.conn.Publish(topic, b)
-}
-
-func (n *natsBroker) Subscribe(topic string, handler Handler, opts ...SubscribeOption) (Subscriber, error) {
-	if n.conn == nil {
-		return nil, errors.New("not connected")
-	}
-
-	opt := SubscribeOptions{
-		AutoAck: true,
-		Context: context.Background(),
-	}
-
-	for _, o := range opts {
-		o(&opt)
-	}
-
-	fn := func(msg *nats.Msg) {
-		var m Message
-		if err := n.opts.Codec.Unmarshal(msg.Data, &m); err != nil {
-			return
-		}
-		handler(&publication{m: &m, t: msg.Subject})
-	}
-
-	var sub *nats.Subscription
-	var err error
-
-	n.RLock()
-	if len(opt.Queue) > 0 {
-		sub, err = n.conn.QueueSubscribe(topic, opt.Queue, fn)
-	} else {
-		sub, err = n.conn.Subscribe(topic, fn)
-	}
-	n.RUnlock()
-	if err != nil {
-		return nil, err
-	}
-	return &subscriber{s: sub, opts: opt}, nil
-}
-
-func (n *natsBroker) String() string {
-	return "eats"
-}
-
-func (n *natsBroker) setOption(opts ...Option) {
-	for _, o := range opts {
-		o(&n.opts)
-	}
-
-	n.Once.Do(func() {
-		n.nopts = nats.GetDefaultOptions()
-	})
-
-	// local embedded server
-	n.local = true
-	// set to drain
-	n.drain = true
-
-	if !n.opts.Secure {
-		n.opts.Secure = n.nopts.Secure
-	}
-
-	if n.opts.TLSConfig == nil {
-		n.opts.TLSConfig = n.nopts.TLSConfig
-	}
-
-	n.addrs = n.setAddrs(n.opts.Addrs)
-}
-
-func (n *natsBroker) onClose(conn *nats.Conn) {
-	n.closeCh <- nil
-}
-
-func (n *natsBroker) onDisconnectedError(conn *nats.Conn, err error) {
-	n.closeCh <- err
-}
-
-func (n *natsBroker) onAsyncError(conn *nats.Conn, sub *nats.Subscription, err error) {
-	// There are kinds of different async error nats might callback, but we are interested
-	// in ErrDrainTimeout only here.
-	if err == nats.ErrDrainTimeout {
-		n.closeCh <- err
-	}
-}
-
-func NewBroker(opts ...Option) Broker {
-	options := Options{
-		// Default codec
-		Codec:    json.Marshaler{},
-		Context:  context.Background(),
-		Registry: registry.DefaultRegistry,
-	}
-
-	n := &natsBroker{
-		opts:    options,
-		closeCh: make(chan error),
-	}
-	n.setOption(opts...)
-
-	return n
-}

broker/memory.go

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

broker/memory/memory.go

@@ -1,197 +0,0 @@
-// Package memory provides a memory broker
-package memory
-
-import (
-	"errors"
-	"math/rand"
-	"sync"
-	"time"
-
-	"github.com/google/uuid"
-	"github.com/micro/go-micro/v2/broker"
-	maddr "github.com/micro/go-micro/v2/util/addr"
-	mnet "github.com/micro/go-micro/v2/util/net"
-)
-
-type memoryBroker struct {
-	opts broker.Options
-
-	addr string
-	sync.RWMutex
-	connected   bool
-	Subscribers map[string][]*memorySubscriber
-}
-
-type memoryEvent struct {
-	topic   string
-	message *broker.Message
-}
-
-type memorySubscriber struct {
-	id      string
-	topic   string
-	exit    chan bool
-	handler broker.Handler
-	opts    broker.SubscribeOptions
-}
-
-func (m *memoryBroker) Options() broker.Options {
-	return m.opts
-}
-
-func (m *memoryBroker) Address() string {
-	return m.addr
-}
-
-func (m *memoryBroker) Connect() error {
-	m.Lock()
-	defer m.Unlock()
-
-	if m.connected {
-		return nil
-	}
-
-	addr, err := maddr.Extract("::")
-	if err != nil {
-		return err
-	}
-	i := rand.Intn(20000)
-	// set addr with port
-	addr = mnet.HostPort(addr, 10000+i)
-
-	m.addr = addr
-	m.connected = true
-
-	return nil
-}
-
-func (m *memoryBroker) Disconnect() error {
-	m.Lock()
-	defer m.Unlock()
-
-	if !m.connected {
-		return nil
-	}
-
-	m.connected = false
-
-	return nil
-}
-
-func (m *memoryBroker) Init(opts ...broker.Option) error {
-	for _, o := range opts {
-		o(&m.opts)
-	}
-	return nil
-}
-
-func (m *memoryBroker) Publish(topic string, message *broker.Message, opts ...broker.PublishOption) error {
-	m.RLock()
-	if !m.connected {
-		m.RUnlock()
-		return errors.New("not connected")
-	}
-
-	subs, ok := m.Subscribers[topic]
-	m.RUnlock()
-	if !ok {
-		return nil
-	}
-
-	p := &memoryEvent{
-		topic:   topic,
-		message: message,
-	}
-
-	for _, sub := range subs {
-		if err := sub.handler(p); err != nil {
-			return err
-		}
-	}
-
-	return nil
-}
-
-func (m *memoryBroker) Subscribe(topic string, handler broker.Handler, opts ...broker.SubscribeOption) (broker.Subscriber, error) {
-	m.RLock()
-	if !m.connected {
-		m.RUnlock()
-		return nil, errors.New("not connected")
-	}
-	m.RUnlock()
-
-	var options broker.SubscribeOptions
-	for _, o := range opts {
-		o(&options)
-	}
-
-	sub := &memorySubscriber{
-		exit:    make(chan bool, 1),
-		id:      uuid.New().String(),
-		topic:   topic,
-		handler: handler,
-		opts:    options,
-	}
-
-	m.Lock()
-	m.Subscribers[topic] = append(m.Subscribers[topic], sub)
-	m.Unlock()
-
-	go func() {
-		<-sub.exit
-		m.Lock()
-		var newSubscribers []*memorySubscriber
-		for _, sb := range m.Subscribers[topic] {
-			if sb.id == sub.id {
-				continue
-			}
-			newSubscribers = append(newSubscribers, sb)
-		}
-		m.Subscribers[topic] = newSubscribers
-		m.Unlock()
-	}()
-
-	return sub, nil
-}
-
-func (m *memoryBroker) String() string {
-	return "memory"
-}
-
-func (m *memoryEvent) Topic() string {
-	return m.topic
-}
-
-func (m *memoryEvent) Message() *broker.Message {
-	return m.message
-}
-
-func (m *memoryEvent) Ack() error {
-	return nil
-}
-
-func (m *memorySubscriber) Options() broker.SubscribeOptions {
-	return m.opts
-}
-
-func (m *memorySubscriber) Topic() string {
-	return m.topic
-}
-
-func (m *memorySubscriber) Unsubscribe() error {
-	m.exit <- true
-	return nil
-}
-
-func NewBroker(opts ...broker.Option) broker.Broker {
-	var options broker.Options
-	rand.Seed(time.Now().UnixNano())
-	for _, o := range opts {
-		o(&options)
-	}
-
-	return &memoryBroker{
-		opts:        options,
-		Subscribers: make(map[string][]*memorySubscriber),
-	}
-}

broker/memory/memory_test.go

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