Bump travis

[WIP] Memory registry TTL expiry

.gitignore

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

.travis.yml

@@ -1,9 +1,11 @@
 language: go
 go:
-- 1.11.x
-- 1.12.x
+- 1.13.x
 env:
   - GO111MODULE=on
 notifications:
   slack:
     secure: aEvhLbhujaGaKSrOokiG3//PaVHTIrc3fBpoRbCRqfZpyq6WREoapJJhF+tIpWWOwaC9GmChbD6aHo/jMUgwKXVyPSaNjiEL87YzUUpL8B2zslNp1rgfTg/LrzthOx3Q1TYwpaAl3to0fuHUVFX4yMeC2vuThq7WSXgMMxFCtbc=
+cache:
+  directories:
+    - $GOPATH/pkg/mod

README.zh-cn.md

@@ -32,5 +32,5 @@ Go Micro把分布式系统的各种细节抽象出来。下面是它的主要特
 
 ## 快速上手
 
-更多关于架构、安装的资料可以查看[文档](https://micro.mu/docs/go-micro_cn.html)。
+更多关于架构、安装的资料可以查看[文档](https://micro.mu/docs/cn/)。
 

agent/README.md

@@ -1,197 +0,0 @@
-# Agent 
-
-Agent is a library used to create commands, inputs and robot services
-
-## Getting Started
-
-- [Commands](#commands) - Commands are functions executed by the bot based on text based pattern matching.
-- [Inputs](#inputs) - Inputs are plugins for communication e.g Slack, Telegram, IRC, etc.
-- [Services](#services) - Write bots as micro services
-
-## Commands
-
-Commands are functions executed by the bot based on text based pattern matching.
-
-### Write a Command
-
-```go
-import "github.com/micro/go-micro/agent/command"
-
-func Ping() command.Command {
-	usage := "ping"
-	description := "Returns pong"
-
-	return command.NewCommand("ping", usage, desc, func(args ...string) ([]byte, error) {
-		return []byte("pong"), nil
-	})
-}
-```
-
-### Register the command
-
-Add the command to the Commands map with a pattern key that can be matched by golang/regexp.Match
-
-```go
-import "github.com/micro/go-micro/agent/command"
-
-func init() {
-	command.Commands["^ping$"] = Ping()
-}
-```
-
-### Rebuild Micro
-
-Build binary
-```shell
-cd github.com/micro/micro
-
-// For local use
-go build -i -o micro ./main.go
-
-// For docker image
-CGO_ENABLED=0 GOOS=linux go build -a -installsuffix cgo -ldflags '-w' -i -o micro ./main.go
-```
-
-## Inputs
-
-Inputs are plugins for communication e.g Slack, HipChat, XMPP, IRC, SMTP, etc, etc. 
-
-New inputs can be added in the following way.
-
-### Write an Input
-
-Write an input that satisfies the Input interface.
-
-```go
-type Input interface {
-	// Provide cli flags
-	Flags() []cli.Flag
-	// Initialise input using cli context
-	Init(*cli.Context) error
-	// Stream events from the input
-	Stream() (Conn, error)
-	// Start the input
-	Start() error
-	// Stop the input
-	Stop() error
-	// name of the input
-	String() string
-}
-```
-
-### Register the input
-
-Add the input to the Inputs map.
-
-```go
-import "github.com/micro/micro/bot/input"
-
-func init() {
-	input.Inputs["name"] = MyInput
-}
-```
-
-### Rebuild Micro
-
-Build binary
-```shell
-cd github.com/micro/micro
-
-// For local use
-go build -i -o micro ./main.go
-
-// For docker image
-CGO_ENABLED=0 GOOS=linux go build -a -installsuffix cgo -ldflags '-w' -i -o micro ./main.go
-```
-
-## Services
-
-The micro bot supports the ability to create commands as micro services. 
-
-### How does it work?
-
-The bot watches the service registry for services with it's namespace. The default namespace is `go.micro.bot`. 
-Any service within this namespace will automatically be added to the list of available commands. When a command 
-is executed, the bot will call the service with method `Command.Exec`. It also expects the method `Command.Help` 
-to exist for usage info.
-
-
-The service interface is as follows and can be found at [go-micro/agent/proto](https://github.com/micro/go-micro/agent/blob/master/proto/bot.proto)
-
-```
-syntax = "proto3";
-
-package go.micro.bot;
-
-service Command {
-	rpc Help(HelpRequest) returns (HelpResponse) {};
-	rpc Exec(ExecRequest) returns (ExecResponse) {};
-}
-
-message HelpRequest {
-}
-
-message HelpResponse {
-	string usage = 1;
-	string description = 2;
-}
-
-message ExecRequest {
-	repeated string args = 1;
-}
-
-message ExecResponse {
-	bytes result = 1;
-	string error = 2;
-}
-```
-
-### Example
-
-Here's an example echo command as a microservice
-
-```go
-package main
-
-import (
-	"fmt"
-	"strings"
-
-	"github.com/micro/go-micro"
-	"golang.org/x/net/context"
-
-	proto "github.com/micro/go-micro/agent/proto"
-)
-
-type Command struct{}
-
-// Help returns the command usage
-func (c *Command) Help(ctx context.Context, req *proto.HelpRequest, rsp *proto.HelpResponse) error {
-	// Usage should include the name of the command
-	rsp.Usage = "echo"
-	rsp.Description = "This is an example bot command as a micro service which echos the message"
-	return nil
-}
-
-// Exec executes the command
-func (c *Command) Exec(ctx context.Context, req *proto.ExecRequest, rsp *proto.ExecResponse) error {
-	rsp.Result = []byte(strings.Join(req.Args, " "))
-	// rsp.Error could be set to return an error instead
-	// the function error would only be used for service level issues
-	return nil
-}
-
-func main() {
-	service := micro.NewService(
-		micro.Name("go.micro.bot.echo"),
-	)
-
-	service.Init()
-
-	proto.RegisterCommandHandler(service.Server(), new(Command))
-
-	if err := service.Run(); err != nil {
-		fmt.Println(err)
-	}
-}
-```

api/README.md

@@ -1,18 +0,0 @@
-# Go API [![License](https://img.shields.io/:license-apache-blue.svg)](https://opensource.org/licenses/Apache-2.0) [![GoDoc](https://godoc.org/github.com/micro/go-micro/api?status.svg)](https://godoc.org/github.com/micro/go-micro/api) [![Travis CI](https://api.travis-ci.org/micro/go-micro/api.svg?branch=master)](https://travis-ci.org/micro/go-micro/api) [![Go Report Card](https://goreportcard.com/badge/micro/go-micro/api)](https://goreportcard.com/report/github.com/micro/go-micro/api)
-
-Go API is a pluggable API framework driven by service discovery to help build powerful public API gateways.
-
-## Overview
-
-The Go API library provides api gateway routing capabilities. A microservice architecture decouples application logic into 
-separate service. An api gateway provides a single entry point to consolidate these services into a unified api. The 
-Go API uses routes defined in service discovery metadata to generate routing rules and serve http requests.
-
-<img src="https://micro.mu/docs/images/go-api.png?v=1" alt="Go API" />
-
-Go API is the basis for the [micro api](https://micro.mu/docs/api.html).
-
-## Getting Started
-
-See the [docs](https://micro.mu/docs/go-api.html) to learn more
-

api/handler/api/api.go

@@ -6,11 +6,11 @@ import (
 
 	goapi "github.com/micro/go-micro/api"
 	"github.com/micro/go-micro/api/handler"
-	"github.com/micro/go-micro/client"
-	"github.com/micro/go-micro/errors"
-	"github.com/micro/go-micro/selector"
-	"github.com/micro/go-micro/util/ctx"
 	api "github.com/micro/go-micro/api/proto"
+	"github.com/micro/go-micro/client"
+	"github.com/micro/go-micro/client/selector"
+	"github.com/micro/go-micro/errors"
+	"github.com/micro/go-micro/util/ctx"
 )
 
 type apiHandler struct {

api/handler/api/util.go

@@ -8,9 +8,9 @@ import (
 	"net/http"
 	"strings"
 
-	"github.com/micro/go-micro/registry"
-	"github.com/micro/go-micro/selector"
 	api "github.com/micro/go-micro/api/proto"
+	"github.com/micro/go-micro/client/selector"
+	"github.com/micro/go-micro/registry"
 )
 
 func requestToProto(r *http.Request) (*api.Request, error) {

api/handler/broker/broker.go

@@ -120,7 +120,7 @@ func (c *conn) writeLoop() {
 		opts = append(opts, broker.Queue(c.queue))
 	}
 
-	subscriber, err := c.b.Subscribe(c.topic, func(p broker.Publication) error {
+	subscriber, err := c.b.Subscribe(c.topic, func(p broker.Event) error {
 		b, err := json.Marshal(p.Message())
 		if err != nil {
 			return nil

api/handler/cloudevents/event.go

@@ -31,7 +31,7 @@ import (
 	"time"
 	"unicode"
 
-	"github.com/pborman/uuid"
+	"github.com/google/uuid"
 	"gopkg.in/go-playground/validator.v9"
 )
 
@@ -66,7 +66,7 @@ func New(eventType string, mimeType string, payload interface{}) *Event {
 		EventType:          eventType,
 		CloudEventsVersion: CloudEventsVersion,
 		Source:             "https://micro.mu",
-		EventID:            uuid.NewUUID().String(),
+		EventID:            uuid.New().String(),
 		EventTime:          &now,
 		ContentType:        mimeType,
 		Data:               payload,

api/handler/event/event.go

@@ -10,10 +10,10 @@ import (
 	"strings"
 	"time"
 
+	"github.com/google/uuid"
 	"github.com/micro/go-micro/api/handler"
 	proto "github.com/micro/go-micro/api/proto"
 	"github.com/micro/go-micro/util/ctx"
-	"github.com/pborman/uuid"
 )
 
 type event struct {
@@ -73,7 +73,7 @@ func (e *event) ServeHTTP(w http.ResponseWriter, r *http.Request) {
 	ev := &proto.Event{
 		Name: action,
 		// TODO: dedupe event
-		Id:        fmt.Sprintf("%s-%s-%s", topic, action, uuid.NewUUID().String()),
+		Id:        fmt.Sprintf("%s-%s-%s", topic, action, uuid.New().String()),
 		Header:    make(map[string]*proto.Pair),
 		Timestamp: time.Now().Unix(),
 	}

api/handler/http/http.go

@@ -10,7 +10,7 @@ import (
 
 	"github.com/micro/go-micro/api"
 	"github.com/micro/go-micro/api/handler"
-	"github.com/micro/go-micro/selector"
+	"github.com/micro/go-micro/client/selector"
 )
 
 const (
@@ -73,7 +73,7 @@ func (h *httpHandler) getService(r *http.Request) (string, error) {
 		return "", nil
 	}
 
-	return fmt.Sprintf("http://%s:%d", s.Address, s.Port), nil
+	return fmt.Sprintf("http://%s", s.Address), nil
 }
 
 func (h *httpHandler) String() string {

api/handler/http/http_test.go

@@ -4,14 +4,12 @@ import (
 	"net"
 	"net/http"
 	"net/http/httptest"
-	"strconv"
-	"strings"
 	"testing"
 
 	"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/cmd"
+	"github.com/micro/go-micro/config/cmd"
 	"github.com/micro/go-micro/registry"
 	"github.com/micro/go-micro/registry/memory"
 )
@@ -26,21 +24,12 @@ func testHttp(t *testing.T, path, service, ns string) {
 	}
 	defer l.Close()
 
-	parts := strings.Split(l.Addr().String(), ":")
-
-	var host string
-	var port int
-
-	host = parts[0]
-	port, _ = strconv.Atoi(parts[1])
-
 	s := &registry.Service{
 		Name: service,
 		Nodes: []*registry.Node{
 			&registry.Node{
 				Id:      service + "-1",
-				Address: host,
-				Port:    port,
+				Address: l.Addr().String(),
 			},
 		},
 	}

api/handler/rpc/rpc.go

@@ -14,12 +14,12 @@ import (
 	"github.com/micro/go-micro/api/handler"
 	proto "github.com/micro/go-micro/api/internal/proto"
 	"github.com/micro/go-micro/client"
+	"github.com/micro/go-micro/client/selector"
 	"github.com/micro/go-micro/codec"
 	"github.com/micro/go-micro/codec/jsonrpc"
 	"github.com/micro/go-micro/codec/protorpc"
 	"github.com/micro/go-micro/errors"
 	"github.com/micro/go-micro/registry"
-	"github.com/micro/go-micro/selector"
 	"github.com/micro/go-micro/util/ctx"
 )
 
@@ -120,32 +120,6 @@ func (h *rpcHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
 	var rsp []byte
 
 	switch {
-	// json codecs
-	case hasCodec(ct, jsonCodecs):
-		var request json.RawMessage
-		// if the extracted payload isn't empty lets use it
-		if len(br) > 0 {
-			request = json.RawMessage(br)
-		}
-
-		// create request/response
-		var response json.RawMessage
-
-		req := c.NewRequest(
-			service.Name,
-			service.Endpoint.Name,
-			&request,
-			client.WithContentType(ct),
-		)
-
-		// make the call
-		if err := c.Call(cx, req, &response, client.WithSelectOption(so)); err != nil {
-			writeError(w, r, err)
-			return
-		}
-
-		// marshall response
-		rsp, _ = response.MarshalJSON()
 	// proto codecs
 	case hasCodec(ct, protoCodecs):
 		request := &proto.Message{}
@@ -173,8 +147,36 @@ func (h *rpcHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
 		// marshall response
 		rsp, _ = response.Marshal()
 	default:
-		http.Error(w, "Unsupported Content-Type", 400)
-		return
+		// if json codec is not present set to json
+		if !hasCodec(ct, jsonCodecs) {
+			ct = "application/json"
+		}
+
+		// default to trying json
+		var request json.RawMessage
+		// if the extracted payload isn't empty lets use it
+		if len(br) > 0 {
+			request = json.RawMessage(br)
+		}
+
+		// create request/response
+		var response json.RawMessage
+
+		req := c.NewRequest(
+			service.Name,
+			service.Endpoint.Name,
+			&request,
+			client.WithContentType(ct),
+		)
+
+		// make the call
+		if err := c.Call(cx, req, &response, client.WithSelectOption(so)); err != nil {
+			writeError(w, r, err)
+			return
+		}
+
+		// marshall response
+		rsp, _ = response.MarshalJSON()
 	}
 
 	// write the response

api/handler/web/web.go

@@ -13,7 +13,7 @@ import (
 
 	"github.com/micro/go-micro/api"
 	"github.com/micro/go-micro/api/handler"
-	"github.com/micro/go-micro/selector"
+	"github.com/micro/go-micro/client/selector"
 )
 
 const (
@@ -79,7 +79,7 @@ func (wh *webHandler) getService(r *http.Request) (string, error) {
 		return "", nil
 	}
 
-	return fmt.Sprintf("http://%s:%d", s.Address, s.Port), nil
+	return fmt.Sprintf("http://%s", s.Address), nil
 }
 
 // serveWebSocket used to serve a web socket proxied connection

api/router/options.go

@@ -3,7 +3,7 @@ package router
 import (
 	"github.com/micro/go-micro/api/resolver"
 	"github.com/micro/go-micro/api/resolver/micro"
-	"github.com/micro/go-micro/cmd"
+	"github.com/micro/go-micro/config/cmd"
 	"github.com/micro/go-micro/registry"
 )
 

broker/broker.go

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

broker/common_test.go

@@ -1,4 +1,4 @@
-package memory
+package broker
 
 import (
 	"github.com/micro/go-micro/registry"
@@ -6,7 +6,7 @@ import (
 
 var (
 	// mock data
-	Data = map[string][]*registry.Service{
+	testData = map[string][]*registry.Service{
 		"foo": []*registry.Service{
 			{
 				Name:    "foo",
@@ -14,13 +14,11 @@ var (
 				Nodes: []*registry.Node{
 					{
 						Id:      "foo-1.0.0-123",
-						Address: "localhost",
-						Port:    9999,
+						Address: "localhost:9999",
 					},
 					{
 						Id:      "foo-1.0.0-321",
-						Address: "localhost",
-						Port:    9999,
+						Address: "localhost:9999",
 					},
 				},
 			},
@@ -30,8 +28,7 @@ var (
 				Nodes: []*registry.Node{
 					{
 						Id:      "foo-1.0.1-321",
-						Address: "localhost",
-						Port:    6666,
+						Address: "localhost:6666",
 					},
 				},
 			},
@@ -41,8 +38,7 @@ var (
 				Nodes: []*registry.Node{
 					{
 						Id:      "foo-1.0.3-345",
-						Address: "localhost",
-						Port:    8888,
+						Address: "localhost:8888",
 					},
 				},
 			},

broker/http_broker.go

@@ -13,8 +13,6 @@ import (
 	"net/http"
 	"net/url"
 	"runtime"
-	"strconv"
-	"strings"
 	"sync"
 	"time"
 
@@ -59,7 +57,7 @@ type httpSubscriber struct {
 	hb    *httpBroker
 }
 
-type httpPublication struct {
+type httpEvent struct {
 	m *Message
 	t string
 }
@@ -155,15 +153,15 @@ func newHttpBroker(opts ...Option) Broker {
 	return h
 }
 
-func (h *httpPublication) Ack() error {
+func (h *httpEvent) Ack() error {
 	return nil
 }
 
-func (h *httpPublication) Message() *Message {
+func (h *httpEvent) Message() *Message {
 	return h.m
 }
 
-func (h *httpPublication) Topic() string {
+func (h *httpEvent) Topic() string {
 	return h.t
 }
 
@@ -323,7 +321,7 @@ func (h *httpBroker) ServeHTTP(w http.ResponseWriter, req *http.Request) {
 		return
 	}
 
-	p := &httpPublication{m: m, t: topic}
+	p := &httpEvent{m: m, t: topic}
 	id := req.Form.Get("id")
 
 	h.RLock()
@@ -403,6 +401,7 @@ func (h *httpBroker) Connect() error {
 	go func() {
 		h.run(l)
 		h.Lock()
+		h.opts.Addrs = []string{addr}
 		h.address = addr
 		h.Unlock()
 	}()
@@ -542,7 +541,7 @@ func (h *httpBroker) Publish(topic string, msg *Message, opts ...PublishOption)
 		vals := url.Values{}
 		vals.Add("id", node.Id)
 
-		uri := fmt.Sprintf("%s://%s:%d%s?%s", scheme, node.Address, node.Port, DefaultSubPath, vals.Encode())
+		uri := fmt.Sprintf("%s://%s%s?%s", scheme, node.Address, DefaultSubPath, vals.Encode())
 		r, err := h.c.Post(uri, "application/json", bytes.NewReader(b))
 		if err != nil {
 			return err
@@ -613,12 +612,15 @@ func (h *httpBroker) Publish(topic string, msg *Message, opts ...PublishOption)
 }
 
 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
-	parts := strings.Split(h.Address(), ":")
-	host := strings.Join(parts[:len(parts)-1], ":")
-	port, _ := strconv.Atoi(parts[len(parts)-1])
+	host, port, err = net.SplitHostPort(h.Address())
+	if err != nil {
+		return nil, err
+	}
 
 	addr, err := maddr.Extract(host)
 	if err != nil {
@@ -637,8 +639,7 @@ func (h *httpBroker) Subscribe(topic string, handler Handler, opts ...SubscribeO
 	// register service
 	node := &registry.Node{
 		Id:      id,
-		Address: addr,
-		Port:    port,
+		Address: mnet.HostPort(addr, port),
 		Metadata: map[string]string{
 			"secure": fmt.Sprintf("%t", secure),
 		},

broker/http_broker_test.go

@@ -14,7 +14,7 @@ import (
 func newTestRegistry() *memory.Registry {
 	r := memory.NewRegistry()
 	m := r.(*memory.Registry)
-	m.Setup()
+	m.Services = testData
 	return m
 }
 
@@ -47,7 +47,7 @@ func sub(be *testing.B, c int) {
 	done := make(chan bool, c)
 
 	for i := 0; i < c; i++ {
-		sub, err := b.Subscribe(topic, func(p Publication) error {
+		sub, err := b.Subscribe(topic, func(p Event) error {
 			done <- true
 			m := p.Message()
 
@@ -107,7 +107,7 @@ func pub(be *testing.B, c int) {
 
 	done := make(chan bool, c*4)
 
-	sub, err := b.Subscribe(topic, func(p Publication) error {
+	sub, err := b.Subscribe(topic, func(p Event) error {
 		done <- true
 		m := p.Message()
 		if string(m.Body) != string(msg.Body) {
@@ -175,7 +175,7 @@ func TestBroker(t *testing.T) {
 
 	done := make(chan bool)
 
-	sub, err := b.Subscribe("test", func(p Publication) error {
+	sub, err := b.Subscribe("test", func(p Event) error {
 		m := p.Message()
 
 		if string(m.Body) != string(msg.Body) {
@@ -224,7 +224,7 @@ func TestConcurrentSubBroker(t *testing.T) {
 	var wg sync.WaitGroup
 
 	for i := 0; i < 10; i++ {
-		sub, err := b.Subscribe("test", func(p Publication) error {
+		sub, err := b.Subscribe("test", func(p Event) error {
 			defer wg.Done()
 
 			m := p.Message()
@@ -279,7 +279,7 @@ func TestConcurrentPubBroker(t *testing.T) {
 
 	var wg sync.WaitGroup
 
-	sub, err := b.Subscribe("test", func(p Publication) error {
+	sub, err := b.Subscribe("test", func(p Event) error {
 		defer wg.Done()
 
 		m := p.Message()

broker/memory/memory.go

@@ -3,21 +3,26 @@ package memory
 
 import (
 	"errors"
+	"math/rand"
 	"sync"
+	"time"
 
 	"github.com/google/uuid"
 	"github.com/micro/go-micro/broker"
+	maddr "github.com/micro/go-micro/util/addr"
+	mnet "github.com/micro/go-micro/util/net"
 )
 
 type memoryBroker struct {
 	opts broker.Options
 
+	addr string
 	sync.RWMutex
 	connected   bool
 	Subscribers map[string][]*memorySubscriber
 }
 
-type memoryPublication struct {
+type memoryEvent struct {
 	topic   string
 	message *broker.Message
 }
@@ -35,7 +40,7 @@ func (m *memoryBroker) Options() broker.Options {
 }
 
 func (m *memoryBroker) Address() string {
-	return ""
+	return m.addr
 }
 
 func (m *memoryBroker) Connect() error {
@@ -46,6 +51,15 @@ func (m *memoryBroker) Connect() error {
 		return nil
 	}
 
+	addr, err := maddr.Extract("::")
+	if err != nil {
+		return err
+	}
+	i := rand.Intn(20000)
+	// set addr with port
+	addr = mnet.HostPort(addr, 10000+i)
+
+	m.addr = addr
 	m.connected = true
 
 	return nil
@@ -72,19 +86,19 @@ func (m *memoryBroker) Init(opts ...broker.Option) error {
 }
 
 func (m *memoryBroker) Publish(topic string, message *broker.Message, opts ...broker.PublishOption) error {
-	m.Lock()
-	defer m.Unlock()
-
+	m.RLock()
 	if !m.connected {
+		m.RUnlock()
 		return errors.New("not connected")
 	}
 
 	subs, ok := m.Subscribers[topic]
+	m.RUnlock()
 	if !ok {
 		return nil
 	}
 
-	p := &memoryPublication{
+	p := &memoryEvent{
 		topic:   topic,
 		message: message,
 	}
@@ -99,12 +113,12 @@ func (m *memoryBroker) Publish(topic string, message *broker.Message, opts ...br
 }
 
 func (m *memoryBroker) Subscribe(topic string, handler broker.Handler, opts ...broker.SubscribeOption) (broker.Subscriber, error) {
-	m.Lock()
-	defer m.Unlock()
-
+	m.RLock()
 	if !m.connected {
+		m.RUnlock()
 		return nil, errors.New("not connected")
 	}
+	m.RUnlock()
 
 	var options broker.SubscribeOptions
 	for _, o := range opts {
@@ -119,7 +133,9 @@ func (m *memoryBroker) Subscribe(topic string, handler broker.Handler, opts ...b
 		opts:    options,
 	}
 
+	m.Lock()
 	m.Subscribers[topic] = append(m.Subscribers[topic], sub)
+	m.Unlock()
 
 	go func() {
 		<-sub.exit
@@ -142,15 +158,15 @@ func (m *memoryBroker) String() string {
 	return "memory"
 }
 
-func (m *memoryPublication) Topic() string {
+func (m *memoryEvent) Topic() string {
 	return m.topic
 }
 
-func (m *memoryPublication) Message() *broker.Message {
+func (m *memoryEvent) Message() *broker.Message {
 	return m.message
 }
 
-func (m *memoryPublication) Ack() error {
+func (m *memoryEvent) Ack() error {
 	return nil
 }
 
@@ -169,6 +185,7 @@ func (m *memorySubscriber) Unsubscribe() error {
 
 func NewBroker(opts ...broker.Option) broker.Broker {
 	var options broker.Options
+	rand.Seed(time.Now().UnixNano())
 	for _, o := range opts {
 		o(&options)
 	}

broker/memory/memory_test.go

@@ -17,7 +17,7 @@ func TestMemoryBroker(t *testing.T) {
 	topic := "test"
 	count := 10
 
-	fn := func(p broker.Publication) error {
+	fn := func(p broker.Event) error {
 		return nil
 	}
 

broker/nats/nats.go

@@ -13,18 +13,19 @@ import (
 )
 
 type natsBroker struct {
+	sync.Once
 	sync.RWMutex
-	addrs []string
-	conn  *nats.Conn
-	opts  broker.Options
-	nopts nats.Options
-	drain bool
+	addrs   []string
+	conn    *nats.Conn
+	opts    broker.Options
+	nopts   nats.Options
+	drain   bool
+	closeCh chan (error)
 }
 
 type subscriber struct {
-	s     *nats.Subscription
-	opts  broker.SubscribeOptions
-	drain bool
+	s    *nats.Subscription
+	opts broker.SubscribeOptions
 }
 
 type publication struct {
@@ -54,9 +55,6 @@ func (s *subscriber) Topic() string {
 }
 
 func (s *subscriber) Unsubscribe() error {
-	if s.drain {
-		return s.s.Drain()
-	}
 	return s.s.Unsubscribe()
 }
 
@@ -122,20 +120,17 @@ func (n *natsBroker) Connect() error {
 
 func (n *natsBroker) Disconnect() error {
 	n.RLock()
+	defer n.RUnlock()
 	if n.drain {
 		n.conn.Drain()
-	} else {
-		n.conn.Close()
+		return <-n.closeCh
 	}
-	n.RUnlock()
+	n.conn.Close()
 	return nil
 }
 
 func (n *natsBroker) Init(opts ...broker.Option) error {
-	for _, o := range opts {
-		o(&n.opts)
-	}
-	n.addrs = setAddrs(n.opts.Addrs)
+	n.setOption(opts...)
 	return nil
 }
 
@@ -167,11 +162,6 @@ func (n *natsBroker) Subscribe(topic string, handler broker.Handler, opts ...bro
 		o(&opt)
 	}
 
-	var drain bool
-	if _, ok := opt.Context.Value(drainSubscriptionKey{}).(bool); ok {
-		drain = true
-	}
-
 	fn := func(msg *nats.Msg) {
 		var m broker.Message
 		if err := n.opts.Codec.Unmarshal(msg.Data, &m); err != nil {
@@ -193,7 +183,7 @@ func (n *natsBroker) Subscribe(topic string, handler broker.Handler, opts ...bro
 	if err != nil {
 		return nil, err
 	}
-	return &subscriber{s: sub, opts: opt, drain: drain}, nil
+	return &subscriber{s: sub, opts: opt}, nil
 }
 
 func (n *natsBroker) String() string {
@@ -207,39 +197,59 @@ func NewBroker(opts ...broker.Option) broker.Broker {
 		Context: context.Background(),
 	}
 
+	n := &natsBroker{
+		opts: options,
+	}
+	n.setOption(opts...)
+
+	return n
+}
+
+func (n *natsBroker) setOption(opts ...broker.Option) {
 	for _, o := range opts {
-		o(&options)
+		o(&n.opts)
 	}
 
-	natsOpts := nats.GetDefaultOptions()
-	if n, ok := options.Context.Value(optionsKey{}).(nats.Options); ok {
-		natsOpts = n
-	}
+	n.Once.Do(func() {
+		n.nopts = nats.GetDefaultOptions()
+	})
 
-	var drain bool
-	if _, ok := options.Context.Value(drainSubscriptionKey{}).(bool); ok {
-		drain = true
+	if nopts, ok := n.opts.Context.Value(optionsKey{}).(nats.Options); ok {
+		n.nopts = nopts
 	}
 
 	// 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(options.Addrs) == 0 {
-		options.Addrs = natsOpts.Servers
+	if len(n.opts.Addrs) == 0 {
+		n.opts.Addrs = n.nopts.Servers
 	}
 
-	if !options.Secure {
-		options.Secure = natsOpts.Secure
+	if !n.opts.Secure {
+		n.opts.Secure = n.nopts.Secure
 	}
 
-	if options.TLSConfig == nil {
-		options.TLSConfig = natsOpts.TLSConfig
+	if n.opts.TLSConfig == nil {
+		n.opts.TLSConfig = n.nopts.TLSConfig
 	}
+	n.addrs = setAddrs(n.opts.Addrs)
 
-	return &natsBroker{
-		opts:  options,
-		nopts: natsOpts,
-		addrs: setAddrs(options.Addrs),
-		drain: drain,
+	if n.opts.Context.Value(drainConnectionKey{}) != nil {
+		n.drain = true
+		n.closeCh = make(chan error)
+		n.nopts.ClosedCB = n.onClose
+		n.nopts.AsyncErrorCB = n.onAsyncError
+	}
+}
+
+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
 	}
 }

broker/nats/nats_test.go

@@ -38,7 +38,7 @@ var addrTestCases = []struct {
 		"default",
 		"check if default Address is set correctly",
 		map[string]string{
-			"nats://localhost:4222": "",
+			"nats://127.0.0.1:4222": "",
 		},
 	},
 }

broker/nats/options.go

@@ -7,7 +7,6 @@ import (
 
 type optionsKey struct{}
 type drainConnectionKey struct{}
-type drainSubscriptionKey struct{}
 
 // Options accepts nats.Options
 func Options(opts nats.Options) broker.Option {
@@ -16,10 +15,5 @@ func Options(opts nats.Options) broker.Option {
 
 // DrainConnection will drain subscription on close
 func DrainConnection() broker.Option {
-	return setBrokerOption(drainConnectionKey{}, true)
-}
-
-// DrainSubscription will drain pending messages when unsubscribe
-func DrainSubscription() broker.SubscribeOption {
-	return setSubscribeOption(drainSubscriptionKey{}, true)
+	return setBrokerOption(drainConnectionKey{}, struct{}{})
 }

client/buffer.go

@@ -1,14 +0,0 @@
-package client
-
-import (
-	"bytes"
-)
-
-type buffer struct {
-	*bytes.Buffer
-}
-
-func (b *buffer) Close() error {
-	b.Buffer.Reset()
-	return nil
-}

client/client.go

@@ -10,7 +10,7 @@ import (
 
 // Client is the interface used to make requests to services.
 // It supports Request/Response via Transport and Publishing via the Broker.
-// It also supports bidiectional streaming of requests.
+// It also supports bidirectional streaming of requests.
 type Client interface {
 	Init(...Option) error
 	Options() Options

client/common_test.go

@@ -0,0 +1,47 @@
+package client
+
+import (
+	"github.com/micro/go-micro/registry"
+)
+
+var (
+	// mock data
+	testData = map[string][]*registry.Service{
+		"foo": []*registry.Service{
+			{
+				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",
+					},
+				},
+			},
+		},
+	}
+)

client/grpc/buffer.go

@@ -1,14 +0,0 @@
-package grpc
-
-import (
-	"bytes"
-)
-
-type buffer struct {
-	*bytes.Buffer
-}
-
-func (b *buffer) Close() error {
-	b.Buffer.Reset()
-	return nil
-}

client/grpc/codec.go

@@ -2,12 +2,18 @@ package grpc
 
 import (
 	"fmt"
+	"strings"
 
+	b "bytes"
+
+	"github.com/golang/protobuf/jsonpb"
 	"github.com/golang/protobuf/proto"
-	"github.com/json-iterator/go"
+	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"
 )
 
@@ -16,12 +22,15 @@ type protoCodec struct{}
 type bytesCodec struct{}
 type wrapCodec struct{ encoding.Codec }
 
+var jsonpbMarshaler = &jsonpb.Marshaler{}
+
 var (
 	defaultGRPCCodecs = map[string]encoding.Codec{
 		"application/json":         jsonCodec{},
 		"application/proto":        protoCodec{},
 		"application/protobuf":     protoCodec{},
 		"application/octet-stream": protoCodec{},
+		"application/grpc":         protoCodec{},
 		"application/grpc+json":    jsonCodec{},
 		"application/grpc+proto":   protoCodec{},
 		"application/grpc+bytes":   bytesCodec{},
@@ -52,7 +61,28 @@ func (w wrapCodec) String() string {
 	return w.Codec.Name()
 }
 
+func (w wrapCodec) Marshal(v interface{}) ([]byte, error) {
+	b, ok := v.(*bytes.Frame)
+	if ok {
+		return b.Data, nil
+	}
+	return w.Codec.Marshal(v)
+}
+
+func (w wrapCodec) Unmarshal(data []byte, v interface{}) error {
+	b, ok := v.(*bytes.Frame)
+	if ok {
+		b.Data = data
+		return nil
+	}
+	return w.Codec.Unmarshal(data, v)
+}
+
 func (protoCodec) Marshal(v interface{}) ([]byte, error) {
+	b, ok := v.(*bytes.Frame)
+	if ok {
+		return b.Data, nil
+	}
 	return proto.Marshal(v.(proto.Message))
 }
 
@@ -86,13 +116,79 @@ func (bytesCodec) Name() string {
 }
 
 func (jsonCodec) Marshal(v interface{}) ([]byte, error) {
+	if pb, ok := v.(proto.Message); ok {
+		s, err := jsonpbMarshaler.MarshalToString(pb)
+
+		return []byte(s), err
+	}
+
 	return json.Marshal(v)
 }
 
 func (jsonCodec) Unmarshal(data []byte, v interface{}) error {
+	if pb, ok := v.(proto.Message); ok {
+		return jsonpb.Unmarshal(b.NewReader(data), pb)
+	}
+
 	return json.Unmarshal(data, v)
 }
 
 func (jsonCodec) Name() string {
 	return "json"
 }
+
+type grpcCodec struct {
+	// headers
+	id       string
+	target   string
+	method   string
+	endpoint string
+
+	s grpc.ClientStream
+	c encoding.Codec
+}
+
+func (g *grpcCodec) ReadHeader(m *codec.Message, mt codec.MessageType) error {
+	md, err := g.s.Header()
+	if err != nil {
+		return err
+	}
+	if m == nil {
+		m = new(codec.Message)
+	}
+	if m.Header == nil {
+		m.Header = make(map[string]string)
+	}
+	for k, v := range md {
+		m.Header[k] = strings.Join(v, ",")
+	}
+	m.Id = g.id
+	m.Target = g.target
+	m.Method = g.method
+	m.Endpoint = g.endpoint
+	return nil
+}
+
+func (g *grpcCodec) ReadBody(v interface{}) error {
+	if f, ok := v.(*bytes.Frame); ok {
+		return g.s.RecvMsg(f)
+	}
+	return g.s.RecvMsg(v)
+}
+
+func (g *grpcCodec) Write(m *codec.Message, v interface{}) error {
+	// if we don't have a body
+	if v != nil {
+		return g.s.SendMsg(v)
+	}
+	// write the body using the framing codec
+	return g.s.SendMsg(&bytes.Frame{m.Body})
+}
+
+func (g *grpcCodec) Close() error {
+	return g.s.CloseSend()
+}
+
+func (g *grpcCodec) String() string {
+	return g.c.Name()
+}

client/grpc/grpc.go

@@ -2,20 +2,20 @@
 package grpc
 
 import (
-	"bytes"
 	"context"
 	"crypto/tls"
 	"fmt"
+	"os"
 	"sync"
 	"time"
 
 	"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"
 	"github.com/micro/go-micro/errors"
 	"github.com/micro/go-micro/metadata"
 	"github.com/micro/go-micro/registry"
-	"github.com/micro/go-micro/selector"
 	"github.com/micro/go-micro/transport"
 
 	"google.golang.org/grpc"
@@ -31,8 +31,9 @@ type grpcClient struct {
 }
 
 func init() {
-	encoding.RegisterCodec(jsonCodec{})
-	encoding.RegisterCodec(bytesCodec{})
+	encoding.RegisterCodec(wrapCodec{jsonCodec{}})
+	encoding.RegisterCodec(wrapCodec{protoCodec{}})
+	encoding.RegisterCodec(wrapCodec{bytesCodec{}})
 }
 
 // secure returns the dial option for whether its a secure or insecure connection
@@ -48,21 +49,34 @@ func (g *grpcClient) secure() grpc.DialOption {
 }
 
 func (g *grpcClient) next(request client.Request, opts client.CallOptions) (selector.Next, error) {
+	service := request.Service()
+
+	// get proxy
+	if prx := os.Getenv("MICRO_PROXY"); len(prx) > 0 {
+		service = prx
+	}
+
+	// get proxy address
+	if prx := os.Getenv("MICRO_PROXY_ADDRESS"); len(prx) > 0 {
+		opts.Address = []string{prx}
+	}
+
 	// return remote address
 	if len(opts.Address) > 0 {
 		return func() (*registry.Node, error) {
 			return &registry.Node{
-				Address: opts.Address,
+				Address: opts.Address[0],
 			}, nil
 		}, nil
 	}
 
 	// get next nodes from the selector
-	next, err := g.opts.Selector.Select(request.Service(), opts.SelectOptions...)
-	if err != nil && err == selector.ErrNotFound {
-		return nil, errors.NotFound("go.micro.client", err.Error())
-	} else if err != nil {
-		return nil, errors.InternalServerError("go.micro.client", err.Error())
+	next, err := g.opts.Selector.Select(service, opts.SelectOptions...)
+	if err != nil {
+		if err == selector.ErrNotFound {
+			return nil, errors.InternalServerError("go.micro.client", "service %s: %s", service, err.Error())
+		}
+		return nil, errors.InternalServerError("go.micro.client", "error selecting %s node: %s", service, err.Error())
 	}
 
 	return next, nil
@@ -70,9 +84,6 @@ func (g *grpcClient) next(request client.Request, opts client.CallOptions) (sele
 
 func (g *grpcClient) call(ctx context.Context, node *registry.Node, req client.Request, rsp interface{}, opts client.CallOptions) error {
 	address := node.Address
-	if node.Port > 0 {
-		address = fmt.Sprintf("%s:%d", address, node.Port)
-	}
 
 	header := make(map[string]string)
 	if md, ok := metadata.FromContext(ctx); ok {
@@ -99,7 +110,7 @@ func (g *grpcClient) call(ctx context.Context, node *registry.Node, req client.R
 
 	var grr error
 
-	cc, err := g.pool.getConn(address, grpc.WithDefaultCallOptions(grpc.CallCustomCodec(cf)),
+	cc, err := g.pool.getConn(address, grpc.WithDefaultCallOptions(grpc.ForceCodec(cf)),
 		grpc.WithTimeout(opts.DialTimeout), g.secure(),
 		grpc.WithDefaultCallOptions(
 			grpc.MaxCallRecvMsgSize(maxRecvMsgSize),
@@ -116,7 +127,7 @@ func (g *grpcClient) call(ctx context.Context, node *registry.Node, req client.R
 	ch := make(chan error, 1)
 
 	go func() {
-		err := cc.Invoke(ctx, methodToGRPC(req.Endpoint(), req.Body()), req.Body(), rsp, grpc.CallContentSubtype(cf.String()))
+		err := cc.Invoke(ctx, methodToGRPC(req.Service(), req.Endpoint()), req.Body(), rsp, grpc.CallContentSubtype(cf.Name()))
 		ch <- microError(err)
 	}()
 
@@ -132,9 +143,6 @@ func (g *grpcClient) call(ctx context.Context, node *registry.Node, req client.R
 
 func (g *grpcClient) stream(ctx context.Context, node *registry.Node, req client.Request, opts client.CallOptions) (client.Stream, error) {
 	address := node.Address
-	if node.Port > 0 {
-		address = fmt.Sprintf("%s:%d", address, node.Port)
-	}
 
 	header := make(map[string]string)
 	if md, ok := metadata.FromContext(ctx); ok {
@@ -164,7 +172,10 @@ func (g *grpcClient) stream(ctx context.Context, node *registry.Node, req client
 		dialCtx, cancel = context.WithCancel(ctx)
 	}
 	defer cancel()
-	cc, err := grpc.DialContext(dialCtx, address, grpc.WithDefaultCallOptions(grpc.CallCustomCodec(cf)), g.secure())
+
+	wc := wrapCodec{cf}
+
+	cc, err := grpc.DialContext(dialCtx, address, grpc.WithDefaultCallOptions(grpc.ForceCodec(wc)), g.secure())
 	if err != nil {
 		return nil, errors.InternalServerError("go.micro.client", fmt.Sprintf("Error sending request: %v", err))
 	}
@@ -175,16 +186,34 @@ func (g *grpcClient) stream(ctx context.Context, node *registry.Node, req client
 		ServerStreams: true,
 	}
 
-	st, err := cc.NewStream(ctx, desc, methodToGRPC(req.Endpoint(), req.Body()), grpc.CallContentSubtype(cf.String()))
+	st, err := cc.NewStream(ctx, desc, methodToGRPC(req.Service(), req.Endpoint()))
 	if err != nil {
 		return nil, errors.InternalServerError("go.micro.client", fmt.Sprintf("Error creating stream: %v", err))
 	}
 
+	codec := &grpcCodec{
+		s: st,
+		c: wc,
+	}
+
+	// set request codec
+	if r, ok := req.(*grpcRequest); ok {
+		r.codec = codec
+	}
+
+	rsp := &response{
+		conn:   cc,
+		stream: st,
+		codec:  cf,
+		gcodec: codec,
+	}
+
 	return &grpcStream{
-		context: ctx,
-		request: req,
-		stream:  st,
-		conn:    cc,
+		context:  ctx,
+		request:  req,
+		response: rsp,
+		stream:   st,
+		conn:     cc,
 	}, nil
 }
 
@@ -210,7 +239,7 @@ func (g *grpcClient) maxSendMsgSizeValue() int {
 	return v.(int)
 }
 
-func (g *grpcClient) newGRPCCodec(contentType string) (grpc.Codec, error) {
+func (g *grpcClient) newGRPCCodec(contentType string) (encoding.Codec, error) {
 	codecs := make(map[string]encoding.Codec)
 	if g.opts.Context != nil {
 		if v := g.opts.Context.Value(codecsKey{}); v != nil {
@@ -260,7 +289,7 @@ func (g *grpcClient) Options() client.Options {
 }
 
 func (g *grpcClient) NewMessage(topic string, msg interface{}, opts ...client.MessageOption) client.Message {
-	return newGRPCPublication(topic, msg, "application/octet-stream")
+	return newGRPCEvent(topic, msg, g.opts.ContentType, opts...)
 }
 
 func (g *grpcClient) NewRequest(service, method string, req interface{}, reqOpts ...client.RequestOption) client.Request {
@@ -321,15 +350,17 @@ func (g *grpcClient) Call(ctx context.Context, req client.Request, rsp interface
 
 		// select next node
 		node, err := next()
-		if err != nil && err == selector.ErrNotFound {
-			return errors.NotFound("go.micro.client", err.Error())
-		} else if err != nil {
-			return errors.InternalServerError("go.micro.client", err.Error())
+		service := req.Service()
+		if err != nil {
+			if err == selector.ErrNotFound {
+				return errors.InternalServerError("go.micro.client", "service %s: %s", service, err.Error())
+			}
+			return errors.InternalServerError("go.micro.client", "error selecting %s node: %s", service, err.Error())
 		}
 
 		// make the call
 		err = gcall(ctx, node, req, rsp, callOpts)
-		g.opts.Selector.Mark(req.Service(), node, err)
+		g.opts.Selector.Mark(service, node, err)
 		return err
 	}
 
@@ -337,9 +368,9 @@ func (g *grpcClient) Call(ctx context.Context, req client.Request, rsp interface
 	var gerr error
 
 	for i := 0; i <= callOpts.Retries; i++ {
-		go func() {
+		go func(i int) {
 			ch <- call(i)
-		}()
+		}(i)
 
 		select {
 		case <-ctx.Done():
@@ -400,14 +431,16 @@ func (g *grpcClient) Stream(ctx context.Context, req client.Request, opts ...cli
 		}
 
 		node, err := next()
-		if err != nil && err == selector.ErrNotFound {
-			return nil, errors.NotFound("go.micro.client", err.Error())
-		} else if err != nil {
-			return nil, errors.InternalServerError("go.micro.client", err.Error())
+		service := req.Service()
+		if err != nil {
+			if err == selector.ErrNotFound {
+				return nil, errors.InternalServerError("go.micro.client", "service %s: %s", service, err.Error())
+			}
+			return nil, errors.InternalServerError("go.micro.client", "error selecting %s node: %s", service, err.Error())
 		}
 
 		stream, err := g.stream(ctx, node, req, callOpts)
-		g.opts.Selector.Mark(req.Service(), node, err)
+		g.opts.Selector.Mark(service, node, err)
 		return stream, err
 	}
 
@@ -420,10 +453,10 @@ func (g *grpcClient) Stream(ctx context.Context, req client.Request, opts ...cli
 	var grr error
 
 	for i := 0; i <= callOpts.Retries; i++ {
-		go func() {
+		go func(i int) {
 			s, err := call(i)
 			ch <- response{s, err}
-		}()
+		}(i)
 
 		select {
 		case <-ctx.Done():
@@ -457,13 +490,13 @@ func (g *grpcClient) Publish(ctx context.Context, p client.Message, opts ...clie
 	}
 	md["Content-Type"] = p.ContentType()
 
-	cf, err := g.newCodec(p.ContentType())
+	cf, err := g.newGRPCCodec(p.ContentType())
 	if err != nil {
 		return errors.InternalServerError("go.micro.client", err.Error())
 	}
 
-	b := &buffer{bytes.NewBuffer(nil)}
-	if err := cf(b).Write(&codec.Message{Type: codec.Publication}, p.Payload()); err != nil {
+	b, err := cf.Marshal(p.Payload())
+	if err != nil {
 		return errors.InternalServerError("go.micro.client", err.Error())
 	}
 
@@ -473,7 +506,7 @@ func (g *grpcClient) Publish(ctx context.Context, p client.Message, opts ...clie
 
 	return g.opts.Broker.Publish(p.Topic(), &broker.Message{
 		Header: md,
-		Body:   b.Bytes(),
+		Body:   b,
 	})
 }
 

client/grpc/grpc_test.go

@@ -3,14 +3,12 @@ package grpc
 import (
 	"context"
 	"net"
-	"strconv"
-	"strings"
 	"testing"
 
 	"github.com/micro/go-micro/client"
+	"github.com/micro/go-micro/client/selector"
 	"github.com/micro/go-micro/registry"
 	"github.com/micro/go-micro/registry/memory"
-	"github.com/micro/go-micro/selector"
 	pgrpc "google.golang.org/grpc"
 	pb "google.golang.org/grpc/examples/helloworld/helloworld"
 )
@@ -36,22 +34,17 @@ func TestGRPCClient(t *testing.T) {
 	go s.Serve(l)
 	defer s.Stop()
 
-	parts := strings.Split(l.Addr().String(), ":")
-	port, _ := strconv.Atoi(parts[len(parts)-1])
-	addr := strings.Join(parts[:len(parts)-1], ":")
-
 	// create mock registry
 	r := memory.NewRegistry()
 
 	// register service
 	r.Register(&registry.Service{
-		Name:    "test",
+		Name:    "helloworld",
 		Version: "test",
 		Nodes: []*registry.Node{
 			&registry.Node{
 				Id:      "test-1",
-				Address: addr,
-				Port:    port,
+				Address: l.Addr().String(),
 			},
 		},
 	})
@@ -73,7 +66,7 @@ func TestGRPCClient(t *testing.T) {
 	}
 
 	for _, method := range testMethods {
-		req := c.NewRequest("test", method, &pb.HelloRequest{
+		req := c.NewRequest("helloworld", method, &pb.HelloRequest{
 			Name: "John",
 		})
 

client/grpc/message.go

@@ -4,13 +4,13 @@ import (
 	"github.com/micro/go-micro/client"
 )
 
-type grpcPublication struct {
+type grpcEvent struct {
 	topic       string
 	contentType string
 	payload     interface{}
 }
 
-func newGRPCPublication(topic string, payload interface{}, contentType string, opts ...client.MessageOption) client.Message {
+func newGRPCEvent(topic string, payload interface{}, contentType string, opts ...client.MessageOption) client.Message {
 	var options client.MessageOptions
 	for _, o := range opts {
 		o(&options)
@@ -20,21 +20,21 @@ func newGRPCPublication(topic string, payload interface{}, contentType string, o
 		contentType = options.ContentType
 	}
 
-	return &grpcPublication{
+	return &grpcEvent{
 		payload:     payload,
 		topic:       topic,
 		contentType: contentType,
 	}
 }
 
-func (g *grpcPublication) ContentType() string {
+func (g *grpcEvent) ContentType() string {
 	return g.contentType
 }
 
-func (g *grpcPublication) Topic() string {
+func (g *grpcEvent) Topic() string {
 	return g.topic
 }
 
-func (g *grpcPublication) Payload() interface{} {
+func (g *grpcEvent) Payload() interface{} {
 	return g.payload
 }

client/grpc/request.go

@@ -2,7 +2,6 @@ package grpc
 
 import (
 	"fmt"
-	"reflect"
 	"strings"
 
 	"github.com/micro/go-micro/client"
@@ -15,32 +14,28 @@ type grpcRequest struct {
 	contentType string
 	request     interface{}
 	opts        client.RequestOptions
+	codec       codec.Codec
 }
 
-func methodToGRPC(method string, request interface{}) string {
+// service Struct.Method /service.Struct/Method
+func methodToGRPC(service, method string) string {
 	// no method or already grpc method
 	if len(method) == 0 || method[0] == '/' {
 		return method
 	}
-	// can't operate on nil request
-	t := reflect.TypeOf(request)
-	if t == nil {
-		return method
-	}
-	// dereference
-	if t.Kind() == reflect.Ptr {
-		t = t.Elem()
-	}
-	// get package name
-	pParts := strings.Split(t.PkgPath(), "/")
-	pkg := pParts[len(pParts)-1]
+
 	// assume method is Foo.Bar
 	mParts := strings.Split(method, ".")
 	if len(mParts) != 2 {
 		return method
 	}
+
+	if len(service) == 0 {
+		return fmt.Sprintf("/%s/%s", mParts[0], mParts[1])
+	}
+
 	// return /pkg.Foo/Bar
-	return fmt.Sprintf("/%s.%s/%s", pkg, mParts[0], mParts[1])
+	return fmt.Sprintf("/%s.%s/%s", service, mParts[0], mParts[1])
 }
 
 func newGRPCRequest(service, method string, request interface{}, contentType string, reqOpts ...client.RequestOption) client.Request {
@@ -80,7 +75,7 @@ func (g *grpcRequest) Endpoint() string {
 }
 
 func (g *grpcRequest) Codec() codec.Writer {
-	return nil
+	return g.codec
 }
 
 func (g *grpcRequest) Body() interface{} {

client/grpc/request_test.go

@@ -2,45 +2,38 @@ package grpc
 
 import (
 	"testing"
-
-	pb "google.golang.org/grpc/examples/helloworld/helloworld"
 )
 
 func TestMethodToGRPC(t *testing.T) {
 	testData := []struct {
+		service string
 		method  string
 		expect  string
-		request interface{}
 	}{
 		{
+			"helloworld",
 			"Greeter.SayHello",
 			"/helloworld.Greeter/SayHello",
-			new(pb.HelloRequest),
 		},
 		{
+			"helloworld",
 			"/helloworld.Greeter/SayHello",
 			"/helloworld.Greeter/SayHello",
-			new(pb.HelloRequest),
 		},
 		{
+			"",
+			"/helloworld.Greeter/SayHello",
+			"/helloworld.Greeter/SayHello",
+		},
+		{
+			"",
 			"Greeter.SayHello",
-			"/helloworld.Greeter/SayHello",
-			pb.HelloRequest{},
-		},
-		{
-			"/helloworld.Greeter/SayHello",
-			"/helloworld.Greeter/SayHello",
-			pb.HelloRequest{},
-		},
-		{
-			"Greeter.SayHello",
-			"Greeter.SayHello",
-			nil,
+			"/Greeter/SayHello",
 		},
 	}
 
 	for _, d := range testData {
-		method := methodToGRPC(d.method, d.request)
+		method := methodToGRPC(d.service, d.method)
 		if method != d.expect {
 			t.Fatalf("expected %s got %s", d.expect, method)
 		}

client/grpc/response.go

@@ -0,0 +1,44 @@
+package grpc
+
+import (
+	"strings"
+
+	"github.com/micro/go-micro/codec"
+	"github.com/micro/go-micro/codec/bytes"
+	"google.golang.org/grpc"
+	"google.golang.org/grpc/encoding"
+)
+
+type response struct {
+	conn   *grpc.ClientConn
+	stream grpc.ClientStream
+	codec  encoding.Codec
+	gcodec codec.Codec
+}
+
+// Read the response
+func (r *response) Codec() codec.Reader {
+	return r.gcodec
+}
+
+// read the header
+func (r *response) Header() map[string]string {
+	md, err := r.stream.Header()
+	if err != nil {
+		return map[string]string{}
+	}
+	hdr := make(map[string]string)
+	for k, v := range md {
+		hdr[k] = strings.Join(v, ",")
+	}
+	return hdr
+}
+
+// Read the undecoded response
+func (r *response) Read() ([]byte, error) {
+	f := &bytes.Frame{}
+	if err := r.gcodec.ReadBody(f); err != nil {
+		return nil, err
+	}
+	return f.Data, nil
+}

client/grpc/stream.go

@@ -12,11 +12,12 @@ import (
 // Implements the streamer interface
 type grpcStream struct {
 	sync.RWMutex
-	err     error
-	conn    *grpc.ClientConn
-	request client.Request
-	stream  grpc.ClientStream
-	context context.Context
+	err      error
+	conn     *grpc.ClientConn
+	stream   grpc.ClientStream
+	request  client.Request
+	response client.Response
+	context  context.Context
 }
 
 func (g *grpcStream) Context() context.Context {
@@ -28,7 +29,7 @@ func (g *grpcStream) Request() client.Request {
 }
 
 func (g *grpcStream) Response() client.Response {
-	return nil
+	return g.response
 }
 
 func (g *grpcStream) Send(msg interface{}) error {

client/mucp/mucp.go

@@ -1,5 +1,5 @@
-// Package rpc provides an rpc client
-package rpc
+// Package mucp provides an mucp client
+package mucp
 
 import (
 	"github.com/micro/go-micro/client"

client/options.go

@@ -5,9 +5,9 @@ import (
 	"time"
 
 	"github.com/micro/go-micro/broker"
+	"github.com/micro/go-micro/client/selector"
 	"github.com/micro/go-micro/codec"
 	"github.com/micro/go-micro/registry"
-	"github.com/micro/go-micro/selector"
 	"github.com/micro/go-micro/transport"
 )
 
@@ -43,8 +43,8 @@ type Options struct {
 type CallOptions struct {
 	SelectOptions []selector.SelectOption
 
-	// Address of remote host
-	Address string
+	// Address of remote hosts
+	Address []string
 	// Backoff func
 	Backoff BackoffFunc
 	// Check if retriable func
@@ -245,8 +245,8 @@ func WithExchange(e string) PublishOption {
 	}
 }
 
-// WithAddress sets the remote address to use rather than using service discovery
-func WithAddress(a string) CallOption {
+// WithAddress sets the remote addresses to use rather than using service discovery
+func WithAddress(a ...string) CallOption {
 	return func(o *CallOptions) {
 		o.Address = a
 	}

client/pool/default.go

@@ -0,0 +1,114 @@
+package pool
+
+import (
+	"sync"
+	"time"
+
+	"github.com/google/uuid"
+	"github.com/micro/go-micro/transport"
+)
+
+type pool struct {
+	size int
+	ttl  time.Duration
+	tr   transport.Transport
+
+	sync.Mutex
+	conns map[string][]*poolConn
+}
+
+type poolConn struct {
+	transport.Client
+	id      string
+	created time.Time
+}
+
+func newPool(options Options) *pool {
+	return &pool{
+		size:  options.Size,
+		tr:    options.Transport,
+		ttl:   options.TTL,
+		conns: make(map[string][]*poolConn),
+	}
+}
+
+func (p *pool) Close() error {
+	p.Lock()
+	for k, c := range p.conns {
+		for _, conn := range c {
+			conn.Client.Close()
+		}
+		delete(p.conns, k)
+	}
+	p.Unlock()
+	return nil
+}
+
+// NoOp the Close since we manage it
+func (p *poolConn) Close() error {
+	return nil
+}
+
+func (p *poolConn) Id() string {
+	return p.id
+}
+
+func (p *poolConn) Created() time.Time {
+	return p.created
+}
+
+func (p *pool) Get(addr string, opts ...transport.DialOption) (Conn, error) {
+	p.Lock()
+	conns := p.conns[addr]
+
+	// 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 := time.Since(conn.Created()); d > p.ttl {
+			conn.Client.Close()
+			continue
+		}
+
+		// we got a good conn, lets unlock and return it
+		p.Unlock()
+
+		return conn, nil
+	}
+
+	p.Unlock()
+
+	// create new conn
+	c, err := p.tr.Dial(addr, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return &poolConn{
+		Client:  c,
+		id:      uuid.New().String(),
+		created: time.Now(),
+	}, nil
+}
+
+func (p *pool) Release(conn Conn, err error) error {
+	// don't store the conn if it has errored
+	if err != nil {
+		return conn.(*poolConn).Client.Close()
+	}
+
+	// otherwise put it back for reuse
+	p.Lock()
+	conns := p.conns[conn.Remote()]
+	if len(conns) >= p.size {
+		p.Unlock()
+		return conn.(*poolConn).Client.Close()
+	}
+	p.conns[conn.Remote()] = append(conns, conn.(*poolConn))
+	p.Unlock()
+
+	return nil
+}

client/pool/default_test.go

@@ -1,4 +1,4 @@
-package client
+package pool
 
 import (
 	"testing"
@@ -9,12 +9,17 @@ import (
 )
 
 func testPool(t *testing.T, size int, ttl time.Duration) {
-	// zero pool
-	p := newPool(size, ttl)
-
 	// mock transport
 	tr := memory.NewTransport()
 
+	options := Options{
+		TTL:       ttl,
+		Size:      size,
+		Transport: tr,
+	}
+	// zero pool
+	p := newPool(options)
+
 	// listen
 	l, err := tr.Listen(":0")
 	if err != nil {
@@ -43,7 +48,7 @@ func testPool(t *testing.T, size int, ttl time.Duration) {
 
 	for i := 0; i < 10; i++ {
 		// get a conn
-		c, err := p.getConn(l.Addr(), tr)
+		c, err := p.Get(l.Addr())
 		if err != nil {
 			t.Fatal(err)
 		}
@@ -67,7 +72,7 @@ func testPool(t *testing.T, size int, ttl time.Duration) {
 		}
 
 		// release the conn
-		p.release(l.Addr(), c, nil)
+		p.Release(c, nil)
 
 		p.Lock()
 		if i := len(p.conns[l.Addr()]); i > size {
@@ -78,7 +83,7 @@ func testPool(t *testing.T, size int, ttl time.Duration) {
 	}
 }
 
-func TestRPCPool(t *testing.T) {
+func TestClientPool(t *testing.T) {
 	testPool(t, 0, time.Minute)
 	testPool(t, 2, time.Minute)
 }

client/pool/options.go

@@ -0,0 +1,33 @@
+package pool
+
+import (
+	"time"
+
+	"github.com/micro/go-micro/transport"
+)
+
+type Options struct {
+	Transport transport.Transport
+	TTL       time.Duration
+	Size      int
+}
+
+type Option func(*Options)
+
+func Size(i int) Option {
+	return func(o *Options) {
+		o.Size = i
+	}
+}
+
+func Transport(t transport.Transport) Option {
+	return func(o *Options) {
+		o.Transport = t
+	}
+}
+
+func TTL(t time.Duration) Option {
+	return func(o *Options) {
+		o.TTL = t
+	}
+}

client/pool/pool.go

@@ -0,0 +1,35 @@
+// Package pool is a connection pool
+package pool
+
+import (
+	"time"
+
+	"github.com/micro/go-micro/transport"
+)
+
+// Pool is an interface for connection pooling
+type Pool interface {
+	// Close the pool
+	Close() error
+	// Get a connection
+	Get(addr string, opts ...transport.DialOption) (Conn, error)
+	// Releaes the connection
+	Release(c Conn, status error) error
+}
+
+type Conn interface {
+	// unique id of connection
+	Id() string
+	// time it was created
+	Created() time.Time
+	// embedded connection
+	transport.Client
+}
+
+func NewPool(opts ...Option) Pool {
+	var options Options
+	for _, o := range opts {
+		o(&options)
+	}
+	return newPool(options)
+}

client/proto/client.micro.go

@@ -0,0 +1,203 @@
+// Code generated by protoc-gen-micro. DO NOT EDIT.
+// source: micro/go-micro/client/proto/client.proto
+
+package go_micro_client
+
+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 Client service
+
+type ClientService interface {
+	// Call allows a single request to be made
+	Call(ctx context.Context, in *Request, opts ...client.CallOption) (*Response, error)
+	// Stream is a bidirectional stream
+	Stream(ctx context.Context, opts ...client.CallOption) (Client_StreamService, error)
+	// Publish publishes a message and returns an empty Message
+	Publish(ctx context.Context, in *Message, opts ...client.CallOption) (*Message, error)
+}
+
+type clientService struct {
+	c    client.Client
+	name string
+}
+
+func NewClientService(name string, c client.Client) ClientService {
+	if c == nil {
+		c = client.NewClient()
+	}
+	if len(name) == 0 {
+		name = "go.micro.client"
+	}
+	return &clientService{
+		c:    c,
+		name: name,
+	}
+}
+
+func (c *clientService) Call(ctx context.Context, in *Request, opts ...client.CallOption) (*Response, error) {
+	req := c.c.NewRequest(c.name, "Client.Call", in)
+	out := new(Response)
+	err := c.c.Call(ctx, req, out, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *clientService) Stream(ctx context.Context, opts ...client.CallOption) (Client_StreamService, error) {
+	req := c.c.NewRequest(c.name, "Client.Stream", &Request{})
+	stream, err := c.c.Stream(ctx, req, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return &clientServiceStream{stream}, nil
+}
+
+type Client_StreamService interface {
+	SendMsg(interface{}) error
+	RecvMsg(interface{}) error
+	Close() error
+	Send(*Request) error
+	Recv() (*Response, error)
+}
+
+type clientServiceStream struct {
+	stream client.Stream
+}
+
+func (x *clientServiceStream) Close() error {
+	return x.stream.Close()
+}
+
+func (x *clientServiceStream) SendMsg(m interface{}) error {
+	return x.stream.Send(m)
+}
+
+func (x *clientServiceStream) RecvMsg(m interface{}) error {
+	return x.stream.Recv(m)
+}
+
+func (x *clientServiceStream) Send(m *Request) error {
+	return x.stream.Send(m)
+}
+
+func (x *clientServiceStream) Recv() (*Response, error) {
+	m := new(Response)
+	err := x.stream.Recv(m)
+	if err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+func (c *clientService) Publish(ctx context.Context, in *Message, opts ...client.CallOption) (*Message, error) {
+	req := c.c.NewRequest(c.name, "Client.Publish", in)
+	out := new(Message)
+	err := c.c.Call(ctx, req, out, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+// Server API for Client service
+
+type ClientHandler interface {
+	// Call allows a single request to be made
+	Call(context.Context, *Request, *Response) error
+	// Stream is a bidirectional stream
+	Stream(context.Context, Client_StreamStream) error
+	// Publish publishes a message and returns an empty Message
+	Publish(context.Context, *Message, *Message) error
+}
+
+func RegisterClientHandler(s server.Server, hdlr ClientHandler, opts ...server.HandlerOption) error {
+	type client interface {
+		Call(ctx context.Context, in *Request, out *Response) error
+		Stream(ctx context.Context, stream server.Stream) error
+		Publish(ctx context.Context, in *Message, out *Message) error
+	}
+	type Client struct {
+		client
+	}
+	h := &clientHandler{hdlr}
+	return s.Handle(s.NewHandler(&Client{h}, opts...))
+}
+
+type clientHandler struct {
+	ClientHandler
+}
+
+func (h *clientHandler) Call(ctx context.Context, in *Request, out *Response) error {
+	return h.ClientHandler.Call(ctx, in, out)
+}
+
+func (h *clientHandler) Stream(ctx context.Context, stream server.Stream) error {
+	return h.ClientHandler.Stream(ctx, &clientStreamStream{stream})
+}
+
+type Client_StreamStream interface {
+	SendMsg(interface{}) error
+	RecvMsg(interface{}) error
+	Close() error
+	Send(*Response) error
+	Recv() (*Request, error)
+}
+
+type clientStreamStream struct {
+	stream server.Stream
+}
+
+func (x *clientStreamStream) Close() error {
+	return x.stream.Close()
+}
+
+func (x *clientStreamStream) SendMsg(m interface{}) error {
+	return x.stream.Send(m)
+}
+
+func (x *clientStreamStream) RecvMsg(m interface{}) error {
+	return x.stream.Recv(m)
+}
+
+func (x *clientStreamStream) Send(m *Response) error {
+	return x.stream.Send(m)
+}
+
+func (x *clientStreamStream) Recv() (*Request, error) {
+	m := new(Request)
+	if err := x.stream.Recv(m); err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+func (h *clientHandler) Publish(ctx context.Context, in *Message, out *Message) error {
+	return h.ClientHandler.Publish(ctx, in, out)
+}

client/proto/client.pb.go

@@ -0,0 +1,388 @@
+// 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/proto/client.proto

@@ -0,0 +1,30 @@
+syntax = "proto3";
+
+package go.micro.client;
+
+// Client is the micro client interface
+service Client {
+	// Call allows a single request to be made
+	rpc Call(Request) returns (Response) {};
+	// Stream is a bidirectional stream
+	rpc Stream(stream Request) returns (stream Response) {};
+	// Publish publishes a message and returns an empty Message
+	rpc Publish(Message) returns (Message) {};
+}
+
+message Request {
+	string service = 1;
+	string endpoint = 2;
+	string content_type = 3;
+	bytes body = 4;
+}
+
+message Response {
+	bytes body = 1;
+}
+
+message Message {
+	string topic = 1;
+	string content_type = 2;
+	bytes body = 3;
+}

client/rpc_client.go

@@ -1,40 +1,45 @@
 package client
 
 import (
-	"bytes"
 	"context"
 	"fmt"
-	"net"
 	"os"
-	"strconv"
 	"sync"
 	"sync/atomic"
 	"time"
 
 	"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"
 	"github.com/micro/go-micro/errors"
 	"github.com/micro/go-micro/metadata"
 	"github.com/micro/go-micro/registry"
-	"github.com/micro/go-micro/selector"
 	"github.com/micro/go-micro/transport"
+	"github.com/micro/go-micro/util/buf"
 )
 
 type rpcClient struct {
 	once sync.Once
 	opts Options
-	pool *pool
+	pool pool.Pool
 	seq  uint64
 }
 
 func newRpcClient(opt ...Option) Client {
 	opts := newOptions(opt...)
 
+	p := pool.NewPool(
+		pool.Size(opts.PoolSize),
+		pool.TTL(opts.PoolTTL),
+		pool.Transport(opts.Transport),
+	)
+
 	rc := &rpcClient{
 		once: sync.Once{},
 		opts: opts,
-		pool: newPool(opts.PoolSize, opts.PoolTTL),
+		pool: p,
 		seq:  0,
 	}
 
@@ -60,9 +65,6 @@ func (r *rpcClient) newCodec(contentType string) (codec.NewCodec, error) {
 
 func (r *rpcClient) call(ctx context.Context, node *registry.Node, req Request, resp interface{}, opts CallOptions) error {
 	address := node.Address
-	if node.Port > 0 {
-		address = fmt.Sprintf("%s:%d", address, node.Port)
-	}
 
 	msg := &transport.Message{
 		Header: make(map[string]string),
@@ -94,19 +96,22 @@ func (r *rpcClient) call(ctx context.Context, node *registry.Node, req Request,
 		}
 	}
 
-	var grr error
-	c, err := r.pool.getConn(address, r.opts.Transport, transport.WithTimeout(opts.DialTimeout))
+	dOpts := []transport.DialOption{
+		transport.WithStream(),
+	}
+
+	if opts.DialTimeout >= 0 {
+		dOpts = append(dOpts, transport.WithTimeout(opts.DialTimeout))
+	}
+
+	c, err := r.pool.Get(address, dOpts...)
 	if err != nil {
 		return errors.InternalServerError("go.micro.client", "connection error: %v", err)
 	}
-	defer func() {
-		// defer execution of release
-		r.pool.release(address, c, grr)
-	}()
 
 	seq := atomic.LoadUint64(&r.seq)
 	atomic.AddUint64(&r.seq, 1)
-	codec := newRpcCodec(msg, c, cf)
+	codec := newRpcCodec(msg, c, cf, "")
 
 	rsp := &rpcResponse{
 		socket: c,
@@ -114,15 +119,19 @@ func (r *rpcClient) call(ctx context.Context, node *registry.Node, req Request,
 	}
 
 	stream := &rpcStream{
+		id:       fmt.Sprintf("%v", seq),
 		context:  ctx,
 		request:  req,
 		response: rsp,
 		codec:    codec,
 		closed:   make(chan bool),
-		id:       fmt.Sprintf("%v", seq),
+		release:  func(err error) { r.pool.Release(c, err) },
+		sendEOS:  false,
 	}
+	// close the stream on exiting this function
 	defer stream.Close()
 
+	// wait for error response
 	ch := make(chan error, 1)
 
 	go func() {
@@ -148,21 +157,30 @@ func (r *rpcClient) call(ctx context.Context, node *registry.Node, req Request,
 		ch <- nil
 	}()
 
+	var grr error
+
 	select {
 	case err := <-ch:
 		grr = err
 		return err
 	case <-ctx.Done():
-		grr = ctx.Err()
-		return errors.Timeout("go.micro.client", fmt.Sprintf("%v", ctx.Err()))
+		grr = errors.Timeout("go.micro.client", fmt.Sprintf("%v", ctx.Err()))
 	}
+
+	// set the stream error
+	if grr != nil {
+		stream.Lock()
+		stream.err = grr
+		stream.Unlock()
+
+		return grr
+	}
+
+	return nil
 }
 
 func (r *rpcClient) stream(ctx context.Context, node *registry.Node, req Request, opts CallOptions) (Stream, error) {
 	address := node.Address
-	if node.Port > 0 {
-		address = fmt.Sprintf("%s:%d", address, node.Port)
-	}
 
 	msg := &transport.Message{
 		Header: make(map[string]string),
@@ -207,7 +225,13 @@ func (r *rpcClient) stream(ctx context.Context, node *registry.Node, req Request
 		return nil, errors.InternalServerError("go.micro.client", "connection error: %v", err)
 	}
 
-	codec := newRpcCodec(msg, c, cf)
+	// increment the sequence number
+	seq := atomic.LoadUint64(&r.seq)
+	atomic.AddUint64(&r.seq, 1)
+	id := fmt.Sprintf("%v", seq)
+
+	// create codec with stream id
+	codec := newRpcCodec(msg, c, cf, id)
 
 	rsp := &rpcResponse{
 		socket: c,
@@ -220,16 +244,24 @@ func (r *rpcClient) stream(ctx context.Context, node *registry.Node, req Request
 	}
 
 	stream := &rpcStream{
+		id:       id,
 		context:  ctx,
 		request:  req,
 		response: rsp,
-		closed:   make(chan bool),
 		codec:    codec,
+		// used to close the stream
+		closed: make(chan bool),
+		// signal the end of stream,
+		sendEOS: true,
+		// release func
+		release: func(err error) { c.Close() },
 	}
 
+	// wait for error response
 	ch := make(chan error, 1)
 
 	go func() {
+		// send the first message
 		ch <- stream.Send(req.Body())
 	}()
 
@@ -243,6 +275,12 @@ func (r *rpcClient) stream(ctx context.Context, node *registry.Node, req Request
 	}
 
 	if grr != nil {
+		// set the error
+		stream.Lock()
+		stream.err = grr
+		stream.Unlock()
+
+		// close the stream
 		stream.Close()
 		return nil, grr
 	}
@@ -253,17 +291,22 @@ func (r *rpcClient) stream(ctx context.Context, node *registry.Node, req Request
 func (r *rpcClient) Init(opts ...Option) error {
 	size := r.opts.PoolSize
 	ttl := r.opts.PoolTTL
+	tr := r.opts.Transport
 
 	for _, o := range opts {
 		o(&r.opts)
 	}
 
 	// update pool configuration if the options changed
-	if size != r.opts.PoolSize || ttl != r.opts.PoolTTL {
-		r.pool.Lock()
-		r.pool.size = r.opts.PoolSize
-		r.pool.ttl = int64(r.opts.PoolTTL.Seconds())
-		r.pool.Unlock()
+	if size != r.opts.PoolSize || ttl != r.opts.PoolTTL || tr != r.opts.Transport {
+		// close existing pool
+		r.pool.Close()
+		// create new pool
+		r.pool = pool.NewPool(
+			pool.Size(r.opts.PoolSize),
+			pool.TTL(r.opts.PoolTTL),
+			pool.Transport(r.opts.Transport),
+		)
 	}
 
 	return nil
@@ -283,34 +326,36 @@ func (r *rpcClient) next(request Request, opts CallOptions) (selector.Next, erro
 
 	// get proxy address
 	if prx := os.Getenv("MICRO_PROXY_ADDRESS"); len(prx) > 0 {
-		opts.Address = prx
+		opts.Address = []string{prx}
 	}
 
 	// return remote address
 	if len(opts.Address) > 0 {
-		address := opts.Address
-		port := 0
+		nodes := make([]*registry.Node, len(opts.Address))
 
-		host, sport, err := net.SplitHostPort(opts.Address)
-		if err == nil {
-			address = host
-			port, _ = strconv.Atoi(sport)
+		for i, address := range opts.Address {
+			nodes[i] = &registry.Node{
+				Address: address,
+				// Set the protocol
+				Metadata: map[string]string{
+					"protocol": "mucp",
+				},
+			}
 		}
 
+		// crude return method
 		return func() (*registry.Node, error) {
-			return &registry.Node{
-				Address: address,
-				Port:    port,
-			}, nil
+			return nodes[time.Now().Unix()%int64(len(nodes))], nil
 		}, nil
 	}
 
 	// get next nodes from the selector
 	next, err := r.opts.Selector.Select(service, opts.SelectOptions...)
-	if err != nil && err == selector.ErrNotFound {
-		return nil, errors.NotFound("go.micro.client", "service %s: %v", service, err.Error())
-	} else if err != nil {
-		return nil, errors.InternalServerError("go.micro.client", "error selecting %s node: %v", service, err.Error())
+	if err != nil {
+		if err == selector.ErrNotFound {
+			return nil, errors.InternalServerError("go.micro.client", "service %s: %s", service, err.Error())
+		}
+		return nil, errors.InternalServerError("go.micro.client", "error selecting %s node: %s", service, err.Error())
 	}
 
 	return next, nil
@@ -370,15 +415,17 @@ func (r *rpcClient) Call(ctx context.Context, request Request, response interfac
 
 		// select next node
 		node, err := next()
-		if err != nil && err == selector.ErrNotFound {
-			return errors.NotFound("go.micro.client", "service %s: %v", request.Service(), err.Error())
-		} else if err != nil {
-			return errors.InternalServerError("go.micro.client", "error getting next %s node: %v", request.Service(), err.Error())
+		service := request.Service()
+		if err != nil {
+			if err == selector.ErrNotFound {
+				return errors.InternalServerError("go.micro.client", "service %s: %s", service, err.Error())
+			}
+			return errors.InternalServerError("go.micro.client", "error getting next %s node: %s", service, err.Error())
 		}
 
 		// make the call
 		err = rcall(ctx, node, request, response, callOpts)
-		r.opts.Selector.Mark(request.Service(), node, err)
+		r.opts.Selector.Mark(service, node, err)
 		return err
 	}
 
@@ -447,14 +494,16 @@ func (r *rpcClient) Stream(ctx context.Context, request Request, opts ...CallOpt
 		}
 
 		node, err := next()
-		if err != nil && err == selector.ErrNotFound {
-			return nil, errors.NotFound("go.micro.client", "service %s: %v", request.Service(), err.Error())
-		} else if err != nil {
-			return nil, errors.InternalServerError("go.micro.client", "error getting next %s node: %v", request.Service(), err.Error())
+		service := request.Service()
+		if err != nil {
+			if err == selector.ErrNotFound {
+				return nil, errors.InternalServerError("go.micro.client", "service %s: %s", service, err.Error())
+			}
+			return nil, errors.InternalServerError("go.micro.client", "error getting next %s node: %s", service, err.Error())
 		}
 
 		stream, err := r.stream(ctx, node, request, callOpts)
-		r.opts.Selector.Mark(request.Service(), node, err)
+		r.opts.Selector.Mark(service, node, err)
 		return stream, err
 	}
 
@@ -533,10 +582,13 @@ func (r *rpcClient) Publish(ctx context.Context, msg Message, opts ...PublishOpt
 	if err != nil {
 		return errors.InternalServerError("go.micro.client", err.Error())
 	}
-	b := &buffer{bytes.NewBuffer(nil)}
+
+	// new buffer
+	b := buf.New(nil)
+
 	if err := cf(b).Write(&codec.Message{
 		Target: topic,
-		Type:   codec.Publication,
+		Type:   codec.Event,
 		Header: map[string]string{
 			"Micro-Id":    id,
 			"Micro-Topic": msg.Topic(),
@@ -563,5 +615,5 @@ func (r *rpcClient) NewRequest(service, method string, request interface{}, reqO
 }
 
 func (r *rpcClient) String() string {
-	return "rpc"
+	return "mucp"
 }

client/rpc_client_test.go

@@ -5,24 +5,24 @@ import (
 	"fmt"
 	"testing"
 
+	"github.com/micro/go-micro/client/selector"
 	"github.com/micro/go-micro/errors"
 	"github.com/micro/go-micro/registry"
 	"github.com/micro/go-micro/registry/memory"
-	"github.com/micro/go-micro/selector"
 )
 
 func newTestRegistry() registry.Registry {
 	r := memory.NewRegistry()
-	r.(*memory.Registry).Setup()
-	return r
+	reg := r.(*memory.Registry)
+	reg.Services = testData
+	return reg
 }
 
 func TestCallAddress(t *testing.T) {
 	var called bool
 	service := "test.service"
 	endpoint := "Test.Endpoint"
-	address := "10.1.10.1"
-	port := 8080
+	address := "10.1.10.1:8080"
 
 	wrap := func(cf CallFunc) CallFunc {
 		return func(ctx context.Context, node *registry.Node, req Request, rsp interface{}, opts CallOptions) error {
@@ -40,10 +40,6 @@ func TestCallAddress(t *testing.T) {
 				return fmt.Errorf("expected address: %s got %s", address, node.Address)
 			}
 
-			if node.Port != port {
-				return fmt.Errorf("expected address: %d got %d", port, node.Port)
-			}
-
 			// don't do the call
 			return nil
 		}
@@ -59,7 +55,7 @@ func TestCallAddress(t *testing.T) {
 	req := c.NewRequest(service, endpoint, nil)
 
 	// test calling remote address
-	if err := c.Call(context.Background(), req, nil, WithAddress(fmt.Sprintf("%s:%d", address, port))); err != nil {
+	if err := c.Call(context.Background(), req, nil, WithAddress(address)); err != nil {
 		t.Fatal("call with address error", err)
 	}
 
@@ -113,8 +109,7 @@ func TestCallWrapper(t *testing.T) {
 	id := "test.1"
 	service := "test.service"
 	endpoint := "Test.Endpoint"
-	address := "10.1.10.1"
-	port := 8080
+	address := "10.1.10.1:8080"
 
 	wrap := func(cf CallFunc) CallFunc {
 		return func(ctx context.Context, node *registry.Node, req Request, rsp interface{}, opts CallOptions) error {
@@ -151,7 +146,6 @@ func TestCallWrapper(t *testing.T) {
 			&registry.Node{
 				Id:      id,
 				Address: address,
-				Port:    port,
 			},
 		},
 	})

client/rpc_codec.go

@@ -39,6 +39,9 @@ type rpcCodec struct {
 
 	req *transport.Message
 	buf *readWriteCloser
+
+	// signify if its a stream
+	stream string
 }
 
 type readWriteCloser struct {
@@ -113,7 +116,7 @@ func getHeaders(m *codec.Message) {
 	}
 }
 
-func setHeaders(m *codec.Message) {
+func setHeaders(m *codec.Message, stream string) {
 	set := func(hdr, v string) {
 		if len(v) == 0 {
 			return
@@ -126,6 +129,11 @@ func setHeaders(m *codec.Message) {
 	set("Micro-Service", m.Target)
 	set("Micro-Method", m.Method)
 	set("Micro-Endpoint", m.Endpoint)
+	set("Micro-Error", m.Error)
+
+	if len(stream) > 0 {
+		set("Micro-Stream", stream)
+	}
 }
 
 // setupProtocol sets up the old protocol
@@ -149,7 +157,7 @@ func setupProtocol(msg *transport.Message, node *registry.Node) codec.NewCodec {
 	return defaultCodecs[msg.Header["Content-Type"]]
 }
 
-func newRpcCodec(req *transport.Message, client transport.Client, c codec.NewCodec) codec.Codec {
+func newRpcCodec(req *transport.Message, client transport.Client, c codec.NewCodec, stream string) codec.Codec {
 	rwc := &readWriteCloser{
 		wbuf: bytes.NewBuffer(nil),
 		rbuf: bytes.NewBuffer(nil),
@@ -159,6 +167,7 @@ func newRpcCodec(req *transport.Message, client transport.Client, c codec.NewCod
 		client: client,
 		codec:  c(rwc),
 		req:    req,
+		stream: stream,
 	}
 	return r
 }
@@ -177,7 +186,7 @@ func (c *rpcCodec) Write(m *codec.Message, body interface{}) error {
 	}
 
 	// set the mucp headers
-	setHeaders(m)
+	setHeaders(m, c.stream)
 
 	// if body is bytes Frame don't encode
 	if body != nil {
@@ -240,6 +249,12 @@ func (c *rpcCodec) ReadHeader(m *codec.Message, r codec.MessageType) error {
 
 func (c *rpcCodec) ReadBody(b interface{}) error {
 	// read body
+	// read raw data
+	if v, ok := b.(*raw.Frame); ok {
+		v.Data = c.buf.rbuf.Bytes()
+		return nil
+	}
+
 	if err := c.codec.ReadBody(b); err != nil {
 		return errors.InternalServerError("go.micro.client.codec", err.Error())
 	}

client/rpc_pool.go

@@ -1,87 +0,0 @@
-package client
-
-import (
-	"sync"
-	"time"
-
-	"github.com/micro/go-micro/transport"
-)
-
-type pool struct {
-	size int
-	ttl  int64
-
-	sync.Mutex
-	conns map[string][]*poolConn
-}
-
-type poolConn struct {
-	transport.Client
-	created int64
-}
-
-func newPool(size int, ttl time.Duration) *pool {
-	return &pool{
-		size:  size,
-		ttl:   int64(ttl.Seconds()),
-		conns: make(map[string][]*poolConn),
-	}
-}
-
-// NoOp the Close since we manage it
-func (p *poolConn) Close() error {
-	return nil
-}
-
-func (p *pool) getConn(addr string, tr transport.Transport, opts ...transport.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.Client.Close()
-			continue
-		}
-
-		// we got a good conn, lets unlock and return it
-		p.Unlock()
-
-		return conn, nil
-	}
-
-	p.Unlock()
-
-	// create new conn
-	c, err := tr.Dial(addr, opts...)
-	if err != nil {
-		return nil, err
-	}
-	return &poolConn{c, time.Now().Unix()}, nil
-}
-
-func (p *pool) release(addr string, conn *poolConn, err error) {
-	// don't store the conn if it has errored
-	if err != nil {
-		conn.Client.Close()
-		return
-	}
-
-	// otherwise put it back for reuse
-	p.Lock()
-	conns := p.conns[addr]
-	if len(conns) >= p.size {
-		p.Unlock()
-		conn.Client.Close()
-		return
-	}
-	p.conns[addr] = append(conns, conn)
-	p.Unlock()
-}

client/rpc_stream.go

@@ -18,6 +18,12 @@ type rpcStream struct {
 	response Response
 	codec    codec.Codec
 	context  context.Context
+
+	// signal whether we should send EOS
+	sendEOS bool
+
+	// release releases the connection back to the pool
+	release func(err error)
 }
 
 func (r *rpcStream) isClosed() bool {
@@ -120,6 +126,26 @@ func (r *rpcStream) Close() error {
 		return nil
 	default:
 		close(r.closed)
-		return r.codec.Close()
+
+		// send the end of stream message
+		if r.sendEOS {
+			// no need to check for error
+			r.codec.Write(&codec.Message{
+				Id:       r.id,
+				Target:   r.request.Service(),
+				Method:   r.request.Method(),
+				Endpoint: r.request.Endpoint(),
+				Type:     codec.Error,
+				Error:    lastStreamResponseError,
+			}, nil)
+		}
+
+		err := r.codec.Close()
+
+		// release the connection
+		r.release(r.Error())
+
+		// return the codec error
+		return err
 	}
 }

client/selector/common_test.go

@@ -0,0 +1,47 @@
+package selector
+
+import (
+	"github.com/micro/go-micro/registry"
+)
+
+var (
+	// mock data
+	testData = map[string][]*registry.Service{
+		"foo": []*registry.Service{
+			{
+				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",
+					},
+				},
+			},
+		},
+	}
+)

client/selector/default.go

@@ -51,6 +51,9 @@ func (c *registrySelector) Select(service string, opts ...SelectOption) (Next, e
 	// if that fails go directly to the registry
 	services, err := c.rc.GetService(service)
 	if err != nil {
+		if err == registry.ErrNotFound {
+			return nil, ErrNotFound
+		}
 		return nil, err
 	}
 

client/selector/default_test.go

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

client/selector/dns/dns.go

@@ -2,11 +2,12 @@
 package dns
 
 import (
+	"fmt"
 	"net"
 	"strconv"
 
+	"github.com/micro/go-micro/client/selector"
 	"github.com/micro/go-micro/registry"
-	"github.com/micro/go-micro/selector"
 )
 
 type dnsSelector struct {
@@ -66,8 +67,7 @@ func (d *dnsSelector) Select(service string, opts ...selector.SelectOption) (sel
 	for _, node := range srv {
 		nodes = append(nodes, &registry.Node{
 			Id:      node.Target,
-			Address: node.Target,
-			Port:    int(node.Port),
+			Address: fmt.Sprintf("%s:%d", node.Target, node.Port),
 		})
 	}
 

client/selector/registry/options.go

@@ -4,7 +4,7 @@ import (
 	"context"
 	"time"
 
-	"github.com/micro/go-micro/selector"
+	"github.com/micro/go-micro/client/selector"
 )
 
 // Set the registry cache ttl

client/selector/registry/registry.go

@@ -2,7 +2,7 @@
 package registry
 
 import (
-	"github.com/micro/go-micro/selector"
+	"github.com/micro/go-micro/client/selector"
 )
 
 // NewSelector returns a new registry selector

client/selector/router/router.go

@@ -0,0 +1,272 @@
+// Package router is a network/router selector
+package router
+
+import (
+	"context"
+	"os"
+	"sort"
+	"sync"
+
+	"github.com/micro/go-micro/client"
+	"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"
+)
+
+type routerSelector struct {
+	opts selector.Options
+
+	// the router
+	r router.Router
+
+	// the client we have
+	c client.Client
+
+	// the client for the remote router
+	rs pb.RouterService
+
+	// name of the router
+	name string
+
+	// address of the remote router
+	addr string
+
+	// whether to use the remote router
+	remote bool
+}
+
+type clientKey struct{}
+type routerKey struct{}
+
+// getRoutes returns the routes whether they are remote or local
+func (r *routerSelector) getRoutes(service string) ([]router.Route, error) {
+	if !r.remote {
+		// lookup router for routes for the service
+		return r.r.Lookup(router.NewQuery(
+			router.QueryService(service),
+		))
+	}
+
+	// lookup the remote router
+
+	var addrs []string
+
+	// set the remote address if specified
+	if len(r.addr) > 0 {
+		addrs = append(addrs, r.addr)
+	} else {
+		// we have a name so we need to check the registry
+		services, err := r.c.Options().Registry.GetService(r.name)
+		if err != nil {
+			return nil, err
+		}
+
+		for _, service := range services {
+			for _, node := range service.Nodes {
+				addrs = append(addrs, node.Address)
+			}
+		}
+	}
+
+	// no router addresses available
+	if len(addrs) == 0 {
+		return nil, selector.ErrNoneAvailable
+	}
+
+	var pbRoutes *pb.LookupResponse
+	var err error
+
+	// TODO: implement backoff and retries
+	for _, addr := range addrs {
+		// call the router
+		pbRoutes, err = r.rs.Lookup(context.Background(), &pb.LookupRequest{
+			Query: &pb.Query{
+				Service: service,
+			},
+		}, client.WithAddress(addr))
+		if err != nil {
+			continue
+		}
+		break
+	}
+
+	// errored out
+	if err != nil {
+		return nil, err
+	}
+
+	// no routes
+	if pbRoutes == nil {
+		return nil, selector.ErrNoneAvailable
+	}
+
+	var routes []router.Route
+
+	// convert from pb to []*router.Route
+	for _, r := range pbRoutes.Routes {
+		routes = append(routes, router.Route{
+			Service: r.Service,
+			Address: r.Address,
+			Gateway: r.Gateway,
+			Network: r.Network,
+			Link:    r.Link,
+			Metric:  int(r.Metric),
+		})
+	}
+
+	return routes, nil
+}
+
+func (r *routerSelector) Init(opts ...selector.Option) error {
+	// no op
+	return nil
+}
+
+func (r *routerSelector) Options() selector.Options {
+	return r.opts
+}
+
+func (r *routerSelector) Select(service string, opts ...selector.SelectOption) (selector.Next, error) {
+	// TODO: pull routes asynchronously and cache
+	routes, err := r.getRoutes(service)
+	if err != nil {
+		return nil, err
+	}
+
+	// no routes return not found error
+	if len(routes) == 0 {
+		return nil, selector.ErrNotFound
+	}
+
+	// TODO: apply filters by pseudo constructing service
+
+	// sort the routes based on metric
+	sort.Slice(routes, func(i, j int) bool {
+		return routes[i].Metric < routes[j].Metric
+	})
+
+	// roundrobin assuming routes are in metric preference order
+	var i int
+	var mtx sync.Mutex
+
+	return func() (*registry.Node, error) {
+		// get index and increment counter with every call to next
+		mtx.Lock()
+		idx := i
+		i++
+		mtx.Unlock()
+
+		// get route based on idx
+		route := routes[idx%len(routes)]
+
+		// defaults to gateway and no port
+		address := route.Address
+		if len(route.Gateway) > 0 {
+			address = route.Gateway
+		}
+
+		// return as a node
+		return &registry.Node{
+			// TODO: add id and metadata if we can
+			Address: address,
+		}, nil
+	}, nil
+}
+
+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 {
+	// stop the router advertisements
+	return r.r.Stop()
+}
+
+func (r *routerSelector) String() string {
+	return "router"
+}
+
+// NewSelector returns a new router based selector
+func NewSelector(opts ...selector.Option) selector.Selector {
+	options := selector.Options{
+		Context: context.Background(),
+	}
+
+	for _, o := range opts {
+		o(&options)
+	}
+
+	// set default registry if not set
+	if options.Registry == nil {
+		options.Registry = registry.DefaultRegistry
+	}
+
+	// try get router from the context
+	r, ok := options.Context.Value(routerKey{}).(router.Router)
+	if !ok {
+		// TODO: Use router.DefaultRouter?
+		r = router.NewRouter(
+			router.Registry(options.Registry),
+		)
+	}
+
+	// try get client from the context
+	c, ok := options.Context.Value(clientKey{}).(client.Client)
+	if !ok {
+		c = client.DefaultClient
+	}
+
+	// get the router from env vars if its a remote service
+	remote := true
+	routerName := os.Getenv("MICRO_ROUTER")
+	routerAddress := os.Getenv("MICRO_ROUTER_ADDRESS")
+
+	// start the router advertisements if we're running it locally
+	if len(routerName) == 0 && len(routerAddress) == 0 {
+		go r.Advertise()
+		remote = false
+	}
+
+	return &routerSelector{
+		opts: options,
+		// set the internal router
+		r: r,
+		// set the client
+		c: c,
+		// set the router client
+		rs: pb.NewRouterService(routerName, c),
+		// name of the router
+		name: routerName,
+		// address of router
+		addr: routerAddress,
+		// let ourselves know to use the remote router
+		remote: remote,
+	}
+}
+
+// WithClient sets the client for the request
+func WithClient(c client.Client) selector.Option {
+	return func(o *selector.Options) {
+		if o.Context == nil {
+			o.Context = context.Background()
+		}
+		o.Context = context.WithValue(o.Context, clientKey{}, c)
+	}
+}
+
+// WithRouter sets the router as an option
+func WithRouter(r router.Router) selector.Option {
+	return func(o *selector.Options) {
+		if o.Context == nil {
+			o.Context = context.Background()
+		}
+		o.Context = context.WithValue(o.Context, routerKey{}, r)
+	}
+}

client/selector/static/static.go

@@ -2,11 +2,8 @@
 package static
 
 import (
-	"net"
-	"strconv"
-
+	"github.com/micro/go-micro/client/selector"
 	"github.com/micro/go-micro/registry"
-	"github.com/micro/go-micro/selector"
 )
 
 // staticSelector is a static selector
@@ -26,20 +23,10 @@ func (s *staticSelector) Options() selector.Options {
 }
 
 func (s *staticSelector) Select(service string, opts ...selector.SelectOption) (selector.Next, error) {
-	var port int
-	addr, pt, err := net.SplitHostPort(service)
-	if err != nil {
-		addr = service
-		port = 0
-	} else {
-		port, _ = strconv.Atoi(pt)
-	}
-
 	return func() (*registry.Node, error) {
 		return &registry.Node{
 			Id:      service,
-			Address: addr,
-			Port:    port,
+			Address: service,
 		}, nil
 	}, nil
 }

client/selector/strategy_test.go

@@ -14,13 +14,11 @@ func TestStrategies(t *testing.T) {
 			Nodes: []*registry.Node{
 				&registry.Node{
 					Id:      "test1-1",
-					Address: "10.0.0.1",
-					Port:    1001,
+					Address: "10.0.0.1:1001",
 				},
 				&registry.Node{
 					Id:      "test1-2",
-					Address: "10.0.0.2",
-					Port:    1002,
+					Address: "10.0.0.2:1002",
 				},
 			},
 		},
@@ -30,13 +28,11 @@ func TestStrategies(t *testing.T) {
 			Nodes: []*registry.Node{
 				&registry.Node{
 					Id:      "test1-3",
-					Address: "10.0.0.3",
-					Port:    1003,
+					Address: "10.0.0.3:1003",
 				},
 				&registry.Node{
 					Id:      "test1-4",
-					Address: "10.0.0.4",
-					Port:    1004,
+					Address: "10.0.0.4:1004",
 				},
 			},
 		},

codec/codec.go

@@ -9,7 +9,7 @@ const (
 	Error MessageType = iota
 	Request
 	Response
-	Publication
+	Event
 )
 
 type MessageType int

codec/grpc/grpc.go

@@ -89,9 +89,22 @@ func (c *Codec) Write(m *codec.Message, b interface{}) error {
 		m.Header[":authority"] = m.Target
 		m.Header["content-type"] = c.ContentType
 	case codec.Response:
-		m.Header["Trailer"] = "grpc-status, grpc-message"
+		m.Header["Trailer"] = "grpc-status" //, grpc-message"
+		m.Header["content-type"] = c.ContentType
+		m.Header[":status"] = "200"
 		m.Header["grpc-status"] = "0"
-		m.Header["grpc-message"] = ""
+		//		m.Header["grpc-message"] = ""
+	case codec.Error:
+		m.Header["Trailer"] = "grpc-status, grpc-message"
+		// micro end of stream
+		if m.Error == "EOS" {
+			m.Header["grpc-status"] = "0"
+		} else {
+			m.Header["grpc-message"] = m.Error
+			m.Header["grpc-status"] = "13"
+		}
+
+		return nil
 	}
 
 	// marshal content

codec/json/json.go

@@ -5,6 +5,8 @@ import (
 	"encoding/json"
 	"io"
 
+	"github.com/golang/protobuf/jsonpb"
+	"github.com/golang/protobuf/proto"
 	"github.com/micro/go-micro/codec"
 )
 
@@ -22,6 +24,9 @@ func (c *Codec) ReadBody(b interface{}) error {
 	if b == nil {
 		return nil
 	}
+	if pb, ok := b.(proto.Message); ok {
+		return jsonpb.UnmarshalNext(c.Decoder, pb)
+	}
 	return c.Decoder.Decode(b)
 }
 

codec/json/marshaler.go

@@ -2,6 +2,9 @@ package json
 
 import (
 	"encoding/json"
+
+	"github.com/golang/protobuf/jsonpb"
+	"github.com/golang/protobuf/proto"
 )
 
 type Marshaler struct{}
@@ -11,6 +14,9 @@ func (j Marshaler) Marshal(v interface{}) ([]byte, error) {
 }
 
 func (j Marshaler) Unmarshal(d []byte, v interface{}) error {
+	if pb, ok := v.(proto.Message); ok {
+		return jsonpb.UnmarshalString(string(d), pb)
+	}
 	return json.Unmarshal(d, v)
 }
 

codec/jsonrpc/jsonrpc.go

@@ -33,7 +33,7 @@ func (j *jsonCodec) Write(m *codec.Message, b interface{}) error {
 		return j.c.Write(m, b)
 	case codec.Response, codec.Error:
 		return j.s.Write(m, b)
-	case codec.Publication:
+	case codec.Event:
 		data, err := json.Marshal(b)
 		if err != nil {
 			return err
@@ -54,7 +54,7 @@ func (j *jsonCodec) ReadHeader(m *codec.Message, mt codec.MessageType) error {
 		return j.s.ReadHeader(m)
 	case codec.Response:
 		return j.c.ReadHeader(m)
-	case codec.Publication:
+	case codec.Event:
 		_, err := io.Copy(j.buf, j.rwc)
 		return err
 	default:
@@ -69,7 +69,7 @@ func (j *jsonCodec) ReadBody(b interface{}) error {
 		return j.s.ReadBody(b)
 	case codec.Response:
 		return j.c.ReadBody(b)
-	case codec.Publication:
+	case codec.Event:
 		if b != nil {
 			return json.Unmarshal(j.buf.Bytes(), b)
 		}

codec/protorpc/protorpc.go

@@ -99,7 +99,7 @@ func (c *protoCodec) Write(m *codec.Message, b interface{}) error {
 				return err
 			}
 		}
-	case codec.Publication:
+	case codec.Event:
 		data, err := proto.Marshal(b.(proto.Message))
 		if err != nil {
 			return err
@@ -141,7 +141,7 @@ func (c *protoCodec) ReadHeader(m *codec.Message, mt codec.MessageType) error {
 		m.Method = rtmp.GetServiceMethod()
 		m.Id = fmt.Sprintf("%d", rtmp.GetSeq())
 		m.Error = rtmp.GetError()
-	case codec.Publication:
+	case codec.Event:
 		_, err := io.Copy(c.buf, c.rwc)
 		return err
 	default:
@@ -159,7 +159,7 @@ func (c *protoCodec) ReadBody(b interface{}) error {
 		if err != nil {
 			return err
 		}
-	case codec.Publication:
+	case codec.Event:
 		data = c.buf.Bytes()
 	default:
 		return fmt.Errorf("Unrecognised message type: %v", c.mt)

codec/text/text.go

@@ -30,6 +30,9 @@ func (c *Codec) ReadBody(b interface{}) error {
 	}
 
 	switch b.(type) {
+	case *string:
+		v := b.(*string)
+		*v = string(buf)
 	case *[]byte:
 		v := b.(*[]byte)
 		*v = buf
@@ -51,6 +54,12 @@ func (c *Codec) Write(m *codec.Message, b interface{}) error {
 	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)
 	default:
@@ -65,7 +74,7 @@ func (c *Codec) Close() error {
 }
 
 func (c *Codec) String() string {
-	return "bytes"
+	return "text"
 }
 
 func NewCodec(c io.ReadWriteCloser) codec.Codec {

common_test.go

@@ -0,0 +1,47 @@
+package micro
+
+import (
+	"github.com/micro/go-micro/registry"
+)
+
+var (
+	// mock data
+	testData = map[string][]*registry.Service{
+		"foo": []*registry.Service{
+			{
+				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/README.md

@@ -1,6 +1,6 @@
 # Config [![GoDoc](https://godoc.org/github.com/micro/go-micro/config?status.svg)](https://godoc.org/github.com/micro/go-micro/config)
 
-Go Config is a pluggable dynamic config library.
+Config is a pluggable dynamic config package
 
 Most config in applications are statically configured or include complex logic to load from multiple sources. 
 Go Config makes this easy, pluggable and mergeable. You'll never have to deal with config in the same way again.

config/cmd/cmd.go

@@ -11,7 +11,11 @@ import (
 
 	"github.com/micro/cli"
 	"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/server"
+	sgrpc "github.com/micro/go-micro/server/grpc"
+	smucp "github.com/micro/go-micro/server/mucp"
 	"github.com/micro/go-micro/util/log"
 
 	// brokers
@@ -26,17 +30,20 @@ import (
 	"github.com/micro/go-micro/registry/gossip"
 	"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/selector"
-	"github.com/micro/go-micro/selector/dns"
-	"github.com/micro/go-micro/selector/static"
+	"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"
 )
 
 type Cmd interface {
@@ -89,11 +96,13 @@ var (
 		cli.IntFlag{
 			Name:   "register_ttl",
 			EnvVar: "MICRO_REGISTER_TTL",
+			Value:  60,
 			Usage:  "Register TTL in seconds",
 		},
 		cli.IntFlag{
 			Name:   "register_interval",
 			EnvVar: "MICRO_REGISTER_INTERVAL",
+			Value:  30,
 			Usage:  "Register interval in seconds",
 		},
 		cli.StringFlag{
@@ -176,31 +185,39 @@ var (
 	}
 
 	DefaultClients = map[string]func(...client.Option) client.Client{
-		"rpc": client.NewClient,
+		"rpc":  client.NewClient,
+		"mucp": cmucp.NewClient,
+		"grpc": cgrpc.NewClient,
 	}
 
 	DefaultRegistries = map[string]func(...registry.Option) registry.Registry{
-		"consul": consul.NewRegistry,
-		"gossip": gossip.NewRegistry,
-		"mdns":   mdns.NewRegistry,
-		"memory": rmem.NewRegistry,
+		"go.micro.registry": regSrv.NewRegistry,
+		"service":           regSrv.NewRegistry,
+		"consul":            consul.NewRegistry,
+		"gossip":            gossip.NewRegistry,
+		"mdns":              mdns.NewRegistry,
+		"memory":            rmem.NewRegistry,
 	}
 
 	DefaultSelectors = map[string]func(...selector.Option) selector.Selector{
 		"default": selector.NewSelector,
 		"dns":     dns.NewSelector,
 		"cache":   selector.NewSelector,
+		"router":  router.NewSelector,
 		"static":  static.NewSelector,
 	}
 
 	DefaultServers = map[string]func(...server.Option) server.Server{
-		"rpc": server.NewServer,
+		"rpc":  server.NewServer,
+		"mucp": smucp.NewServer,
+		"grpc": sgrpc.NewServer,
 	}
 
 	DefaultTransports = map[string]func(...transport.Option) transport.Transport{
 		"memory": tmem.NewTransport,
 		"http":   thttp.NewTransport,
 		"grpc":   tgrpc.NewTransport,
+		"quic":   quic.NewTransport,
 	}
 
 	// used for default selection as the fall back
@@ -405,11 +422,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.GlobalInt("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.GlobalInt("register_interval")); val >= 0 {
 		serverOpts = append(serverOpts, server.RegisterInterval(val*time.Second))
 	}
 

config/cmd/options.go

@@ -5,8 +5,8 @@ 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/registry"
-	"github.com/micro/go-micro/selector"
 	"github.com/micro/go-micro/server"
 	"github.com/micro/go-micro/transport"
 )

config/default_test.go

@@ -8,9 +8,29 @@ import (
 	"testing"
 	"time"
 
+	"github.com/micro/go-micro/config/source/env"
 	"github.com/micro/go-micro/config/source/file"
 )
 
+var (
+	sep = string(os.PathSeparator)
+)
+
+func createFileForIssue18(t *testing.T, content string) *os.File {
+	data := []byte(content)
+	path := filepath.Join(os.TempDir(), fmt.Sprintf("file.%d", time.Now().UnixNano()))
+	fh, err := os.Create(path)
+	if err != nil {
+		t.Error(err)
+	}
+	_, err = fh.Write(data)
+	if err != nil {
+		t.Error(err)
+	}
+
+	return fh
+}
+
 func createFileForTest(t *testing.T) *os.File {
 	data := []byte(`{"foo": "bar"}`)
 	path := filepath.Join(os.TempDir(), fmt.Sprintf("file.%d", time.Now().UnixNano()))
@@ -26,7 +46,7 @@ func createFileForTest(t *testing.T) *os.File {
 	return fh
 }
 
-func TestLoadWithGoodFile(t *testing.T) {
+func TestConfigLoadWithGoodFile(t *testing.T) {
 	fh := createFileForTest(t)
 	path := fh.Name()
 	defer func() {
@@ -44,7 +64,7 @@ func TestLoadWithGoodFile(t *testing.T) {
 	}
 }
 
-func TestLoadWithInvalidFile(t *testing.T) {
+func TestConfigLoadWithInvalidFile(t *testing.T) {
 	fh := createFileForTest(t)
 	path := fh.Name()
 	defer func() {
@@ -68,34 +88,35 @@ func TestLoadWithInvalidFile(t *testing.T) {
 	}
 }
 
-func TestConsul(t *testing.T) {
-	/*consulSource := consul.NewSource(
-		// optionally specify consul address; default to localhost:8500
-		consul.WithAddress("131.150.38.111:8500"),
-		// optionally specify prefix; defaults to /micro/config
-		consul.WithPrefix("/project"),
-		// optionally strip the provided prefix from the keys, defaults to false
-		consul.StripPrefix(true),
-		consul.WithDatacenter("dc1"),
-		consul.WithToken("xxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx"),
+func TestConfigMerge(t *testing.T) {
+	fh := createFileForIssue18(t, `{
+  "amqp": {
+    "host": "rabbit.platform",
+    "port": 80
+  },
+  "handler": {
+    "exchange": "springCloudBus"
+  }
+}`)
+	path := fh.Name()
+	defer func() {
+		fh.Close()
+		os.Remove(path)
+	}()
+	os.Setenv("AMQP_HOST", "rabbit.testing.com")
+
+	conf := NewConfig()
+	conf.Load(
+		file.NewSource(
+			file.WithPath(path),
+		),
+		env.NewSource(),
 	)
 
-	// Create new config
-	conf := NewConfig()
-
-	// Load file source
-	err := conf.Load(consulSource)
-	if err != nil {
-		t.Error(err)
-		return
+	actualHost := conf.Get("amqp", "host").String("backup")
+	if actualHost != "rabbit.testing.com" {
+		t.Fatalf("Expected %v but got %v",
+			"rabbit.testing.com",
+			actualHost)
 	}
-
-	m := conf.Map()
-	t.Log("m: ", m)
-
-	v := conf.Get("project", "dc111", "port")
-
-	t.Log("v: ", v.Int(13))*/
-
-	t.Log("OK")
 }

config/issue18_test.go

@@ -1,60 +0,0 @@
-package config
-
-import (
-	"fmt"
-	"os"
-	"path/filepath"
-	"testing"
-	"time"
-
-	"github.com/micro/go-micro/config/source/env"
-	"github.com/micro/go-micro/config/source/file"
-)
-
-func createFileForIssue18(t *testing.T, content string) *os.File {
-	data := []byte(content)
-	path := filepath.Join(os.TempDir(), fmt.Sprintf("file.%d", time.Now().UnixNano()))
-	fh, err := os.Create(path)
-	if err != nil {
-		t.Error(err)
-	}
-	_, err = fh.Write(data)
-	if err != nil {
-		t.Error(err)
-	}
-
-	return fh
-}
-
-func TestIssue18(t *testing.T) {
-	fh := createFileForIssue18(t, `{
-  "amqp": {
-    "host": "rabbit.platform",
-    "port": 80
-  },
-  "handler": {
-    "exchange": "springCloudBus"
-  }
-}`)
-	path := fh.Name()
-	defer func() {
-		fh.Close()
-		os.Remove(path)
-	}()
-	os.Setenv("AMQP_HOST", "rabbit.testing.com")
-
-	conf := NewConfig()
-	conf.Load(
-		file.NewSource(
-			file.WithPath(path),
-		),
-		env.NewSource(),
-	)
-
-	actualHost := conf.Get("amqp", "host").String("backup")
-	if actualHost != "rabbit.testing.com" {
-		t.Fatalf("Expected %v but got %v",
-			"rabbit.testing.com",
-			actualHost)
-	}
-}

config/options/default.go

@@ -0,0 +1,34 @@
+package options
+
+type defaultOptions struct {
+	opts *Values
+}
+
+type stringKey struct{}
+
+func (d *defaultOptions) Init(opts ...Option) error {
+	if d.opts == nil {
+		d.opts = new(Values)
+	}
+	for _, o := range opts {
+		if err := d.opts.Option(o); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func (d *defaultOptions) Values() *Values {
+	return d.opts
+}
+
+func (d *defaultOptions) String() string {
+	if d.opts == nil {
+		d.opts = new(Values)
+	}
+	n, ok := d.opts.Get(stringKey{})
+	if ok {
+		return n.(string)
+	}
+	return "Values"
+}

config/options/options.go

@@ -0,0 +1,73 @@
+// Package options provides a way to initialise options
+package options
+
+import (
+	"sync"
+)
+
+// Options is used for initialisation
+type Options interface {
+	// Initialise options
+	Init(...Option) error
+	// Options returns the current options
+	Values() *Values
+	// The name for who these options exist
+	String() string
+}
+
+// Values holds the set of option values and protects them
+type Values struct {
+	sync.RWMutex
+	values map[interface{}]interface{}
+}
+
+// Option gives access to options
+type Option func(o *Values) error
+
+// Get a value from options
+func (o *Values) Get(k interface{}) (interface{}, bool) {
+	o.RLock()
+	defer o.RUnlock()
+	v, ok := o.values[k]
+	return v, ok
+}
+
+// Set a value in the options
+func (o *Values) Set(k, v interface{}) error {
+	o.Lock()
+	defer o.Unlock()
+	if o.values == nil {
+		o.values = map[interface{}]interface{}{}
+	}
+	o.values[k] = v
+	return nil
+}
+
+// SetOption executes an option
+func (o *Values) Option(op Option) error {
+	return op(o)
+}
+
+// WithValue allows you to set any value within the options
+func WithValue(k, v interface{}) Option {
+	return func(o *Values) error {
+		return o.Set(k, v)
+	}
+}
+
+// WithOption gives you the ability to create an option that accesses values
+func WithOption(o Option) Option {
+	return o
+}
+
+// String sets the string
+func WithString(s string) Option {
+	return WithValue(stringKey{}, s)
+}
+
+// NewOptions returns a new initialiser
+func NewOptions(opts ...Option) Options {
+	o := new(defaultOptions)
+	o.Init(opts...)
+	return o
+}

config/reader/json/values_test.go

@@ -1,39 +1,85 @@
 package json
 
 import (
+	"reflect"
 	"testing"
 
 	"github.com/micro/go-micro/config/source"
 )
 
 func TestValues(t *testing.T) {
-	data := []byte(`{"foo": "bar", "baz": {"bar": "cat"}}`)
-
+	emptyStr := ""
 	testData := []struct {
-		path  []string
-		value string
+		csdata   []byte
+		path     []string
+		accepter interface{}
+		value    interface{}
 	}{
 		{
+			[]byte(`{"foo": "bar", "baz": {"bar": "cat"}}`),
 			[]string{"foo"},
+			emptyStr,
 			"bar",
 		},
 		{
+			[]byte(`{"foo": "bar", "baz": {"bar": "cat"}}`),
 			[]string{"baz", "bar"},
+			emptyStr,
 			"cat",
 		},
 	}
 
-	values, err := newValues(&source.ChangeSet{
-		Data: data,
-	})
+	for idx, test := range testData {
+		values, err := newValues(&source.ChangeSet{
+			Data: test.csdata,
+		})
+		if err != nil {
+			t.Fatal(err)
+		}
 
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	for _, test := range testData {
-		if v := values.Get(test.path...).String(""); v != test.value {
-			t.Fatalf("Expected %s got %s for path %v", test.value, v, test.path)
+		err = values.Get(test.path...).Scan(&test.accepter)
+		if err != nil {
+			t.Fatal(err)
+		}
+		if test.accepter != test.value {
+			t.Fatalf("No.%d Expected %v got %v for path %v", idx, test.value, test.accepter, test.path)
+		}
+	}
+}
+
+func TestStructArray(t *testing.T) {
+	type T struct {
+		Foo string
+	}
+
+	emptyTSlice := []T{}
+
+	testData := []struct {
+		csdata   []byte
+		accepter []T
+		value    []T
+	}{
+		{
+			[]byte(`[{"foo": "bar"}]`),
+			emptyTSlice,
+			[]T{T{Foo: "bar"}},
+		},
+	}
+
+	for idx, test := range testData {
+		values, err := newValues(&source.ChangeSet{
+			Data: test.csdata,
+		})
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		err = values.Get().Scan(&test.accepter)
+		if err != nil {
+			t.Fatal(err)
+		}
+		if !reflect.DeepEqual(test.accepter, test.value) {
+			t.Fatalf("No.%d Expected %v got %v", idx, test.value, test.accepter)
 		}
 	}
 }

config/source/cli/cli.go

@@ -9,7 +9,7 @@ import (
 
 	"github.com/imdario/mergo"
 	"github.com/micro/cli"
-	"github.com/micro/go-micro/cmd"
+	"github.com/micro/go-micro/config/cmd"
 	"github.com/micro/go-micro/config/source"
 )
 

config/source/cli/cli_test.go

@@ -6,7 +6,7 @@ import (
 	"testing"
 
 	"github.com/micro/cli"
-	"github.com/micro/go-micro/cmd"
+	"github.com/micro/go-micro/config/cmd"
 	"github.com/micro/go-micro/config/source"
 )
 

config/source/consul/README.md

@@ -44,6 +44,6 @@ Load the source into config
 // Create new config
 conf := config.NewConfig()
 
-// Load file source
+// Load consul source
 conf.Load(consulSource)
 ```

config/source/consul/consul.go

@@ -74,6 +74,11 @@ func NewSource(opts ...source.Option) source.Source {
 	// use default config
 	config := api.DefaultConfig()
 
+	// use the consul config passed in the options if any
+	if co, ok := options.Context.Value(configKey{}).(*api.Config); ok {
+		config = co
+	}
+
 	// check if there are any addrs
 	a, ok := options.Context.Value(addressKey{}).(string)
 	if ok {

config/source/consul/options.go

@@ -3,6 +3,7 @@ package consul
 import (
 	"context"
 
+	"github.com/hashicorp/consul/api"
 	"github.com/micro/go-micro/config/source"
 )
 
@@ -11,6 +12,7 @@ type prefixKey struct{}
 type stripPrefixKey struct{}
 type dcKey struct{}
 type tokenKey struct{}
+type configKey struct{}
 
 // WithAddress sets the consul address
 func WithAddress(a string) source.Option {
@@ -61,3 +63,13 @@ func WithToken(p string) source.Option {
 		o.Context = context.WithValue(o.Context, tokenKey{}, p)
 	}
 }
+
+// WithConfig set consul-specific options
+func WithConfig(c *api.Config) source.Option {
+	return func(o *source.Options) {
+		if o.Context == nil {
+			o.Context = context.Background()
+		}
+		o.Context = context.WithValue(o.Context, configKey{}, c)
+	}
+}

config/source/consul/util.go

@@ -8,40 +8,80 @@ import (
 	"github.com/micro/go-micro/config/encoder"
 )
 
+type configValue interface {
+	Value() interface{}
+	Decode(encoder.Encoder, []byte) error
+}
+type configArrayValue struct {
+	v []interface{}
+}
+
+func (a *configArrayValue) Value() interface{} { return a.v }
+func (a *configArrayValue) Decode(e encoder.Encoder, b []byte) error {
+	return e.Decode(b, &a.v)
+}
+
+type configMapValue struct {
+	v map[string]interface{}
+}
+
+func (m *configMapValue) Value() interface{} { return m.v }
+func (m *configMapValue) Decode(e encoder.Encoder, b []byte) error {
+	return e.Decode(b, &m.v)
+}
+
 func makeMap(e encoder.Encoder, kv api.KVPairs, stripPrefix string) (map[string]interface{}, error) {
+
 	data := make(map[string]interface{})
 
 	// consul guarantees lexicographic order, so no need to sort
 	for _, v := range kv {
-		pathString := strings.TrimPrefix(strings.TrimPrefix(v.Key, stripPrefix), "/")
-		var val map[string]interface{}
+		pathString := strings.TrimPrefix(strings.TrimPrefix(v.Key, strings.TrimPrefix(stripPrefix, "/")), "/")
+		if pathString == "" {
+			continue
+		}
+		var val configValue
+		var err error
 
 		// ensure a valid value is stored at this location
 		if len(v.Value) > 0 {
-			if err := e.Decode(v.Value, &val); err != nil {
+			// try to decode into map value or array value
+			arrayV := &configArrayValue{v: []interface{}{}}
+			mapV := &configMapValue{v: map[string]interface{}{}}
+			switch {
+			case arrayV.Decode(e, v.Value) == nil:
+				val = arrayV
+			case mapV.Decode(e, v.Value) == nil:
+				val = mapV
+			default:
 				return nil, fmt.Errorf("faild decode value. path: %s, error: %s", pathString, err)
 			}
 		}
 
 		// set target at the root
 		target := data
-
-		// then descend to the target location, creating as we go, if need be
-		if pathString != "" {
-			path := strings.Split(pathString, "/")
-			// find (or create) the location we want to put this value at
-			for _, dir := range path {
-				if _, ok := target[dir]; !ok {
-					target[dir] = make(map[string]interface{})
-				}
-				target = target[dir].(map[string]interface{})
+		path := strings.Split(pathString, "/")
+		// find (or create) the leaf node we want to put this value at
+		for _, dir := range path[:len(path)-1] {
+			if _, ok := target[dir]; !ok {
+				target[dir] = make(map[string]interface{})
 			}
-
+			target = target[dir].(map[string]interface{})
 		}
 
+		leafDir := path[len(path)-1]
+
 		// copy over the keys from the value
-		for k := range val {
-			target[k] = val[k]
+		switch val.(type) {
+		case *configArrayValue:
+			target[leafDir] = val.Value()
+		case *configMapValue:
+			target[leafDir] = make(map[string]interface{})
+			target = target[leafDir].(map[string]interface{})
+			mapv := val.Value().(map[string]interface{})
+			for k := range mapv {
+				target[k] = mapv[k]
+			}
 		}
 	}
 

config/source/consul/watcher.go

@@ -1,7 +1,6 @@
 package consul
 
 import (
-	"errors"
 	"time"
 
 	"github.com/hashicorp/consul/api"
@@ -80,7 +79,7 @@ func (w *watcher) Next() (*source.ChangeSet, error) {
 	case cs := <-w.ch:
 		return cs, nil
 	case <-w.exit:
-		return nil, errors.New("watcher stopped")
+		return nil, source.ErrWatcherStopped
 	}
 }
 

config/source/env/README.md

@@ -91,6 +91,6 @@ Load the source into config
 // Create new config
 conf := config.NewConfig()
 
-// Load file source
+// Load env source
 conf.Load(src)
 ```

config/source/env/env_test.go

@@ -86,8 +86,8 @@ func TestEnvvar_Prefixes(t *testing.T) {
 }
 
 func TestEnvvar_WatchNextNoOpsUntilStop(t *testing.T) {
-	source := NewSource(WithStrippedPrefix("GOMICRO_"))
-	w, err := source.Watch()
+	src := NewSource(WithStrippedPrefix("GOMICRO_"))
+	w, err := src.Watch()
 	if err != nil {
 		t.Error(err)
 	}
@@ -97,7 +97,7 @@ func TestEnvvar_WatchNextNoOpsUntilStop(t *testing.T) {
 		w.Stop()
 	}()
 
-	if _, err := w.Next(); err.Error() != "watcher stopped" {
+	if _, err := w.Next(); err != source.ErrWatcherStopped {
 		t.Errorf("expected watcher stopped error, got %v", err)
 	}
 }

config/source/env/watcher.go

@@ -1,8 +1,6 @@
 package env
 
 import (
-	"errors"
-
 	"github.com/micro/go-micro/config/source"
 )
 
@@ -13,7 +11,7 @@ type watcher struct {
 func (w *watcher) Next() (*source.ChangeSet, error) {
 	<-w.exit
 
-	return nil, errors.New("watcher stopped")
+	return nil, source.ErrWatcherStopped
 }
 
 func (w *watcher) Stop() error {

config/source/etcd/README.md

@@ -1,51 +0,0 @@
-# Etcd Source
-
-The etcd source reads config from etcd key/values
-
-This source supports etcd version 3 and beyond.
-
-## Etcd Format
-
-The etcd source expects keys under the default prefix `/micro/config` (prefix can be changed)
-
-Values are expected to be JSON
-
-```
-// set database
-etcdctl put /micro/config/database '{"address": "10.0.0.1", "port": 3306}'
-// set cache
-etcdctl put /micro/config/cache '{"address": "10.0.0.2", "port": 6379}'
-```
-
-Keys are split on `/` so access becomes
-
-```
-conf.Get("micro", "config", "database")
-```
-
-## New Source
-
-Specify source with data
-
-```go
-etcdSource := etcd.NewSource(
-	// optionally specify etcd address; default to localhost:8500
-	etcd.WithAddress("10.0.0.10:8500"),
-	// optionally specify prefix; defaults to /micro/config
-	etcd.WithPrefix("/my/prefix"),
-	// optionally strip the provided prefix from the keys, defaults to false
-	etcd.StripPrefix(true),
-)
-```
-
-## Load Source
-
-Load the source into config
-
-```go
-// Create new config
-conf := config.NewConfig()
-
-// Load file source
-conf.Load(etcdSource)
-```

config/source/etcd/etcd.go

@@ -1,134 +0,0 @@
-package etcd
-
-import (
-	"context"
-	"fmt"
-	"net"
-	"time"
-
-	"github.com/micro/go-micro/config/source"
-	cetcd "go.etcd.io/etcd/clientv3"
-	"go.etcd.io/etcd/mvcc/mvccpb"
-)
-
-// Currently a single etcd reader
-type etcd struct {
-	prefix      string
-	stripPrefix string
-	opts        source.Options
-	client      *cetcd.Client
-	cerr        error
-}
-
-var (
-	DefaultPrefix = "/micro/config/"
-)
-
-func (c *etcd) Read() (*source.ChangeSet, error) {
-	if c.cerr != nil {
-		return nil, c.cerr
-	}
-
-	rsp, err := c.client.Get(context.Background(), c.prefix, cetcd.WithPrefix())
-	if err != nil {
-		return nil, err
-	}
-
-	if rsp == nil || len(rsp.Kvs) == 0 {
-		return nil, fmt.Errorf("source not found: %s", c.prefix)
-	}
-
-	var kvs []*mvccpb.KeyValue
-	for _, v := range rsp.Kvs {
-		kvs = append(kvs, (*mvccpb.KeyValue)(v))
-	}
-
-	data := makeMap(c.opts.Encoder, kvs, c.stripPrefix)
-
-	b, err := c.opts.Encoder.Encode(data)
-	if err != nil {
-		return nil, fmt.Errorf("error reading source: %v", err)
-	}
-
-	cs := &source.ChangeSet{
-		Timestamp: time.Now(),
-		Source:    c.String(),
-		Data:      b,
-		Format:    c.opts.Encoder.String(),
-	}
-	cs.Checksum = cs.Sum()
-
-	return cs, nil
-}
-
-func (c *etcd) String() string {
-	return "etcd"
-}
-
-func (c *etcd) Watch() (source.Watcher, error) {
-	if c.cerr != nil {
-		return nil, c.cerr
-	}
-	cs, err := c.Read()
-	if err != nil {
-		return nil, err
-	}
-	return newWatcher(c.prefix, c.stripPrefix, c.client.Watcher, cs, c.opts)
-}
-
-func NewSource(opts ...source.Option) source.Source {
-	options := source.NewOptions(opts...)
-
-	var endpoints []string
-
-	// check if there are any addrs
-	addrs, ok := options.Context.Value(addressKey{}).([]string)
-	if ok {
-		for _, a := range addrs {
-			addr, port, err := net.SplitHostPort(a)
-			if ae, ok := err.(*net.AddrError); ok && ae.Err == "missing port in address" {
-				port = "2379"
-				addr = a
-				endpoints = append(endpoints, fmt.Sprintf("%s:%s", addr, port))
-			} else if err == nil {
-				endpoints = append(endpoints, fmt.Sprintf("%s:%s", addr, port))
-			}
-		}
-	}
-
-	if len(endpoints) == 0 {
-		endpoints = []string{"localhost:2379"}
-	}
-
-	config := cetcd.Config{
-		Endpoints: endpoints,
-	}
-
-	u, ok := options.Context.Value(authKey{}).(*authCreds)
-	if ok {
-		config.Username = u.Username
-		config.Password = u.Password
-	}
-
-	// use default config
-	client, err := cetcd.New(config)
-
-	prefix := DefaultPrefix
-	sp := ""
-	f, ok := options.Context.Value(prefixKey{}).(string)
-	if ok {
-		prefix = f
-	}
-
-	if b, ok := options.Context.Value(stripPrefixKey{}).(bool); ok && b {
-		sp = prefix
-	}
-
-	return &etcd{
-		prefix:      prefix,
-		stripPrefix: sp,
-		opts:        options,
-		client:      client,
-		cerr:        err,
-	}
-}

config/source/etcd/options.go

@@ -1,58 +0,0 @@
-package etcd
-
-import (
-	"context"
-
-	"github.com/micro/go-micro/config/source"
-)
-
-type addressKey struct{}
-type prefixKey struct{}
-type stripPrefixKey struct{}
-type authKey struct{}
-
-type authCreds struct {
-	Username string
-	Password string
-}
-
-// WithAddress sets the consul address
-func WithAddress(a ...string) source.Option {
-	return func(o *source.Options) {
-		if o.Context == nil {
-			o.Context = context.Background()
-		}
-		o.Context = context.WithValue(o.Context, addressKey{}, a)
-	}
-}
-
-// WithPrefix sets the key prefix to use
-func WithPrefix(p string) source.Option {
-	return func(o *source.Options) {
-		if o.Context == nil {
-			o.Context = context.Background()
-		}
-		o.Context = context.WithValue(o.Context, prefixKey{}, p)
-	}
-}
-
-// StripPrefix indicates whether to remove the prefix from config entries, or leave it in place.
-func StripPrefix(strip bool) source.Option {
-	return func(o *source.Options) {
-		if o.Context == nil {
-			o.Context = context.Background()
-		}
-
-		o.Context = context.WithValue(o.Context, stripPrefixKey{}, strip)
-	}
-}
-
-// Auth allows you to specify username/password
-func Auth(username, password string) source.Option {
-	return func(o *source.Options) {
-		if o.Context == nil {
-			o.Context = context.Background()
-		}
-		o.Context = context.WithValue(o.Context, authKey{}, &authCreds{Username: username, Password: password})
-	}
-}

config/source/etcd/util.go

@@ -1,89 +0,0 @@
-package etcd
-
-import (
-	"strings"
-
-	"github.com/micro/go-micro/config/encoder"
-	"go.etcd.io/etcd/clientv3"
-	"go.etcd.io/etcd/mvcc/mvccpb"
-)
-
-func makeEvMap(e encoder.Encoder, data map[string]interface{}, kv []*clientv3.Event, stripPrefix string) map[string]interface{} {
-	if data == nil {
-		data = make(map[string]interface{})
-	}
-
-	for _, v := range kv {
-		switch mvccpb.Event_EventType(v.Type) {
-		case mvccpb.DELETE:
-			data = update(e, data, (*mvccpb.KeyValue)(v.Kv), "delete", stripPrefix)
-		default:
-			data = update(e, data, (*mvccpb.KeyValue)(v.Kv), "insert", stripPrefix)
-		}
-	}
-
-	return data
-}
-
-func makeMap(e encoder.Encoder, kv []*mvccpb.KeyValue, stripPrefix string) map[string]interface{} {
-	data := make(map[string]interface{})
-
-	for _, v := range kv {
-		data = update(e, data, v, "put", stripPrefix)
-	}
-
-	return data
-}
-
-func update(e encoder.Encoder, data map[string]interface{}, v *mvccpb.KeyValue, action, stripPrefix string) map[string]interface{} {
-	// remove prefix if non empty, and ensure leading / is removed as well
-	vkey := strings.TrimPrefix(strings.TrimPrefix(string(v.Key), stripPrefix), "/")
-	// split on prefix
-	haveSplit := strings.Contains(vkey, "/")
-	keys := strings.Split(vkey, "/")
-
-	var vals interface{}
-	e.Decode(v.Value, &vals)
-
-	if !haveSplit && len(keys) == 1 {
-		switch action {
-		case "delete":
-			data = make(map[string]interface{})
-		default:
-			v, ok := vals.(map[string]interface{})
-			if ok {
-				data = v
-			}
-		}
-		return data
-	}
-
-	// set data for first iteration
-	kvals := data
-	// iterate the keys and make maps
-	for i, k := range keys {
-		kval, ok := kvals[k].(map[string]interface{})
-		if !ok {
-			// create next map
-			kval = make(map[string]interface{})
-			// set it
-			kvals[k] = kval
-		}
-
-		// last key: write vals
-		if l := len(keys) - 1; i == l {
-			switch action {
-			case "delete":
-				delete(kvals, k)
-			default:
-				kvals[k] = vals
-			}
-			break
-		}
-
-		// set kvals for next iterator
-		kvals = kval
-	}
-
-	return data
-}

config/source/etcd/watcher.go

@@ -1,113 +0,0 @@
-package etcd
-
-import (
-	"context"
-	"errors"
-	"sync"
-	"time"
-
-	"github.com/micro/go-micro/config/source"
-	cetcd "go.etcd.io/etcd/clientv3"
-)
-
-type watcher struct {
-	opts        source.Options
-	name        string
-	stripPrefix string
-
-	sync.RWMutex
-	cs *source.ChangeSet
-
-	ch   chan *source.ChangeSet
-	exit chan bool
-}
-
-func newWatcher(key, strip string, wc cetcd.Watcher, cs *source.ChangeSet, opts source.Options) (source.Watcher, error) {
-	w := &watcher{
-		opts:        opts,
-		name:        "etcd",
-		stripPrefix: strip,
-		cs:          cs,
-		ch:          make(chan *source.ChangeSet),
-		exit:        make(chan bool),
-	}
-
-	ch := wc.Watch(context.Background(), key, cetcd.WithPrefix())
-
-	go w.run(wc, ch)
-
-	return w, nil
-}
-
-func (w *watcher) handle(evs []*cetcd.Event) {
-	w.RLock()
-	data := w.cs.Data
-	w.RUnlock()
-
-	var vals map[string]interface{}
-
-	// unpackage existing changeset
-	if err := w.opts.Encoder.Decode(data, &vals); err != nil {
-		return
-	}
-
-	// update base changeset
-	d := makeEvMap(w.opts.Encoder, vals, evs, w.stripPrefix)
-
-	// pack the changeset
-	b, err := w.opts.Encoder.Encode(d)
-	if err != nil {
-		return
-	}
-
-	// create new changeset
-	cs := &source.ChangeSet{
-		Timestamp: time.Now(),
-		Source:    w.name,
-		Data:      b,
-		Format:    w.opts.Encoder.String(),
-	}
-	cs.Checksum = cs.Sum()
-
-	// set base change set
-	w.Lock()
-	w.cs = cs
-	w.Unlock()
-
-	// send update
-	w.ch <- cs
-}
-
-func (w *watcher) run(wc cetcd.Watcher, ch cetcd.WatchChan) {
-	for {
-		select {
-		case rsp, ok := <-ch:
-			if !ok {
-				return
-			}
-			w.handle(rsp.Events)
-		case <-w.exit:
-			wc.Close()
-			return
-		}
-	}
-}
-
-func (w *watcher) Next() (*source.ChangeSet, error) {
-	select {
-	case cs := <-w.ch:
-		return cs, nil
-	case <-w.exit:
-		return nil, errors.New("watcher stopped")
-	}
-}
-
-func (w *watcher) Stop() error {
-	select {
-	case <-w.exit:
-		return nil
-	default:
-		close(w.exit)
-	}
-	return nil
-}

config/source/file/watcher.go

@@ -1,7 +1,8 @@
+//+build !linux
+
 package file
 
 import (
-	"errors"
 	"os"
 
 	"github.com/fsnotify/fsnotify"
@@ -34,7 +35,7 @@ func (w *watcher) Next() (*source.ChangeSet, error) {
 	// is it closed?
 	select {
 	case <-w.exit:
-		return nil, errors.New("watcher stopped")
+		return nil, source.ErrWatcherStopped
 	default:
 	}
 
@@ -57,7 +58,7 @@ func (w *watcher) Next() (*source.ChangeSet, error) {
 	case err := <-w.fw.Errors:
 		return nil, err
 	case <-w.exit:
-		return nil, errors.New("watcher stopped")
+		return nil, source.ErrWatcherStopped
 	}
 }
 

config/source/file/watcher_linux.go

@@ -0,0 +1,71 @@
+//+build linux
+
+package file
+
+import (
+	"os"
+
+	"github.com/fsnotify/fsnotify"
+	"github.com/micro/go-micro/config/source"
+)
+
+type watcher struct {
+	f *file
+
+	fw   *fsnotify.Watcher
+	exit chan bool
+}
+
+func newWatcher(f *file) (source.Watcher, error) {
+	fw, err := fsnotify.NewWatcher()
+	if err != nil {
+		return nil, err
+	}
+
+	fw.Add(f.path)
+
+	return &watcher{
+		f:    f,
+		fw:   fw,
+		exit: make(chan bool),
+	}, nil
+}
+
+func (w *watcher) Next() (*source.ChangeSet, error) {
+	// is it closed?
+	select {
+	case <-w.exit:
+		return nil, source.ErrWatcherStopped
+	default:
+	}
+
+	// try get the event
+	select {
+	case event, _ := <-w.fw.Events:
+		if event.Op == fsnotify.Rename {
+			// check existence of file, and add watch again
+			_, err := os.Stat(event.Name)
+			if err == nil || os.IsExist(err) {
+				w.fw.Add(event.Name)
+			}
+		}
+
+		c, err := w.f.Read()
+		if err != nil {
+			return nil, err
+		}
+
+		// add path again for the event bug of fsnotify
+		w.fw.Add(w.f.path)
+
+		return c, nil
+	case err := <-w.fw.Errors:
+		return nil, err
+	case <-w.exit:
+		return nil, source.ErrWatcherStopped
+	}
+}
+
+func (w *watcher) Stop() error {
+	return w.fw.Close()
+}

config/source/flag/README.md

@@ -42,6 +42,6 @@ Load the source into config
 // Create new config
 conf := config.NewConfig()
 
-// Load file source
+// Load flag source
 conf.Load(flagSource)
 ```

config/source/flag/flag_test.go

@@ -12,13 +12,14 @@ var (
 	dbpw   = flag.String("database-password", "", "db pw")
 )
 
-func init() {
+func initTestFlags() {
 	flag.Set("database-host", "localhost")
 	flag.Set("database-password", "some-password")
 	flag.Parse()
 }
 
 func TestFlagsrc_Read(t *testing.T) {
+	initTestFlags()
 	source := NewSource()
 	c, err := source.Read()
 	if err != nil {
@@ -46,6 +47,7 @@ func TestFlagsrc_Read(t *testing.T) {
 }
 
 func TestFlagsrc_ReadAll(t *testing.T) {
+	initTestFlags()
 	source := NewSource(IncludeUnset(true))
 	c, err := source.Read()
 	if err != nil {

config/source/memory/README.md

@@ -27,7 +27,7 @@ Specify source with data
 
 ```go
 memorySource := memory.NewSource(
-	memory.WithData(data),
+	memory.WithJSON(data),
 )
 ```
 
@@ -39,6 +39,6 @@ Load the source into config
 // Create new config
 conf := config.NewConfig()
 
-// Load file source
+// Load memory source
 conf.Load(memorySource)
 ```