go mod tidy

Bump dep to fix platform web using new debug.Stats proto fields

.github/FUNDING.yml

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

.github/ISSUE_TEMPLATE/bug_report.md

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

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

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

.github/ISSUE_TEMPLATE/question.md

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

.golangci.yml

@@ -0,0 +1,26 @@
+run:
+  deadline: 10m
+linters:
+  disable-all: false
+  enable-all: false
+  enable:
+    - megacheck
+    - staticcheck
+    - deadcode
+    - varcheck
+    - gosimple
+    - unused
+    - prealloc
+    - scopelint
+    - gocritic
+    - goimports
+    - unconvert
+    - govet
+    - nakedret
+    - structcheck
+    - gosec
+  disable:
+    - maligned
+    - interfacer
+    - typecheck
+    - dupl

.travis.yml

@@ -3,6 +3,12 @@ go:
 - 1.13.x
 env:
   - GO111MODULE=on IN_TRAVIS_CI=yes
+before_script:
+  - go install github.com/golangci/golangci-lint/cmd/golangci-lint
+script:
+  - golangci-lint run || true
+  - go test -v -race ./... || true
+  - go test -v ./...
 notifications:
   slack:
     secure: aEvhLbhujaGaKSrOokiG3//PaVHTIrc3fBpoRbCRqfZpyq6WREoapJJhF+tIpWWOwaC9GmChbD6aHo/jMUgwKXVyPSaNjiEL87YzUUpL8B2zslNp1rgfTg/LrzthOx3Q1TYwpaAl3to0fuHUVFX4yMeC2vuThq7WSXgMMxFCtbc=

CNAME

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

Dockerfile

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

README.md

@@ -12,7 +12,7 @@ but everything can be easily swapped out.
 
 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 [Slack](http://slack.micro.mu/) community.
+Follow us on [Twitter](https://twitter.com/microhq) or join the [Community](https://micro.mu/slack).
 
 ## Features
 
@@ -20,8 +20,7 @@ Go Micro abstracts away the details of distributed systems. Here are the main fe
 
 - **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. You can optionally set gossip using the SWIM protocol for p2p networks or consul for a
-resilient cloud-native setup.
+multicast DNS (mdns), a zeroconf system.
 
 - **Load Balancing** - Client side load balancing built on service discovery. Once we have the addresses of any number of instances 
 of a service we now need a way to decide which node to route to. We use random hashed load balancing to provide even distribution 
@@ -33,11 +32,11 @@ and server handle this by default. This includes protobuf and json 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 http/1.1 or http2 when tls is enabled.
+transport is [gRPC](https://grpc.io/).
 
 - **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 is point-to-point http/1.1 or http2 when tls 
-is enabled.
+Event notifications are a core pattern in micro service development. The default messaging system is an embedded [NATS](https://nats.io/) 
+server.
 
 - **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 
@@ -45,5 +44,5 @@ are pluggable and allows Go Micro to be runtime agnostic. You can plugin any und
 
 ## Getting Started
 
-See the [docs](https://micro.mu/docs/go-micro.html) for detailed information on the architecture, installation and use of go-micro.
+See the [docs](https://micro.mu/docs/framework.html) for detailed information on the architecture, installation and use of go-micro.
 

_config.yml

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

agent/input/discord/discord.go

@@ -8,7 +8,7 @@ import (
 	"strings"
 
 	"github.com/bwmarrin/discordgo"
-	"github.com/micro/cli"
+	"github.com/micro/cli/v2"
 	"github.com/micro/go-micro/agent/input"
 )
 
@@ -36,21 +36,21 @@ type discordInput struct {
 
 func (d *discordInput) Flags() []cli.Flag {
 	return []cli.Flag{
-		cli.StringFlag{
-			Name:   "discord_token",
-			EnvVar: "MICRO_DISCORD_TOKEN",
-			Usage:  "Discord token (prefix with Bot if it's for bot account)",
+		&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",
-			EnvVar: "MICRO_DISCORD_WHITELIST",
-			Usage:  "Discord Whitelist (seperated by ,)",
+		&cli.StringFlag{
+			Name:    "discord_whitelist",
+			EnvVars: []string{"MICRO_DISCORD_WHITELIST"},
+			Usage:   "Discord Whitelist (seperated by ,)",
 		},
-		cli.StringFlag{
-			Name:   "discord_prefix",
-			Usage:  "Discord Prefix",
-			EnvVar: "MICRO_DISCORD_PREFIX",
-			Value:  "Micro ",
+		&cli.StringFlag{
+			Name:    "discord_prefix",
+			Usage:   "Discord Prefix",
+			EnvVars: []string{"MICRO_DISCORD_PREFIX"},
+			Value:   "Micro ",
 		},
 	}
 }

agent/input/input.go

@@ -2,7 +2,7 @@
 package input
 
 import (
-	"github.com/micro/cli"
+	"github.com/micro/cli/v2"
 )
 
 type EventType string

agent/input/slack/slack.go

@@ -4,7 +4,7 @@ import (
 	"errors"
 	"sync"
 
-	"github.com/micro/cli"
+	"github.com/micro/cli/v2"
 	"github.com/micro/go-micro/agent/input"
 	"github.com/nlopes/slack"
 )
@@ -26,15 +26,15 @@ func init() {
 
 func (p *slackInput) Flags() []cli.Flag {
 	return []cli.Flag{
-		cli.BoolFlag{
-			Name:   "slack_debug",
-			Usage:  "Slack debug output",
-			EnvVar: "MICRO_SLACK_DEBUG",
+		&cli.BoolFlag{
+			Name:    "slack_debug",
+			Usage:   "Slack debug output",
+			EnvVars: []string{"MICRO_SLACK_DEBUG"},
 		},
-		cli.StringFlag{
-			Name:   "slack_token",
-			Usage:  "Slack token",
-			EnvVar: "MICRO_SLACK_TOKEN",
+		&cli.StringFlag{
+			Name:    "slack_token",
+			Usage:   "Slack token",
+			EnvVars: []string{"MICRO_SLACK_TOKEN"},
 		},
 	}
 }

agent/input/telegram/conn.go

@@ -8,7 +8,7 @@ import (
 	"github.com/forestgiant/sliceutil"
 	"github.com/micro/go-micro/agent/input"
 	"github.com/micro/go-micro/util/log"
-	"gopkg.in/telegram-bot-api.v4"
+	tgbotapi "gopkg.in/telegram-bot-api.v4"
 )
 
 type telegramConn struct {
@@ -44,11 +44,9 @@ func (tc *telegramConn) run() {
 	tc.recv = updates
 	tc.syncCond.Signal()
 
-	for {
-		select {
-		case <-tc.exit:
-			return
-		}
+	select {
+	case <-tc.exit:
+		return
 	}
 }
 

agent/input/telegram/telegram.go

@@ -5,9 +5,9 @@ import (
 	"strings"
 	"sync"
 
-	"github.com/micro/cli"
+	"github.com/micro/cli/v2"
 	"github.com/micro/go-micro/agent/input"
-	"gopkg.in/telegram-bot-api.v4"
+	tgbotapi "gopkg.in/telegram-bot-api.v4"
 )
 
 type telegramInput struct {
@@ -34,20 +34,20 @@ func init() {
 
 func (ti *telegramInput) Flags() []cli.Flag {
 	return []cli.Flag{
-		cli.BoolFlag{
-			Name:   "telegram_debug",
-			EnvVar: "MICRO_TELEGRAM_DEBUG",
-			Usage:  "Telegram debug output",
+		&cli.BoolFlag{
+			Name:    "telegram_debug",
+			EnvVars: []string{"MICRO_TELEGRAM_DEBUG"},
+			Usage:   "Telegram debug output",
 		},
-		cli.StringFlag{
-			Name:   "telegram_token",
-			EnvVar: "MICRO_TELEGRAM_TOKEN",
-			Usage:  "Telegram token",
+		&cli.StringFlag{
+			Name:    "telegram_token",
+			EnvVars: []string{"MICRO_TELEGRAM_TOKEN"},
+			Usage:   "Telegram token",
 		},
-		cli.StringFlag{
-			Name:   "telegram_whitelist",
-			EnvVar: "MICRO_TELEGRAM_WHITELIST",
-			Usage:  "Telegram bot's users (comma-separated values)",
+		&cli.StringFlag{
+			Name:    "telegram_whitelist",
+			EnvVars: []string{"MICRO_TELEGRAM_WHITELIST"},
+			Usage:   "Telegram bot's users (comma-separated values)",
 		},
 	}
 }

agent/proto/bot.pb.go

@@ -1,11 +1,13 @@
 // Code generated by protoc-gen-go. DO NOT EDIT.
-// source: github.com/micro/go-bot/proto/bot.proto
+// source: github.com/micro/go-micro/agent/proto/bot.proto
 
 package go_micro_bot
 
-import proto "github.com/golang/protobuf/proto"
-import fmt "fmt"
-import math "math"
+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
@@ -16,7 +18,7 @@ var _ = math.Inf
 // 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.ProtoPackageIsVersion2 // please upgrade the proto package
+const _ = proto.ProtoPackageIsVersion3 // please upgrade the proto package
 
 type HelpRequest struct {
 	XXX_NoUnkeyedLiteral struct{} `json:"-"`
@@ -28,16 +30,17 @@ 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_bot_654832eab83ed4b5, []int{0}
+	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 (dst *HelpRequest) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_HelpRequest.Merge(dst, src)
+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)
@@ -60,16 +63,17 @@ 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_bot_654832eab83ed4b5, []int{1}
+	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 (dst *HelpResponse) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_HelpResponse.Merge(dst, src)
+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)
@@ -105,16 +109,17 @@ 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_bot_654832eab83ed4b5, []int{2}
+	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 (dst *ExecRequest) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_ExecRequest.Merge(dst, src)
+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)
@@ -144,16 +149,17 @@ 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_bot_654832eab83ed4b5, []int{3}
+	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 (dst *ExecResponse) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_ExecResponse.Merge(dst, src)
+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)
@@ -186,25 +192,25 @@ func init() {
 }
 
 func init() {
-	proto.RegisterFile("github.com/micro/go-bot/proto/bot.proto", fileDescriptor_bot_654832eab83ed4b5)
+	proto.RegisterFile("github.com/micro/go-micro/agent/proto/bot.proto", fileDescriptor_018e8d5b14a89d12)
 }
 
-var fileDescriptor_bot_654832eab83ed4b5 = []byte{
+var fileDescriptor_018e8d5b14a89d12 = []byte{
 	// 246 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x6c, 0x90, 0x41, 0x4b, 0xc4, 0x30,
-	0x10, 0x85, 0xb7, 0xba, 0xae, 0xec, 0xb4, 0x5e, 0x82, 0x48, 0xdd, 0x53, 0xcd, 0xc5, 0xbd, 0x98,
-	0x82, 0x5e, 0x05, 0x0f, 0xa2, 0x78, 0xee, 0x3f, 0x68, 0xba, 0x43, 0x2c, 0x6c, 0x3b, 0x35, 0x99,
-	0x82, 0xff, 0xc1, 0x3f, 0x2d, 0x4d, 0x72, 0x08, 0xcb, 0xde, 0xe6, 0x65, 0x86, 0xf7, 0xbe, 0x17,
-	0x78, 0x34, 0x3d, 0x7f, 0xcf, 0x5a, 0x75, 0x34, 0xd4, 0x43, 0xdf, 0x59, 0xaa, 0x0d, 0x3d, 0x69,
-	0xe2, 0x7a, 0xb2, 0xc4, 0x54, 0x6b, 0x62, 0xe5, 0x27, 0x51, 0x18, 0x52, 0xfe, 0x40, 0x69, 0x62,
-	0x79, 0x03, 0xf9, 0x17, 0x1e, 0xa7, 0x06, 0x7f, 0x66, 0x74, 0x2c, 0x3f, 0xa1, 0x08, 0xd2, 0x4d,
-	0x34, 0x3a, 0x14, 0xb7, 0x70, 0x35, 0xbb, 0xd6, 0x60, 0x99, 0x55, 0xd9, 0x7e, 0xdb, 0x04, 0x21,
-	0x2a, 0xc8, 0x0f, 0xe8, 0x3a, 0xdb, 0x4f, 0xdc, 0xd3, 0x58, 0x5e, 0xf8, 0x5d, 0xfa, 0x24, 0x1f,
-	0x20, 0xff, 0xf8, 0xc5, 0x2e, 0xda, 0x0a, 0x01, 0xeb, 0xd6, 0x1a, 0x57, 0x66, 0xd5, 0xe5, 0x7e,
-	0xdb, 0xf8, 0x59, 0xbe, 0x42, 0x11, 0x4e, 0x62, 0xd4, 0x1d, 0x6c, 0x2c, 0xba, 0xf9, 0xc8, 0x3e,
-	0xab, 0x68, 0xa2, 0x5a, 0x10, 0xd0, 0x5a, 0xb2, 0x31, 0x26, 0x88, 0xe7, 0xbf, 0x0c, 0xae, 0xdf,
-	0x69, 0x18, 0xda, 0xf1, 0x20, 0xde, 0x60, 0xbd, 0x40, 0x8b, 0x7b, 0x95, 0x56, 0x53, 0x49, 0xaf,
-	0xdd, 0xee, 0xdc, 0x2a, 0x04, 0xcb, 0xd5, 0x62, 0xb0, 0xa0, 0x9c, 0x1a, 0x24, 0x0d, 0x4e, 0x0d,
-	0x52, 0x72, 0xb9, 0xd2, 0x1b, 0xff, 0xb5, 0x2f, 0xff, 0x01, 0x00, 0x00, 0xff, 0xff, 0xcb, 0x77,
-	0xdf, 0x28, 0x85, 0x01, 0x00, 0x00,
+	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,23 +1,13 @@
 // Code generated by protoc-gen-micro. DO NOT EDIT.
-// source: github.com/micro/go-bot/proto/bot.proto
+// source: github.com/micro/go-micro/agent/proto/bot.proto
 
-/*
-Package go_micro_bot is a generated protocol buffer package.
-
-It is generated from these files:
-	github.com/micro/go-bot/proto/bot.proto
-
-It has these top-level messages:
-	HelpRequest
-	HelpResponse
-	ExecRequest
-	ExecResponse
-*/
 package go_micro_bot
 
-import proto "github.com/golang/protobuf/proto"
-import fmt "fmt"
-import math "math"
+import (
+	fmt "fmt"
+	proto "github.com/golang/protobuf/proto"
+	math "math"
+)
 
 import (
 	context "context"
@@ -34,7 +24,7 @@ var _ = math.Inf
 // 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.ProtoPackageIsVersion2 // please upgrade the proto package
+const _ = proto.ProtoPackageIsVersion3 // please upgrade the proto package
 
 // Reference imports to suppress errors if they are not otherwise used.
 var _ context.Context
@@ -94,12 +84,12 @@ type CommandHandler interface {
 }
 
 func RegisterCommandHandler(s server.Server, hdlr CommandHandler, opts ...server.HandlerOption) error {
-	type _command interface {
+	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
+		command
 	}
 	h := &commandHandler{hdlr}
 	return s.Handle(s.NewHandler(&Command{h}, opts...))

api/api.go

@@ -57,14 +57,25 @@ func Encode(e *Endpoint) map[string]string {
 		return nil
 	}
 
-	return map[string]string{
-		"endpoint":    e.Name,
-		"description": e.Description,
-		"method":      strings.Join(e.Method, ","),
-		"path":        strings.Join(e.Path, ","),
-		"host":        strings.Join(e.Host, ","),
-		"handler":     e.Handler,
+	// endpoint map
+	ep := make(map[string]string)
+
+	// set vals only if they exist
+	set := func(k, v string) {
+		if len(v) == 0 {
+			return
+		}
+		ep[k] = v
 	}
+
+	set("endpoint", e.Name)
+	set("description", e.Description)
+	set("handler", e.Handler)
+	set("method", strings.Join(e.Method, ","))
+	set("path", strings.Join(e.Path, ","))
+	set("host", strings.Join(e.Host, ","))
+
+	return ep
 }
 
 // Decode decodes endpoint metadata into an endpoint

api/handler/api/util.go

@@ -29,16 +29,20 @@ func requestToProto(r *http.Request) (*api.Request, error) {
 
 	ct, _, err := mime.ParseMediaType(r.Header.Get("Content-Type"))
 	if err != nil {
-		ct = "application/x-www-form-urlencoded"
+		ct = "text/plain; charset=UTF-8" //default CT is text/plain
 		r.Header.Set("Content-Type", ct)
 	}
 
-	switch ct {
-	case "application/x-www-form-urlencoded":
-		// expect form vals
-	default:
-		data, _ := ioutil.ReadAll(r.Body)
-		req.Body = string(data)
+	//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

api/handler/cloudevents/event.go

@@ -32,7 +32,7 @@ import (
 	"unicode"
 
 	"github.com/google/uuid"
-	"gopkg.in/go-playground/validator.v9"
+	validator "gopkg.in/go-playground/validator.v9"
 )
 
 const (

api/handler/event/event.go

@@ -2,6 +2,7 @@
 package event
 
 import (
+	"encoding/json"
 	"fmt"
 	"io/ioutil"
 	"net/http"
@@ -91,12 +92,17 @@ func (e *event) ServeHTTP(w http.ResponseWriter, r *http.Request) {
 	}
 
 	// set body
-	b, err := ioutil.ReadAll(r.Body)
-	if err != nil {
-		http.Error(w, err.Error(), 500)
-		return
+	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)
 	}
-	ev.Data = string(b)
 
 	// get client
 	c := e.options.Service.Client()

api/handler/http/http_test.go

@@ -9,14 +9,12 @@ import (
 	"github.com/micro/go-micro/api/handler"
 	"github.com/micro/go-micro/api/router"
 	regRouter "github.com/micro/go-micro/api/router/registry"
-	"github.com/micro/go-micro/config/cmd"
 	"github.com/micro/go-micro/registry"
 	"github.com/micro/go-micro/registry/memory"
 )
 
 func testHttp(t *testing.T, path, service, ns string) {
 	r := memory.NewRegistry()
-	cmd.DefaultCmd = cmd.NewCmd(cmd.Registry(&r))
 
 	l, err := net.Listen("tcp", "127.0.0.1:0")
 	if err != nil {
@@ -57,6 +55,7 @@ func testHttp(t *testing.T, path, service, ns string) {
 	rt := regRouter.NewRouter(
 		router.WithHandler("http"),
 		router.WithNamespace(ns),
+		router.WithRegistry(r),
 	)
 
 	p := NewHandler(handler.WithRouter(rt))

api/handler/rpc/rpc_test.go

@@ -7,7 +7,7 @@ import (
 	"testing"
 
 	"github.com/golang/protobuf/proto"
-	"github.com/micro/go-micro/api/proto"
+	go_api "github.com/micro/go-micro/api/proto"
 )
 
 func TestRequestPayloadFromRequest(t *testing.T) {

api/proto/api.pb.go

@@ -3,9 +3,11 @@
 
 package go_api
 
-import proto "github.com/golang/protobuf/proto"
-import fmt "fmt"
-import math "math"
+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
@@ -16,7 +18,7 @@ var _ = math.Inf
 // 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.ProtoPackageIsVersion2 // please upgrade the proto package
+const _ = proto.ProtoPackageIsVersion3 // please upgrade the proto package
 
 type Pair struct {
 	Key                  string   `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"`
@@ -30,16 +32,17 @@ 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_api_17a7876430d97ebd, []int{0}
+	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 (dst *Pair) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_Pair.Merge(dst, src)
+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)
@@ -83,16 +86,17 @@ 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_api_17a7876430d97ebd, []int{1}
+	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 (dst *Request) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_Request.Merge(dst, src)
+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)
@@ -167,16 +171,17 @@ 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_api_17a7876430d97ebd, []int{2}
+	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 (dst *Response) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_Response.Merge(dst, src)
+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)
@@ -230,16 +235,17 @@ 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_api_17a7876430d97ebd, []int{3}
+	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 (dst *Event) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_Event.Merge(dst, src)
+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)
@@ -298,35 +304,35 @@ func init() {
 }
 
 func init() {
-	proto.RegisterFile("github.com/micro/go-micro/api/proto/api.proto", fileDescriptor_api_17a7876430d97ebd)
+	proto.RegisterFile("github.com/micro/go-micro/api/proto/api.proto", fileDescriptor_7b6696ef87ec1943)
 }
 
-var fileDescriptor_api_17a7876430d97ebd = []byte{
-	// 410 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x53, 0xc1, 0x6e, 0xd4, 0x30,
-	0x10, 0x55, 0xe2, 0x24, 0x6d, 0x66, 0x11, 0x42, 0x3e, 0x20, 0x53, 0x2a, 0xb4, 0xca, 0x85, 0x15,
-	0x52, 0x13, 0x68, 0x39, 0x20, 0xae, 0xb0, 0x2a, 0xc7, 0xca, 0x7f, 0xe0, 0x6d, 0xac, 0xc4, 0x62,
-	0x13, 0x9b, 0xd8, 0xa9, 0xb4, 0x1f, 0xc7, 0x81, 0xcf, 0xe0, 0x6f, 0x90, 0x27, 0xde, 0xdd, 0xb2,
-	0x5a, 0x2e, 0x74, 0x6f, 0x2f, 0xf6, 0x9b, 0x37, 0x6f, 0xde, 0x38, 0xf0, 0xb6, 0x51, 0xae, 0x1d,
-	0x57, 0xe5, 0xbd, 0xee, 0xaa, 0x4e, 0xdd, 0x0f, 0xba, 0x6a, 0xf4, 0x95, 0x30, 0xaa, 0x32, 0x83,
-	0x76, 0xba, 0x12, 0x46, 0x95, 0x88, 0x68, 0xd6, 0xe8, 0x52, 0x18, 0x55, 0xbc, 0x87, 0xe4, 0x4e,
-	0xa8, 0x81, 0xbe, 0x00, 0xf2, 0x5d, 0x6e, 0x58, 0x34, 0x8f, 0x16, 0x39, 0xf7, 0x90, 0xbe, 0x84,
-	0xec, 0x41, 0xac, 0x47, 0x69, 0x59, 0x3c, 0x27, 0x8b, 0x9c, 0x87, 0xaf, 0xe2, 0x17, 0x81, 0x33,
-	0x2e, 0x7f, 0x8c, 0xd2, 0x3a, 0xcf, 0xe9, 0xa4, 0x6b, 0x75, 0x1d, 0x0a, 0xc3, 0x17, 0xa5, 0x90,
-	0x18, 0xe1, 0x5a, 0x16, 0xe3, 0x29, 0x62, 0x7a, 0x03, 0x59, 0x2b, 0x45, 0x2d, 0x07, 0x46, 0xe6,
-	0x64, 0x31, 0xbb, 0x7e, 0x5d, 0x4e, 0x16, 0xca, 0x20, 0x56, 0x7e, 0xc3, 0xdb, 0x65, 0xef, 0x86,
-	0x0d, 0x0f, 0x54, 0xfa, 0x0e, 0x48, 0x23, 0x1d, 0x4b, 0xb0, 0x82, 0x1d, 0x56, 0xdc, 0x4a, 0x37,
-	0xd1, 0x3d, 0x89, 0x5e, 0x41, 0x62, 0xb4, 0x75, 0x2c, 0x45, 0xf2, 0xab, 0x43, 0xf2, 0x9d, 0xb6,
-	0x81, 0x8d, 0x34, 0xef, 0x71, 0xa5, 0xeb, 0x0d, 0xcb, 0x26, 0x8f, 0x1e, 0xfb, 0x14, 0xc6, 0x61,
-	0xcd, 0xce, 0xa6, 0x14, 0xc6, 0x61, 0x7d, 0x71, 0x0b, 0xb3, 0x47, 0xbe, 0x8e, 0xc4, 0x54, 0x40,
-	0x8a, 0xc1, 0xe0, 0xac, 0xb3, 0xeb, 0x67, 0xdb, 0xb6, 0x3e, 0x55, 0x3e, 0x5d, 0x7d, 0x8e, 0x3f,
-	0x45, 0x17, 0x5f, 0xe1, 0x7c, 0x6b, 0xf7, 0x09, 0x2a, 0x4b, 0xc8, 0x77, 0x73, 0xfc, 0xbf, 0x4c,
-	0xf1, 0x33, 0x82, 0x73, 0x2e, 0xad, 0xd1, 0xbd, 0x95, 0xf4, 0x0d, 0x80, 0x75, 0xc2, 0x8d, 0xf6,
-	0x8b, 0xae, 0x25, 0xaa, 0xa5, 0xfc, 0xd1, 0x09, 0xfd, 0xb8, 0x5b, 0x5c, 0x8c, 0xc9, 0x5e, 0xee,
-	0x93, 0x9d, 0x14, 0x8e, 0x6e, 0x6e, 0x1b, 0x2f, 0xd9, 0xc7, 0x7b, 0xb2, 0x30, 0x8b, 0xdf, 0x11,
-	0xa4, 0xcb, 0x07, 0xd9, 0xe3, 0x16, 0x7b, 0xd1, 0xc9, 0x20, 0x82, 0x98, 0x3e, 0x87, 0x58, 0xd5,
-	0xe1, 0xed, 0xc5, 0xaa, 0xa6, 0x97, 0x90, 0x3b, 0xd5, 0x49, 0xeb, 0x44, 0x67, 0xd0, 0x0f, 0xe1,
-	0xfb, 0x03, 0xfa, 0x61, 0x37, 0x5e, 0xf2, 0xf7, 0xc3, 0xc1, 0x06, 0xff, 0x9a, 0xad, 0x16, 0x4e,
-	0xb0, 0x74, 0x6a, 0xea, 0xf1, 0xc9, 0x66, 0x5b, 0x65, 0xf8, 0x83, 0xde, 0xfc, 0x09, 0x00, 0x00,
-	0xff, 0xff, 0x7a, 0xb4, 0xd4, 0x8f, 0xcb, 0x03, 0x00, 0x00,
+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,23 +1,13 @@
 // Code generated by protoc-gen-micro. DO NOT EDIT.
 // source: github.com/micro/go-micro/api/proto/api.proto
 
-/*
-Package go_api is a generated protocol buffer package.
-
-It is generated from these files:
-	github.com/micro/go-micro/api/proto/api.proto
-
-It has these top-level messages:
-	Pair
-	Request
-	Response
-	Event
-*/
 package go_api
 
-import proto "github.com/golang/protobuf/proto"
-import fmt "fmt"
-import math "math"
+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
@@ -28,4 +18,4 @@ var _ = math.Inf
 // 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.ProtoPackageIsVersion2 // please upgrade the proto package
+const _ = proto.ProtoPackageIsVersion3 // please upgrade the proto package

api/router/options.go

@@ -3,7 +3,6 @@ package router
 import (
 	"github.com/micro/go-micro/api/resolver"
 	"github.com/micro/go-micro/api/resolver/micro"
-	"github.com/micro/go-micro/config/cmd"
 	"github.com/micro/go-micro/registry"
 )
 
@@ -19,7 +18,7 @@ type Option func(o *Options)
 func NewOptions(opts ...Option) Options {
 	options := Options{
 		Handler:  "meta",
-		Registry: *cmd.DefaultOptions().Registry,
+		Registry: registry.DefaultRegistry,
 	}
 
 	for _, o := range opts {

api/server/acme/certmagic/storage.go

@@ -81,8 +81,7 @@ func (s *storage) Delete(key string) error {
 }
 
 func (s *storage) Exists(key string) bool {
-	_, err := s.store.Read(key)
-	if err != nil {
+	if _, err := s.store.Read(key); err != nil {
 		return false
 	}
 	return true
@@ -93,6 +92,8 @@ func (s *storage) List(prefix string, recursive bool) ([]string, error) {
 	if err != nil {
 		return nil, err
 	}
+
+	//nolint:prealloc
 	var results []string
 	for _, r := range records {
 		if strings.HasPrefix(r.Key, prefix) {

auth/auth.go

@@ -0,0 +1,40 @@
+// Package auth provides authentication and authorization capability
+package auth
+
+import (
+	"time"
+)
+
+// Auth providers authentication and authorization
+type Auth interface {
+	// Generate a new auth token
+	Generate(string) (*Token, error)
+	// Revoke an authorization token
+	Revoke(*Token) error
+	// Grant access to a resource
+	Grant(*Token, *Service) error
+	// Verify a token can access a resource
+	Verify(*Token, *Service) error
+}
+
+// Service is some thing to provide access to
+type Service struct {
+	// Name of the resource
+	Name string
+	// Endpoint is the specific endpoint
+	Endpoint string
+}
+
+// Token providers by an auth provider
+type Token struct {
+	// Unique token id
+	Id string `json: "id"`
+	// Time of token creation
+	Created time.Time `json:"created"`
+	// Time of token expiry
+	Expiry time.Time `json:"expiry"`
+	// Roles associated with the token
+	Roles []string `json:"roles"`
+	// Any other associated metadata
+	Metadata map[string]string `json:"metadata"`
+}

broker/broker.go

@@ -38,13 +38,9 @@ type Subscriber interface {
 }
 
 var (
-	DefaultBroker Broker = newHttpBroker()
+	DefaultBroker Broker = NewBroker()
 )
 
-func NewBroker(opts ...Option) Broker {
-	return newHttpBroker(opts...)
-}
-
 func Init(opts ...Option) error {
 	return DefaultBroker.Init(opts...)
 }

broker/default.go

@@ -0,0 +1,459 @@
+package broker
+
+import (
+	"context"
+	"errors"
+	"net"
+	"net/url"
+	"strconv"
+	"strings"
+	"sync"
+	"time"
+
+	"github.com/micro/go-micro/codec/json"
+	"github.com/micro/go-micro/registry"
+	"github.com/micro/go-micro/util/addr"
+	"github.com/micro/go-micro/util/log"
+	"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.Log(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 <-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
+		n.connected = true
+	}
+
+	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.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
+		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()
+		return <-n.closeCh
+	}
+
+	// close the client connection
+	n.conn.Close()
+
+	// shutdown the local server
+	// and deregister
+	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) 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,
+	}
+	n.setOption(opts...)
+
+	return n
+}

broker/http/http.go

@@ -1,11 +0,0 @@
-// Package http provides a http based message broker
-package http
-
-import (
-	"github.com/micro/go-micro/broker"
-)
-
-// NewBroker returns a new http broker
-func NewBroker(opts ...broker.Option) broker.Broker {
-	return broker.NewBroker(opts...)
-}

broker/http/options.go

@@ -1,23 +0,0 @@
-package http
-
-import (
-	"context"
-	"net/http"
-
-	"github.com/micro/go-micro/broker"
-)
-
-// Handle registers the handler for the given pattern.
-func Handle(pattern string, handler http.Handler) broker.Option {
-	return func(o *broker.Options) {
-		if o.Context == nil {
-			o.Context = context.Background()
-		}
-		handlers, ok := o.Context.Value("http_handlers").(map[string]http.Handler)
-		if !ok {
-			handlers = make(map[string]http.Handler)
-		}
-		handlers[pattern] = handler
-		o.Context = context.WithValue(o.Context, "http_handlers", handlers)
-	}
-}

broker/http_broker.go

@@ -1,704 +0,0 @@
-package broker
-
-import (
-	"bytes"
-	"context"
-	"crypto/tls"
-	"errors"
-	"fmt"
-	"io"
-	"io/ioutil"
-	"math/rand"
-	"net"
-	"net/http"
-	"net/url"
-	"runtime"
-	"sync"
-	"time"
-
-	"github.com/google/uuid"
-	"github.com/micro/go-micro/codec/json"
-	merr "github.com/micro/go-micro/errors"
-	"github.com/micro/go-micro/registry"
-	"github.com/micro/go-micro/registry/cache"
-	maddr "github.com/micro/go-micro/util/addr"
-	mnet "github.com/micro/go-micro/util/net"
-	mls "github.com/micro/go-micro/util/tls"
-	"golang.org/x/net/http2"
-)
-
-// HTTP Broker is a point to point async broker
-type httpBroker struct {
-	id      string
-	address string
-	opts    Options
-
-	mux *http.ServeMux
-
-	c *http.Client
-	r registry.Registry
-
-	sync.RWMutex
-	subscribers map[string][]*httpSubscriber
-	running     bool
-	exit        chan chan error
-
-	// offline message inbox
-	mtx   sync.RWMutex
-	inbox map[string][][]byte
-}
-
-type httpSubscriber struct {
-	opts  SubscribeOptions
-	id    string
-	topic string
-	fn    Handler
-	svc   *registry.Service
-	hb    *httpBroker
-}
-
-type httpEvent struct {
-	m *Message
-	t string
-}
-
-var (
-	DefaultSubPath   = "/_sub"
-	broadcastVersion = "ff.http.broadcast"
-	registerTTL      = time.Minute
-	registerInterval = time.Second * 30
-)
-
-func init() {
-	rand.Seed(time.Now().Unix())
-}
-
-func newTransport(config *tls.Config) *http.Transport {
-	if config == nil {
-		config = &tls.Config{
-			InsecureSkipVerify: true,
-		}
-	}
-
-	dialTLS := func(network string, addr string) (net.Conn, error) {
-		return tls.Dial(network, addr, config)
-	}
-
-	t := &http.Transport{
-		Proxy: http.ProxyFromEnvironment,
-		Dial: (&net.Dialer{
-			Timeout:   30 * time.Second,
-			KeepAlive: 30 * time.Second,
-		}).Dial,
-		TLSHandshakeTimeout: 10 * time.Second,
-		DialTLS:             dialTLS,
-	}
-	runtime.SetFinalizer(&t, func(tr **http.Transport) {
-		(*tr).CloseIdleConnections()
-	})
-
-	// setup http2
-	http2.ConfigureTransport(t)
-
-	return t
-}
-
-func newHttpBroker(opts ...Option) Broker {
-	options := Options{
-		Codec:   json.Marshaler{},
-		Context: context.TODO(),
-	}
-
-	for _, o := range opts {
-		o(&options)
-	}
-
-	// set address
-	addr := ":0"
-	if len(options.Addrs) > 0 && len(options.Addrs[0]) > 0 {
-		addr = options.Addrs[0]
-	}
-
-	// get registry
-	reg, ok := options.Context.Value(registryKey).(registry.Registry)
-	if !ok {
-		reg = registry.DefaultRegistry
-	}
-
-	h := &httpBroker{
-		id:          "broker-" + uuid.New().String(),
-		address:     addr,
-		opts:        options,
-		r:           reg,
-		c:           &http.Client{Transport: newTransport(options.TLSConfig)},
-		subscribers: make(map[string][]*httpSubscriber),
-		exit:        make(chan chan error),
-		mux:         http.NewServeMux(),
-		inbox:       make(map[string][][]byte),
-	}
-
-	// specify the message handler
-	h.mux.Handle(DefaultSubPath, h)
-
-	// get optional handlers
-	if h.opts.Context != nil {
-		handlers, ok := h.opts.Context.Value("http_handlers").(map[string]http.Handler)
-		if ok {
-			for pattern, handler := range handlers {
-				h.mux.Handle(pattern, handler)
-			}
-		}
-	}
-
-	return h
-}
-
-func (h *httpEvent) Ack() error {
-	return nil
-}
-
-func (h *httpEvent) Message() *Message {
-	return h.m
-}
-
-func (h *httpEvent) Topic() string {
-	return h.t
-}
-
-func (h *httpSubscriber) Options() SubscribeOptions {
-	return h.opts
-}
-
-func (h *httpSubscriber) Topic() string {
-	return h.topic
-}
-
-func (h *httpSubscriber) Unsubscribe() error {
-	return h.hb.unsubscribe(h)
-}
-
-func (h *httpBroker) saveMessage(topic string, msg []byte) {
-	h.mtx.Lock()
-	defer h.mtx.Unlock()
-
-	// get messages
-	c := h.inbox[topic]
-
-	// save message
-	c = append(c, msg)
-
-	// max length 64
-	if len(c) > 64 {
-		c = c[:64]
-	}
-
-	// save inbox
-	h.inbox[topic] = c
-}
-
-func (h *httpBroker) getMessage(topic string, num int) [][]byte {
-	h.mtx.Lock()
-	defer h.mtx.Unlock()
-
-	// get messages
-	c, ok := h.inbox[topic]
-	if !ok {
-		return nil
-	}
-
-	// more message than requests
-	if len(c) >= num {
-		msg := c[:num]
-		h.inbox[topic] = c[num:]
-		return msg
-	}
-
-	// reset inbox
-	h.inbox[topic] = nil
-
-	// return all messages
-	return c
-}
-
-func (h *httpBroker) subscribe(s *httpSubscriber) error {
-	h.Lock()
-	defer h.Unlock()
-
-	if err := h.r.Register(s.svc, registry.RegisterTTL(registerTTL)); err != nil {
-		return err
-	}
-
-	h.subscribers[s.topic] = append(h.subscribers[s.topic], s)
-	return nil
-}
-
-func (h *httpBroker) unsubscribe(s *httpSubscriber) error {
-	h.Lock()
-	defer h.Unlock()
-
-	var subscribers []*httpSubscriber
-
-	// look for subscriber
-	for _, sub := range h.subscribers[s.topic] {
-		// deregister and skip forward
-		if sub.id == s.id {
-			_ = h.r.Deregister(sub.svc)
-			continue
-		}
-		// keep subscriber
-		subscribers = append(subscribers, sub)
-	}
-
-	// set subscribers
-	h.subscribers[s.topic] = subscribers
-
-	return nil
-}
-
-func (h *httpBroker) run(l net.Listener) {
-	t := time.NewTicker(registerInterval)
-	defer t.Stop()
-
-	for {
-		select {
-		// heartbeat for each subscriber
-		case <-t.C:
-			h.RLock()
-			for _, subs := range h.subscribers {
-				for _, sub := range subs {
-					_ = h.r.Register(sub.svc, registry.RegisterTTL(registerTTL))
-				}
-			}
-			h.RUnlock()
-		// received exit signal
-		case ch := <-h.exit:
-			ch <- l.Close()
-			h.RLock()
-			for _, subs := range h.subscribers {
-				for _, sub := range subs {
-					_ = h.r.Deregister(sub.svc)
-				}
-			}
-			h.RUnlock()
-			return
-		}
-	}
-}
-
-func (h *httpBroker) ServeHTTP(w http.ResponseWriter, req *http.Request) {
-	if req.Method != "POST" {
-		err := merr.BadRequest("go.micro.broker", "Method not allowed")
-		http.Error(w, err.Error(), http.StatusMethodNotAllowed)
-		return
-	}
-	defer req.Body.Close()
-
-	req.ParseForm()
-
-	b, err := ioutil.ReadAll(req.Body)
-	if err != nil {
-		errr := merr.InternalServerError("go.micro.broker", "Error reading request body: %v", err)
-		w.WriteHeader(500)
-		w.Write([]byte(errr.Error()))
-		return
-	}
-
-	var m *Message
-	if err = h.opts.Codec.Unmarshal(b, &m); err != nil {
-		errr := merr.InternalServerError("go.micro.broker", "Error parsing request body: %v", err)
-		w.WriteHeader(500)
-		w.Write([]byte(errr.Error()))
-		return
-	}
-
-	topic := m.Header[":topic"]
-	delete(m.Header, ":topic")
-
-	if len(topic) == 0 {
-		errr := merr.InternalServerError("go.micro.broker", "Topic not found")
-		w.WriteHeader(500)
-		w.Write([]byte(errr.Error()))
-		return
-	}
-
-	p := &httpEvent{m: m, t: topic}
-	id := req.Form.Get("id")
-
-	var subs []Handler
-
-	h.RLock()
-	for _, subscriber := range h.subscribers[topic] {
-		if id != subscriber.id {
-			continue
-		}
-		subs = append(subs, subscriber.fn)
-	}
-	h.RUnlock()
-
-	// execute the handler
-	for _, fn := range subs {
-		fn(p)
-	}
-}
-
-func (h *httpBroker) Address() string {
-	h.RLock()
-	defer h.RUnlock()
-	return h.address
-}
-
-func (h *httpBroker) Connect() error {
-	h.RLock()
-	if h.running {
-		h.RUnlock()
-		return nil
-	}
-	h.RUnlock()
-
-	h.Lock()
-	defer h.Unlock()
-
-	var l net.Listener
-	var err error
-
-	if h.opts.Secure || h.opts.TLSConfig != nil {
-		config := h.opts.TLSConfig
-
-		fn := func(addr string) (net.Listener, error) {
-			if config == nil {
-				hosts := []string{addr}
-
-				// check if its a valid host:port
-				if host, _, err := net.SplitHostPort(addr); err == nil {
-					if len(host) == 0 {
-						hosts = maddr.IPs()
-					} else {
-						hosts = []string{host}
-					}
-				}
-
-				// generate a certificate
-				cert, err := mls.Certificate(hosts...)
-				if err != nil {
-					return nil, err
-				}
-				config = &tls.Config{Certificates: []tls.Certificate{cert}}
-			}
-			return tls.Listen("tcp", addr, config)
-		}
-
-		l, err = mnet.Listen(h.address, fn)
-	} else {
-		fn := func(addr string) (net.Listener, error) {
-			return net.Listen("tcp", addr)
-		}
-
-		l, err = mnet.Listen(h.address, fn)
-	}
-
-	if err != nil {
-		return err
-	}
-
-	addr := h.address
-	h.address = l.Addr().String()
-
-	go http.Serve(l, h.mux)
-	go func() {
-		h.run(l)
-		h.Lock()
-		h.opts.Addrs = []string{addr}
-		h.address = addr
-		h.Unlock()
-	}()
-
-	// get registry
-	reg, ok := h.opts.Context.Value(registryKey).(registry.Registry)
-	if !ok {
-		reg = registry.DefaultRegistry
-	}
-	// set cache
-	h.r = cache.New(reg)
-
-	// set running
-	h.running = true
-	return nil
-}
-
-func (h *httpBroker) Disconnect() error {
-	h.RLock()
-	if !h.running {
-		h.RUnlock()
-		return nil
-	}
-	h.RUnlock()
-
-	h.Lock()
-	defer h.Unlock()
-
-	// stop cache
-	rc, ok := h.r.(cache.Cache)
-	if ok {
-		rc.Stop()
-	}
-
-	// exit and return err
-	ch := make(chan error)
-	h.exit <- ch
-	err := <-ch
-
-	// set not running
-	h.running = false
-	return err
-}
-
-func (h *httpBroker) Init(opts ...Option) error {
-	h.RLock()
-	if h.running {
-		h.RUnlock()
-		return errors.New("cannot init while connected")
-	}
-	h.RUnlock()
-
-	h.Lock()
-	defer h.Unlock()
-
-	for _, o := range opts {
-		o(&h.opts)
-	}
-
-	if len(h.opts.Addrs) > 0 && len(h.opts.Addrs[0]) > 0 {
-		h.address = h.opts.Addrs[0]
-	}
-
-	if len(h.id) == 0 {
-		h.id = "broker-" + uuid.New().String()
-	}
-
-	// get registry
-	reg, ok := h.opts.Context.Value(registryKey).(registry.Registry)
-	if !ok {
-		reg = registry.DefaultRegistry
-	}
-
-	// get cache
-	if rc, ok := h.r.(cache.Cache); ok {
-		rc.Stop()
-	}
-
-	// set registry
-	h.r = cache.New(reg)
-
-	// reconfigure tls config
-	if c := h.opts.TLSConfig; c != nil {
-		h.c = &http.Client{
-			Transport: newTransport(c),
-		}
-	}
-
-	return nil
-}
-
-func (h *httpBroker) Options() Options {
-	return h.opts
-}
-
-func (h *httpBroker) Publish(topic string, msg *Message, opts ...PublishOption) error {
-	// create the message first
-	m := &Message{
-		Header: make(map[string]string),
-		Body:   msg.Body,
-	}
-
-	for k, v := range msg.Header {
-		m.Header[k] = v
-	}
-
-	m.Header[":topic"] = topic
-
-	// encode the message
-	b, err := h.opts.Codec.Marshal(m)
-	if err != nil {
-		return err
-	}
-
-	// save the message
-	h.saveMessage(topic, b)
-
-	// now attempt to get the service
-	h.RLock()
-	s, err := h.r.GetService(topic)
-	if err != nil {
-		h.RUnlock()
-		// ignore error
-		return nil
-	}
-	h.RUnlock()
-
-	pub := func(node *registry.Node, t string, b []byte) error {
-		scheme := "http"
-
-		// check if secure is added in metadata
-		if node.Metadata["secure"] == "true" {
-			scheme = "https"
-		}
-
-		vals := url.Values{}
-		vals.Add("id", node.Id)
-
-		uri := fmt.Sprintf("%s://%s%s?%s", scheme, node.Address, DefaultSubPath, vals.Encode())
-		r, err := h.c.Post(uri, "application/json", bytes.NewReader(b))
-		if err != nil {
-			return err
-		}
-
-		// discard response body
-		io.Copy(ioutil.Discard, r.Body)
-		r.Body.Close()
-		return nil
-	}
-
-	srv := func(s []*registry.Service, b []byte) {
-		for _, service := range s {
-			var nodes []*registry.Node
-
-			for _, node := range service.Nodes {
-				// only use nodes tagged with broker http
-				if node.Metadata["broker"] != "http" {
-					continue
-				}
-
-				// look for nodes for the topic
-				if node.Metadata["topic"] != topic {
-					continue
-				}
-
-				nodes = append(nodes, node)
-			}
-
-			// only process if we have nodes
-			if len(nodes) == 0 {
-				continue
-			}
-
-			switch service.Version {
-			// broadcast version means broadcast to all nodes
-			case broadcastVersion:
-				var success bool
-
-				// publish to all nodes
-				for _, node := range nodes {
-					// publish async
-					if err := pub(node, topic, b); err == nil {
-						success = true
-					}
-				}
-
-				// save if it failed to publish at least once
-				if !success {
-					h.saveMessage(topic, b)
-				}
-			default:
-				// select node to publish to
-				node := nodes[rand.Int()%len(nodes)]
-
-				// publish async to one node
-				if err := pub(node, topic, b); err != nil {
-					// if failed save it
-					h.saveMessage(topic, b)
-				}
-			}
-		}
-	}
-
-	// do the rest async
-	go func() {
-		// get a third of the backlog
-		messages := h.getMessage(topic, 8)
-		delay := (len(messages) > 1)
-
-		// publish all the messages
-		for _, msg := range messages {
-			// serialize here
-			srv(s, msg)
-
-			// sending a backlog of messages
-			if delay {
-				time.Sleep(time.Millisecond * 100)
-			}
-		}
-	}()
-
-	return nil
-}
-
-func (h *httpBroker) Subscribe(topic string, handler Handler, opts ...SubscribeOption) (Subscriber, error) {
-	var err error
-	var host, port string
-	options := NewSubscribeOptions(opts...)
-
-	// parse address for host, port
-	host, port, err = net.SplitHostPort(h.Address())
-	if err != nil {
-		return nil, err
-	}
-
-	addr, err := maddr.Extract(host)
-	if err != nil {
-		return nil, err
-	}
-
-	// create unique id
-	id := h.id + "." + uuid.New().String()
-
-	var secure bool
-
-	if h.opts.Secure || h.opts.TLSConfig != nil {
-		secure = true
-	}
-
-	// register service
-	node := &registry.Node{
-		Id:      id,
-		Address: mnet.HostPort(addr, port),
-		Metadata: map[string]string{
-			"secure": fmt.Sprintf("%t", secure),
-			"broker": "http",
-			"topic":  topic,
-		},
-	}
-
-	// check for queue group or broadcast queue
-	version := options.Queue
-	if len(version) == 0 {
-		version = broadcastVersion
-	}
-
-	service := &registry.Service{
-		Name:    topic,
-		Version: version,
-		Nodes:   []*registry.Node{node},
-	}
-
-	// generate subscriber
-	subscriber := &httpSubscriber{
-		opts:  options,
-		hb:    h,
-		id:    id,
-		topic: topic,
-		fn:    handler,
-		svc:   service,
-	}
-
-	// subscribe now
-	if err := h.subscribe(subscriber); err != nil {
-		return nil, err
-	}
-
-	// return the subscriber
-	return subscriber, nil
-}
-
-func (h *httpBroker) String() string {
-	return "http"
-}

broker/http_broker_test.go

@@ -1,351 +0,0 @@
-package broker
-
-import (
-	"sync"
-	"testing"
-	"time"
-
-	glog "github.com/go-log/log"
-	"github.com/google/uuid"
-	"github.com/micro/go-micro/registry/memory"
-	"github.com/micro/go-micro/util/log"
-)
-
-func newTestRegistry() *memory.Registry {
-	r := memory.NewRegistry()
-	m := r.(*memory.Registry)
-	m.Services = testData
-	return m
-}
-
-func sub(be *testing.B, c int) {
-	// set no op logger
-	log.SetLogger(glog.DefaultLogger)
-
-	be.StopTimer()
-	m := newTestRegistry()
-
-	b := NewBroker(Registry(m))
-	topic := uuid.New().String()
-
-	if err := b.Init(); err != nil {
-		be.Fatalf("Unexpected init error: %v", err)
-	}
-
-	if err := b.Connect(); err != nil {
-		be.Fatalf("Unexpected connect error: %v", err)
-	}
-
-	msg := &Message{
-		Header: map[string]string{
-			"Content-Type": "application/json",
-		},
-		Body: []byte(`{"message": "Hello World"}`),
-	}
-
-	var subs []Subscriber
-	done := make(chan bool, c)
-
-	for i := 0; i < c; i++ {
-		sub, err := b.Subscribe(topic, func(p Event) error {
-			done <- true
-			m := p.Message()
-
-			if string(m.Body) != string(msg.Body) {
-				be.Fatalf("Unexpected msg %s, expected %s", string(m.Body), string(msg.Body))
-			}
-
-			return nil
-		}, Queue("shared"))
-		if err != nil {
-			be.Fatalf("Unexpected subscribe error: %v", err)
-		}
-		subs = append(subs, sub)
-	}
-
-	for i := 0; i < be.N; i++ {
-		be.StartTimer()
-		if err := b.Publish(topic, msg); err != nil {
-			be.Fatalf("Unexpected publish error: %v", err)
-		}
-		<-done
-		be.StopTimer()
-	}
-
-	for _, sub := range subs {
-		sub.Unsubscribe()
-	}
-
-	if err := b.Disconnect(); err != nil {
-		be.Fatalf("Unexpected disconnect error: %v", err)
-	}
-}
-
-func pub(be *testing.B, c int) {
-	// set no op logger
-	log.SetLogger(glog.DefaultLogger)
-
-	be.StopTimer()
-	m := newTestRegistry()
-	b := NewBroker(Registry(m))
-	topic := uuid.New().String()
-
-	if err := b.Init(); err != nil {
-		be.Fatalf("Unexpected init error: %v", err)
-	}
-
-	if err := b.Connect(); err != nil {
-		be.Fatalf("Unexpected connect error: %v", err)
-	}
-
-	msg := &Message{
-		Header: map[string]string{
-			"Content-Type": "application/json",
-		},
-		Body: []byte(`{"message": "Hello World"}`),
-	}
-
-	done := make(chan bool, c*4)
-
-	sub, err := b.Subscribe(topic, func(p Event) error {
-		done <- true
-		m := p.Message()
-		if string(m.Body) != string(msg.Body) {
-			be.Fatalf("Unexpected msg %s, expected %s", string(m.Body), string(msg.Body))
-		}
-		return nil
-	}, Queue("shared"))
-	if err != nil {
-		be.Fatalf("Unexpected subscribe error: %v", err)
-	}
-
-	var wg sync.WaitGroup
-	ch := make(chan int, c*4)
-	be.StartTimer()
-
-	for i := 0; i < c; i++ {
-		go func() {
-			for range ch {
-				if err := b.Publish(topic, msg); err != nil {
-					be.Fatalf("Unexpected publish error: %v", err)
-				}
-				select {
-				case <-done:
-				case <-time.After(time.Second):
-				}
-				wg.Done()
-			}
-		}()
-	}
-
-	for i := 0; i < be.N; i++ {
-		wg.Add(1)
-		ch <- i
-	}
-
-	wg.Wait()
-	be.StopTimer()
-	sub.Unsubscribe()
-	close(ch)
-	close(done)
-
-	if err := b.Disconnect(); err != nil {
-		be.Fatalf("Unexpected disconnect error: %v", err)
-	}
-}
-
-func TestBroker(t *testing.T) {
-	m := newTestRegistry()
-	b := NewBroker(Registry(m))
-
-	if err := b.Init(); err != nil {
-		t.Fatalf("Unexpected init error: %v", err)
-	}
-
-	if err := b.Connect(); err != nil {
-		t.Fatalf("Unexpected connect error: %v", err)
-	}
-
-	msg := &Message{
-		Header: map[string]string{
-			"Content-Type": "application/json",
-		},
-		Body: []byte(`{"message": "Hello World"}`),
-	}
-
-	done := make(chan bool)
-
-	sub, err := b.Subscribe("test", func(p Event) error {
-		m := p.Message()
-
-		if string(m.Body) != string(msg.Body) {
-			t.Fatalf("Unexpected msg %s, expected %s", string(m.Body), string(msg.Body))
-		}
-
-		close(done)
-		return nil
-	})
-	if err != nil {
-		t.Fatalf("Unexpected subscribe error: %v", err)
-	}
-
-	if err := b.Publish("test", msg); err != nil {
-		t.Fatalf("Unexpected publish error: %v", err)
-	}
-
-	<-done
-	sub.Unsubscribe()
-
-	if err := b.Disconnect(); err != nil {
-		t.Fatalf("Unexpected disconnect error: %v", err)
-	}
-}
-
-func TestConcurrentSubBroker(t *testing.T) {
-	m := newTestRegistry()
-	b := NewBroker(Registry(m))
-
-	if err := b.Init(); err != nil {
-		t.Fatalf("Unexpected init error: %v", err)
-	}
-
-	if err := b.Connect(); err != nil {
-		t.Fatalf("Unexpected connect error: %v", err)
-	}
-
-	msg := &Message{
-		Header: map[string]string{
-			"Content-Type": "application/json",
-		},
-		Body: []byte(`{"message": "Hello World"}`),
-	}
-
-	var subs []Subscriber
-	var wg sync.WaitGroup
-
-	for i := 0; i < 10; i++ {
-		sub, err := b.Subscribe("test", func(p Event) error {
-			defer wg.Done()
-
-			m := p.Message()
-
-			if string(m.Body) != string(msg.Body) {
-				t.Fatalf("Unexpected msg %s, expected %s", string(m.Body), string(msg.Body))
-			}
-
-			return nil
-		})
-		if err != nil {
-			t.Fatalf("Unexpected subscribe error: %v", err)
-		}
-
-		wg.Add(1)
-		subs = append(subs, sub)
-	}
-
-	if err := b.Publish("test", msg); err != nil {
-		t.Fatalf("Unexpected publish error: %v", err)
-	}
-
-	wg.Wait()
-
-	for _, sub := range subs {
-		sub.Unsubscribe()
-	}
-
-	if err := b.Disconnect(); err != nil {
-		t.Fatalf("Unexpected disconnect error: %v", err)
-	}
-}
-
-func TestConcurrentPubBroker(t *testing.T) {
-	m := newTestRegistry()
-	b := NewBroker(Registry(m))
-
-	if err := b.Init(); err != nil {
-		t.Fatalf("Unexpected init error: %v", err)
-	}
-
-	if err := b.Connect(); err != nil {
-		t.Fatalf("Unexpected connect error: %v", err)
-	}
-
-	msg := &Message{
-		Header: map[string]string{
-			"Content-Type": "application/json",
-		},
-		Body: []byte(`{"message": "Hello World"}`),
-	}
-
-	var wg sync.WaitGroup
-
-	sub, err := b.Subscribe("test", func(p Event) error {
-		defer wg.Done()
-
-		m := p.Message()
-
-		if string(m.Body) != string(msg.Body) {
-			t.Fatalf("Unexpected msg %s, expected %s", string(m.Body), string(msg.Body))
-		}
-
-		return nil
-	})
-	if err != nil {
-		t.Fatalf("Unexpected subscribe error: %v", err)
-	}
-
-	for i := 0; i < 10; i++ {
-		wg.Add(1)
-
-		if err := b.Publish("test", msg); err != nil {
-			t.Fatalf("Unexpected publish error: %v", err)
-		}
-	}
-
-	wg.Wait()
-
-	sub.Unsubscribe()
-
-	if err := b.Disconnect(); err != nil {
-		t.Fatalf("Unexpected disconnect error: %v", err)
-	}
-}
-
-func BenchmarkSub1(b *testing.B) {
-	sub(b, 1)
-}
-func BenchmarkSub8(b *testing.B) {
-	sub(b, 8)
-}
-
-func BenchmarkSub32(b *testing.B) {
-	sub(b, 32)
-}
-
-func BenchmarkSub64(b *testing.B) {
-	sub(b, 64)
-}
-
-func BenchmarkSub128(b *testing.B) {
-	sub(b, 128)
-}
-
-func BenchmarkPub1(b *testing.B) {
-	pub(b, 1)
-}
-
-func BenchmarkPub8(b *testing.B) {
-	pub(b, 8)
-}
-
-func BenchmarkPub32(b *testing.B) {
-	pub(b, 32)
-}
-
-func BenchmarkPub64(b *testing.B) {
-	pub(b, 64)
-}
-
-func BenchmarkPub128(b *testing.B) {
-	pub(b, 128)
-}

broker/nats/nats.go

@@ -4,23 +4,44 @@ package nats
 import (
 	"context"
 	"errors"
+	"net"
+	"net/url"
+	"strconv"
 	"strings"
 	"sync"
+	"time"
 
 	"github.com/micro/go-micro/broker"
 	"github.com/micro/go-micro/codec/json"
+	"github.com/micro/go-micro/registry"
+	"github.com/micro/go-micro/util/addr"
+	"github.com/micro/go-micro/util/log"
+	"github.com/nats-io/nats-server/v2/server"
 	nats "github.com/nats-io/nats.go"
 )
 
 type natsBroker struct {
 	sync.Once
 	sync.RWMutex
-	addrs   []string
-	conn    *nats.Conn
-	opts    broker.Options
-	nopts   nats.Options
+
+	// indicate if we're connected
+	connected bool
+
+	addrs []string
+	conn  *nats.Conn
+	opts  broker.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 {
@@ -62,6 +83,7 @@ func (n *natsBroker) Address() string {
 	if n.conn != nil && n.conn.IsConnected() {
 		return n.conn.ConnectedUrl()
 	}
+
 	if len(n.addrs) > 0 {
 		return n.addrs[0]
 	}
@@ -69,7 +91,8 @@ func (n *natsBroker) Address() string {
 	return ""
 }
 
-func setAddrs(addrs []string) []string {
+func (n *natsBroker) setAddrs(addrs []string) []string {
+	//nolint:prealloc
 	var cAddrs []string
 	for _, addr := range addrs {
 		if len(addr) == 0 {
@@ -80,16 +103,186 @@ func setAddrs(addrs []string) []string {
 		}
 		cAddrs = append(cAddrs, addr)
 	}
-	if len(cAddrs) == 0 {
+	// 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 {
+	var host string
+	var port int
+	var local bool
+
+	// with no address we just default it
+	// this is a local client address
+	if len(n.addrs) == 0 {
+		// find an advertiseable ip
+		if h, err := addr.Extract(""); err != nil {
+			host = "127.0.0.1"
+		} else {
+			host = h
+		}
+
+		port = -1
+		local = true
+	} else {
+		address := n.addrs[0]
+		if strings.HasPrefix(address, "nats://") {
+			address = strings.TrimPrefix(address, "nats://")
+		}
+
+		// check if its a local address and only then embed
+		if addr.IsLocal(address) {
+			h, p, err := net.SplitHostPort(address)
+			if err == nil {
+				host = h
+				port, _ = strconv.Atoi(p)
+				local = true
+			}
+		}
+	}
+
+	// we only setup a server for local things
+	if !local {
+		return nil
+	}
+
+	// 1. create new server
+	// 2. register the server
+	// 3. connect to other servers
+	var cOpts server.ClusterOpts
+	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.Log(err)
+					continue
+				}
+				// append to the cluster routes
+				routes = append(routes, u)
+			}
+		}
+	}
+
+	// try get existing server
+	s := n.server
+
+	// get a host address
+	caddr, err := addr.Extract("")
+	if err != nil {
+		caddr = "0.0.0.0"
+	}
+
+	// set cluster opts
+	cOpts = server.ClusterOpts{
+		Host: caddr,
+		Port: -1,
+	}
+
+	if s == nil {
+		var err error
+		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.addrs = []string{s.ClientURL()}
+
+	go func() {
+		// register the cluster address
+		for {
+			select {
+			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: s.ClusterAddr().String()},
+					},
+				})
+				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: s.ClusterAddr().String()},
+					},
+				}, 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 embedded server if asked to
+		if n.local {
+			if err := n.serve(n.exit); err != nil {
+				return err
+			}
+		}
+
+		// set to connected
+		n.connected = true
+	}
+
 	status := nats.CLOSED
 	if n.conn != nil {
 		status = n.conn.Status()
@@ -121,11 +314,29 @@ func (n *natsBroker) Connect() error {
 func (n *natsBroker) Disconnect() error {
 	n.RLock()
 	defer n.RUnlock()
+
+	// drain the connection if specified
 	if n.drain {
 		n.conn.Drain()
 		return <-n.closeCh
 	}
+
+	// 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
 }
 
@@ -190,21 +401,6 @@ func (n *natsBroker) String() string {
 	return "nats"
 }
 
-func NewBroker(opts ...broker.Option) broker.Broker {
-	options := broker.Options{
-		// Default codec
-		Codec:   json.Marshaler{},
-		Context: context.Background(),
-	}
-
-	n := &natsBroker{
-		opts: options,
-	}
-	n.setOption(opts...)
-
-	return n
-}
-
 func (n *natsBroker) setOption(opts ...broker.Option) {
 	for _, o := range opts {
 		o(&n.opts)
@@ -218,10 +414,15 @@ func (n *natsBroker) setOption(opts ...broker.Option) {
 		n.nopts = nopts
 	}
 
+	local, ok := n.opts.Context.Value(localServerKey{}).(bool)
+	if ok {
+		n.local = local
+	}
+
 	// broker.Options have higher priority than nats.Options
 	// only if Addrs, Secure or TLSConfig were not set through a broker.Option
 	// we read them from nats.Option
-	if len(n.opts.Addrs) == 0 {
+	if len(n.opts.Addrs) == 0 && !n.local {
 		n.opts.Addrs = n.nopts.Servers
 	}
 
@@ -232,7 +433,7 @@ func (n *natsBroker) setOption(opts ...broker.Option) {
 	if n.opts.TLSConfig == nil {
 		n.opts.TLSConfig = n.nopts.TLSConfig
 	}
-	n.addrs = setAddrs(n.opts.Addrs)
+	n.addrs = n.setAddrs(n.opts.Addrs)
 
 	if n.opts.Context.Value(drainConnectionKey{}) != nil {
 		n.drain = true
@@ -253,3 +454,19 @@ func (n *natsBroker) onAsyncError(conn *nats.Conn, sub *nats.Subscription, err e
 		n.closeCh <- err
 	}
 }
+
+func NewBroker(opts ...broker.Option) broker.Broker {
+	options := broker.Options{
+		// Default codec
+		Codec:    json.Marshaler{},
+		Context:  context.Background(),
+		Registry: registry.DefaultRegistry,
+	}
+
+	n := &natsBroker{
+		opts: options,
+	}
+	n.setOption(opts...)
+
+	return n
+}

broker/nats/nats_test.go

@@ -94,6 +94,5 @@ func TestInitAddrs(t *testing.T) {
 				}
 			}
 		})
-
 	}
 }

broker/nats/options.go

@@ -7,12 +7,18 @@ import (
 
 type optionsKey struct{}
 type drainConnectionKey struct{}
+type localServerKey struct{}
 
 // Options accepts nats.Options
 func Options(opts nats.Options) broker.Option {
 	return setBrokerOption(optionsKey{}, opts)
 }
 
+// LocalServer embeds a local server rather than connecting to one
+func LocalServer() broker.Option {
+	return setBrokerOption(localServerKey{}, true)
+}
+
 // DrainConnection will drain subscription on close
 func DrainConnection() broker.Option {
 	return setBrokerOption(drainConnectionKey{}, struct{}{})

broker/options.go

@@ -13,6 +13,8 @@ type Options struct {
 	Secure    bool
 	Codec     codec.Marshaler
 	TLSConfig *tls.Config
+	// Registry used for clustering
+	Registry registry.Registry
 	// Other options for implementations of the interface
 	// can be stored in a context
 	Context context.Context
@@ -44,10 +46,6 @@ type PublishOption func(*PublishOptions)
 
 type SubscribeOption func(*SubscribeOptions)
 
-var (
-	registryKey = "github.com/micro/go-micro/registry"
-)
-
 func NewSubscribeOptions(opts ...SubscribeOption) SubscribeOptions {
 	opt := SubscribeOptions{
 		AutoAck: true,
@@ -92,7 +90,7 @@ func Queue(name string) SubscribeOption {
 
 func Registry(r registry.Registry) Option {
 	return func(o *Options) {
-		o.Context = context.WithValue(o.Context, registryKey, r)
+		o.Registry = r
 	}
 }
 

broker/service/handler/handler.go

@@ -1,66 +0,0 @@
-package handler
-
-import (
-	"context"
-
-	"github.com/micro/go-micro/broker"
-	pb "github.com/micro/go-micro/broker/service/proto"
-	"github.com/micro/go-micro/errors"
-	"github.com/micro/go-micro/util/log"
-)
-
-type Broker struct {
-	Broker broker.Broker
-}
-
-func (b *Broker) Publish(ctx context.Context, req *pb.PublishRequest, rsp *pb.Empty) error {
-	log.Debugf("Publishing message to %s topic", req.Topic)
-	err := b.Broker.Publish(req.Topic, &broker.Message{
-		Header: req.Message.Header,
-		Body:   req.Message.Body,
-	})
-	log.Debugf("Published message to %s topic", req.Topic)
-	if err != nil {
-		return errors.InternalServerError("go.micro.broker", err.Error())
-	}
-	return nil
-}
-
-func (b *Broker) Subscribe(ctx context.Context, req *pb.SubscribeRequest, stream pb.Broker_SubscribeStream) error {
-	errChan := make(chan error, 1)
-
-	// message handler to stream back messages from broker
-	handler := func(p broker.Event) error {
-		if err := stream.Send(&pb.Message{
-			Header: p.Message().Header,
-			Body:   p.Message().Body,
-		}); err != nil {
-			select {
-			case errChan <- err:
-				return err
-			default:
-				return err
-			}
-		}
-		return nil
-	}
-
-	log.Debugf("Subscribing to %s topic", req.Topic)
-	sub, err := b.Broker.Subscribe(req.Topic, handler, broker.Queue(req.Queue))
-	if err != nil {
-		return errors.InternalServerError("go.micro.broker", err.Error())
-	}
-	defer func() {
-		log.Debugf("Unsubscribing from topic %s", req.Topic)
-		sub.Unsubscribe()
-	}()
-
-	select {
-	case <-ctx.Done():
-		log.Debugf("Context done for subscription to topic %s", req.Topic)
-		return nil
-	case err := <-errChan:
-		log.Debugf("Subscription error for topic %s: %v", req.Topic, err)
-		return err
-	}
-}

broker/service/proto/broker.pb.go

@@ -1,13 +1,11 @@
 // Code generated by protoc-gen-go. DO NOT EDIT.
-// source: github.com/micro/go-micro/broker/proto/broker.proto
+// source: micro/go-micro/broker/service/proto/broker.proto
 
 package go_micro_broker
 
 import (
-	context "context"
 	fmt "fmt"
 	proto "github.com/golang/protobuf/proto"
-	grpc "google.golang.org/grpc"
 	math "math"
 )
 
@@ -32,7 +30,7 @@ func (m *Empty) Reset()         { *m = Empty{} }
 func (m *Empty) String() string { return proto.CompactTextString(m) }
 func (*Empty) ProtoMessage()    {}
 func (*Empty) Descriptor() ([]byte, []int) {
-	return fileDescriptor_5edf81766900dd99, []int{0}
+	return fileDescriptor_178fdc60944ff5e5, []int{0}
 }
 
 func (m *Empty) XXX_Unmarshal(b []byte) error {
@@ -65,7 +63,7 @@ func (m *PublishRequest) Reset()         { *m = PublishRequest{} }
 func (m *PublishRequest) String() string { return proto.CompactTextString(m) }
 func (*PublishRequest) ProtoMessage()    {}
 func (*PublishRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_5edf81766900dd99, []int{1}
+	return fileDescriptor_178fdc60944ff5e5, []int{1}
 }
 
 func (m *PublishRequest) XXX_Unmarshal(b []byte) error {
@@ -112,7 +110,7 @@ func (m *SubscribeRequest) Reset()         { *m = SubscribeRequest{} }
 func (m *SubscribeRequest) String() string { return proto.CompactTextString(m) }
 func (*SubscribeRequest) ProtoMessage()    {}
 func (*SubscribeRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_5edf81766900dd99, []int{2}
+	return fileDescriptor_178fdc60944ff5e5, []int{2}
 }
 
 func (m *SubscribeRequest) XXX_Unmarshal(b []byte) error {
@@ -159,7 +157,7 @@ func (m *Message) Reset()         { *m = Message{} }
 func (m *Message) String() string { return proto.CompactTextString(m) }
 func (*Message) ProtoMessage()    {}
 func (*Message) Descriptor() ([]byte, []int) {
-	return fileDescriptor_5edf81766900dd99, []int{3}
+	return fileDescriptor_178fdc60944ff5e5, []int{3}
 }
 
 func (m *Message) XXX_Unmarshal(b []byte) error {
@@ -203,162 +201,29 @@ func init() {
 }
 
 func init() {
-	proto.RegisterFile("github.com/micro/go-micro/broker/proto/broker.proto", fileDescriptor_5edf81766900dd99)
+	proto.RegisterFile("micro/go-micro/broker/service/proto/broker.proto", fileDescriptor_178fdc60944ff5e5)
 }
 
-var fileDescriptor_5edf81766900dd99 = []byte{
-	// 309 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x7c, 0x91, 0xcf, 0x4a, 0xf3, 0x40,
-	0x14, 0xc5, 0x3b, 0xed, 0xd7, 0x86, 0xde, 0x7e, 0x68, 0x19, 0x8a, 0x84, 0x6e, 0x8c, 0xc1, 0x45,
-	0x36, 0x4e, 0x24, 0xdd, 0xa8, 0x88, 0x0b, 0xb1, 0xe0, 0x42, 0x41, 0xc6, 0x9d, 0xbb, 0x4c, 0x3a,
-	0x24, 0xa1, 0x8d, 0x93, 0x4e, 0x66, 0x84, 0xbc, 0x88, 0x2b, 0x1f, 0x56, 0x3a, 0x93, 0xfa, 0xa7,
-	0xa1, 0xee, 0xee, 0x49, 0x7e, 0x73, 0xee, 0xe1, 0x5c, 0x98, 0xa5, 0xb9, 0xca, 0x34, 0x23, 0x89,
-	0x28, 0xc2, 0x22, 0x4f, 0xa4, 0x08, 0x53, 0x71, 0x66, 0x07, 0x26, 0xc5, 0x92, 0xcb, 0xb0, 0x94,
-	0x42, 0x6d, 0x05, 0x31, 0x02, 0x1f, 0xa6, 0x82, 0x18, 0x86, 0xd8, 0xcf, 0xbe, 0x03, 0xfd, 0x79,
-	0x51, 0xaa, 0xda, 0x7f, 0x81, 0x83, 0x27, 0xcd, 0x56, 0x79, 0x95, 0x51, 0xbe, 0xd6, 0xbc, 0x52,
-	0x78, 0x02, 0x7d, 0x25, 0xca, 0x3c, 0x71, 0x91, 0x87, 0x82, 0x21, 0xb5, 0x02, 0x47, 0xe0, 0x14,
-	0xbc, 0xaa, 0xe2, 0x94, 0xbb, 0x5d, 0x0f, 0x05, 0xa3, 0xc8, 0x25, 0x3b, 0x9e, 0xe4, 0xd1, 0xfe,
-	0xa7, 0x5b, 0xd0, 0xbf, 0x81, 0xf1, 0xb3, 0x66, 0x55, 0x22, 0x73, 0xc6, 0xff, 0x76, 0x9f, 0x40,
-	0x7f, 0xad, 0xb9, 0xb6, 0xde, 0x43, 0x6a, 0x85, 0xff, 0x8e, 0xc0, 0x69, 0x4c, 0xf1, 0x35, 0x0c,
-	0x32, 0x1e, 0x2f, 0xb8, 0x74, 0x91, 0xd7, 0x0b, 0x46, 0xd1, 0xe9, 0xbe, 0xf5, 0xe4, 0xde, 0x60,
-	0xf3, 0x57, 0x25, 0x6b, 0xda, 0xbc, 0xc1, 0x18, 0xfe, 0x31, 0xb1, 0xa8, 0x8d, 0xfd, 0x7f, 0x6a,
-	0xe6, 0xe9, 0x25, 0x8c, 0x7e, 0xa0, 0x78, 0x0c, 0xbd, 0x25, 0xaf, 0x9b, 0x58, 0x9b, 0x71, 0x13,
-	0xea, 0x2d, 0x5e, 0x7d, 0x87, 0x32, 0xe2, 0xaa, 0x7b, 0x81, 0xa2, 0x0f, 0x04, 0x83, 0x5b, 0xb3,
-	0x15, 0xdf, 0x81, 0xd3, 0xf4, 0x87, 0x8f, 0x5b, 0x91, 0x7e, 0x37, 0x3b, 0x3d, 0x6a, 0x01, 0xf6,
-	0x06, 0x1d, 0xfc, 0x00, 0xc3, 0xaf, 0xa6, 0xf0, 0x49, 0x0b, 0xdb, 0x6d, 0x71, 0xba, 0xb7, 0x7c,
-	0xbf, 0x73, 0x8e, 0xd8, 0xc0, 0x1c, 0x7d, 0xf6, 0x19, 0x00, 0x00, 0xff, 0xff, 0x25, 0x38, 0xfa,
-	0x02, 0x2b, 0x02, 0x00, 0x00,
-}
-
-// Reference imports to suppress errors if they are not otherwise used.
-var _ context.Context
-var _ grpc.ClientConn
-
-// This is a compile-time assertion to ensure that this generated file
-// is compatible with the grpc package it is being compiled against.
-const _ = grpc.SupportPackageIsVersion4
-
-// BrokerClient is the client API for Broker service.
-//
-// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
-type BrokerClient interface {
-	Publish(ctx context.Context, in *PublishRequest, opts ...grpc.CallOption) (*Empty, error)
-	Subscribe(ctx context.Context, in *SubscribeRequest, opts ...grpc.CallOption) (Broker_SubscribeClient, error)
-}
-
-type brokerClient struct {
-	cc *grpc.ClientConn
-}
-
-func NewBrokerClient(cc *grpc.ClientConn) BrokerClient {
-	return &brokerClient{cc}
-}
-
-func (c *brokerClient) Publish(ctx context.Context, in *PublishRequest, opts ...grpc.CallOption) (*Empty, error) {
-	out := new(Empty)
-	err := c.cc.Invoke(ctx, "/go.micro.broker.Broker/Publish", in, out, opts...)
-	if err != nil {
-		return nil, err
-	}
-	return out, nil
-}
-
-func (c *brokerClient) Subscribe(ctx context.Context, in *SubscribeRequest, opts ...grpc.CallOption) (Broker_SubscribeClient, error) {
-	stream, err := c.cc.NewStream(ctx, &_Broker_serviceDesc.Streams[0], "/go.micro.broker.Broker/Subscribe", opts...)
-	if err != nil {
-		return nil, err
-	}
-	x := &brokerSubscribeClient{stream}
-	if err := x.ClientStream.SendMsg(in); err != nil {
-		return nil, err
-	}
-	if err := x.ClientStream.CloseSend(); err != nil {
-		return nil, err
-	}
-	return x, nil
-}
-
-type Broker_SubscribeClient interface {
-	Recv() (*Message, error)
-	grpc.ClientStream
-}
-
-type brokerSubscribeClient struct {
-	grpc.ClientStream
-}
-
-func (x *brokerSubscribeClient) Recv() (*Message, error) {
-	m := new(Message)
-	if err := x.ClientStream.RecvMsg(m); err != nil {
-		return nil, err
-	}
-	return m, nil
-}
-
-// BrokerServer is the server API for Broker service.
-type BrokerServer interface {
-	Publish(context.Context, *PublishRequest) (*Empty, error)
-	Subscribe(*SubscribeRequest, Broker_SubscribeServer) error
-}
-
-func RegisterBrokerServer(s *grpc.Server, srv BrokerServer) {
-	s.RegisterService(&_Broker_serviceDesc, srv)
-}
-
-func _Broker_Publish_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
-	in := new(PublishRequest)
-	if err := dec(in); err != nil {
-		return nil, err
-	}
-	if interceptor == nil {
-		return srv.(BrokerServer).Publish(ctx, in)
-	}
-	info := &grpc.UnaryServerInfo{
-		Server:     srv,
-		FullMethod: "/go.micro.broker.Broker/Publish",
-	}
-	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
-		return srv.(BrokerServer).Publish(ctx, req.(*PublishRequest))
-	}
-	return interceptor(ctx, in, info, handler)
-}
-
-func _Broker_Subscribe_Handler(srv interface{}, stream grpc.ServerStream) error {
-	m := new(SubscribeRequest)
-	if err := stream.RecvMsg(m); err != nil {
-		return err
-	}
-	return srv.(BrokerServer).Subscribe(m, &brokerSubscribeServer{stream})
-}
-
-type Broker_SubscribeServer interface {
-	Send(*Message) error
-	grpc.ServerStream
-}
-
-type brokerSubscribeServer struct {
-	grpc.ServerStream
-}
-
-func (x *brokerSubscribeServer) Send(m *Message) error {
-	return x.ServerStream.SendMsg(m)
-}
-
-var _Broker_serviceDesc = grpc.ServiceDesc{
-	ServiceName: "go.micro.broker.Broker",
-	HandlerType: (*BrokerServer)(nil),
-	Methods: []grpc.MethodDesc{
-		{
-			MethodName: "Publish",
-			Handler:    _Broker_Publish_Handler,
-		},
-	},
-	Streams: []grpc.StreamDesc{
-		{
-			StreamName:    "Subscribe",
-			Handler:       _Broker_Subscribe_Handler,
-			ServerStreams: true,
-		},
-	},
-	Metadata: "github.com/micro/go-micro/broker/proto/broker.proto",
+var fileDescriptor_178fdc60944ff5e5 = []byte{
+	// 305 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x7c, 0x51, 0x4d, 0x4f, 0xc2, 0x40,
+	0x14, 0x64, 0x41, 0x68, 0x78, 0x18, 0x25, 0x1b, 0x62, 0x1a, 0x2e, 0x62, 0xe3, 0x81, 0x8b, 0x5b,
+	0x52, 0x2f, 0x6a, 0x8c, 0x07, 0x23, 0x89, 0x07, 0x4d, 0xcc, 0x7a, 0xf3, 0xd6, 0x2d, 0x2f, 0xa5,
+	0x81, 0xba, 0x65, 0xb7, 0x25, 0xe9, 0x1f, 0xf1, 0xe4, 0x8f, 0x35, 0xec, 0x16, 0x3f, 0x68, 0xf0,
+	0x36, 0xf3, 0x76, 0x76, 0xde, 0x64, 0x1e, 0x4c, 0xd2, 0x24, 0x52, 0xd2, 0x8f, 0xe5, 0x85, 0x05,
+	0x42, 0xc9, 0x05, 0x2a, 0x5f, 0xa3, 0x5a, 0x27, 0x11, 0xfa, 0x99, 0x92, 0xf9, 0x76, 0xc8, 0x0c,
+	0xa1, 0xc7, 0xb1, 0x64, 0x46, 0xcb, 0xec, 0xd8, 0x73, 0xa0, 0x3d, 0x4d, 0xb3, 0xbc, 0xf4, 0xde,
+	0xe0, 0xe8, 0xa5, 0x10, 0xcb, 0x44, 0xcf, 0x39, 0xae, 0x0a, 0xd4, 0x39, 0x1d, 0x40, 0x3b, 0x97,
+	0x59, 0x12, 0xb9, 0x64, 0x44, 0xc6, 0x5d, 0x6e, 0x09, 0x0d, 0xc0, 0x49, 0x51, 0xeb, 0x30, 0x46,
+	0xb7, 0x39, 0x22, 0xe3, 0x5e, 0xe0, 0xb2, 0x1d, 0x4f, 0xf6, 0x6c, 0xdf, 0xf9, 0x56, 0xe8, 0xdd,
+	0x41, 0xff, 0xb5, 0x10, 0x3a, 0x52, 0x89, 0xc0, 0xff, 0xdd, 0x07, 0xd0, 0x5e, 0x15, 0x58, 0x58,
+	0xef, 0x2e, 0xb7, 0xc4, 0xfb, 0x20, 0xe0, 0x54, 0xa6, 0xf4, 0x16, 0x3a, 0x73, 0x0c, 0x67, 0xa8,
+	0x5c, 0x32, 0x6a, 0x8d, 0x7b, 0xc1, 0xf9, 0xbe, 0xf5, 0xec, 0xd1, 0xc8, 0xa6, 0xef, 0xb9, 0x2a,
+	0x79, 0xf5, 0x87, 0x52, 0x38, 0x10, 0x72, 0x56, 0x1a, 0xfb, 0x43, 0x6e, 0xf0, 0xf0, 0x1a, 0x7a,
+	0xbf, 0xa4, 0xb4, 0x0f, 0xad, 0x05, 0x96, 0x55, 0xac, 0x0d, 0xdc, 0x84, 0x5a, 0x87, 0xcb, 0x9f,
+	0x50, 0x86, 0xdc, 0x34, 0xaf, 0x48, 0xf0, 0x49, 0xa0, 0x73, 0x6f, 0xb6, 0xd2, 0x07, 0x70, 0xaa,
+	0xfe, 0xe8, 0x69, 0x2d, 0xd2, 0xdf, 0x66, 0x87, 0x27, 0x35, 0x81, 0xbd, 0x41, 0x83, 0x3e, 0x41,
+	0xf7, 0xbb, 0x29, 0x7a, 0x56, 0x93, 0xed, 0xb6, 0x38, 0xdc, 0x5b, 0xbe, 0xd7, 0x98, 0x10, 0xd1,
+	0x31, 0x47, 0xbf, 0xfc, 0x0a, 0x00, 0x00, 0xff, 0xff, 0x60, 0x8c, 0x40, 0xd5, 0x28, 0x02, 0x00,
+	0x00,
 }

broker/service/proto/broker.pb.micro.go

@@ -1,5 +1,5 @@
 // Code generated by protoc-gen-micro. DO NOT EDIT.
-// source: github.com/micro/go-micro/broker/proto/broker.proto
+// source: micro/go-micro/broker/service/proto/broker.proto
 
 package go_micro_broker
 

broker/service/service.go

@@ -124,9 +124,11 @@ func NewBroker(opts ...broker.Option) broker.Broker {
 		addrs = []string{"127.0.0.1:8001"}
 	}
 
+	cli := client.DefaultClient
+
 	return &serviceBroker{
 		Addrs:   addrs,
-		Client:  pb.NewBrokerService(DefaultName, client.DefaultClient),
+		Client:  pb.NewBrokerService(DefaultName, cli),
 		options: options,
 	}
 }

client/client.go

@@ -110,6 +110,9 @@ var (
 	DefaultPoolSize = 100
 	// DefaultPoolTTL sets the connection pool ttl
 	DefaultPoolTTL = time.Minute
+
+	// NewClient returns a new client
+	NewClient func(...Option) Client = newRpcClient
 )
 
 // Makes a synchronous call to a service using the default client
@@ -128,11 +131,6 @@ func NewMessage(topic string, payload interface{}, opts ...MessageOption) Messag
 	return DefaultClient.NewMessage(topic, payload, opts...)
 }
 
-// Creates a new client with the options passed in
-func NewClient(opt ...Option) Client {
-	return newRpcClient(opt...)
-}
-
 // Creates a new request using the default client. Content Type will
 // be set to the default within options and use the appropriate codec
 func NewRequest(service, endpoint string, request interface{}, reqOpts ...RequestOption) Request {

client/common_test.go

@@ -15,10 +15,16 @@ var (
 					{
 						Id:      "foo-1.0.0-123",
 						Address: "localhost:9999",
+						Metadata: map[string]string{
+							"protocol": "mucp",
+						},
 					},
 					{
 						Id:      "foo-1.0.0-321",
 						Address: "localhost:9999",
+						Metadata: map[string]string{
+							"protocol": "mucp",
+						},
 					},
 				},
 			},
@@ -29,6 +35,9 @@ var (
 					{
 						Id:      "foo-1.0.1-321",
 						Address: "localhost:6666",
+						Metadata: map[string]string{
+							"protocol": "mucp",
+						},
 					},
 				},
 			},
@@ -39,6 +48,9 @@ var (
 					{
 						Id:      "foo-1.0.3-345",
 						Address: "localhost:8888",
+						Metadata: map[string]string{
+							"protocol": "mucp",
+						},
 					},
 				},
 			},

client/grpc/codec.go

@@ -11,8 +11,6 @@ import (
 	jsoniter "github.com/json-iterator/go"
 	"github.com/micro/go-micro/codec"
 	"github.com/micro/go-micro/codec/bytes"
-	"github.com/micro/go-micro/codec/jsonrpc"
-	"github.com/micro/go-micro/codec/protorpc"
 	"google.golang.org/grpc"
 	"google.golang.org/grpc/encoding"
 )
@@ -36,14 +34,6 @@ var (
 		"application/grpc+bytes":   bytesCodec{},
 	}
 
-	defaultRPCCodecs = map[string]codec.NewCodec{
-		"application/json":         jsonrpc.NewCodec,
-		"application/json-rpc":     jsonrpc.NewCodec,
-		"application/protobuf":     protorpc.NewCodec,
-		"application/proto-rpc":    protorpc.NewCodec,
-		"application/octet-stream": protorpc.NewCodec,
-	}
-
 	json = jsoniter.ConfigCompatibleWithStandardLibrary
 )
 
@@ -126,10 +116,12 @@ func (jsonCodec) Marshal(v interface{}) ([]byte, error) {
 }
 
 func (jsonCodec) Unmarshal(data []byte, v interface{}) error {
+	if len(data) == 0 {
+		return nil
+	}
 	if pb, ok := v.(proto.Message); ok {
 		return jsonpb.Unmarshal(b.NewReader(data), pb)
 	}
-
 	return json.Unmarshal(data, v)
 }
 
@@ -182,7 +174,7 @@ func (g *grpcCodec) Write(m *codec.Message, v interface{}) error {
 		return g.s.SendMsg(v)
 	}
 	// write the body using the framing codec
-	return g.s.SendMsg(&bytes.Frame{m.Body})
+	return g.s.SendMsg(&bytes.Frame{Data: m.Body})
 }
 
 func (g *grpcCodec) Close() error {

client/grpc/grpc.go

@@ -12,11 +12,10 @@ import (
 	"github.com/micro/go-micro/broker"
 	"github.com/micro/go-micro/client"
 	"github.com/micro/go-micro/client/selector"
-	"github.com/micro/go-micro/codec"
+	raw "github.com/micro/go-micro/codec/bytes"
 	"github.com/micro/go-micro/errors"
 	"github.com/micro/go-micro/metadata"
 	"github.com/micro/go-micro/registry"
-	"github.com/micro/go-micro/transport"
 
 	"google.golang.org/grpc"
 	"google.golang.org/grpc/credentials"
@@ -208,11 +207,15 @@ func (g *grpcClient) stream(ctx context.Context, node *registry.Node, req client
 		ServerStreams: true,
 	}
 
-	grpcCallOptions := []grpc.CallOption{}
+	grpcCallOptions := []grpc.CallOption{grpc.CallContentSubtype(cf.Name())}
 	if opts := g.getGrpcCallOptions(); opts != nil {
 		grpcCallOptions = append(grpcCallOptions, opts...)
 	}
-	st, err := cc.NewStream(ctx, desc, methodToGRPC(req.Service(), req.Endpoint()), grpcCallOptions...)
+
+	// create a new cancelling context
+	newCtx, cancel := context.WithCancel(ctx)
+
+	st, err := cc.NewStream(newCtx, desc, methodToGRPC(req.Service(), req.Endpoint()), grpcCallOptions...)
 	if err != nil {
 		return nil, errors.InternalServerError("go.micro.client", fmt.Sprintf("Error creating stream: %v", err))
 	}
@@ -240,9 +243,32 @@ func (g *grpcClient) stream(ctx context.Context, node *registry.Node, req client
 		response: rsp,
 		stream:   st,
 		conn:     cc,
+		cancel:   cancel,
 	}, nil
 }
 
+func (g *grpcClient) poolMaxStreams() int {
+	if g.opts.Context == nil {
+		return DefaultPoolMaxStreams
+	}
+	v := g.opts.Context.Value(poolMaxStreams{})
+	if v == nil {
+		return DefaultPoolMaxStreams
+	}
+	return v.(int)
+}
+
+func (g *grpcClient) poolMaxIdle() int {
+	if g.opts.Context == nil {
+		return DefaultPoolMaxIdle
+	}
+	v := g.opts.Context.Value(poolMaxIdle{})
+	if v == nil {
+		return DefaultPoolMaxIdle
+	}
+	return v.(int)
+}
+
 func (g *grpcClient) maxRecvMsgSizeValue() int {
 	if g.opts.Context == nil {
 		return DefaultMaxRecvMsgSize
@@ -281,16 +307,6 @@ func (g *grpcClient) newGRPCCodec(contentType string) (encoding.Codec, error) {
 	return nil, fmt.Errorf("Unsupported Content-Type: %s", contentType)
 }
 
-func (g *grpcClient) newCodec(contentType string) (codec.NewCodec, error) {
-	if c, ok := g.opts.Codecs[contentType]; ok {
-		return c, nil
-	}
-	if cf, ok := defaultRPCCodecs[contentType]; ok {
-		return cf, nil
-	}
-	return nil, fmt.Errorf("Unsupported Content-Type: %s", contentType)
-}
-
 func (g *grpcClient) Init(opts ...client.Option) error {
 	size := g.opts.PoolSize
 	ttl := g.opts.PoolTTL
@@ -338,7 +354,9 @@ func (g *grpcClient) Call(ctx context.Context, req client.Request, rsp interface
 	d, ok := ctx.Deadline()
 	if !ok {
 		// no deadline so we create a new one
-		ctx, _ = context.WithTimeout(ctx, callOpts.RequestTimeout)
+		var cancel context.CancelFunc
+		ctx, cancel = context.WithTimeout(ctx, callOpts.RequestTimeout)
+		defer cancel()
 	} else {
 		// got a deadline so no need to setup context
 		// but we need to set the timeout we pass along
@@ -510,29 +528,56 @@ func (g *grpcClient) Stream(ctx context.Context, req client.Request, opts ...cli
 }
 
 func (g *grpcClient) Publish(ctx context.Context, p client.Message, opts ...client.PublishOption) error {
+	var options client.PublishOptions
+	for _, o := range opts {
+		o(&options)
+	}
+
 	md, ok := metadata.FromContext(ctx)
 	if !ok {
 		md = make(map[string]string)
 	}
 	md["Content-Type"] = p.ContentType()
+	md["Micro-Topic"] = p.Topic()
 
 	cf, err := g.newGRPCCodec(p.ContentType())
 	if err != nil {
 		return errors.InternalServerError("go.micro.client", err.Error())
 	}
 
-	b, err := cf.Marshal(p.Payload())
-	if err != nil {
-		return errors.InternalServerError("go.micro.client", err.Error())
+	var body []byte
+
+	// passed in raw data
+	if d, ok := p.Payload().(*raw.Frame); ok {
+		body = d.Data
+	} else {
+		// set the body
+		b, err := cf.Marshal(p.Payload())
+		if err != nil {
+			return errors.InternalServerError("go.micro.client", err.Error())
+		}
+		body = b
 	}
 
 	g.once.Do(func() {
 		g.opts.Broker.Connect()
 	})
 
-	return g.opts.Broker.Publish(p.Topic(), &broker.Message{
+	topic := p.Topic()
+
+	// get proxy topic
+	if prx := os.Getenv("MICRO_PROXY"); len(prx) > 0 {
+		options.Exchange = prx
+	}
+
+	// get the exchange
+	if len(options.Exchange) > 0 {
+		topic = options.Exchange
+	}
+
+	return g.opts.Broker.Publish(topic, &broker.Message{
 		Header: md,
-		Body:   b,
+		Body:   body,
 	})
 }
 
@@ -581,47 +626,21 @@ func (g *grpcClient) getGrpcCallOptions() []grpc.CallOption {
 }
 
 func newClient(opts ...client.Option) client.Client {
-	options := client.Options{
-		Codecs: make(map[string]codec.NewCodec),
-		CallOptions: client.CallOptions{
-			Backoff:        client.DefaultBackoff,
-			Retry:          client.DefaultRetry,
-			Retries:        client.DefaultRetries,
-			RequestTimeout: client.DefaultRequestTimeout,
-			DialTimeout:    transport.DefaultDialTimeout,
-		},
-		PoolSize: client.DefaultPoolSize,
-		PoolTTL:  client.DefaultPoolTTL,
-	}
+	options := client.NewOptions()
+	// default content type for grpc
+	options.ContentType = "application/grpc+proto"
 
 	for _, o := range opts {
 		o(&options)
 	}
 
-	if len(options.ContentType) == 0 {
-		options.ContentType = "application/grpc+proto"
-	}
-
-	if options.Broker == nil {
-		options.Broker = broker.DefaultBroker
-	}
-
-	if options.Registry == nil {
-		options.Registry = registry.DefaultRegistry
-	}
-
-	if options.Selector == nil {
-		options.Selector = selector.NewSelector(
-			selector.Registry(options.Registry),
-		)
-	}
-
 	rc := &grpcClient{
 		once: sync.Once{},
 		opts: options,
-		pool: newPool(options.PoolSize, options.PoolTTL),
 	}
 
+	rc.pool = newPool(options.PoolSize, options.PoolTTL, rc.poolMaxIdle(), rc.poolMaxStreams())
+
 	c := client.Client(rc)
 
 	// wrap in reverse

client/grpc/grpc_pool.go

@@ -11,73 +11,181 @@ type pool struct {
 	size int
 	ttl  int64
 
+	//  max streams on a *poolConn
+	maxStreams int
+	//  max idle conns
+	maxIdle int
+
 	sync.Mutex
-	conns map[string][]*poolConn
+	conns map[string]*streamsPool
+}
+
+type streamsPool struct {
+	//  head of list
+	head *poolConn
+	//  busy conns list
+	busy *poolConn
+	//  the siza of list
+	count int
+	//  idle conn
+	idle int
 }
 
 type poolConn struct {
+	//  grpc conn
 	*grpc.ClientConn
+	err  error
+	addr string
+
+	//  pool and streams pool
+	pool    *pool
+	sp      *streamsPool
+	streams int
 	created int64
+
+	//  list
+	pre  *poolConn
+	next *poolConn
+	in   bool
 }
 
-func newPool(size int, ttl time.Duration) *pool {
+func newPool(size int, ttl time.Duration, idle int, ms int) *pool {
+	if ms <= 0 {
+		ms = 1
+	}
+	if idle < 0 {
+		idle = 0
+	}
 	return &pool{
-		size:  size,
-		ttl:   int64(ttl.Seconds()),
-		conns: make(map[string][]*poolConn),
+		size:       size,
+		ttl:        int64(ttl.Seconds()),
+		maxStreams: ms,
+		maxIdle:    idle,
+		conns:      make(map[string]*streamsPool),
 	}
 }
 
 func (p *pool) getConn(addr string, opts ...grpc.DialOption) (*poolConn, error) {
-	p.Lock()
-	conns := p.conns[addr]
 	now := time.Now().Unix()
-
-	// while we have conns check age and then return one
-	// otherwise we'll create a new conn
-	for len(conns) > 0 {
-		conn := conns[len(conns)-1]
-		conns = conns[:len(conns)-1]
-		p.conns[addr] = conns
-
-		// if conn is old kill it and move on
-		if d := now - conn.created; d > p.ttl {
-			conn.ClientConn.Close()
+	p.Lock()
+	sp, ok := p.conns[addr]
+	if !ok {
+		sp = &streamsPool{head: &poolConn{}, busy: &poolConn{}, count: 0, idle: 0}
+		p.conns[addr] = sp
+	}
+	//  while we have conns check streams and then return one
+	//  otherwise we'll create a new conn
+	conn := sp.head.next
+	for conn != nil {
+		//  a old conn
+		if now-conn.created > p.ttl {
+			next := conn.next
+			if conn.streams == 0 {
+				removeConn(conn)
+				conn.ClientConn.Close()
+				sp.idle--
+			}
+			conn = next
 			continue
 		}
-
-		// we got a good conn, lets unlock and return it
+		//  a busy conn
+		if conn.streams >= p.maxStreams {
+			next := conn.next
+			removeConn(conn)
+			addConnAfter(conn, sp.busy)
+			conn = next
+			continue
+		}
+		//  a idle conn
+		if conn.streams == 0 {
+			sp.idle--
+		}
+		//  a good conn
+		conn.streams++
 		p.Unlock()
-
 		return conn, nil
 	}
-
 	p.Unlock()
 
-	// create new conn
+	//  create new conn
 	cc, err := grpc.Dial(addr, opts...)
 	if err != nil {
 		return nil, err
 	}
+	conn = &poolConn{cc, nil, addr, p, sp, 1, time.Now().Unix(), nil, nil, false}
 
-	return &poolConn{cc, time.Now().Unix()}, nil
+	//  add conn to streams pool
+	p.Lock()
+	if sp.count < p.size {
+		addConnAfter(conn, sp.head)
+	}
+	p.Unlock()
+
+	return conn, nil
 }
 
 func (p *pool) release(addr string, conn *poolConn, err error) {
-	// don't store the conn if it has errored
-	if err != nil {
-		conn.ClientConn.Close()
-		return
-	}
-
-	// otherwise put it back for reuse
 	p.Lock()
-	conns := p.conns[addr]
-	if len(conns) >= p.size {
+	p, sp, created := conn.pool, conn.sp, conn.created
+	//  try to add conn
+	if !conn.in && sp.count < p.size {
+		addConnAfter(conn, sp.head)
+	}
+	if !conn.in {
 		p.Unlock()
 		conn.ClientConn.Close()
 		return
 	}
-	p.conns[addr] = append(conns, conn)
+	//  a busy conn
+	if conn.streams >= p.maxStreams {
+		removeConn(conn)
+		addConnAfter(conn, sp.head)
+	}
+	conn.streams--
+	//  if streams == 0, we can do something
+	if conn.streams == 0 {
+		//  1. it has errored
+		//  2. too many idle conn or
+		//  3. conn is too old
+		now := time.Now().Unix()
+		if err != nil || sp.idle >= p.maxIdle || now-created > p.ttl {
+			removeConn(conn)
+			p.Unlock()
+			conn.ClientConn.Close()
+			return
+		}
+		sp.idle++
+	}
 	p.Unlock()
+	return
+}
+
+func (conn *poolConn) Close() {
+	conn.pool.release(conn.addr, conn, conn.err)
+}
+
+func removeConn(conn *poolConn) {
+	if conn.pre != nil {
+		conn.pre.next = conn.next
+	}
+	if conn.next != nil {
+		conn.next.pre = conn.pre
+	}
+	conn.pre = nil
+	conn.next = nil
+	conn.in = false
+	conn.sp.count--
+	return
+}
+
+func addConnAfter(conn *poolConn, after *poolConn) {
+	conn.next = after.next
+	conn.pre = after
+	if after.next != nil {
+		after.next.pre = conn
+	}
+	after.next = conn
+	conn.in = true
+	conn.sp.count++
+	return
 }

client/grpc/grpc_pool_test.go

@@ -1,17 +1,17 @@
 package grpc
 
 import (
+	"context"
 	"net"
 	"testing"
 	"time"
 
-	"context"
 	"google.golang.org/grpc"
 	pgrpc "google.golang.org/grpc"
 	pb "google.golang.org/grpc/examples/helloworld/helloworld"
 )
 
-func testPool(t *testing.T, size int, ttl time.Duration) {
+func testPool(t *testing.T, size int, ttl time.Duration, idle int, ms int) {
 	// setup server
 	l, err := net.Listen("tcp", ":0")
 	if err != nil {
@@ -26,7 +26,7 @@ func testPool(t *testing.T, size int, ttl time.Duration) {
 	defer s.Stop()
 
 	// zero pool
-	p := newPool(size, ttl)
+	p := newPool(size, ttl, idle, ms)
 
 	for i := 0; i < 10; i++ {
 		// get a conn
@@ -50,7 +50,7 @@ func testPool(t *testing.T, size int, ttl time.Duration) {
 		p.release(l.Addr().String(), cc, nil)
 
 		p.Lock()
-		if i := len(p.conns[l.Addr().String()]); i > size {
+		if i := p.conns[l.Addr().String()].count; i > size {
 			p.Unlock()
 			t.Fatalf("pool size %d is greater than expected %d", i, size)
 		}
@@ -59,6 +59,6 @@ func testPool(t *testing.T, size int, ttl time.Duration) {
 }
 
 func TestGRPCPool(t *testing.T) {
-	testPool(t, 0, time.Minute)
-	testPool(t, 2, time.Minute)
+	testPool(t, 0, time.Minute, 10, 2)
+	testPool(t, 2, time.Minute, 10, 1)
 }

client/grpc/grpc_test.go

@@ -45,6 +45,9 @@ func TestGRPCClient(t *testing.T) {
 			{
 				Id:      "test-1",
 				Address: l.Addr().String(),
+				Metadata: map[string]string{
+					"protocol": "grpc",
+				},
 			},
 		},
 	})

client/grpc/options.go

@@ -11,6 +11,14 @@ import (
 )
 
 var (
+	// DefaultPoolMaxStreams maximum streams on a connectioin
+	// (20)
+	DefaultPoolMaxStreams = 20
+
+	// DefaultPoolMaxIdle maximum idle conns of a pool
+	// (50)
+	DefaultPoolMaxIdle = 50
+
 	// DefaultMaxRecvMsgSize maximum message that client can receive
 	// (4 MB).
 	DefaultMaxRecvMsgSize = 1024 * 1024 * 4
@@ -20,6 +28,8 @@ var (
 	DefaultMaxSendMsgSize = 1024 * 1024 * 4
 )
 
+type poolMaxStreams struct{}
+type poolMaxIdle struct{}
 type codecsKey struct{}
 type tlsAuth struct{}
 type maxRecvMsgSizeKey struct{}
@@ -27,6 +37,26 @@ type maxSendMsgSizeKey struct{}
 type grpcDialOptions struct{}
 type grpcCallOptions struct{}
 
+// maximum streams on a connectioin
+func PoolMaxStreams(n int) client.Option {
+	return func(o *client.Options) {
+		if o.Context == nil {
+			o.Context = context.Background()
+		}
+		o.Context = context.WithValue(o.Context, poolMaxStreams{}, n)
+	}
+}
+
+// maximum idle conns of a pool
+func PoolMaxIdle(d int) client.Option {
+	return func(o *client.Options) {
+		if o.Context == nil {
+			o.Context = context.Background()
+		}
+		o.Context = context.WithValue(o.Context, poolMaxIdle{}, d)
+	}
+}
+
 // gRPC Codec to be used to encode/decode requests for a given content type
 func Codec(contentType string, c encoding.Codec) client.Option {
 	return func(o *client.Options) {

client/grpc/stream.go

@@ -12,12 +12,14 @@ import (
 // Implements the streamer interface
 type grpcStream struct {
 	sync.RWMutex
+	closed   bool
 	err      error
 	conn     *grpc.ClientConn
 	stream   grpc.ClientStream
 	request  client.Request
 	response client.Response
 	context  context.Context
+	cancel   func()
 }
 
 func (g *grpcStream) Context() context.Context {
@@ -43,14 +45,12 @@ func (g *grpcStream) Send(msg interface{}) error {
 func (g *grpcStream) Recv(msg interface{}) (err error) {
 	defer g.setError(err)
 	if err = g.stream.RecvMsg(msg); err != nil {
-		if err == io.EOF {
-			// #202 - inconsistent gRPC stream behavior
-			// the only way to tell if the stream is done is when we get a EOF on the Recv
-			// here we should close the underlying gRPC ClientConn
-			closeErr := g.conn.Close()
-			if closeErr != nil {
-				err = closeErr
-			}
+		// #202 - inconsistent gRPC stream behavior
+		// the only way to tell if the stream is done is when we get a EOF on the Recv
+		// here we should close the underlying gRPC ClientConn
+		closeErr := g.Close()
+		if err == io.EOF && closeErr != nil {
+			err = closeErr
 		}
 	}
 	return
@@ -74,5 +74,15 @@ func (g *grpcStream) setError(e error) {
 // stream should still be able to receive after this function call
 // TODO: should the conn be closed in another way?
 func (g *grpcStream) Close() error {
-	return g.stream.CloseSend()
+	g.Lock()
+	defer g.Unlock()
+
+	if g.closed {
+		return nil
+	}
+	// cancel the context
+	g.cancel()
+	g.closed = true
+	g.stream.CloseSend()
+	return g.conn.Close()
 }

client/mock/context.go

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

client/mock/mock.go

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

client/mock/mock_test.go

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

client/mock/options.go

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

client/options.go

@@ -85,9 +85,11 @@ type RequestOptions struct {
 	Context context.Context
 }
 
-func newOptions(options ...Option) Options {
+func NewOptions(options ...Option) Options {
 	opts := Options{
-		Codecs: make(map[string]codec.NewCodec),
+		Context:     context.Background(),
+		ContentType: DefaultContentType,
+		Codecs:      make(map[string]codec.NewCodec),
 		CallOptions: CallOptions{
 			Backoff:        DefaultBackoff,
 			Retry:          DefaultRetry,
@@ -95,36 +97,18 @@ func newOptions(options ...Option) Options {
 			RequestTimeout: DefaultRequestTimeout,
 			DialTimeout:    transport.DefaultDialTimeout,
 		},
-		PoolSize: DefaultPoolSize,
-		PoolTTL:  DefaultPoolTTL,
+		PoolSize:  DefaultPoolSize,
+		PoolTTL:   DefaultPoolTTL,
+		Broker:    broker.DefaultBroker,
+		Selector:  selector.DefaultSelector,
+		Registry:  registry.DefaultRegistry,
+		Transport: transport.DefaultTransport,
 	}
 
 	for _, o := range options {
 		o(&opts)
 	}
 
-	if len(opts.ContentType) == 0 {
-		opts.ContentType = DefaultContentType
-	}
-
-	if opts.Broker == nil {
-		opts.Broker = broker.DefaultBroker
-	}
-
-	if opts.Registry == nil {
-		opts.Registry = registry.DefaultRegistry
-	}
-
-	if opts.Selector == nil {
-		opts.Selector = selector.NewSelector(
-			selector.Registry(opts.Registry),
-		)
-	}
-
-	if opts.Transport == nil {
-		opts.Transport = transport.DefaultTransport
-	}
-
 	return opts
 }
 
@@ -156,7 +140,7 @@ func PoolSize(d int) Option {
 	}
 }
 
-// PoolSize sets the connection pool size
+// PoolTTL sets the connection pool ttl
 func PoolTTL(d time.Duration) Option {
 	return func(o *Options) {
 		o.PoolTTL = d
@@ -167,6 +151,8 @@ func PoolTTL(d time.Duration) Option {
 func Registry(r registry.Registry) Option {
 	return func(o *Options) {
 		o.Registry = r
+		// set in the selector
+		o.Selector.Init(selector.Registry(r))
 	}
 }
 

client/options_test.go

@@ -23,7 +23,7 @@ func TestCallOptions(t *testing.T) {
 		var cl Client
 
 		if d.set {
-			opts = newOptions(
+			opts = NewOptions(
 				Retries(d.retries),
 				RequestTimeout(d.rtimeout),
 				DialTimeout(d.dtimeout),
@@ -35,7 +35,7 @@ func TestCallOptions(t *testing.T) {
 				DialTimeout(d.dtimeout),
 			)
 		} else {
-			opts = newOptions()
+			opts = NewOptions()
 			cl = NewClient()
 		}
 

client/proto/client.pb.go

@@ -1,388 +0,0 @@
-// Code generated by protoc-gen-go. DO NOT EDIT.
-// source: micro/go-micro/client/proto/client.proto
-
-package go_micro_client
-
-import (
-	context "context"
-	fmt "fmt"
-	proto "github.com/golang/protobuf/proto"
-	grpc "google.golang.org/grpc"
-	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 Request struct {
-	Service              string   `protobuf:"bytes,1,opt,name=service,proto3" json:"service,omitempty"`
-	Endpoint             string   `protobuf:"bytes,2,opt,name=endpoint,proto3" json:"endpoint,omitempty"`
-	ContentType          string   `protobuf:"bytes,3,opt,name=content_type,json=contentType,proto3" json:"content_type,omitempty"`
-	Body                 []byte   `protobuf:"bytes,4,opt,name=body,proto3" json:"body,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_7d733ae29171347b, []int{0}
-}
-
-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) GetService() string {
-	if m != nil {
-		return m.Service
-	}
-	return ""
-}
-
-func (m *Request) GetEndpoint() string {
-	if m != nil {
-		return m.Endpoint
-	}
-	return ""
-}
-
-func (m *Request) GetContentType() string {
-	if m != nil {
-		return m.ContentType
-	}
-	return ""
-}
-
-func (m *Request) GetBody() []byte {
-	if m != nil {
-		return m.Body
-	}
-	return nil
-}
-
-type Response struct {
-	Body                 []byte   `protobuf:"bytes,1,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_7d733ae29171347b, []int{1}
-}
-
-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) GetBody() []byte {
-	if m != nil {
-		return m.Body
-	}
-	return nil
-}
-
-type Message struct {
-	Topic                string   `protobuf:"bytes,1,opt,name=topic,proto3" json:"topic,omitempty"`
-	ContentType          string   `protobuf:"bytes,2,opt,name=content_type,json=contentType,proto3" json:"content_type,omitempty"`
-	Body                 []byte   `protobuf:"bytes,3,opt,name=body,proto3" json:"body,omitempty"`
-	XXX_NoUnkeyedLiteral struct{} `json:"-"`
-	XXX_unrecognized     []byte   `json:"-"`
-	XXX_sizecache        int32    `json:"-"`
-}
-
-func (m *Message) Reset()         { *m = Message{} }
-func (m *Message) String() string { return proto.CompactTextString(m) }
-func (*Message) ProtoMessage()    {}
-func (*Message) Descriptor() ([]byte, []int) {
-	return fileDescriptor_7d733ae29171347b, []int{2}
-}
-
-func (m *Message) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_Message.Unmarshal(m, b)
-}
-func (m *Message) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_Message.Marshal(b, m, deterministic)
-}
-func (m *Message) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_Message.Merge(m, src)
-}
-func (m *Message) XXX_Size() int {
-	return xxx_messageInfo_Message.Size(m)
-}
-func (m *Message) XXX_DiscardUnknown() {
-	xxx_messageInfo_Message.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_Message proto.InternalMessageInfo
-
-func (m *Message) GetTopic() string {
-	if m != nil {
-		return m.Topic
-	}
-	return ""
-}
-
-func (m *Message) GetContentType() string {
-	if m != nil {
-		return m.ContentType
-	}
-	return ""
-}
-
-func (m *Message) GetBody() []byte {
-	if m != nil {
-		return m.Body
-	}
-	return nil
-}
-
-func init() {
-	proto.RegisterType((*Request)(nil), "go.micro.client.Request")
-	proto.RegisterType((*Response)(nil), "go.micro.client.Response")
-	proto.RegisterType((*Message)(nil), "go.micro.client.Message")
-}
-
-func init() {
-	proto.RegisterFile("micro/go-micro/client/proto/client.proto", fileDescriptor_7d733ae29171347b)
-}
-
-var fileDescriptor_7d733ae29171347b = []byte{
-	// 270 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x9c, 0x91, 0x41, 0x4b, 0xc3, 0x40,
-	0x10, 0x85, 0xbb, 0x6d, 0x4c, 0xea, 0x58, 0x10, 0x06, 0x0f, 0x6b, 0x0e, 0x52, 0x73, 0xca, 0xc5,
-	0x54, 0xf4, 0x2c, 0x1e, 0x72, 0x16, 0x24, 0x8a, 0x57, 0x49, 0xb6, 0x43, 0x5c, 0x48, 0x77, 0xd7,
-	0xec, 0xb6, 0x90, 0x1f, 0xe9, 0x7f, 0x12, 0x36, 0xa9, 0x15, 0x6d, 0x2f, 0xbd, 0xcd, 0x9b, 0x6f,
-	0x79, 0x33, 0xfb, 0x06, 0xd2, 0x95, 0x14, 0xad, 0x5e, 0xd4, 0xfa, 0xa6, 0x2f, 0x44, 0x23, 0x49,
-	0xb9, 0x85, 0x69, 0xb5, 0xdb, 0x8a, 0xcc, 0x0b, 0x3c, 0xaf, 0x75, 0xe6, 0xdf, 0x64, 0x7d, 0x3b,
-	0xd9, 0x40, 0x54, 0xd0, 0xe7, 0x9a, 0xac, 0x43, 0x0e, 0x91, 0xa5, 0x76, 0x23, 0x05, 0x71, 0x36,
-	0x67, 0xe9, 0x69, 0xb1, 0x95, 0x18, 0xc3, 0x94, 0xd4, 0xd2, 0x68, 0xa9, 0x1c, 0x1f, 0x7b, 0xf4,
-	0xa3, 0xf1, 0x1a, 0x66, 0x42, 0x2b, 0x47, 0xca, 0xbd, 0xbb, 0xce, 0x10, 0x9f, 0x78, 0x7e, 0x36,
-	0xf4, 0x5e, 0x3b, 0x43, 0x88, 0x10, 0x54, 0x7a, 0xd9, 0xf1, 0x60, 0xce, 0xd2, 0x59, 0xe1, 0xeb,
-	0xe4, 0x0a, 0xa6, 0x05, 0x59, 0xa3, 0x95, 0xdd, 0x71, 0xf6, 0x8b, 0xbf, 0x41, 0xf4, 0x44, 0xd6,
-	0x96, 0x35, 0xe1, 0x05, 0x9c, 0x38, 0x6d, 0xa4, 0x18, 0xb6, 0xea, 0xc5, 0xbf, 0xb9, 0xe3, 0xc3,
-	0x73, 0x27, 0x3b, 0xdf, 0xbb, 0x2f, 0x06, 0x61, 0xee, 0xbf, 0x8e, 0x0f, 0x10, 0xe4, 0x65, 0xd3,
-	0x20, 0xcf, 0xfe, 0x84, 0x92, 0x0d, 0x89, 0xc4, 0x97, 0x7b, 0x48, 0xbf, 0x73, 0x32, 0xc2, 0x1c,
-	0xc2, 0x17, 0xd7, 0x52, 0xb9, 0x3a, 0xd2, 0x20, 0x65, 0xb7, 0x0c, 0x1f, 0x21, 0x7a, 0x5e, 0x57,
-	0x8d, 0xb4, 0x1f, 0x7b, 0x5c, 0x86, 0x00, 0xe2, 0x83, 0x24, 0x19, 0x55, 0xa1, 0xbf, 0xeb, 0xfd,
-	0x77, 0x00, 0x00, 0x00, 0xff, 0xff, 0x0a, 0x76, 0x1f, 0x51, 0x03, 0x02, 0x00, 0x00,
-}
-
-// Reference imports to suppress errors if they are not otherwise used.
-var _ context.Context
-var _ grpc.ClientConn
-
-// This is a compile-time assertion to ensure that this generated file
-// is compatible with the grpc package it is being compiled against.
-const _ = grpc.SupportPackageIsVersion4
-
-// ClientClient is the client API for Client service.
-//
-// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
-type ClientClient interface {
-	// Call allows a single request to be made
-	Call(ctx context.Context, in *Request, opts ...grpc.CallOption) (*Response, error)
-	// Stream is a bidirectional stream
-	Stream(ctx context.Context, opts ...grpc.CallOption) (Client_StreamClient, error)
-	// Publish publishes a message and returns an empty Message
-	Publish(ctx context.Context, in *Message, opts ...grpc.CallOption) (*Message, error)
-}
-
-type clientClient struct {
-	cc *grpc.ClientConn
-}
-
-func NewClientClient(cc *grpc.ClientConn) ClientClient {
-	return &clientClient{cc}
-}
-
-func (c *clientClient) Call(ctx context.Context, in *Request, opts ...grpc.CallOption) (*Response, error) {
-	out := new(Response)
-	err := c.cc.Invoke(ctx, "/go.micro.client.Client/Call", in, out, opts...)
-	if err != nil {
-		return nil, err
-	}
-	return out, nil
-}
-
-func (c *clientClient) Stream(ctx context.Context, opts ...grpc.CallOption) (Client_StreamClient, error) {
-	stream, err := c.cc.NewStream(ctx, &_Client_serviceDesc.Streams[0], "/go.micro.client.Client/Stream", opts...)
-	if err != nil {
-		return nil, err
-	}
-	x := &clientStreamClient{stream}
-	return x, nil
-}
-
-type Client_StreamClient interface {
-	Send(*Request) error
-	Recv() (*Response, error)
-	grpc.ClientStream
-}
-
-type clientStreamClient struct {
-	grpc.ClientStream
-}
-
-func (x *clientStreamClient) Send(m *Request) error {
-	return x.ClientStream.SendMsg(m)
-}
-
-func (x *clientStreamClient) Recv() (*Response, error) {
-	m := new(Response)
-	if err := x.ClientStream.RecvMsg(m); err != nil {
-		return nil, err
-	}
-	return m, nil
-}
-
-func (c *clientClient) Publish(ctx context.Context, in *Message, opts ...grpc.CallOption) (*Message, error) {
-	out := new(Message)
-	err := c.cc.Invoke(ctx, "/go.micro.client.Client/Publish", in, out, opts...)
-	if err != nil {
-		return nil, err
-	}
-	return out, nil
-}
-
-// ClientServer is the server API for Client service.
-type ClientServer interface {
-	// Call allows a single request to be made
-	Call(context.Context, *Request) (*Response, error)
-	// Stream is a bidirectional stream
-	Stream(Client_StreamServer) error
-	// Publish publishes a message and returns an empty Message
-	Publish(context.Context, *Message) (*Message, error)
-}
-
-func RegisterClientServer(s *grpc.Server, srv ClientServer) {
-	s.RegisterService(&_Client_serviceDesc, srv)
-}
-
-func _Client_Call_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
-	in := new(Request)
-	if err := dec(in); err != nil {
-		return nil, err
-	}
-	if interceptor == nil {
-		return srv.(ClientServer).Call(ctx, in)
-	}
-	info := &grpc.UnaryServerInfo{
-		Server:     srv,
-		FullMethod: "/go.micro.client.Client/Call",
-	}
-	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
-		return srv.(ClientServer).Call(ctx, req.(*Request))
-	}
-	return interceptor(ctx, in, info, handler)
-}
-
-func _Client_Stream_Handler(srv interface{}, stream grpc.ServerStream) error {
-	return srv.(ClientServer).Stream(&clientStreamServer{stream})
-}
-
-type Client_StreamServer interface {
-	Send(*Response) error
-	Recv() (*Request, error)
-	grpc.ServerStream
-}
-
-type clientStreamServer struct {
-	grpc.ServerStream
-}
-
-func (x *clientStreamServer) Send(m *Response) error {
-	return x.ServerStream.SendMsg(m)
-}
-
-func (x *clientStreamServer) Recv() (*Request, error) {
-	m := new(Request)
-	if err := x.ServerStream.RecvMsg(m); err != nil {
-		return nil, err
-	}
-	return m, nil
-}
-
-func _Client_Publish_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
-	in := new(Message)
-	if err := dec(in); err != nil {
-		return nil, err
-	}
-	if interceptor == nil {
-		return srv.(ClientServer).Publish(ctx, in)
-	}
-	info := &grpc.UnaryServerInfo{
-		Server:     srv,
-		FullMethod: "/go.micro.client.Client/Publish",
-	}
-	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
-		return srv.(ClientServer).Publish(ctx, req.(*Message))
-	}
-	return interceptor(ctx, in, info, handler)
-}
-
-var _Client_serviceDesc = grpc.ServiceDesc{
-	ServiceName: "go.micro.client.Client",
-	HandlerType: (*ClientServer)(nil),
-	Methods: []grpc.MethodDesc{
-		{
-			MethodName: "Call",
-			Handler:    _Client_Call_Handler,
-		},
-		{
-			MethodName: "Publish",
-			Handler:    _Client_Publish_Handler,
-		},
-	},
-	Streams: []grpc.StreamDesc{
-		{
-			StreamName:    "Stream",
-			Handler:       _Client_Stream_Handler,
-			ServerStreams: true,
-			ClientStreams: true,
-		},
-	},
-	Metadata: "micro/go-micro/client/proto/client.proto",
-}

client/rpc_client.go

@@ -10,14 +10,15 @@ import (
 
 	"github.com/google/uuid"
 	"github.com/micro/go-micro/broker"
-	"github.com/micro/go-micro/client/pool"
 	"github.com/micro/go-micro/client/selector"
 	"github.com/micro/go-micro/codec"
+	raw "github.com/micro/go-micro/codec/bytes"
 	"github.com/micro/go-micro/errors"
 	"github.com/micro/go-micro/metadata"
 	"github.com/micro/go-micro/registry"
 	"github.com/micro/go-micro/transport"
 	"github.com/micro/go-micro/util/buf"
+	"github.com/micro/go-micro/util/pool"
 )
 
 type rpcClient struct {
@@ -28,7 +29,7 @@ type rpcClient struct {
 }
 
 func newRpcClient(opt ...Option) Client {
-	opts := newOptions(opt...)
+	opts := NewOptions(opt...)
 
 	p := pool.NewPool(
 		pool.Size(opts.PoolSize),
@@ -161,7 +162,6 @@ func (r *rpcClient) call(ctx context.Context, node *registry.Node, req Request,
 
 	select {
 	case err := <-ch:
-		grr = err
 		return err
 	case <-ctx.Done():
 		grr = errors.Timeout("go.micro.client", fmt.Sprintf("%v", ctx.Err()))
@@ -316,6 +316,22 @@ func (r *rpcClient) Options() Options {
 	return r.opts
 }
 
+// hasProxy checks if we have proxy set in the environment
+func (r *rpcClient) hasProxy() bool {
+	// get proxy
+	if prx := os.Getenv("MICRO_PROXY"); len(prx) > 0 {
+		return true
+	}
+
+	// get proxy address
+	if prx := os.Getenv("MICRO_PROXY_ADDRESS"); len(prx) > 0 {
+		return true
+	}
+
+	return false
+}
+
+// next returns an iterator for the next nodes to call
 func (r *rpcClient) next(request Request, opts CallOptions) (selector.Next, error) {
 	service := request.Service()
 
@@ -377,7 +393,9 @@ func (r *rpcClient) Call(ctx context.Context, request Request, response interfac
 	d, ok := ctx.Deadline()
 	if !ok {
 		// no deadline so we create a new one
-		ctx, _ = context.WithTimeout(ctx, callOpts.RequestTimeout)
+		var cancel context.CancelFunc
+		ctx, cancel = context.WithTimeout(ctx, callOpts.RequestTimeout)
+		defer cancel()
 	} else {
 		// got a deadline so no need to setup context
 		// but we need to set the timeout we pass along
@@ -429,10 +447,18 @@ func (r *rpcClient) Call(ctx context.Context, request Request, response interfac
 		return err
 	}
 
-	ch := make(chan error, callOpts.Retries+1)
+	// get the retries
+	retries := callOpts.Retries
+
+	// disable retries when using a proxy
+	if r.hasProxy() {
+		retries = 0
+	}
+
+	ch := make(chan error, retries+1)
 	var gerr error
 
-	for i := 0; i <= callOpts.Retries; i++ {
+	for i := 0; i <= retries; i++ {
 		go func(i int) {
 			ch <- call(i)
 		}(i)
@@ -512,10 +538,18 @@ func (r *rpcClient) Stream(ctx context.Context, request Request, opts ...CallOpt
 		err    error
 	}
 
-	ch := make(chan response, callOpts.Retries+1)
+	// get the retries
+	retries := callOpts.Retries
+
+	// disable retries when using a proxy
+	if r.hasProxy() {
+		retries = 0
+	}
+
+	ch := make(chan response, retries+1)
 	var grr error
 
-	for i := 0; i <= callOpts.Retries; i++ {
+	for i := 0; i <= retries; i++ {
 		go func(i int) {
 			s, err := call(i)
 			ch <- response{s, err}
@@ -583,26 +617,37 @@ func (r *rpcClient) Publish(ctx context.Context, msg Message, opts ...PublishOpt
 		return errors.InternalServerError("go.micro.client", err.Error())
 	}
 
-	// new buffer
-	b := buf.New(nil)
+	var body []byte
 
-	if err := cf(b).Write(&codec.Message{
-		Target: topic,
-		Type:   codec.Event,
-		Header: map[string]string{
-			"Micro-Id":    id,
-			"Micro-Topic": msg.Topic(),
-		},
-	}, msg.Payload()); err != nil {
-		return errors.InternalServerError("go.micro.client", err.Error())
+	// passed in raw data
+	if d, ok := msg.Payload().(*raw.Frame); ok {
+		body = d.Data
+	} else {
+		// new buffer
+		b := buf.New(nil)
+
+		if err := cf(b).Write(&codec.Message{
+			Target: topic,
+			Type:   codec.Event,
+			Header: map[string]string{
+				"Micro-Id":    id,
+				"Micro-Topic": msg.Topic(),
+			},
+		}, msg.Payload()); err != nil {
+			return errors.InternalServerError("go.micro.client", err.Error())
+		}
+
+		// set the body
+		body = b.Bytes()
 	}
+
 	r.once.Do(func() {
 		r.opts.Broker.Connect()
 	})
 
 	return r.opts.Broker.Publish(topic, &broker.Message{
 		Header: md,
-		Body:   b.Bytes(),
+		Body:   body,
 	})
 }
 

client/rpc_client_test.go

@@ -12,10 +12,7 @@ import (
 )
 
 func newTestRegistry() registry.Registry {
-	r := memory.NewRegistry()
-	reg := r.(*memory.Registry)
-	reg.Services = testData
-	return reg
+	return memory.NewRegistry(memory.Services(testData))
 }
 
 func TestCallAddress(t *testing.T) {
@@ -146,6 +143,9 @@ func TestCallWrapper(t *testing.T) {
 			{
 				Id:      id,
 				Address: address,
+				Metadata: map[string]string{
+					"protocol": "mucp",
+				},
 			},
 		},
 	})

client/rpc_codec.go

@@ -88,32 +88,24 @@ func (rwc *readWriteCloser) Close() error {
 }
 
 func getHeaders(m *codec.Message) {
-	get := func(hdr string) string {
-		if hd := m.Header[hdr]; len(hd) > 0 {
-			return hd
+	set := func(v, hdr string) string {
+		if len(v) > 0 {
+			return v
 		}
-		// old
-		return m.Header["X-"+hdr]
+		return m.Header[hdr]
 	}
 
 	// check error in header
-	if len(m.Error) == 0 {
-		m.Error = get("Micro-Error")
-	}
+	m.Error = set(m.Error, "Micro-Error")
 
 	// check endpoint in header
-	if len(m.Endpoint) == 0 {
-		m.Endpoint = get("Micro-Endpoint")
-	}
+	m.Endpoint = set(m.Endpoint, "Micro-Endpoint")
 
 	// check method in header
-	if len(m.Method) == 0 {
-		m.Method = get("Micro-Method")
-	}
+	m.Method = set(m.Method, "Micro-Method")
 
-	if len(m.Id) == 0 {
-		m.Id = get("Micro-Id")
-	}
+	// set the request id
+	m.Id = set(m.Id, "Micro-Id")
 }
 
 func setHeaders(m *codec.Message, stream string) {
@@ -122,7 +114,6 @@ func setHeaders(m *codec.Message, stream string) {
 			return
 		}
 		m.Header[hdr] = v
-		m.Header["X-"+hdr] = v
 	}
 
 	set("Micro-Id", m.Id)
@@ -145,6 +136,11 @@ func setupProtocol(msg *transport.Message, node *registry.Node) codec.NewCodec {
 		return nil
 	}
 
+	// processing topic publishing
+	if len(msg.Header["Micro-Topic"]) > 0 {
+		return nil
+	}
+
 	// no protocol use old codecs
 	switch msg.Header["Content-Type"] {
 	case "application/json":
@@ -190,32 +186,30 @@ func (c *rpcCodec) Write(m *codec.Message, body interface{}) error {
 
 	// if body is bytes Frame don't encode
 	if body != nil {
-		b, ok := body.(*raw.Frame)
-		if ok {
+		if b, ok := body.(*raw.Frame); ok {
 			// set body
 			m.Body = b.Data
-			body = nil
+		} else {
+			// write to codec
+			if err := c.codec.Write(m, body); err != nil {
+				return errors.InternalServerError("go.micro.client.codec", err.Error())
+			}
+			// set body
+			m.Body = c.buf.wbuf.Bytes()
 		}
 	}
 
-	if len(m.Body) == 0 {
-		// write to codec
-		if err := c.codec.Write(m, body); err != nil {
-			return errors.InternalServerError("go.micro.client.codec", err.Error())
-		}
-		// set body
-		m.Body = c.buf.wbuf.Bytes()
-	}
-
 	// create new transport message
 	msg := transport.Message{
 		Header: m.Header,
 		Body:   m.Body,
 	}
+
 	// send the request
 	if err := c.client.Send(&msg); err != nil {
 		return errors.InternalServerError("go.micro.client.transport", err.Error())
 	}
+
 	return nil
 }
 

client/rpc_stream.go

@@ -83,7 +83,10 @@ func (r *rpcStream) Recv(msg interface{}) error {
 
 	var resp codec.Message
 
-	if err := r.codec.ReadHeader(&resp, codec.Response); err != nil {
+	r.Unlock()
+	err := r.codec.ReadHeader(&resp, codec.Response)
+	r.Lock()
+	if err != nil {
 		if err == io.EOF && !r.isClosed() {
 			r.err = io.ErrUnexpectedEOF
 			return io.ErrUnexpectedEOF
@@ -102,11 +105,17 @@ func (r *rpcStream) Recv(msg interface{}) error {
 		} else {
 			r.err = io.EOF
 		}
-		if err := r.codec.ReadBody(nil); err != nil {
+		r.Unlock()
+		err = r.codec.ReadBody(nil)
+		r.Lock()
+		if err != nil {
 			r.err = err
 		}
 	default:
-		if err := r.codec.ReadBody(msg); err != nil {
+		r.Unlock()
+		err = r.codec.ReadBody(msg)
+		r.Lock()
+		if err != nil {
 			r.err = err
 		}
 	}
@@ -121,11 +130,15 @@ func (r *rpcStream) Error() error {
 }
 
 func (r *rpcStream) Close() error {
+	r.RLock()
+
 	select {
 	case <-r.closed:
+		r.RUnlock()
 		return nil
 	default:
 		close(r.closed)
+		r.RUnlock()
 
 		// send the end of stream message
 		if r.sendEOS {

client/selector/default_test.go

@@ -9,9 +9,7 @@ import (
 func TestRegistrySelector(t *testing.T) {
 	counts := map[string]int{}
 
-	r := memory.NewRegistry()
-	rg := r.(*memory.Registry)
-	rg.Services = testData
+	r := memory.NewRegistry(memory.Services(testData))
 	cache := NewSelector(Registry(r))
 
 	next, err := cache.Select("foo")

client/selector/dns/dns.go

@@ -63,7 +63,7 @@ func (d *dnsSelector) Select(service string, opts ...selector.SelectOption) (sel
 		}
 	}
 
-	var nodes []*registry.Node
+	nodes := make([]*registry.Node, 0, len(srv))
 	for _, node := range srv {
 		nodes = append(nodes, &registry.Node{
 			Id:      node.Target,
@@ -99,13 +99,9 @@ func (d *dnsSelector) Select(service string, opts ...selector.SelectOption) (sel
 	return sopts.Strategy(services), nil
 }
 
-func (d *dnsSelector) Mark(service string, node *registry.Node, err error) {
-	return
-}
+func (d *dnsSelector) Mark(service string, node *registry.Node, err error) {}
 
-func (d *dnsSelector) Reset(service string) {
-	return
-}
+func (d *dnsSelector) Reset(service string) {}
 
 func (d *dnsSelector) Close() error {
 	return nil

client/selector/router/router.go

@@ -11,7 +11,7 @@ import (
 	"github.com/micro/go-micro/client/selector"
 	"github.com/micro/go-micro/registry"
 	"github.com/micro/go-micro/router"
-	pb "github.com/micro/go-micro/router/proto"
+	pb "github.com/micro/go-micro/router/service/proto"
 )
 
 type routerSelector struct {
@@ -101,7 +101,7 @@ func (r *routerSelector) getRoutes(service string) ([]router.Route, error) {
 		return nil, selector.ErrNoneAvailable
 	}
 
-	var routes []router.Route
+	routes := make([]router.Route, 0, len(pbRoutes.Routes))
 
 	// convert from pb to []*router.Route
 	for _, r := range pbRoutes.Routes {
@@ -176,12 +176,10 @@ func (r *routerSelector) Select(service string, opts ...selector.SelectOption) (
 
 func (r *routerSelector) Mark(service string, node *registry.Node, err error) {
 	// TODO: pass back metrics or information to the router
-	return
 }
 
 func (r *routerSelector) Reset(service string) {
 	// TODO: reset the metrics or information at the router
-	return
 }
 
 func (r *routerSelector) Close() error {

client/selector/selector.go

@@ -3,6 +3,7 @@ package selector
 
 import (
 	"errors"
+
 	"github.com/micro/go-micro/registry"
 )
 

client/selector/strategy.go

@@ -14,7 +14,7 @@ func init() {
 
 // Random is a random strategy algorithm for node selection
 func Random(services []*registry.Service) Next {
-	var nodes []*registry.Node
+	nodes := make([]*registry.Node, 0, len(services))
 
 	for _, service := range services {
 		nodes = append(nodes, service.Nodes...)
@@ -32,7 +32,7 @@ func Random(services []*registry.Service) Next {
 
 // RoundRobin is a roundrobin strategy algorithm for node selection
 func RoundRobin(services []*registry.Service) Next {
-	var nodes []*registry.Node
+	nodes := make([]*registry.Node, 0, len(services))
 
 	for _, service := range services {
 		nodes = append(nodes, service.Nodes...)

client/service/proto/client.pb.go

@@ -0,0 +1,210 @@
+// Code generated by protoc-gen-go. DO NOT EDIT.
+// source: github.com/micro/go-micro/client/proto/client.proto
+
+package go_micro_client
+
+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 Request struct {
+	Service              string   `protobuf:"bytes,1,opt,name=service,proto3" json:"service,omitempty"`
+	Endpoint             string   `protobuf:"bytes,2,opt,name=endpoint,proto3" json:"endpoint,omitempty"`
+	ContentType          string   `protobuf:"bytes,3,opt,name=content_type,json=contentType,proto3" json:"content_type,omitempty"`
+	Body                 []byte   `protobuf:"bytes,4,opt,name=body,proto3" json:"body,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_d418333f021a3308, []int{0}
+}
+
+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) GetService() string {
+	if m != nil {
+		return m.Service
+	}
+	return ""
+}
+
+func (m *Request) GetEndpoint() string {
+	if m != nil {
+		return m.Endpoint
+	}
+	return ""
+}
+
+func (m *Request) GetContentType() string {
+	if m != nil {
+		return m.ContentType
+	}
+	return ""
+}
+
+func (m *Request) GetBody() []byte {
+	if m != nil {
+		return m.Body
+	}
+	return nil
+}
+
+type Response struct {
+	Body                 []byte   `protobuf:"bytes,1,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_d418333f021a3308, []int{1}
+}
+
+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) GetBody() []byte {
+	if m != nil {
+		return m.Body
+	}
+	return nil
+}
+
+type Message struct {
+	Topic                string   `protobuf:"bytes,1,opt,name=topic,proto3" json:"topic,omitempty"`
+	ContentType          string   `protobuf:"bytes,2,opt,name=content_type,json=contentType,proto3" json:"content_type,omitempty"`
+	Body                 []byte   `protobuf:"bytes,3,opt,name=body,proto3" json:"body,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *Message) Reset()         { *m = Message{} }
+func (m *Message) String() string { return proto.CompactTextString(m) }
+func (*Message) ProtoMessage()    {}
+func (*Message) Descriptor() ([]byte, []int) {
+	return fileDescriptor_d418333f021a3308, []int{2}
+}
+
+func (m *Message) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_Message.Unmarshal(m, b)
+}
+func (m *Message) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_Message.Marshal(b, m, deterministic)
+}
+func (m *Message) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_Message.Merge(m, src)
+}
+func (m *Message) XXX_Size() int {
+	return xxx_messageInfo_Message.Size(m)
+}
+func (m *Message) XXX_DiscardUnknown() {
+	xxx_messageInfo_Message.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_Message proto.InternalMessageInfo
+
+func (m *Message) GetTopic() string {
+	if m != nil {
+		return m.Topic
+	}
+	return ""
+}
+
+func (m *Message) GetContentType() string {
+	if m != nil {
+		return m.ContentType
+	}
+	return ""
+}
+
+func (m *Message) GetBody() []byte {
+	if m != nil {
+		return m.Body
+	}
+	return nil
+}
+
+func init() {
+	proto.RegisterType((*Request)(nil), "go.micro.client.Request")
+	proto.RegisterType((*Response)(nil), "go.micro.client.Response")
+	proto.RegisterType((*Message)(nil), "go.micro.client.Message")
+}
+
+func init() {
+	proto.RegisterFile("github.com/micro/go-micro/client/proto/client.proto", fileDescriptor_d418333f021a3308)
+}
+
+var fileDescriptor_d418333f021a3308 = []byte{
+	// 279 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x9c, 0x91, 0x31, 0x4f, 0xfb, 0x30,
+	0x10, 0xc5, 0xeb, 0xb6, 0xff, 0xa4, 0xff, 0xa3, 0x12, 0x92, 0xc5, 0x60, 0x32, 0xa0, 0x92, 0x29,
+	0x0b, 0x0e, 0xa2, 0x33, 0x62, 0xc8, 0x8c, 0x84, 0x02, 0x62, 0x45, 0x89, 0x7b, 0x4a, 0x2d, 0x25,
+	0xb6, 0x89, 0x9d, 0x4a, 0xf9, 0x90, 0x7c, 0x27, 0x24, 0x27, 0xa5, 0x08, 0xda, 0x85, 0xed, 0xde,
+	0xfd, 0xac, 0x77, 0xe7, 0x77, 0xb0, 0xae, 0xa4, 0xdb, 0x76, 0x25, 0x17, 0xba, 0x49, 0x1b, 0x29,
+	0x5a, 0x9d, 0x56, 0xfa, 0x66, 0x28, 0x44, 0x2d, 0x51, 0xb9, 0xd4, 0xb4, 0xda, 0xed, 0x05, 0xf7,
+	0x82, 0x9e, 0x57, 0x9a, 0xfb, 0x37, 0x7c, 0x68, 0xc7, 0x3b, 0x08, 0x73, 0x7c, 0xef, 0xd0, 0x3a,
+	0xca, 0x20, 0xb4, 0xd8, 0xee, 0xa4, 0x40, 0x46, 0x56, 0x24, 0xf9, 0x9f, 0xef, 0x25, 0x8d, 0x60,
+	0x81, 0x6a, 0x63, 0xb4, 0x54, 0x8e, 0x4d, 0x3d, 0xfa, 0xd2, 0xf4, 0x1a, 0x96, 0x42, 0x2b, 0x87,
+	0xca, 0xbd, 0xb9, 0xde, 0x20, 0x9b, 0x79, 0x7e, 0x36, 0xf6, 0x5e, 0x7a, 0x83, 0x94, 0xc2, 0xbc,
+	0xd4, 0x9b, 0x9e, 0xcd, 0x57, 0x24, 0x59, 0xe6, 0xbe, 0x8e, 0xaf, 0x60, 0x91, 0xa3, 0x35, 0x5a,
+	0xd9, 0x03, 0x27, 0xdf, 0xf8, 0x2b, 0x84, 0x8f, 0x68, 0x6d, 0x51, 0x21, 0xbd, 0x80, 0x7f, 0x4e,
+	0x1b, 0x29, 0xc6, 0xad, 0x06, 0xf1, 0x6b, 0xee, 0xf4, 0xf4, 0xdc, 0xd9, 0xc1, 0xf7, 0xee, 0x83,
+	0x40, 0x90, 0xf9, 0xaf, 0xd3, 0x7b, 0x98, 0x67, 0x45, 0x5d, 0x53, 0xc6, 0x7f, 0x84, 0xc2, 0xc7,
+	0x44, 0xa2, 0xcb, 0x23, 0x64, 0xd8, 0x39, 0x9e, 0xd0, 0x0c, 0x82, 0x67, 0xd7, 0x62, 0xd1, 0xfc,
+	0xd1, 0x20, 0x21, 0xb7, 0x84, 0x3e, 0x40, 0xf8, 0xd4, 0x95, 0xb5, 0xb4, 0xdb, 0x23, 0x2e, 0x63,
+	0x00, 0xd1, 0x49, 0x12, 0x4f, 0xca, 0xc0, 0xdf, 0x75, 0xfd, 0x19, 0x00, 0x00, 0xff, 0xff, 0xb6,
+	0x4d, 0x6e, 0xd5, 0x0e, 0x02, 0x00, 0x00,
+}

client/service/proto/client.pb.micro.go

@@ -1,5 +1,5 @@
 // Code generated by protoc-gen-micro. DO NOT EDIT.
-// source: micro/go-micro/client/proto/client.proto
+// source: github.com/micro/go-micro/client/proto/client.proto
 
 package go_micro_client
 

codec/bytes/bytes.go

@@ -29,12 +29,10 @@ func (c *Codec) ReadBody(b interface{}) error {
 		return err
 	}
 
-	switch b.(type) {
+	switch v := b.(type) {
 	case *[]byte:
-		v := b.(*[]byte)
 		*v = buf
 	case *Frame:
-		v := b.(*Frame)
 		v.Data = buf
 	default:
 		return fmt.Errorf("failed to read body: %v is not type of *[]byte", b)
@@ -45,14 +43,13 @@ func (c *Codec) ReadBody(b interface{}) error {
 
 func (c *Codec) Write(m *codec.Message, b interface{}) error {
 	var v []byte
-	switch b.(type) {
+	switch vb := b.(type) {
 	case *Frame:
-		v = b.(*Frame).Data
+		v = vb.Data
 	case *[]byte:
-		ve := b.(*[]byte)
-		v = *ve
+		v = *vb
 	case []byte:
-		v = b.([]byte)
+		v = vb
 	default:
 		return fmt.Errorf("failed to write: %v is not type of *[]byte or []byte", b)
 	}

codec/bytes/marshaler.go

@@ -12,25 +12,22 @@ type Message struct {
 }
 
 func (n Marshaler) Marshal(v interface{}) ([]byte, error) {
-	switch v.(type) {
+	switch ve := v.(type) {
 	case *[]byte:
-		ve := v.(*[]byte)
 		return *ve, nil
 	case []byte:
-		return v.([]byte), nil
+		return ve, nil
 	case *Message:
-		return v.(*Message).Body, nil
+		return ve.Body, nil
 	}
 	return nil, errors.New("invalid message")
 }
 
 func (n Marshaler) Unmarshal(d []byte, v interface{}) error {
-	switch v.(type) {
+	switch ve := v.(type) {
 	case *[]byte:
-		ve := v.(*[]byte)
 		*ve = d
 	case *Message:
-		ve := v.(*Message)
 		ve.Body = d
 	}
 	return errors.New("invalid message")

codec/grpc/grpc.go

@@ -126,6 +126,10 @@ func (c *Codec) Write(m *codec.Message, b interface{}) error {
 		return err
 	}
 
+	if len(buf) == 0 {
+		return nil
+	}
+
 	return encode(0, buf, c.Conn)
 }
 

codec/jsonrpc/jsonrpc.go

@@ -60,7 +60,6 @@ func (j *jsonCodec) ReadHeader(m *codec.Message, mt codec.MessageType) error {
 	default:
 		return fmt.Errorf("Unrecognised message type: %v", mt)
 	}
-	return nil
 }
 
 func (j *jsonCodec) ReadBody(b interface{}) error {

codec/text/text.go

@@ -29,15 +29,12 @@ func (c *Codec) ReadBody(b interface{}) error {
 		return err
 	}
 
-	switch b.(type) {
+	switch v := b.(type) {
 	case *string:
-		v := b.(*string)
 		*v = string(buf)
 	case *[]byte:
-		v := b.(*[]byte)
 		*v = buf
 	case *Frame:
-		v := b.(*Frame)
 		v.Data = buf
 	default:
 		return fmt.Errorf("failed to read body: %v is not type of *[]byte", b)
@@ -48,20 +45,17 @@ func (c *Codec) ReadBody(b interface{}) error {
 
 func (c *Codec) Write(m *codec.Message, b interface{}) error {
 	var v []byte
-	switch b.(type) {
+	switch ve := b.(type) {
 	case *Frame:
-		v = b.(*Frame).Data
+		v = ve.Data
 	case *[]byte:
-		ve := b.(*[]byte)
 		v = *ve
 	case *string:
-		ve := b.(*string)
 		v = []byte(*ve)
 	case string:
-		ve := b.(string)
 		v = []byte(ve)
 	case []byte:
-		v = b.([]byte)
+		v = ve
 	default:
 		return fmt.Errorf("failed to write: %v is not type of *[]byte or []byte", b)
 	}

common_test.go

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

config/cmd/cmd.go

@@ -3,51 +3,58 @@ package cmd
 
 import (
 	"fmt"
-	"io"
 	"math/rand"
-	"os"
 	"strings"
 	"time"
 
-	"github.com/micro/cli"
+	"github.com/micro/go-micro/broker"
 	"github.com/micro/go-micro/client"
-	cgrpc "github.com/micro/go-micro/client/grpc"
-	cmucp "github.com/micro/go-micro/client/mucp"
+	"github.com/micro/go-micro/client/selector"
+	"github.com/micro/go-micro/debug/trace"
+	"github.com/micro/go-micro/registry"
+	"github.com/micro/go-micro/runtime"
 	"github.com/micro/go-micro/server"
-	sgrpc "github.com/micro/go-micro/server/grpc"
-	smucp "github.com/micro/go-micro/server/mucp"
+	"github.com/micro/go-micro/store"
+	"github.com/micro/go-micro/transport"
 	"github.com/micro/go-micro/util/log"
 
+	// clients
+	cgrpc "github.com/micro/go-micro/client/grpc"
+	cmucp "github.com/micro/go-micro/client/mucp"
+
+	// servers
+	"github.com/micro/cli/v2"
+	sgrpc "github.com/micro/go-micro/server/grpc"
+	smucp "github.com/micro/go-micro/server/mucp"
+
 	// brokers
-	"github.com/micro/go-micro/broker"
-	"github.com/micro/go-micro/broker/http"
 	"github.com/micro/go-micro/broker/memory"
 	"github.com/micro/go-micro/broker/nats"
 	brokerSrv "github.com/micro/go-micro/broker/service"
 
 	// registries
-	"github.com/micro/go-micro/registry"
 	"github.com/micro/go-micro/registry/etcd"
+	kreg "github.com/micro/go-micro/registry/kubernetes"
 	"github.com/micro/go-micro/registry/mdns"
 	rmem "github.com/micro/go-micro/registry/memory"
 	regSrv "github.com/micro/go-micro/registry/service"
 
 	// selectors
-	"github.com/micro/go-micro/client/selector"
 	"github.com/micro/go-micro/client/selector/dns"
 	"github.com/micro/go-micro/client/selector/router"
 	"github.com/micro/go-micro/client/selector/static"
 
 	// transports
-	"github.com/micro/go-micro/transport"
-	tgrpc "github.com/micro/go-micro/transport/grpc"
 	thttp "github.com/micro/go-micro/transport/http"
 	tmem "github.com/micro/go-micro/transport/memory"
-	"github.com/micro/go-micro/transport/quic"
 
-	// runtimes
-	"github.com/micro/go-micro/runtime"
-	"github.com/micro/go-micro/runtime/kubernetes"
+	// stores
+	memStore "github.com/micro/go-micro/store/memory"
+	svcStore "github.com/micro/go-micro/store/service"
+
+	// tracers
+	// jTracer "github.com/micro/go-micro/debug/trace/jaeger"
+	memTracer "github.com/micro/go-micro/debug/trace/memory"
 )
 
 type Cmd interface {
@@ -71,155 +78,180 @@ var (
 	DefaultCmd = newCmd()
 
 	DefaultFlags = []cli.Flag{
-		cli.StringFlag{
-			Name:   "runtime",
-			Usage:  "Micro runtime",
-			EnvVar: "MICRO_RUNTIME",
-			Value:  "local",
+		&cli.StringFlag{
+			Name:    "client",
+			EnvVars: []string{"MICRO_CLIENT"},
+			Usage:   "Client for go-micro; rpc",
 		},
-		cli.StringFlag{
-			Name:   "client",
-			EnvVar: "MICRO_CLIENT",
-			Usage:  "Client for go-micro; rpc",
+		&cli.StringFlag{
+			Name:    "client_request_timeout",
+			EnvVars: []string{"MICRO_CLIENT_REQUEST_TIMEOUT"},
+			Usage:   "Sets the client request timeout. e.g 500ms, 5s, 1m. Default: 5s",
 		},
-		cli.StringFlag{
-			Name:   "client_request_timeout",
-			EnvVar: "MICRO_CLIENT_REQUEST_TIMEOUT",
-			Usage:  "Sets the client request timeout. e.g 500ms, 5s, 1m. Default: 5s",
+		&cli.IntFlag{
+			Name:    "client_retries",
+			EnvVars: []string{"MICRO_CLIENT_RETRIES"},
+			Value:   client.DefaultRetries,
+			Usage:   "Sets the client retries. Default: 1",
 		},
-		cli.IntFlag{
-			Name:   "client_retries",
-			EnvVar: "MICRO_CLIENT_RETRIES",
-			Value:  client.DefaultRetries,
-			Usage:  "Sets the client retries. Default: 1",
+		&cli.IntFlag{
+			Name:    "client_pool_size",
+			EnvVars: []string{"MICRO_CLIENT_POOL_SIZE"},
+			Usage:   "Sets the client connection pool size. Default: 1",
 		},
-		cli.IntFlag{
-			Name:   "client_pool_size",
-			EnvVar: "MICRO_CLIENT_POOL_SIZE",
-			Usage:  "Sets the client connection pool size. Default: 1",
+		&cli.StringFlag{
+			Name:    "client_pool_ttl",
+			EnvVars: []string{"MICRO_CLIENT_POOL_TTL"},
+			Usage:   "Sets the client connection pool ttl. e.g 500ms, 5s, 1m. Default: 1m",
 		},
-		cli.StringFlag{
-			Name:   "client_pool_ttl",
-			EnvVar: "MICRO_CLIENT_POOL_TTL",
-			Usage:  "Sets the client connection pool ttl. e.g 500ms, 5s, 1m. Default: 1m",
+		&cli.IntFlag{
+			Name:    "register_ttl",
+			EnvVars: []string{"MICRO_REGISTER_TTL"},
+			Value:   60,
+			Usage:   "Register TTL in seconds",
 		},
-		cli.IntFlag{
-			Name:   "register_ttl",
-			EnvVar: "MICRO_REGISTER_TTL",
-			Value:  60,
-			Usage:  "Register TTL in seconds",
+		&cli.IntFlag{
+			Name:    "register_interval",
+			EnvVars: []string{"MICRO_REGISTER_INTERVAL"},
+			Value:   30,
+			Usage:   "Register interval in seconds",
 		},
-		cli.IntFlag{
-			Name:   "register_interval",
-			EnvVar: "MICRO_REGISTER_INTERVAL",
-			Value:  30,
-			Usage:  "Register interval in seconds",
+		&cli.StringFlag{
+			Name:    "server",
+			EnvVars: []string{"MICRO_SERVER"},
+			Usage:   "Server for go-micro; rpc",
 		},
-		cli.StringFlag{
-			Name:   "server",
-			EnvVar: "MICRO_SERVER",
-			Usage:  "Server for go-micro; rpc",
+		&cli.StringFlag{
+			Name:    "server_name",
+			EnvVars: []string{"MICRO_SERVER_NAME"},
+			Usage:   "Name of the server. go.micro.srv.example",
 		},
-		cli.StringFlag{
-			Name:   "server_name",
-			EnvVar: "MICRO_SERVER_NAME",
-			Usage:  "Name of the server. go.micro.srv.example",
+		&cli.StringFlag{
+			Name:    "server_version",
+			EnvVars: []string{"MICRO_SERVER_VERSION"},
+			Usage:   "Version of the server. 1.1.0",
 		},
-		cli.StringFlag{
-			Name:   "server_version",
-			EnvVar: "MICRO_SERVER_VERSION",
-			Usage:  "Version of the server. 1.1.0",
+		&cli.StringFlag{
+			Name:    "server_id",
+			EnvVars: []string{"MICRO_SERVER_ID"},
+			Usage:   "Id of the server. Auto-generated if not specified",
 		},
-		cli.StringFlag{
-			Name:   "server_id",
-			EnvVar: "MICRO_SERVER_ID",
-			Usage:  "Id of the server. Auto-generated if not specified",
+		&cli.StringFlag{
+			Name:    "server_address",
+			EnvVars: []string{"MICRO_SERVER_ADDRESS"},
+			Usage:   "Bind address for the server. 127.0.0.1:8080",
 		},
-		cli.StringFlag{
-			Name:   "server_address",
-			EnvVar: "MICRO_SERVER_ADDRESS",
-			Usage:  "Bind address for the server. 127.0.0.1:8080",
+		&cli.StringFlag{
+			Name:    "server_advertise",
+			EnvVars: []string{"MICRO_SERVER_ADVERTISE"},
+			Usage:   "Used instead of the server_address when registering with discovery. 127.0.0.1:8080",
 		},
-		cli.StringFlag{
-			Name:   "server_advertise",
-			EnvVar: "MICRO_SERVER_ADVERTISE",
-			Usage:  "Used instead of the server_address when registering with discovery. 127.0.0.1:8080",
+		&cli.StringSliceFlag{
+			Name:    "server_metadata",
+			EnvVars: []string{"MICRO_SERVER_METADATA"},
+			Value:   &cli.StringSlice{},
+			Usage:   "A list of key-value pairs defining metadata. version=1.0.0",
 		},
-		cli.StringSliceFlag{
-			Name:   "server_metadata",
-			EnvVar: "MICRO_SERVER_METADATA",
-			Value:  &cli.StringSlice{},
-			Usage:  "A list of key-value pairs defining metadata. version=1.0.0",
+		&cli.StringFlag{
+			Name:    "broker",
+			EnvVars: []string{"MICRO_BROKER"},
+			Usage:   "Broker for pub/sub. http, nats, rabbitmq",
 		},
-		cli.StringFlag{
-			Name:   "broker",
-			EnvVar: "MICRO_BROKER",
-			Usage:  "Broker for pub/sub. http, nats, rabbitmq",
+		&cli.StringFlag{
+			Name:    "broker_address",
+			EnvVars: []string{"MICRO_BROKER_ADDRESS"},
+			Usage:   "Comma-separated list of broker addresses",
 		},
-		cli.StringFlag{
-			Name:   "broker_address",
-			EnvVar: "MICRO_BROKER_ADDRESS",
-			Usage:  "Comma-separated list of broker addresses",
+		&cli.StringFlag{
+			Name:    "profile",
+			Usage:   "Debug profiler for cpu and memory stats",
+			EnvVars: []string{"MICRO_DEBUG_PROFILE"},
 		},
-		cli.StringFlag{
-			Name:   "registry",
-			EnvVar: "MICRO_REGISTRY",
-			Usage:  "Registry for discovery. etcd, mdns",
+		&cli.StringFlag{
+			Name:    "registry",
+			EnvVars: []string{"MICRO_REGISTRY"},
+			Usage:   "Registry for discovery. etcd, mdns",
 		},
-		cli.StringFlag{
-			Name:   "registry_address",
-			EnvVar: "MICRO_REGISTRY_ADDRESS",
-			Usage:  "Comma-separated list of registry addresses",
+		&cli.StringFlag{
+			Name:    "registry_address",
+			EnvVars: []string{"MICRO_REGISTRY_ADDRESS"},
+			Usage:   "Comma-separated list of registry addresses",
 		},
-		cli.StringFlag{
-			Name:   "selector",
-			EnvVar: "MICRO_SELECTOR",
-			Usage:  "Selector used to pick nodes for querying",
+		&cli.StringFlag{
+			Name:    "runtime",
+			Usage:   "Runtime for building and running services e.g local, kubernetes",
+			EnvVars: []string{"MICRO_RUNTIME"},
+			Value:   "local",
 		},
-		cli.StringFlag{
-			Name:   "transport",
-			EnvVar: "MICRO_TRANSPORT",
-			Usage:  "Transport mechanism used; http",
+		&cli.StringFlag{
+			Name:    "selector",
+			EnvVars: []string{"MICRO_SELECTOR"},
+			Usage:   "Selector used to pick nodes for querying",
 		},
-		cli.StringFlag{
-			Name:   "transport_address",
-			EnvVar: "MICRO_TRANSPORT_ADDRESS",
-			Usage:  "Comma-separated list of transport addresses",
+		&cli.StringFlag{
+			Name:    "store",
+			EnvVars: []string{"MICRO_STORE"},
+			Usage:   "Store used for key-value storage",
+		},
+		&cli.StringFlag{
+			Name:    "store_address",
+			EnvVars: []string{"MICRO_STORE_ADDRESS"},
+			Usage:   "Comma-separated list of store addresses",
+		},
+		&cli.StringFlag{
+			Name:    "store_namespace",
+			EnvVars: []string{"MICRO_STORE_NAMESPACE"},
+			Usage:   "Namespace for store data",
+		},
+		&cli.StringFlag{
+			Name:    "transport",
+			EnvVars: []string{"MICRO_TRANSPORT"},
+			Usage:   "Transport mechanism used; http",
+		},
+		&cli.StringFlag{
+			Name:    "transport_address",
+			EnvVars: []string{"MICRO_TRANSPORT_ADDRESS"},
+			Usage:   "Comma-separated list of transport addresses",
+		},
+		&cli.StringFlag{
+			Name:    "tracer",
+			EnvVars: []string{"MICRO_TRACER"},
+			Usage:   "Tracer for distributed tracing, e.g. memory, jaeger",
+			Value:   "memory",
+		},
+		&cli.StringFlag{
+			Name:    "tracer_address",
+			EnvVars: []string{"MICRO_TRACER_ADDRESS"},
+			Usage:   "Comma-separated list of tracer addresses",
 		},
 	}
 
 	DefaultBrokers = map[string]func(...broker.Option) broker.Broker{
-		"go.micro.broker": brokerSrv.NewBroker,
-		"service":         brokerSrv.NewBroker,
-		"http":            http.NewBroker,
-		"memory":          memory.NewBroker,
-		"nats":            nats.NewBroker,
+		"service": brokerSrv.NewBroker,
+		"memory":  memory.NewBroker,
+		"nats":    nats.NewBroker,
 	}
 
 	DefaultClients = map[string]func(...client.Option) client.Client{
-		"rpc":  client.NewClient,
 		"mucp": cmucp.NewClient,
 		"grpc": cgrpc.NewClient,
 	}
 
 	DefaultRegistries = map[string]func(...registry.Option) registry.Registry{
-		"go.micro.registry": regSrv.NewRegistry,
-		"service":           regSrv.NewRegistry,
-		"etcd":              etcd.NewRegistry,
-		"mdns":              mdns.NewRegistry,
-		"memory":            rmem.NewRegistry,
+		"service":    regSrv.NewRegistry,
+		"etcd":       etcd.NewRegistry,
+		"mdns":       mdns.NewRegistry,
+		"memory":     rmem.NewRegistry,
+		"kubernetes": kreg.NewRegistry,
 	}
 
 	DefaultSelectors = map[string]func(...selector.Option) selector.Selector{
-		"default": selector.NewSelector,
-		"dns":     dns.NewSelector,
-		"cache":   selector.NewSelector,
-		"router":  router.NewSelector,
-		"static":  static.NewSelector,
+		"dns":    dns.NewSelector,
+		"router": router.NewSelector,
+		"static": static.NewSelector,
 	}
 
 	DefaultServers = map[string]func(...server.Option) server.Server{
-		"rpc":  server.NewServer,
 		"mucp": smucp.NewServer,
 		"grpc": sgrpc.NewServer,
 	}
@@ -227,32 +259,35 @@ var (
 	DefaultTransports = map[string]func(...transport.Option) transport.Transport{
 		"memory": tmem.NewTransport,
 		"http":   thttp.NewTransport,
-		"grpc":   tgrpc.NewTransport,
-		"quic":   quic.NewTransport,
 	}
 
 	DefaultRuntimes = map[string]func(...runtime.Option) runtime.Runtime{
-		"local":      runtime.NewRuntime,
-		"kubernetes": kubernetes.NewRuntime,
+		"local": runtime.NewRuntime,
+	}
+
+	DefaultStores = map[string]func(...store.Option) store.Store{
+		"memory":  memStore.NewStore,
+		"service": svcStore.NewStore,
+	}
+
+	DefaultTracers = map[string]func(...trace.Option) trace.Tracer{
+		"memory": memTracer.NewTracer,
+		// "jaeger": jTracer.NewTracer,
 	}
 
 	// used for default selection as the fall back
-	defaultClient    = "rpc"
-	defaultServer    = "rpc"
-	defaultBroker    = "http"
+	defaultClient    = "grpc"
+	defaultServer    = "grpc"
+	defaultBroker    = "eats"
 	defaultRegistry  = "mdns"
 	defaultSelector  = "registry"
 	defaultTransport = "http"
 	defaultRuntime   = "local"
+	defaultStore     = "memory"
 )
 
 func init() {
 	rand.Seed(time.Now().Unix())
-	help := cli.HelpPrinter
-	cli.HelpPrinter = func(writer io.Writer, templ string, data interface{}) {
-		help(writer, templ, data)
-		os.Exit(0)
-	}
 }
 
 func newCmd(opts ...Option) Cmd {
@@ -264,6 +299,8 @@ func newCmd(opts ...Option) Cmd {
 		Selector:  &selector.DefaultSelector,
 		Transport: &transport.DefaultTransport,
 		Runtime:   &runtime.DefaultRuntime,
+		Store:     &store.DefaultStore,
+		Tracer:    &trace.DefaultTracer,
 
 		Brokers:    DefaultBrokers,
 		Clients:    DefaultClients,
@@ -272,6 +309,8 @@ func newCmd(opts ...Option) Cmd {
 		Servers:    DefaultServers,
 		Transports: DefaultTransports,
 		Runtimes:   DefaultRuntimes,
+		Stores:     DefaultStores,
+		Tracers:    DefaultTracers,
 	}
 
 	for _, o := range opts {
@@ -290,7 +329,9 @@ func newCmd(opts ...Option) Cmd {
 	cmd.app.Usage = cmd.opts.Description
 	cmd.app.Before = cmd.Before
 	cmd.app.Flags = DefaultFlags
-	cmd.app.Action = func(c *cli.Context) {}
+	cmd.app.Action = func(c *cli.Context) error {
+		return nil
+	}
 
 	if len(options.Version) == 0 {
 		cmd.app.HideVersion = true
@@ -312,6 +353,16 @@ func (c *cmd) Before(ctx *cli.Context) error {
 	var serverOpts []server.Option
 	var clientOpts []client.Option
 
+	// Set the store
+	if name := ctx.String("store"); len(name) > 0 {
+		s, ok := c.opts.Stores[name]
+		if !ok {
+			return fmt.Errorf("Unsupported store: %s", name)
+		}
+
+		*c.opts.Store = s()
+	}
+
 	// Set the runtime
 	if name := ctx.String("runtime"); len(name) > 0 {
 		r, ok := c.opts.Runtimes[name]
@@ -322,6 +373,16 @@ func (c *cmd) Before(ctx *cli.Context) error {
 		*c.opts.Runtime = r()
 	}
 
+	// Set the tracer
+	if name := ctx.String("tracer"); len(name) > 0 {
+		r, ok := c.opts.Tracers[name]
+		if !ok {
+			return fmt.Errorf("Unsupported tracer: %s", name)
+		}
+
+		*c.opts.Tracer = r()
+	}
+
 	// Set the client
 	if name := ctx.String("client"); len(name) > 0 {
 		// only change if we have the client and type differs
@@ -431,6 +492,18 @@ func (c *cmd) Before(ctx *cli.Context) error {
 		}
 	}
 
+	if len(ctx.String("store_address")) > 0 {
+		if err := (*c.opts.Store).Init(store.Nodes(strings.Split(ctx.String("store_address"), ",")...)); err != nil {
+			log.Fatalf("Error configuring store: %v", err)
+		}
+	}
+
+	if len(ctx.String("store_namespace")) > 0 {
+		if err := (*c.opts.Store).Init(store.Namespace(ctx.String("store_address"))); err != nil {
+			log.Fatalf("Error configuring store: %v", err)
+		}
+	}
+
 	if len(ctx.String("server_name")) > 0 {
 		serverOpts = append(serverOpts, server.Name(ctx.String("server_name")))
 	}
@@ -451,11 +524,11 @@ func (c *cmd) Before(ctx *cli.Context) error {
 		serverOpts = append(serverOpts, server.Advertise(ctx.String("server_advertise")))
 	}
 
-	if ttl := time.Duration(ctx.GlobalInt("register_ttl")); ttl >= 0 {
+	if ttl := time.Duration(ctx.Int("register_ttl")); ttl >= 0 {
 		serverOpts = append(serverOpts, server.RegisterTTL(ttl*time.Second))
 	}
 
-	if val := time.Duration(ctx.GlobalInt("register_interval")); val >= 0 {
+	if val := time.Duration(ctx.Int("register_interval")); val >= 0 {
 		serverOpts = append(serverOpts, server.RegisterInterval(val*time.Second))
 	}
 
@@ -506,8 +579,12 @@ func (c *cmd) Init(opts ...Option) error {
 	for _, o := range opts {
 		o(&c.opts)
 	}
-	c.app.Name = c.opts.Name
-	c.app.Version = c.opts.Version
+	if len(c.opts.Name) > 0 {
+		c.app.Name = c.opts.Name
+	}
+	if len(c.opts.Version) > 0 {
+		c.app.Version = c.opts.Version
+	}
 	c.app.HideVersion = len(c.opts.Version) == 0
 	c.app.Usage = c.opts.Description
 	c.app.RunAndExitOnError()

config/cmd/options.go

@@ -6,9 +6,11 @@ import (
 	"github.com/micro/go-micro/broker"
 	"github.com/micro/go-micro/client"
 	"github.com/micro/go-micro/client/selector"
+	"github.com/micro/go-micro/debug/trace"
 	"github.com/micro/go-micro/registry"
 	"github.com/micro/go-micro/runtime"
 	"github.com/micro/go-micro/server"
+	"github.com/micro/go-micro/store"
 	"github.com/micro/go-micro/transport"
 )
 
@@ -26,6 +28,8 @@ type Options struct {
 	Client    *client.Client
 	Server    *server.Server
 	Runtime   *runtime.Runtime
+	Store     *store.Store
+	Tracer    *trace.Tracer
 
 	Brokers    map[string]func(...broker.Option) broker.Broker
 	Clients    map[string]func(...client.Option) client.Client
@@ -34,6 +38,8 @@ type Options struct {
 	Servers    map[string]func(...server.Option) server.Server
 	Transports map[string]func(...transport.Option) transport.Transport
 	Runtimes   map[string]func(...runtime.Option) runtime.Runtime
+	Stores     map[string]func(...store.Option) store.Store
+	Tracers    map[string]func(...trace.Option) trace.Tracer
 
 	// Other options for implementations of the interface
 	// can be stored in a context
@@ -97,6 +103,12 @@ func Server(s *server.Server) Option {
 	}
 }
 
+func Tracer(t *trace.Tracer) Option {
+	return func(o *Options) {
+		o.Tracer = t
+	}
+}
+
 // New broker func
 func NewBroker(name string, b func(...broker.Option) broker.Broker) Option {
 	return func(o *Options) {
@@ -145,3 +157,10 @@ func NewRuntime(name string, r func(...runtime.Option) runtime.Runtime) Option {
 		o.Runtimes[name] = r
 	}
 }
+
+// New tracer func
+func NewTracer(name string, t func(...trace.Option) trace.Tracer) Option {
+	return func(o *Options) {
+		o.Tracers[name] = t
+	}
+}

config/config.go

@@ -43,11 +43,11 @@ type Option func(o *Options)
 
 var (
 	// Default Config Manager
-	DefaultConfig = NewConfig()
+	DefaultConfig, _ = NewConfig()
 )
 
 // NewConfig returns new config
-func NewConfig(opts ...Option) Config {
+func NewConfig(opts ...Option) (Config, error) {
 	return newConfig(opts...)
 }
 

config/default.go

@@ -30,7 +30,7 @@ type watcher struct {
 	value reader.Value
 }
 
-func newConfig(opts ...Option) Config {
+func newConfig(opts ...Option) (Config, error) {
 	options := Options{
 		Loader: memory.NewLoader(),
 		Reader: json.NewReader(),
@@ -40,9 +40,18 @@ func newConfig(opts ...Option) Config {
 		o(&options)
 	}
 
-	options.Loader.Load(options.Source...)
-	snap, _ := options.Loader.Snapshot()
-	vals, _ := options.Reader.Values(snap.ChangeSet)
+	if err := options.Loader.Load(options.Source...); err != nil {
+		return nil, err
+	}
+
+	snap, err := options.Loader.Snapshot()
+	if err != nil {
+		return nil, err
+	}
+	vals, err := options.Reader.Values(snap.ChangeSet)
+	if err != nil {
+		return nil, err
+	}
 
 	c := &config{
 		exit: make(chan bool),
@@ -53,7 +62,7 @@ func newConfig(opts ...Option) Config {
 
 	go c.run()
 
-	return c
+	return c, nil
 }
 
 func (c *config) run() {
@@ -172,6 +181,28 @@ func (c *config) Get(path ...string) reader.Value {
 	return newValue()
 }
 
+func (c *config) Set(val interface{}, path ...string) {
+	c.Lock()
+	defer c.Unlock()
+
+	if c.vals != nil {
+		c.vals.Set(val, path...)
+	}
+
+	return
+}
+
+func (c *config) Del(path ...string) {
+	c.Lock()
+	defer c.Unlock()
+
+	if c.vals != nil {
+		c.vals.Del(path...)
+	}
+
+	return
+}
+
 func (c *config) Bytes() []byte {
 	c.RLock()
 	defer c.RUnlock()

config/default_test.go

@@ -55,7 +55,10 @@ func TestConfigLoadWithGoodFile(t *testing.T) {
 	}()
 
 	// Create new config
-	conf := NewConfig()
+	conf, err := NewConfig()
+	if err != nil {
+		t.Fatalf("Expected no error but got %v", err)
+	}
 	// Load file source
 	if err := conf.Load(file.NewSource(
 		file.WithPath(path),
@@ -73,9 +76,12 @@ func TestConfigLoadWithInvalidFile(t *testing.T) {
 	}()
 
 	// Create new config
-	conf := NewConfig()
+	conf, err := NewConfig()
+	if err != nil {
+		t.Fatalf("Expected no error but got %v", err)
+	}
 	// Load file source
-	err := conf.Load(file.NewSource(
+	err = conf.Load(file.NewSource(
 		file.WithPath(path),
 		file.WithPath("/i/do/not/exists.json"),
 	))
@@ -105,13 +111,18 @@ func TestConfigMerge(t *testing.T) {
 	}()
 	os.Setenv("AMQP_HOST", "rabbit.testing.com")
 
-	conf := NewConfig()
-	conf.Load(
+	conf, err := NewConfig()
+	if err != nil {
+		t.Fatalf("Expected no error but got %v", err)
+	}
+	if err := conf.Load(
 		file.NewSource(
 			file.WithPath(path),
 		),
 		env.NewSource(),
-	)
+	); err != nil {
+		t.Fatalf("Expected no error but got %v", err)
+	}
 
 	actualHost := conf.Get("amqp", "host").String("backup")
 	if actualHost != "rabbit.testing.com" {

config/loader/memory/memory.go

@@ -2,6 +2,7 @@ package memory
 
 import (
 	"bytes"
+	"container/list"
 	"errors"
 	"fmt"
 	"strings"
@@ -28,8 +29,7 @@ type memory struct {
 	// all the sources
 	sources []source.Source
 
-	idx      int
-	watchers map[int]*watcher
+	watchers *list.List
 }
 
 type watcher struct {
@@ -153,11 +153,11 @@ func (m *memory) reload() error {
 }
 
 func (m *memory) update() {
-	var watchers []*watcher
+	watchers := make([]*watcher, 0, m.watchers.Len())
 
 	m.RLock()
-	for _, w := range m.watchers {
-		watchers = append(watchers, w)
+	for e := m.watchers.Front(); e != nil; e = e.Next() {
+		watchers = append(watchers, e.Value.(*watcher))
 	}
 	m.RUnlock()
 
@@ -193,6 +193,7 @@ func (m *memory) Snapshot() (*loader.Snapshot, error) {
 
 // Sync loads all the sources, calls the parser and updates the config
 func (m *memory) Sync() error {
+	//nolint:prealloc
 	var sets []*source.ChangeSet
 
 	m.Lock()
@@ -335,16 +336,14 @@ func (m *memory) Watch(path ...string) (loader.Watcher, error) {
 		updates: make(chan reader.Value, 1),
 	}
 
-	id := m.idx
-	m.watchers[id] = w
-	m.idx++
+	e := m.watchers.PushBack(w)
 
 	m.Unlock()
 
 	go func() {
 		<-w.exit
 		m.Lock()
-		delete(m.watchers, id)
+		m.watchers.Remove(e)
 		m.Unlock()
 	}()
 
@@ -403,7 +402,7 @@ func NewLoader(opts ...loader.Option) loader.Loader {
 	m := &memory{
 		exit:     make(chan bool),
 		opts:     options,
-		watchers: make(map[int]*watcher),
+		watchers: list.New(),
 		sources:  options.Source,
 	}
 

config/options/options.go

@@ -2,6 +2,7 @@
 package options
 
 import (
+	"log"
 	"sync"
 )
 
@@ -68,6 +69,8 @@ func WithString(s string) Option {
 // NewOptions returns a new initialiser
 func NewOptions(opts ...Option) Options {
 	o := new(defaultOptions)
-	o.Init(opts...)
+	if err := o.Init(opts...); err != nil {
+		log.Fatal(err)
+	}
 	return o
 }

config/reader/json/values.go

@@ -30,13 +30,6 @@ func newValues(ch *source.ChangeSet) (reader.Values, error) {
 	return &jsonValues{ch, sj}, nil
 }
 
-func newValue(s *simple.Json) reader.Value {
-	if s == nil {
-		s = simple.New()
-	}
-	return &jsonValue{s}
-}
-
 func (j *jsonValues) Get(path ...string) reader.Value {
 	return &jsonValue{j.sj.GetPath(path...)}
 }

config/reader/reader.go

@@ -18,6 +18,8 @@ type Reader interface {
 type Values interface {
 	Bytes() []byte
 	Get(path ...string) Value
+	Set(val interface{}, path ...string)
+	Del(path ...string)
 	Map() map[string]interface{}
 	Scan(v interface{}) error
 }

config/source/cli/cli.go

@@ -8,7 +8,7 @@ import (
 	"time"
 
 	"github.com/imdario/mergo"
-	"github.com/micro/cli"
+	"github.com/micro/cli/v2"
 	"github.com/micro/go-micro/config/cmd"
 	"github.com/micro/go-micro/config/source"
 )
@@ -21,11 +21,6 @@ type cliSource struct {
 func (c *cliSource) Read() (*source.ChangeSet, error) {
 	var changes map[string]interface{}
 
-	for _, name := range c.ctx.GlobalFlagNames() {
-		tmp := toEntry(name, c.ctx.GlobalGeneric(name))
-		mergo.Map(&changes, tmp) // need to sort error handling
-	}
-
 	for _, name := range c.ctx.FlagNames() {
 		tmp := toEntry(name, c.ctx.Generic(name))
 		mergo.Map(&changes, tmp) // need to sort error handling
@@ -78,6 +73,11 @@ func (c *cliSource) Watch() (source.Watcher, error) {
 	return source.NewNoopWatcher()
 }
 
+// Write is unsupported
+func (c *cliSource) Write(cs *source.ChangeSet) error {
+	return nil
+}
+
 func (c *cliSource) String() string {
 	return "cli"
 }

config/source/cli/cli_test.go

@@ -5,7 +5,7 @@ import (
 	"os"
 	"testing"
 
-	"github.com/micro/cli"
+	"github.com/micro/cli/v2"
 	"github.com/micro/go-micro/config/cmd"
 	"github.com/micro/go-micro/config/source"
 )
@@ -17,14 +17,15 @@ func test(t *testing.T, withContext bool) {
 	app := cmd.App()
 	app.Name = "testapp"
 	app.Flags = []cli.Flag{
-		cli.StringFlag{Name: "db-host"},
+		&cli.StringFlag{Name: "db-host"},
 	}
 
 	// with context
 	if withContext {
 		// set action
-		app.Action = func(c *cli.Context) {
+		app.Action = func(c *cli.Context) error {
 			src = WithContext(c)
+			return nil
 		}
 
 		// run app

config/source/cli/options.go

@@ -3,7 +3,7 @@ package cli
 import (
 	"context"
 
-	"github.com/micro/cli"
+	"github.com/micro/cli/v2"
 	"github.com/micro/go-micro/config/source"
 )
 

config/source/cli/util.go

@@ -5,7 +5,7 @@ import (
 	"flag"
 	"strings"
 
-	"github.com/micro/cli"
+	"github.com/micro/cli/v2"
 )
 
 func copyFlag(name string, ff *flag.Flag, set *flag.FlagSet) {
@@ -22,7 +22,7 @@ func normalizeFlags(flags []cli.Flag, set *flag.FlagSet) error {
 		visited[f.Name] = true
 	})
 	for _, f := range flags {
-		parts := strings.Split(f.GetName(), ",")
+		parts := f.Names()
 		if len(parts) == 1 {
 			continue
 		}

config/source/env/env.go

@@ -105,6 +105,10 @@ func (e *env) Watch() (source.Watcher, error) {
 	return newWatcher()
 }
 
+func (e *env) Write(cs *source.ChangeSet) error {
+	return nil
+}
+
 func (e *env) String() string {
 	return "env"
 }

config/source/env/options.go

@@ -35,6 +35,7 @@ func WithPrefix(p ...string) source.Option {
 }
 
 func appendUnderscore(prefixes []string) []string {
+	//nolint:prealloc
 	var result []string
 	for _, p := range prefixes {
 		if !strings.HasSuffix(p, "_") {

config/source/etcd/etcd.go

@@ -38,7 +38,7 @@ func (c *etcd) Read() (*source.ChangeSet, error) {
 		return nil, fmt.Errorf("source not found: %s", c.prefix)
 	}
 
-	var kvs []*mvccpb.KeyValue
+	kvs := make([]*mvccpb.KeyValue, 0, len(rsp.Kvs))
 	for _, v := range rsp.Kvs {
 		kvs = append(kvs, (*mvccpb.KeyValue)(v))
 	}
@@ -76,6 +76,10 @@ func (c *etcd) Watch() (source.Watcher, error) {
 	return newWatcher(c.prefix, c.stripPrefix, c.client.Watcher, cs, c.opts)
 }
 
+func (c *etcd) Write(cs *source.ChangeSet) error {
+	return nil
+}
+
 func NewSource(opts ...source.Option) source.Source {
 	options := source.NewOptions(opts...)
 

config/source/file/file.go

@@ -54,6 +54,10 @@ func (f *file) Watch() (source.Watcher, error) {
 	return newWatcher(f)
 }
 
+func (f *file) Write(cs *source.ChangeSet) error {
+	return nil
+}
+
 func NewSource(opts ...source.Option) source.Source {
 	options := source.NewOptions(opts...)
 	path := DefaultPath

config/source/flag/flag.go

@@ -77,6 +77,10 @@ func (fs *flagsrc) Watch() (source.Watcher, error) {
 	return source.NewNoopWatcher()
 }
 
+func (fs *flagsrc) Write(cs *source.ChangeSet) error {
+	return nil
+}
+
 func (fs *flagsrc) String() string {
 	return "flag"
 }

config/source/memory/memory.go

@@ -41,6 +41,10 @@ func (s *memory) Watch() (source.Watcher, error) {
 	return w, nil
 }
 
+func (m *memory) Write(cs *source.ChangeSet) error {
+	return nil
+}
+
 // Update allows manual updates of the config data.
 func (s *memory) Update(c *source.ChangeSet) {
 	// don't process nil

config/source/service/options.go

@@ -0,0 +1,38 @@
+package service
+
+import (
+	"context"
+
+	"github.com/micro/go-micro/config/source"
+)
+
+type serviceNameKey struct{}
+type keyKey struct{}
+type pathKey struct{}
+
+func ServiceName(name string) source.Option {
+	return func(o *source.Options) {
+		if o.Context == nil {
+			o.Context = context.Background()
+		}
+		o.Context = context.WithValue(o.Context, serviceNameKey{}, name)
+	}
+}
+
+func Key(key string) source.Option {
+	return func(o *source.Options) {
+		if o.Context == nil {
+			o.Context = context.Background()
+		}
+		o.Context = context.WithValue(o.Context, keyKey{}, key)
+	}
+}
+
+func Path(path string) source.Option {
+	return func(o *source.Options) {
+		if o.Context == nil {
+			o.Context = context.Background()
+		}
+		o.Context = context.WithValue(o.Context, pathKey{}, path)
+	}
+}

config/source/service/proto/service.pb.go

@@ -0,0 +1,660 @@
+// Code generated by protoc-gen-go. DO NOT EDIT.
+// source: go-micro/config/source/service/proto/service.proto
+
+package service
+
+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 ChangeSet struct {
+	Data                 []byte   `protobuf:"bytes,1,opt,name=data,proto3" json:"data,omitempty"`
+	Checksum             string   `protobuf:"bytes,2,opt,name=checksum,proto3" json:"checksum,omitempty"`
+	Format               string   `protobuf:"bytes,3,opt,name=format,proto3" json:"format,omitempty"`
+	Source               string   `protobuf:"bytes,4,opt,name=source,proto3" json:"source,omitempty"`
+	Timestamp            int64    `protobuf:"varint,5,opt,name=timestamp,proto3" json:"timestamp,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *ChangeSet) Reset()         { *m = ChangeSet{} }
+func (m *ChangeSet) String() string { return proto.CompactTextString(m) }
+func (*ChangeSet) ProtoMessage()    {}
+func (*ChangeSet) Descriptor() ([]byte, []int) {
+	return fileDescriptor_05971a9aaecb0484, []int{0}
+}
+
+func (m *ChangeSet) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_ChangeSet.Unmarshal(m, b)
+}
+func (m *ChangeSet) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_ChangeSet.Marshal(b, m, deterministic)
+}
+func (m *ChangeSet) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_ChangeSet.Merge(m, src)
+}
+func (m *ChangeSet) XXX_Size() int {
+	return xxx_messageInfo_ChangeSet.Size(m)
+}
+func (m *ChangeSet) XXX_DiscardUnknown() {
+	xxx_messageInfo_ChangeSet.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_ChangeSet proto.InternalMessageInfo
+
+func (m *ChangeSet) GetData() []byte {
+	if m != nil {
+		return m.Data
+	}
+	return nil
+}
+
+func (m *ChangeSet) GetChecksum() string {
+	if m != nil {
+		return m.Checksum
+	}
+	return ""
+}
+
+func (m *ChangeSet) GetFormat() string {
+	if m != nil {
+		return m.Format
+	}
+	return ""
+}
+
+func (m *ChangeSet) GetSource() string {
+	if m != nil {
+		return m.Source
+	}
+	return ""
+}
+
+func (m *ChangeSet) GetTimestamp() int64 {
+	if m != nil {
+		return m.Timestamp
+	}
+	return 0
+}
+
+type Change struct {
+	Key                  string     `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"`
+	Path                 string     `protobuf:"bytes,2,opt,name=path,proto3" json:"path,omitempty"`
+	ChangeSet            *ChangeSet `protobuf:"bytes,3,opt,name=changeSet,proto3" json:"changeSet,omitempty"`
+	XXX_NoUnkeyedLiteral struct{}   `json:"-"`
+	XXX_unrecognized     []byte     `json:"-"`
+	XXX_sizecache        int32      `json:"-"`
+}
+
+func (m *Change) Reset()         { *m = Change{} }
+func (m *Change) String() string { return proto.CompactTextString(m) }
+func (*Change) ProtoMessage()    {}
+func (*Change) Descriptor() ([]byte, []int) {
+	return fileDescriptor_05971a9aaecb0484, []int{1}
+}
+
+func (m *Change) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_Change.Unmarshal(m, b)
+}
+func (m *Change) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_Change.Marshal(b, m, deterministic)
+}
+func (m *Change) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_Change.Merge(m, src)
+}
+func (m *Change) XXX_Size() int {
+	return xxx_messageInfo_Change.Size(m)
+}
+func (m *Change) XXX_DiscardUnknown() {
+	xxx_messageInfo_Change.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_Change proto.InternalMessageInfo
+
+func (m *Change) GetKey() string {
+	if m != nil {
+		return m.Key
+	}
+	return ""
+}
+
+func (m *Change) GetPath() string {
+	if m != nil {
+		return m.Path
+	}
+	return ""
+}
+
+func (m *Change) GetChangeSet() *ChangeSet {
+	if m != nil {
+		return m.ChangeSet
+	}
+	return nil
+}
+
+type CreateRequest struct {
+	Change               *Change  `protobuf:"bytes,1,opt,name=change,proto3" json:"change,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *CreateRequest) Reset()         { *m = CreateRequest{} }
+func (m *CreateRequest) String() string { return proto.CompactTextString(m) }
+func (*CreateRequest) ProtoMessage()    {}
+func (*CreateRequest) Descriptor() ([]byte, []int) {
+	return fileDescriptor_05971a9aaecb0484, []int{2}
+}
+
+func (m *CreateRequest) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_CreateRequest.Unmarshal(m, b)
+}
+func (m *CreateRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_CreateRequest.Marshal(b, m, deterministic)
+}
+func (m *CreateRequest) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_CreateRequest.Merge(m, src)
+}
+func (m *CreateRequest) XXX_Size() int {
+	return xxx_messageInfo_CreateRequest.Size(m)
+}
+func (m *CreateRequest) XXX_DiscardUnknown() {
+	xxx_messageInfo_CreateRequest.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_CreateRequest proto.InternalMessageInfo
+
+func (m *CreateRequest) GetChange() *Change {
+	if m != nil {
+		return m.Change
+	}
+	return nil
+}
+
+type CreateResponse struct {
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *CreateResponse) Reset()         { *m = CreateResponse{} }
+func (m *CreateResponse) String() string { return proto.CompactTextString(m) }
+func (*CreateResponse) ProtoMessage()    {}
+func (*CreateResponse) Descriptor() ([]byte, []int) {
+	return fileDescriptor_05971a9aaecb0484, []int{3}
+}
+
+func (m *CreateResponse) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_CreateResponse.Unmarshal(m, b)
+}
+func (m *CreateResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_CreateResponse.Marshal(b, m, deterministic)
+}
+func (m *CreateResponse) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_CreateResponse.Merge(m, src)
+}
+func (m *CreateResponse) XXX_Size() int {
+	return xxx_messageInfo_CreateResponse.Size(m)
+}
+func (m *CreateResponse) XXX_DiscardUnknown() {
+	xxx_messageInfo_CreateResponse.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_CreateResponse proto.InternalMessageInfo
+
+type UpdateRequest struct {
+	Change               *Change  `protobuf:"bytes,1,opt,name=change,proto3" json:"change,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *UpdateRequest) Reset()         { *m = UpdateRequest{} }
+func (m *UpdateRequest) String() string { return proto.CompactTextString(m) }
+func (*UpdateRequest) ProtoMessage()    {}
+func (*UpdateRequest) Descriptor() ([]byte, []int) {
+	return fileDescriptor_05971a9aaecb0484, []int{4}
+}
+
+func (m *UpdateRequest) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_UpdateRequest.Unmarshal(m, b)
+}
+func (m *UpdateRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_UpdateRequest.Marshal(b, m, deterministic)
+}
+func (m *UpdateRequest) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_UpdateRequest.Merge(m, src)
+}
+func (m *UpdateRequest) XXX_Size() int {
+	return xxx_messageInfo_UpdateRequest.Size(m)
+}
+func (m *UpdateRequest) XXX_DiscardUnknown() {
+	xxx_messageInfo_UpdateRequest.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_UpdateRequest proto.InternalMessageInfo
+
+func (m *UpdateRequest) GetChange() *Change {
+	if m != nil {
+		return m.Change
+	}
+	return nil
+}
+
+type UpdateResponse struct {
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *UpdateResponse) Reset()         { *m = UpdateResponse{} }
+func (m *UpdateResponse) String() string { return proto.CompactTextString(m) }
+func (*UpdateResponse) ProtoMessage()    {}
+func (*UpdateResponse) Descriptor() ([]byte, []int) {
+	return fileDescriptor_05971a9aaecb0484, []int{5}
+}
+
+func (m *UpdateResponse) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_UpdateResponse.Unmarshal(m, b)
+}
+func (m *UpdateResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_UpdateResponse.Marshal(b, m, deterministic)
+}
+func (m *UpdateResponse) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_UpdateResponse.Merge(m, src)
+}
+func (m *UpdateResponse) XXX_Size() int {
+	return xxx_messageInfo_UpdateResponse.Size(m)
+}
+func (m *UpdateResponse) XXX_DiscardUnknown() {
+	xxx_messageInfo_UpdateResponse.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_UpdateResponse proto.InternalMessageInfo
+
+type DeleteRequest struct {
+	Change               *Change  `protobuf:"bytes,1,opt,name=change,proto3" json:"change,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *DeleteRequest) Reset()         { *m = DeleteRequest{} }
+func (m *DeleteRequest) String() string { return proto.CompactTextString(m) }
+func (*DeleteRequest) ProtoMessage()    {}
+func (*DeleteRequest) Descriptor() ([]byte, []int) {
+	return fileDescriptor_05971a9aaecb0484, []int{6}
+}
+
+func (m *DeleteRequest) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_DeleteRequest.Unmarshal(m, b)
+}
+func (m *DeleteRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_DeleteRequest.Marshal(b, m, deterministic)
+}
+func (m *DeleteRequest) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_DeleteRequest.Merge(m, src)
+}
+func (m *DeleteRequest) XXX_Size() int {
+	return xxx_messageInfo_DeleteRequest.Size(m)
+}
+func (m *DeleteRequest) XXX_DiscardUnknown() {
+	xxx_messageInfo_DeleteRequest.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_DeleteRequest proto.InternalMessageInfo
+
+func (m *DeleteRequest) GetChange() *Change {
+	if m != nil {
+		return m.Change
+	}
+	return nil
+}
+
+type DeleteResponse struct {
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *DeleteResponse) Reset()         { *m = DeleteResponse{} }
+func (m *DeleteResponse) String() string { return proto.CompactTextString(m) }
+func (*DeleteResponse) ProtoMessage()    {}
+func (*DeleteResponse) Descriptor() ([]byte, []int) {
+	return fileDescriptor_05971a9aaecb0484, []int{7}
+}
+
+func (m *DeleteResponse) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_DeleteResponse.Unmarshal(m, b)
+}
+func (m *DeleteResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_DeleteResponse.Marshal(b, m, deterministic)
+}
+func (m *DeleteResponse) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_DeleteResponse.Merge(m, src)
+}
+func (m *DeleteResponse) XXX_Size() int {
+	return xxx_messageInfo_DeleteResponse.Size(m)
+}
+func (m *DeleteResponse) XXX_DiscardUnknown() {
+	xxx_messageInfo_DeleteResponse.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_DeleteResponse proto.InternalMessageInfo
+
+type ListRequest struct {
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *ListRequest) Reset()         { *m = ListRequest{} }
+func (m *ListRequest) String() string { return proto.CompactTextString(m) }
+func (*ListRequest) ProtoMessage()    {}
+func (*ListRequest) Descriptor() ([]byte, []int) {
+	return fileDescriptor_05971a9aaecb0484, []int{8}
+}
+
+func (m *ListRequest) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_ListRequest.Unmarshal(m, b)
+}
+func (m *ListRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_ListRequest.Marshal(b, m, deterministic)
+}
+func (m *ListRequest) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_ListRequest.Merge(m, src)
+}
+func (m *ListRequest) XXX_Size() int {
+	return xxx_messageInfo_ListRequest.Size(m)
+}
+func (m *ListRequest) XXX_DiscardUnknown() {
+	xxx_messageInfo_ListRequest.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_ListRequest proto.InternalMessageInfo
+
+type ListResponse struct {
+	Values               []*Change `protobuf:"bytes,1,rep,name=values,proto3" json:"values,omitempty"`
+	XXX_NoUnkeyedLiteral struct{}  `json:"-"`
+	XXX_unrecognized     []byte    `json:"-"`
+	XXX_sizecache        int32     `json:"-"`
+}
+
+func (m *ListResponse) Reset()         { *m = ListResponse{} }
+func (m *ListResponse) String() string { return proto.CompactTextString(m) }
+func (*ListResponse) ProtoMessage()    {}
+func (*ListResponse) Descriptor() ([]byte, []int) {
+	return fileDescriptor_05971a9aaecb0484, []int{9}
+}
+
+func (m *ListResponse) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_ListResponse.Unmarshal(m, b)
+}
+func (m *ListResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_ListResponse.Marshal(b, m, deterministic)
+}
+func (m *ListResponse) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_ListResponse.Merge(m, src)
+}
+func (m *ListResponse) XXX_Size() int {
+	return xxx_messageInfo_ListResponse.Size(m)
+}
+func (m *ListResponse) XXX_DiscardUnknown() {
+	xxx_messageInfo_ListResponse.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_ListResponse proto.InternalMessageInfo
+
+func (m *ListResponse) GetValues() []*Change {
+	if m != nil {
+		return m.Values
+	}
+	return nil
+}
+
+type ReadRequest struct {
+	Key                  string   `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"`
+	Path                 string   `protobuf:"bytes,2,opt,name=path,proto3" json:"path,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *ReadRequest) Reset()         { *m = ReadRequest{} }
+func (m *ReadRequest) String() string { return proto.CompactTextString(m) }
+func (*ReadRequest) ProtoMessage()    {}
+func (*ReadRequest) Descriptor() ([]byte, []int) {
+	return fileDescriptor_05971a9aaecb0484, []int{10}
+}
+
+func (m *ReadRequest) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_ReadRequest.Unmarshal(m, b)
+}
+func (m *ReadRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_ReadRequest.Marshal(b, m, deterministic)
+}
+func (m *ReadRequest) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_ReadRequest.Merge(m, src)
+}
+func (m *ReadRequest) XXX_Size() int {
+	return xxx_messageInfo_ReadRequest.Size(m)
+}
+func (m *ReadRequest) XXX_DiscardUnknown() {
+	xxx_messageInfo_ReadRequest.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_ReadRequest proto.InternalMessageInfo
+
+func (m *ReadRequest) GetKey() string {
+	if m != nil {
+		return m.Key
+	}
+	return ""
+}
+
+func (m *ReadRequest) GetPath() string {
+	if m != nil {
+		return m.Path
+	}
+	return ""
+}
+
+type ReadResponse struct {
+	Change               *Change  `protobuf:"bytes,1,opt,name=change,proto3" json:"change,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *ReadResponse) Reset()         { *m = ReadResponse{} }
+func (m *ReadResponse) String() string { return proto.CompactTextString(m) }
+func (*ReadResponse) ProtoMessage()    {}
+func (*ReadResponse) Descriptor() ([]byte, []int) {
+	return fileDescriptor_05971a9aaecb0484, []int{11}
+}
+
+func (m *ReadResponse) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_ReadResponse.Unmarshal(m, b)
+}
+func (m *ReadResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_ReadResponse.Marshal(b, m, deterministic)
+}
+func (m *ReadResponse) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_ReadResponse.Merge(m, src)
+}
+func (m *ReadResponse) XXX_Size() int {
+	return xxx_messageInfo_ReadResponse.Size(m)
+}
+func (m *ReadResponse) XXX_DiscardUnknown() {
+	xxx_messageInfo_ReadResponse.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_ReadResponse proto.InternalMessageInfo
+
+func (m *ReadResponse) GetChange() *Change {
+	if m != nil {
+		return m.Change
+	}
+	return nil
+}
+
+type WatchRequest struct {
+	Key                  string   `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"`
+	Path                 string   `protobuf:"bytes,2,opt,name=path,proto3" json:"path,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *WatchRequest) Reset()         { *m = WatchRequest{} }
+func (m *WatchRequest) String() string { return proto.CompactTextString(m) }
+func (*WatchRequest) ProtoMessage()    {}
+func (*WatchRequest) Descriptor() ([]byte, []int) {
+	return fileDescriptor_05971a9aaecb0484, []int{12}
+}
+
+func (m *WatchRequest) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_WatchRequest.Unmarshal(m, b)
+}
+func (m *WatchRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_WatchRequest.Marshal(b, m, deterministic)
+}
+func (m *WatchRequest) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_WatchRequest.Merge(m, src)
+}
+func (m *WatchRequest) XXX_Size() int {
+	return xxx_messageInfo_WatchRequest.Size(m)
+}
+func (m *WatchRequest) XXX_DiscardUnknown() {
+	xxx_messageInfo_WatchRequest.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_WatchRequest proto.InternalMessageInfo
+
+func (m *WatchRequest) GetKey() string {
+	if m != nil {
+		return m.Key
+	}
+	return ""
+}
+
+func (m *WatchRequest) GetPath() string {
+	if m != nil {
+		return m.Path
+	}
+	return ""
+}
+
+type WatchResponse struct {
+	Key                  string     `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"`
+	ChangeSet            *ChangeSet `protobuf:"bytes,2,opt,name=changeSet,proto3" json:"changeSet,omitempty"`
+	XXX_NoUnkeyedLiteral struct{}   `json:"-"`
+	XXX_unrecognized     []byte     `json:"-"`
+	XXX_sizecache        int32      `json:"-"`
+}
+
+func (m *WatchResponse) Reset()         { *m = WatchResponse{} }
+func (m *WatchResponse) String() string { return proto.CompactTextString(m) }
+func (*WatchResponse) ProtoMessage()    {}
+func (*WatchResponse) Descriptor() ([]byte, []int) {
+	return fileDescriptor_05971a9aaecb0484, []int{13}
+}
+
+func (m *WatchResponse) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_WatchResponse.Unmarshal(m, b)
+}
+func (m *WatchResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_WatchResponse.Marshal(b, m, deterministic)
+}
+func (m *WatchResponse) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_WatchResponse.Merge(m, src)
+}
+func (m *WatchResponse) XXX_Size() int {
+	return xxx_messageInfo_WatchResponse.Size(m)
+}
+func (m *WatchResponse) XXX_DiscardUnknown() {
+	xxx_messageInfo_WatchResponse.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_WatchResponse proto.InternalMessageInfo
+
+func (m *WatchResponse) GetKey() string {
+	if m != nil {
+		return m.Key
+	}
+	return ""
+}
+
+func (m *WatchResponse) GetChangeSet() *ChangeSet {
+	if m != nil {
+		return m.ChangeSet
+	}
+	return nil
+}
+
+func init() {
+	proto.RegisterType((*ChangeSet)(nil), "ChangeSet")
+	proto.RegisterType((*Change)(nil), "Change")
+	proto.RegisterType((*CreateRequest)(nil), "CreateRequest")
+	proto.RegisterType((*CreateResponse)(nil), "CreateResponse")
+	proto.RegisterType((*UpdateRequest)(nil), "UpdateRequest")
+	proto.RegisterType((*UpdateResponse)(nil), "UpdateResponse")
+	proto.RegisterType((*DeleteRequest)(nil), "DeleteRequest")
+	proto.RegisterType((*DeleteResponse)(nil), "DeleteResponse")
+	proto.RegisterType((*ListRequest)(nil), "ListRequest")
+	proto.RegisterType((*ListResponse)(nil), "ListResponse")
+	proto.RegisterType((*ReadRequest)(nil), "ReadRequest")
+	proto.RegisterType((*ReadResponse)(nil), "ReadResponse")
+	proto.RegisterType((*WatchRequest)(nil), "WatchRequest")
+	proto.RegisterType((*WatchResponse)(nil), "WatchResponse")
+}
+
+func init() {
+	proto.RegisterFile("go-micro/config/source/service/proto/service.proto", fileDescriptor_05971a9aaecb0484)
+}
+
+var fileDescriptor_05971a9aaecb0484 = []byte{
+	// 443 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x94, 0x93, 0xcf, 0x6a, 0xdb, 0x40,
+	0x10, 0xc6, 0x2d, 0xdb, 0x51, 0xab, 0xb1, 0x24, 0x87, 0x39, 0x14, 0x21, 0x0a, 0x35, 0x82, 0x82,
+	0x69, 0xe9, 0x2a, 0x38, 0x7d, 0x03, 0xf7, 0xd6, 0x9e, 0x54, 0x4a, 0x7b, 0xdd, 0xca, 0x13, 0x5b,
+	0x24, 0xf2, 0xaa, 0xda, 0x75, 0xa0, 0x8f, 0x90, 0xb7, 0x2e, 0xfb, 0x47, 0xb1, 0xe4, 0x82, 0x89,
+	0x6f, 0x3b, 0x33, 0x3b, 0xdf, 0x7c, 0x9a, 0x9f, 0x16, 0x56, 0x5b, 0xf1, 0xa9, 0xae, 0xca, 0x56,
+	0xe4, 0xa5, 0xd8, 0xdf, 0x55, 0xdb, 0x5c, 0x8a, 0x43, 0x5b, 0x52, 0x2e, 0xa9, 0x7d, 0xac, 0x4a,
+	0xca, 0x9b, 0x56, 0x28, 0xd1, 0x45, 0xcc, 0x44, 0xd9, 0x93, 0x07, 0xc1, 0x7a, 0xc7, 0xf7, 0x5b,
+	0xfa, 0x4e, 0x0a, 0x11, 0xa6, 0x1b, 0xae, 0x78, 0xe2, 0x2d, 0xbc, 0x65, 0x58, 0x98, 0x33, 0xa6,
+	0xf0, 0xba, 0xdc, 0x51, 0x79, 0x2f, 0x0f, 0x75, 0x32, 0x5e, 0x78, 0xcb, 0xa0, 0x78, 0x8e, 0xf1,
+	0x0d, 0xf8, 0x77, 0xa2, 0xad, 0xb9, 0x4a, 0x26, 0xa6, 0xe2, 0x22, 0x9d, 0xb7, 0xb3, 0x93, 0xa9,
+	0xcd, 0xdb, 0x08, 0xdf, 0x42, 0xa0, 0xaa, 0x9a, 0xa4, 0xe2, 0x75, 0x93, 0x5c, 0x2d, 0xbc, 0xe5,
+	0xa4, 0x38, 0x26, 0xb2, 0x5f, 0xe0, 0x5b, 0x2b, 0x78, 0x0d, 0x93, 0x7b, 0xfa, 0x6b, 0x6c, 0x04,
+	0x85, 0x3e, 0x6a, 0x67, 0x0d, 0x57, 0x3b, 0xe7, 0xc0, 0x9c, 0x71, 0x09, 0x41, 0xd9, 0x59, 0x37,
+	0x06, 0x66, 0x2b, 0x60, 0xcf, 0x1f, 0x53, 0x1c, 0x8b, 0xd9, 0x0d, 0x44, 0xeb, 0x96, 0xb8, 0xa2,
+	0x82, 0xfe, 0x1c, 0x48, 0x2a, 0x7c, 0x07, 0xbe, 0xad, 0x9a, 0x19, 0xb3, 0xd5, 0x2b, 0xd7, 0x57,
+	0xb8, 0x74, 0x76, 0x0d, 0x71, 0xd7, 0x21, 0x1b, 0xb1, 0x97, 0xa4, 0x35, 0x7e, 0x34, 0x9b, 0x0b,
+	0x35, 0xba, 0x8e, 0xa3, 0xc6, 0x17, 0x7a, 0xa0, 0xcb, 0x34, 0xba, 0x0e, 0xa7, 0x11, 0xc1, 0xec,
+	0x5b, 0x25, 0x95, 0x53, 0xc8, 0x72, 0x08, 0x6d, 0x68, 0xcb, 0x5a, 0xf1, 0x91, 0x3f, 0x1c, 0x48,
+	0x26, 0xde, 0x62, 0x32, 0x50, 0xb4, 0xe9, 0xec, 0x16, 0x66, 0x05, 0xf1, 0x4d, 0xe7, 0xe0, 0x45,
+	0xab, 0xd6, 0x53, 0x6c, 0xd3, 0x71, 0xca, 0x79, 0xdf, 0x9f, 0x21, 0xfc, 0xc9, 0x55, 0xb9, 0xbb,
+	0x6c, 0xcc, 0x57, 0x88, 0x5c, 0x97, 0x9b, 0xf3, 0x7f, 0xdb, 0x00, 0xfa, 0xf8, 0x0c, 0xf4, 0xd5,
+	0xd3, 0x18, 0xfc, 0xb5, 0x79, 0x08, 0xf8, 0x11, 0x7c, 0x4b, 0x13, 0x63, 0x36, 0xf8, 0x11, 0xd2,
+	0x39, 0x3b, 0xc1, 0x3c, 0xd2, 0x97, 0x2d, 0x36, 0x8c, 0xd9, 0x80, 0x78, 0x3a, 0x67, 0x27, 0x3c,
+	0xcd, 0x65, 0xcb, 0x07, 0x63, 0x36, 0x40, 0x9b, 0xce, 0xd9, 0x09, 0xb8, 0x11, 0xbe, 0x87, 0xa9,
+	0x66, 0x85, 0x21, 0xeb, 0x11, 0x4c, 0x23, 0xd6, 0x07, 0x68, 0xaf, 0xe9, 0x65, 0x63, 0xc8, 0x7a,
+	0xa0, 0xd2, 0x88, 0xf5, 0x09, 0x64, 0x23, 0xfc, 0x00, 0x57, 0x66, 0x59, 0x18, 0xb1, 0xfe, 0xaa,
+	0xd3, 0x98, 0x0d, 0x76, 0x98, 0x8d, 0x6e, 0xbc, 0xdf, 0xbe, 0x79, 0xed, 0xb7, 0xff, 0x02, 0x00,
+	0x00, 0xff, 0xff, 0xea, 0xa0, 0x1e, 0x8e, 0x23, 0x04, 0x00, 0x00,
+}

config/source/service/proto/service.pb.micro.go

@@ -0,0 +1,241 @@
+// Code generated by protoc-gen-micro. DO NOT EDIT.
+// source: go-micro/config/source/service/proto/service.proto
+
+package service
+
+import (
+	fmt "fmt"
+	proto "github.com/golang/protobuf/proto"
+	math "math"
+)
+
+import (
+	context "context"
+	client "github.com/micro/go-micro/client"
+	server "github.com/micro/go-micro/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 Config service
+
+type ConfigService interface {
+	Create(ctx context.Context, in *CreateRequest, opts ...client.CallOption) (*CreateResponse, error)
+	Update(ctx context.Context, in *UpdateRequest, opts ...client.CallOption) (*UpdateResponse, error)
+	Delete(ctx context.Context, in *DeleteRequest, opts ...client.CallOption) (*DeleteResponse, error)
+	List(ctx context.Context, in *ListRequest, opts ...client.CallOption) (*ListResponse, error)
+	Read(ctx context.Context, in *ReadRequest, opts ...client.CallOption) (*ReadResponse, error)
+	Watch(ctx context.Context, in *WatchRequest, opts ...client.CallOption) (Config_WatchService, error)
+}
+
+type configService struct {
+	c    client.Client
+	name string
+}
+
+func NewConfigService(name string, c client.Client) ConfigService {
+	if c == nil {
+		c = client.NewClient()
+	}
+	if len(name) == 0 {
+		name = "config"
+	}
+	return &configService{
+		c:    c,
+		name: name,
+	}
+}
+
+func (c *configService) Create(ctx context.Context, in *CreateRequest, opts ...client.CallOption) (*CreateResponse, error) {
+	req := c.c.NewRequest(c.name, "Config.Create", in)
+	out := new(CreateResponse)
+	err := c.c.Call(ctx, req, out, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *configService) Update(ctx context.Context, in *UpdateRequest, opts ...client.CallOption) (*UpdateResponse, error) {
+	req := c.c.NewRequest(c.name, "Config.Update", in)
+	out := new(UpdateResponse)
+	err := c.c.Call(ctx, req, out, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *configService) Delete(ctx context.Context, in *DeleteRequest, opts ...client.CallOption) (*DeleteResponse, error) {
+	req := c.c.NewRequest(c.name, "Config.Delete", in)
+	out := new(DeleteResponse)
+	err := c.c.Call(ctx, req, out, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *configService) List(ctx context.Context, in *ListRequest, opts ...client.CallOption) (*ListResponse, error) {
+	req := c.c.NewRequest(c.name, "Config.List", in)
+	out := new(ListResponse)
+	err := c.c.Call(ctx, req, out, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *configService) Read(ctx context.Context, in *ReadRequest, opts ...client.CallOption) (*ReadResponse, error) {
+	req := c.c.NewRequest(c.name, "Config.Read", in)
+	out := new(ReadResponse)
+	err := c.c.Call(ctx, req, out, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *configService) Watch(ctx context.Context, in *WatchRequest, opts ...client.CallOption) (Config_WatchService, error) {
+	req := c.c.NewRequest(c.name, "Config.Watch", &WatchRequest{})
+	stream, err := c.c.Stream(ctx, req, opts...)
+	if err != nil {
+		return nil, err
+	}
+	if err := stream.Send(in); err != nil {
+		return nil, err
+	}
+	return &configServiceWatch{stream}, nil
+}
+
+type Config_WatchService interface {
+	SendMsg(interface{}) error
+	RecvMsg(interface{}) error
+	Close() error
+	Recv() (*WatchResponse, error)
+}
+
+type configServiceWatch struct {
+	stream client.Stream
+}
+
+func (x *configServiceWatch) Close() error {
+	return x.stream.Close()
+}
+
+func (x *configServiceWatch) SendMsg(m interface{}) error {
+	return x.stream.Send(m)
+}
+
+func (x *configServiceWatch) RecvMsg(m interface{}) error {
+	return x.stream.Recv(m)
+}
+
+func (x *configServiceWatch) Recv() (*WatchResponse, error) {
+	m := new(WatchResponse)
+	err := x.stream.Recv(m)
+	if err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+// Server API for Config service
+
+type ConfigHandler interface {
+	Create(context.Context, *CreateRequest, *CreateResponse) error
+	Update(context.Context, *UpdateRequest, *UpdateResponse) error
+	Delete(context.Context, *DeleteRequest, *DeleteResponse) error
+	List(context.Context, *ListRequest, *ListResponse) error
+	Read(context.Context, *ReadRequest, *ReadResponse) error
+	Watch(context.Context, *WatchRequest, Config_WatchStream) error
+}
+
+func RegisterConfigHandler(s server.Server, hdlr ConfigHandler, opts ...server.HandlerOption) error {
+	type config interface {
+		Create(ctx context.Context, in *CreateRequest, out *CreateResponse) error
+		Update(ctx context.Context, in *UpdateRequest, out *UpdateResponse) error
+		Delete(ctx context.Context, in *DeleteRequest, out *DeleteResponse) error
+		List(ctx context.Context, in *ListRequest, out *ListResponse) error
+		Read(ctx context.Context, in *ReadRequest, out *ReadResponse) error
+		Watch(ctx context.Context, stream server.Stream) error
+	}
+	type Config struct {
+		config
+	}
+	h := &configHandler{hdlr}
+	return s.Handle(s.NewHandler(&Config{h}, opts...))
+}
+
+type configHandler struct {
+	ConfigHandler
+}
+
+func (h *configHandler) Create(ctx context.Context, in *CreateRequest, out *CreateResponse) error {
+	return h.ConfigHandler.Create(ctx, in, out)
+}
+
+func (h *configHandler) Update(ctx context.Context, in *UpdateRequest, out *UpdateResponse) error {
+	return h.ConfigHandler.Update(ctx, in, out)
+}
+
+func (h *configHandler) Delete(ctx context.Context, in *DeleteRequest, out *DeleteResponse) error {
+	return h.ConfigHandler.Delete(ctx, in, out)
+}
+
+func (h *configHandler) List(ctx context.Context, in *ListRequest, out *ListResponse) error {
+	return h.ConfigHandler.List(ctx, in, out)
+}
+
+func (h *configHandler) Read(ctx context.Context, in *ReadRequest, out *ReadResponse) error {
+	return h.ConfigHandler.Read(ctx, in, out)
+}
+
+func (h *configHandler) Watch(ctx context.Context, stream server.Stream) error {
+	m := new(WatchRequest)
+	if err := stream.Recv(m); err != nil {
+		return err
+	}
+	return h.ConfigHandler.Watch(ctx, m, &configWatchStream{stream})
+}
+
+type Config_WatchStream interface {
+	SendMsg(interface{}) error
+	RecvMsg(interface{}) error
+	Close() error
+	Send(*WatchResponse) error
+}
+
+type configWatchStream struct {
+	stream server.Stream
+}
+
+func (x *configWatchStream) Close() error {
+	return x.stream.Close()
+}
+
+func (x *configWatchStream) SendMsg(m interface{}) error {
+	return x.stream.Send(m)
+}
+
+func (x *configWatchStream) RecvMsg(m interface{}) error {
+	return x.stream.Recv(m)
+}
+
+func (x *configWatchStream) Send(m *WatchResponse) error {
+	return x.stream.Send(m)
+}

config/source/service/proto/service.proto

@@ -0,0 +1,67 @@
+syntax = "proto3";
+
+service Config {
+	rpc Create (CreateRequest) returns (CreateResponse) {}
+	rpc Update (UpdateRequest) returns (UpdateResponse) {}
+	rpc Delete (DeleteRequest) returns (DeleteResponse) {}
+	rpc List (ListRequest) returns (ListResponse) {}
+	rpc Read (ReadRequest) returns (ReadResponse) {}
+	rpc Watch (WatchRequest) returns (stream WatchResponse) {}
+}
+
+message ChangeSet {
+    bytes data = 1;
+    string checksum = 2;
+    string format = 3;
+    string source = 4;
+    int64 timestamp = 5;
+}
+
+message Change {
+    string key = 1;
+    string path = 2;
+    ChangeSet changeSet = 3;
+}
+
+message CreateRequest {
+    Change change = 1;
+}
+
+message CreateResponse {}
+
+message UpdateRequest {
+    Change change = 1;
+}
+
+message UpdateResponse {}
+
+message DeleteRequest {
+    Change change = 1;
+}
+
+message DeleteResponse {}
+
+message ListRequest {}
+
+message ListResponse {
+    repeated Change values = 1;
+}
+
+message ReadRequest {
+    string key = 1;
+    string path = 2;
+}
+
+message ReadResponse {
+    Change change = 1;
+}
+
+message WatchRequest {
+    string key = 1;
+    string path = 2;
+}
+
+message WatchResponse {
+    string key = 1;
+    ChangeSet changeSet = 2;
+}

config/source/service/service.go

@@ -0,0 +1,90 @@
+package service
+
+import (
+	"context"
+
+	"github.com/micro/go-micro/client"
+	"github.com/micro/go-micro/config/source"
+	proto "github.com/micro/go-micro/config/source/service/proto"
+	"github.com/micro/go-micro/util/log"
+)
+
+var (
+	DefaultName   = "go.micro.config"
+	DefaultKey    = "NAMESPACE:CONFIG"
+	DefaultPath   = ""
+	DefaultClient = client.DefaultClient
+)
+
+type service struct {
+	serviceName string
+	key         string
+	path        string
+	opts        source.Options
+	client      proto.ConfigService
+}
+
+func (m *service) Read() (set *source.ChangeSet, err error) {
+	req, err := m.client.Read(context.Background(), &proto.ReadRequest{Key: m.key, Path: m.path})
+	if err != nil {
+		return nil, err
+	}
+
+	return toChangeSet(req.Change.ChangeSet), nil
+}
+
+func (m *service) Watch() (w source.Watcher, err error) {
+	stream, err := m.client.Watch(context.Background(), &proto.WatchRequest{Key: m.key, Path: m.path})
+	if err != nil {
+		log.Error("watch err: ", err)
+		return
+	}
+	return newWatcher(stream)
+}
+
+// Write is unsupported
+func (m *service) Write(cs *source.ChangeSet) error {
+	return nil
+}
+
+func (m *service) String() string {
+	return "service"
+}
+
+func NewSource(opts ...source.Option) source.Source {
+	var options source.Options
+	for _, o := range opts {
+		o(&options)
+	}
+
+	addr := DefaultName
+	key := DefaultKey
+	path := DefaultPath
+
+	if options.Context != nil {
+		a, ok := options.Context.Value(serviceNameKey{}).(string)
+		if ok {
+			addr = a
+		}
+
+		k, ok := options.Context.Value(keyKey{}).(string)
+		if ok {
+			key = k
+		}
+
+		p, ok := options.Context.Value(pathKey{}).(string)
+		if ok {
+			path = p
+		}
+	}
+
+	s := &service{
+		serviceName: addr,
+		opts:        options,
+		key:         key,
+		path:        path,
+		client:      proto.NewConfigService(addr, DefaultClient),
+	}
+
+	return s
+}