Merge pull request #1 from micro/master

update
2019-05-27 13:09:34 +08:00 · 2019-05-27 13:09:34 +08:00 · de270314d9
commit de270314d9
parent a0d3917832 b926ae81bb
128 changed files with 7680 additions and 3279 deletions
--- a/.travis.yml
+++ b/.travis.yml
@ -1,7 +1,7 @@
 language: go
 go:
- 1.9.5
+- 1.11.x
- 1.10.x
+- 1.12.x
 notifications:
  slack:
    secure: aEvhLbhujaGaKSrOokiG3//PaVHTIrc3fBpoRbCRqfZpyq6WREoapJJhF+tIpWWOwaC9GmChbD6aHo/jMUgwKXVyPSaNjiEL87YzUUpL8B2zslNp1rgfTg/LrzthOx3Q1TYwpaAl3to0fuHUVFX4yMeC2vuThq7WSXgMMxFCtbc=
--- a/README.md
+++ b/README.md
@ -1,8 +1,14 @@
 # Go Micro [![License](https://img.shields.io/:license-apache-blue.svg)](https://opensource.org/licenses/Apache-2.0) [![GoDoc](https://godoc.org/github.com/micro/go-micro?status.svg)](https://godoc.org/github.com/micro/go-micro) [![Travis CI](https://api.travis-ci.org/micro/go-micro.svg?branch=master)](https://travis-ci.org/micro/go-micro) [![Go Report Card](https://goreportcard.com/badge/micro/go-micro)](https://goreportcard.com/report/github.com/micro/go-micro)
-Go Micro is a pluggable RPC framework for distributed systems development.
+Go Micro is a framework for microservice development.
-The **micro** philosophy is sane defaults with a pluggable architecture. We provide defaults to get you started quickly but everything can be easily swapped out. It comes with built in support for {json,proto}-rpc encoding, consul or multicast dns for service discovery, http for communication and random hashed client side load balancing.
+## Overview
 Go Micro provides the core requirements for distributed systems development including RPC and Event driven communication. 
 The **micro** philosophy is sane defaults with a pluggable architecture. We provide defaults to get you started quickly 
 but everything can be easily swapped out. 
 <img src="https://micro.mu/docs/images/go-micro.svg" />
 Plugins are available at [github.com/micro/go-plugins](https://github.com/micro/go-plugins).
@ -12,448 +18,32 @@ Follow us on [Twitter](https://twitter.com/microhq) or join the [Slack](http://s
 Go Micro abstracts away the details of distributed systems. Here are the main features.
- **Service Discovery** - Automatic service registration and name resolution
+- **Service Discovery** - Automatic service registration and name resolution. Service discovery is at the core of micro service 
- **Load Balancing** - Client side load balancing built on discovery
+development. When service A needs to speak to service B it needs the location of that service. The default discovery mechanism is 
- **Message Encoding** - Dynamic encoding based on content-type with protobuf and json support
+multicast DNS (mdns), a zeroconf system. You can optionally set gossip using the SWIM protocol for p2p networks or consul for a
- **Sync Streaming** - RPC based communication with support for bidirectional streaming
+resilient cloud-native setup.
 - **Async Messaging** - Native PubSub messaging built in for event driven architectures
-Go Micro supports both the Service and Function programming models. Read on to learn more.
+- **Load Balancing** - Client side load balancing built on service discovery. Once we have the addresses of any number of instances 
 of a service we now need a way to decide which node to route to. We use random hashed load balancing to provide even distribution 
 across the services and retry a different node if there's a problem. 
-## Docs
+- **Message Encoding** - Dynamic message encoding based on content-type. The client and server will use codecs along with content-type 
 to seamlessly encode and decode Go types for you. Any variety of messages could be encoded and sent from different clients. The client 
 and server handle this by default. This includes protobuf and json by default.
-For more detailed information on the architecture, installation and use of go-micro checkout the [docs](https://micro.mu/docs).
+- **Request/Response** - RPC based request/response with support for bidirectional streaming. We provide an abstraction for synchronous 
 communication. A request made to a service will be automatically resolved, load balanced, dialled and streamed. The default 
 transport is http/1.1 or http2 when tls is enabled.
-## Learn By Example
+- **Async Messaging** - PubSub is built in as a first class citizen for asynchronous communication and event driven architectures. 
 Event notifications are a core pattern in micro service development. The default messaging is point-to-point http/1.1 or http2 when tls 
 is enabled.
-An example service can be found in [**examples/service**](https://github.com/micro/examples/tree/master/service) and function in [**examples/function**](https://github.com/micro/examples/tree/master/function). 
+- **Pluggable Interfaces** - Go Micro makes use of Go interfaces for each distributed system abstraction. Because of this these interfaces 
 are pluggable and allows Go Micro to be runtime agnostic. You can plugin any underlying technology. Find plugins in 
 [github.com/micro/go-plugins](https://github.com/micro/go-plugins).
-The [**examples**](https://github.com/micro/examples) directory contains examples for using things such as middleware/wrappers, selector filters, pub/sub, grpc, plugins and much more. For the complete greeter example look at [**examples/greeter**](https://github.com/micro/examples/tree/master/greeter). Other examples can be found throughout the GitHub repository.
+## Getting Started
-Watch the [Golang UK Conf 2016](https://www.youtube.com/watch?v=xspaDovwk34) video for a high level overview.
+See the [docs](https://micro.mu/docs/go-micro.html) for detailed information on the architecture, installation and use of go-micro.
 ## Getting started
 - [Install Protobuf](#install-protobuf)
 - [Service Discovery](#service-discovery)
 - [Writing a Service](#writing-a-service)
 - [Writing a Function](#writing-a-function)
 - [Publish & Subscribe](#publish--subscribe)
 - [Plugins](#plugins)
 - [Wrappers](#wrappers)
 ## Install Protobuf
 Protobuf is required for code generation
 You'll need to install:
 - [protoc-gen-micro](https://github.com/micro/protoc-gen-micro)
 ## Service Discovery
 Service discovery is used to resolve service names to addresses. 
 ### Consul
 [Consul](https://www.consul.io/) is used as the default service discovery system. 
 Discovery is pluggable. Find plugins for etcd, kubernetes, zookeeper and more in the [micro/go-plugins](https://github.com/micro/go-plugins) repo.
 [Install guide](https://www.consul.io/intro/getting-started/install.html)
 ### Multicast DNS
 [Multicast DNS](https://en.wikipedia.org/wiki/Multicast_DNS) is a built in service discovery plugin for a zero dependency configuration. 
 Pass `--registry=mdns` to any command or the enviroment variable `MICRO_REGISTRY=mdns`
 ```
 MICRO_REGISTRY=mdns go run main.go
 ```
 ## Writing a service
 This is a simple greeter RPC service example
 Find this example at [examples/service](https://github.com/micro/examples/tree/master/service).
 ### Create service proto
 One of the key requirements of microservices is strongly defined interfaces. Micro uses protobuf to achieve this.
 Here we define the Greeter handler with the method Hello. It takes a HelloRequest and HelloResponse both with one string arguments.
 ```proto
 syntax = "proto3";
 service Greeter {
 	rpc Hello(HelloRequest) returns (HelloResponse) {}
 }
 message HelloRequest {
 	string name = 1;
 }
 message HelloResponse {
 	string greeting = 2;
 }
 ```
 ### Generate the proto
 After writing the proto definition we must compile it using protoc with the micro plugin.
 ```shell
 protoc --proto_path=$GOPATH/src:. --micro_out=. --go_out=. path/to/greeter.proto
 ```
 ### Write the service
 Below is the code for the greeter service. 
 It does the following:
 1. Implements the interface defined for the Greeter handler
 2. Initialises a micro.Service
 3. Registers the Greeter handler
 4. Runs the service
 ```go
 package main
 import (
 	"context"
 	"fmt"
 	micro "github.com/micro/go-micro"
 	proto "github.com/micro/examples/service/proto"
 )
 type Greeter struct{}
 func (g *Greeter) Hello(ctx context.Context, req *proto.HelloRequest, rsp *proto.HelloResponse) error {
 	rsp.Greeting = "Hello " + req.Name
 	return nil
 }
 func main() {
 	// Create a new service. Optionally include some options here.
 	service := micro.NewService(
 		micro.Name("greeter"),
 	)
 	// Init will parse the command line flags.
 	service.Init()
 	// Register handler
 	proto.RegisterGreeterHandler(service.Server(), new(Greeter))
 	// Run the server
 	if err := service.Run(); err != nil {
 		fmt.Println(err)
 	}
 }
 ```
 ### Run service
 ```
 go run examples/service/main.go
 ```
 Output
 ```
 2016/03/14 10:59:14 Listening on [::]:50137
 2016/03/14 10:59:14 Broker Listening on [::]:50138
 2016/03/14 10:59:14 Registering node: greeter-ca62b017-e9d3-11e5-9bbb-68a86d0d36b6
 ```
 ### Define a client
 Below is the client code to query the greeter service. 
 The generated proto includes a greeter client to reduce boilerplate code.
 ```go
 package main
 import (
 	"context"
 	"fmt"
 	micro "github.com/micro/go-micro"
 	proto "github.com/micro/examples/service/proto"
 )
 func main() {
 	// Create a new service. Optionally include some options here.
 	service := micro.NewService(micro.Name("greeter.client"))
 	service.Init()
 	// Create new greeter client
 	greeter := proto.NewGreeterService("greeter", service.Client())
 	// Call the greeter
 	rsp, err := greeter.Hello(context.TODO(), &proto.HelloRequest{Name: "John"})
 	if err != nil {
 		fmt.Println(err)
 	}
 	// Print response
 	fmt.Println(rsp.Greeting)
 }
 ```
 ### Run the client
 ```shell
 go run client.go
 ```
 Output
 ```
 Hello John
 ```
 ## Writing a Function
 Go Micro includes the Function programming model. 
 A Function is a one time executing Service which exits after completing a request. 
 ### Defining a Function
 ```go
 package main
 import (
 	"context"
 	proto "github.com/micro/examples/function/proto"
 	"github.com/micro/go-micro"
 )
 type Greeter struct{}
 func (g *Greeter) Hello(ctx context.Context, req *proto.HelloRequest, rsp *proto.HelloResponse) error {
 	rsp.Greeting = "Hello " + req.Name
 	return nil
 }
 func main() {
 	// create a new function
 	fnc := micro.NewFunction(
 		micro.Name("greeter"),
 	)
 	// init the command line
 	fnc.Init()
 	// register a handler
 	fnc.Handle(new(Greeter))
 	// run the function
 	fnc.Run()
 }
 ```
 It's that simple.
 ## Publish & Subscribe
 Go-micro has a built in message broker interface for event driven architectures.
 PubSub operates on the same protobuf generated messages as RPC. They are encoded/decoded automatically and sent via the broker. 
 By default go-micro includes a point-to-point http broker but this can be swapped out via go-plugins.
 ### Publish
 Create a new publisher with a `topic` name and service client
 ```go
 p := micro.NewPublisher("events", service.Client())
 ```
 Publish a proto message
 ```go
 p.Publish(context.TODO(), &proto.Event{Name: "event"})
 ```
 ### Subscribe
 Create a message handler. It's signature should be `func(context.Context, v interface{}) error`.
 ```go
 func ProcessEvent(ctx context.Context, event *proto.Event) error {
 	fmt.Printf("Got event %+v\n", event)
 	return nil
 }
 ```
 Register the message handler with a `topic`
 ```go
 micro.RegisterSubscriber("events", ProcessEvent)
 ```
 See [examples/pubsub](https://github.com/micro/examples/tree/master/pubsub) for a complete example.
 ## Plugins
 By default go-micro only provides a few implementation of each interface at the core but it's completely pluggable. There's already dozens of plugins which are available at [github.com/micro/go-plugins](https://github.com/micro/go-plugins). Contributions are welcome!
 ### Build with plugins
 If you want to integrate plugins simply link them in a separate file and rebuild
 Create a plugins.go file
 ```go
 import (
        // etcd v3 registry
        _ "github.com/micro/go-plugins/registry/etcdv3"
        // nats transport
        _ "github.com/micro/go-plugins/transport/nats"
        // kafka broker
        _ "github.com/micro/go-plugins/broker/kafka"
 )
 ```
 Build binary
 ```shell
 // For local use
 go build -i -o service ./main.go ./plugins.go
 ```
 Flag usage of plugins
 ```shell
 service --registry=etcdv3 --transport=nats --broker=kafka
 ```
 ### Plugin as option
 Alternatively you can set the plugin as an option to a service
 ```go
 import (
        "github.com/micro/go-micro" 
        // etcd v3 registry
        "github.com/micro/go-plugins/registry/etcdv3"
        // nats transport
        "github.com/micro/go-plugins/transport/nats"
        // kafka broker
        "github.com/micro/go-plugins/broker/kafka"
 )
 func main() {
 	registry := etcdv3.NewRegistry()
 	broker := kafka.NewBroker()
 	transport := nats.NewTransport()
        service := micro.NewService(
                micro.Name("greeter"),
                micro.Registry(registry),
                micro.Broker(broker),
                micro.Transport(transport),
        )
 	service.Init()
 	service.Run()
 }
 ```
 ### Write plugins
 Plugins are a concept built on Go's interface. Each package maintains a high level interface abstraction. 
 Simply implement the interface and pass it in as an option to the service.
 The service discovery interface is called [Registry](https://godoc.org/github.com/micro/go-micro/registry#Registry). 
 Anything which implements this interface can be used as a registry. The same applies to the other packages.
 ```go
 type Registry interface {
    Register(*Service, ...RegisterOption) error
    Deregister(*Service) error
    GetService(string) ([]*Service, error)
    ListServices() ([]*Service, error)
    Watch() (Watcher, error)
    String() string
 }
 ```
 Browse [go-plugins](https://github.com/micro/go-plugins) to get a better idea of implementation details.
 ## Wrappers
 Go-micro includes the notion of middleware as wrappers. The client or handlers can be wrapped using the decorator pattern.
 ### Handler
 Here's an example service handler wrapper which logs the incoming request
 ```go
 // implements the server.HandlerWrapper
 func logWrapper(fn server.HandlerFunc) server.HandlerFunc {
 	return func(ctx context.Context, req server.Request, rsp interface{}) error {
 		fmt.Printf("[%v] server request: %s", time.Now(), req.Method())
 		return fn(ctx, req, rsp)
 	}
 }
 ```
 It can be initialised when creating the service
 ```go
 service := micro.NewService(
 	micro.Name("greeter"),
 	// wrap the handler
 	micro.WrapHandler(logWrapper),
 )
 ```
 ### Client
 Here's an example of a client wrapper which logs requests made
 ```go
 type logWrapper struct {
 	client.Client
 }
 func (l *logWrapper) Call(ctx context.Context, req client.Request, rsp interface{}, opts ...client.CallOption) error {
 	fmt.Printf("[wrapper] client request to service: %s method: %s\n", req.Service(), req.Method())
 	return l.Client.Call(ctx, req, rsp)
 }
 // implements client.Wrapper as logWrapper
 func logWrap(c client.Client) client.Client {
 	return &logWrapper{c}
 }
 ```
 It can be initialised when creating the service
 ```go
 service := micro.NewService(
 	micro.Name("greeter"),
 	// wrap the client
 	micro.WrapClient(logWrap),
 )
 ```
 ## Other Languages
 Check out [ja-micro](https://github.com/Sixt/ja-micro) to write services in Java
 ## Sponsors
 Sixt is an Enterprise Sponsor of Micro
 <a href="https://micro.mu/blog/2016/04/25/announcing-sixt-sponsorship.html"><img src="https://micro.mu/sixt_logo.png" width=150px height="auto" /></a>
 Become a sponsor by backing micro on [Patreon](https://www.patreon.com/microhq)
--- a/README.zh-cn.md
+++ b/README.zh-cn.md
@ -0,0 +1,36 @@
 # Go Micro [![License](https://img.shields.io/:license-apache-blue.svg)](https://opensource.org/licenses/Apache-2.0) [![GoDoc](https://godoc.org/github.com/micro/go-micro?status.svg)](https://godoc.org/github.com/micro/go-micro) [![Travis CI](https://api.travis-ci.org/micro/go-micro.svg?branch=master)](https://travis-ci.org/micro/go-micro) [![Go Report Card](https://goreportcard.com/badge/micro/go-micro)](https://goreportcard.com/report/github.com/micro/go-micro)
 Go Micro是基于Golang的微服务开发框架。
 ## 概览
 Go Micro提供分布式系统开发的核心库，包含RPC与事件驱动的通信机制。
 **micro**的设计哲学是可插拔的架构理念，她提供可快速构建系统的组件，并且可以根据自身的需求剥离默认实现并自行定制。
 <img src="https://micro.mu/docs/images/go-micro.svg" />
 所有插件可在仓库[github.com/micro/go-plugins](https://github.com/micro/go-plugins)中找到。
 可以订阅我们的[Twitter](https://twitter.com/microhq)或者加入[Slack](http://slack.micro.mu/)论坛。
 ## 特性
 Go Micro把分布式系统的各种细节抽象出来。下面是它的主要特性。
 - **服务发现（Service Discovery）** - 自动服务注册与名称解析。服务发现是微服务开发中的核心。当服务A要与服务B协作时，它得知道B在哪里。默认的服务发现系统是Consul，而multicast DNS (mdns，组播)机制作为本地解决方案，或者零依赖的P2P网络中的SWIM协议（gossip）。 
 - **负载均衡（Load Balancing）** - 在服务发现之上构建了负载均衡机制。当我们得到一个服务的任意多个的实例节点时，我们要一个机制去决定要路由到哪一个节点。我们使用随机处理过的哈希负载均衡机制来保证对服务请求颁发的均匀分布，并且在发生问题时进行重试。
 - **消息编码（Message Encoding）** - 支持基于内容类型（content-type）动态编码消息。客户端和服务端会一起使用content-type的格式来对Go进行无缝编/解码。各种各样的消息被编码会发送到不同的客户端，客户端服服务端默认会处理这些消息。content-type默认包含proto-rpc和json-rpc。
 - **Request/Response** - RPC通信基于支持双向流的请求/响应方式，我们提供有抽象的同步通信机制。请求发送到服务时，会自动解析、负载均衡、拨号、转成字节流。默认的传输协议是http/1.1，而tls下使用http2协议。
 - **异步消息（Async Messaging）** - 发布订阅（PubSub）头等功能内置在异步通信与事件驱动架构中。事件通知在微服务开发中处于核心位置。默认的消息传送使用点到点http/1.1，激活tls时则使用http2。
 - **可插拔接口（Pluggable Interfaces）** - Go Micro为每个分布式系统抽象出接口。因此，Go Micro的接口都是可插拔的，允许其在运行时不可知的情况下仍可支持。所以只要实现接口，可以在内部使用任何的技术。更多插件请参考：[github.com/micro/go-plugins](https://github.com/micro/go-plugins)。
 ## 快速上手
 更多关于架构、安装的资料可以查看[文档](https://micro.mu/docs/go-micro_cn.html)。
--- a/broker/codec/codec.go
+++ b/broker/codec/codec.go
@ -1,10 +0,0 @@
 package codec
 // Codec is used for encoding where the broker doesn't natively support
 // headers in the message type. In this case the entire message is
 // encoded as the payload
 type Codec interface {
 	Marshal(interface{}) ([]byte, error)
 	Unmarshal([]byte, interface{}) error
 	String() string
 }
--- a/broker/codec/json/json.go
+++ b/broker/codec/json/json.go
@ -1,25 +0,0 @@
 package json
 import (
 	"encoding/json"
 	"github.com/micro/go-micro/broker/codec"
 )
 type jsonCodec struct{}
 func (j jsonCodec) Marshal(v interface{}) ([]byte, error) {
 	return json.Marshal(v)
 }
 func (j jsonCodec) Unmarshal(d []byte, v interface{}) error {
 	return json.Unmarshal(d, v)
 }
 func (j jsonCodec) String() string {
 	return "json"
 }
 func NewCodec() codec.Codec {
 	return jsonCodec{}
 }
--- a/broker/codec/noop/noop.go
+++ b/broker/codec/noop/noop.go
@ -1,35 +0,0 @@
 package noop
 import (
 	"errors"
 	"github.com/micro/go-micro/broker"
 	"github.com/micro/go-micro/broker/codec"
 )
 type noopCodec struct{}
 func (n noopCodec) Marshal(v interface{}) ([]byte, error) {
 	msg, ok := v.(*broker.Message)
 	if !ok {
 		return nil, errors.New("invalid message")
 	}
 	return msg.Body, nil
 }
 func (n noopCodec) Unmarshal(d []byte, v interface{}) error {
 	msg, ok := v.(*broker.Message)
 	if !ok {
 		return errors.New("invalid message")
 	}
 	msg.Body = d
 	return nil
 }
 func (n noopCodec) String() string {
 	return "noop"
 }
 func NewCodec() codec.Codec {
 	return noopCodec{}
 }
--- a/broker/http/http.go
+++ b/broker/http/http.go
@ -1,9 +1,11 @@
 // Package http provides a http based message broker
 package http
 import (
 	"github.com/micro/go-micro/broker"
 )
 // NewBroker returns a new http broker
 func NewBroker(opts ...broker.Option) broker.Broker {
 	return broker.NewBroker(opts...)
 }
--- a/broker/http/options.go
+++ b/broker/http/options.go
@ -0,0 +1,23 @@
 package http
 import (
 	"context"
 	"net/http"
 	"github.com/micro/go-micro/broker"
 )
 // Handle registers the handler for the given pattern.
 func Handle(pattern string, handler http.Handler) broker.Option {
 	return func(o *broker.Options) {
 		if o.Context == nil {
 			o.Context = context.Background()
 		}
 		handlers, ok := o.Context.Value("http_handlers").(map[string]http.Handler)
 		if !ok {
 			handlers = make(map[string]http.Handler)
 		}
 		handlers[pattern] = handler
 		o.Context = context.WithValue(o.Context, "http_handlers", handlers)
 	}
 }
--- a/broker/http_broker.go
+++ b/broker/http_broker.go
@ -18,15 +18,15 @@ import (
 	"sync"
 	"time"
-	"github.com/micro/go-log"
+	"github.com/google/uuid"
-	"github.com/micro/go-micro/broker/codec/json"
+	"github.com/micro/go-micro/codec/json"
 	merr "github.com/micro/go-micro/errors"
 	"github.com/micro/go-micro/registry"
 	"github.com/micro/go-rcache"
 	maddr "github.com/micro/util/go/lib/addr"
 	mnet "github.com/micro/util/go/lib/net"
 	mls "github.com/micro/util/go/lib/tls"
-	"github.com/pborman/uuid"
+	"golang.org/x/net/http2"
 )
 // HTTP Broker is a point to point async broker
@ -44,6 +44,10 @@ type httpBroker struct {
 	subscribers map[string][]*httpSubscriber
 	running     bool
 	exit        chan chan error
 	// offline message inbox
 	mtx   sync.RWMutex
 	inbox map[string][][]byte
 }
 type httpSubscriber struct {
@ -78,6 +82,10 @@ func newTransport(config *tls.Config) *http.Transport {
 		}
 	}
 	dialTLS := func(network string, addr string) (net.Conn, error) {
 		return tls.Dial(network, addr, config)
 	}
 	t := &http.Transport{
 		Proxy: http.ProxyFromEnvironment,
 		Dial: (&net.Dialer{
@ -85,17 +93,21 @@ func newTransport(config *tls.Config) *http.Transport {
 			KeepAlive: 30 * time.Second,
 		}).Dial,
 		TLSHandshakeTimeout: 10 * time.Second,
-		TLSClientConfig:     config,
+		DialTLS:             dialTLS,
 	}
 	runtime.SetFinalizer(&t, func(tr **http.Transport) {
 		(*tr).CloseIdleConnections()
 	})
 	// setup http2
 	http2.ConfigureTransport(t)
 	return t
 }
 func newHttpBroker(opts ...Option) Broker {
 	options := Options{
-		Codec:   json.NewCodec(),
+		Codec:   json.Marshaler{},
 		Context: context.TODO(),
 	}
@ -116,7 +128,7 @@ func newHttpBroker(opts ...Option) Broker {
 	}
 	h := &httpBroker{
-		id:          "broker-" + uuid.NewUUID().String(),
+		id:          "broker-" + uuid.New().String(),
 		address:     addr,
 		opts:        options,
 		r:           reg,
@ -124,9 +136,22 @@ func newHttpBroker(opts ...Option) Broker {
 		subscribers: make(map[string][]*httpSubscriber),
 		exit:        make(chan chan error),
 		mux:         http.NewServeMux(),
 		inbox:       make(map[string][][]byte),
 	}
 	// specify the message handler
 	h.mux.Handle(DefaultSubPath, h)
 	// get optional handlers
 	if h.opts.Context != nil {
 		handlers, ok := h.opts.Context.Value("http_handlers").(map[string]http.Handler)
 		if ok {
 			for pattern, handler := range handlers {
 				h.mux.Handle(pattern, handler)
 			}
 		}
 	}
 	return h
 }
@ -154,6 +179,49 @@ func (h *httpSubscriber) Unsubscribe() error {
 	return h.hb.unsubscribe(h)
 }
 func (h *httpBroker) saveMessage(topic string, msg []byte) {
 	h.mtx.Lock()
 	defer h.mtx.Unlock()
 	// get messages
 	c := h.inbox[topic]
 	// save message
 	c = append(c, msg)
 	// max length 64
 	if len(c) > 64 {
 		c = c[:64]
 	}
 	// save inbox
 	h.inbox[topic] = c
 }
 func (h *httpBroker) getMessage(topic string, num int) [][]byte {
 	h.mtx.Lock()
 	defer h.mtx.Unlock()
 	// get messages
 	c, ok := h.inbox[topic]
 	if !ok {
 		return nil
 	}
 	// more message than requests
 	if len(c) >= num {
 		msg := c[:num]
 		h.inbox[topic] = c[num:]
 		return msg
 	}
 	// reset inbox
 	h.inbox[topic] = nil
 	// return all messages
 	return c
 }
 func (h *httpBroker) subscribe(s *httpSubscriber) error {
 	h.Lock()
 	defer h.Unlock()
@ -176,7 +244,7 @@ func (h *httpBroker) unsubscribe(s *httpSubscriber) error {
 	for _, sub := range h.subscribers[s.topic] {
 		// deregister and skip forward
 		if sub.id == s.id {
-			h.r.Deregister(sub.svc)
+			_ = h.r.Deregister(sub.svc)
 			continue
 		}
 		// keep subscriber
@ -200,7 +268,7 @@ func (h *httpBroker) run(l net.Listener) {
 			h.RLock()
 			for _, subs := range h.subscribers {
 				for _, sub := range subs {
-					h.r.Register(sub.svc, registry.RegisterTTL(registerTTL))
+					_ = h.r.Register(sub.svc, registry.RegisterTTL(registerTTL))
 				}
 			}
 			h.RUnlock()
@ -210,7 +278,7 @@ func (h *httpBroker) run(l net.Listener) {
 			h.RLock()
 			for _, subs := range h.subscribers {
 				for _, sub := range subs {
-					h.r.Deregister(sub.svc)
+					_ = h.r.Deregister(sub.svc)
 				}
 			}
 			h.RUnlock()
@ -276,7 +344,6 @@ func (h *httpBroker) Address() string {
 }
 func (h *httpBroker) Connect() error {
 	h.RLock()
 	if h.running {
 		h.RUnlock()
@ -329,7 +396,6 @@ func (h *httpBroker) Connect() error {
 		return err
 	}
 	log.Logf("Broker Listening on %s", l.Addr().String())
 	addr := h.address
 	h.address = l.Addr().String()
@ -397,8 +463,12 @@ func (h *httpBroker) Init(opts ...Option) error {
 		o(&h.opts)
 	}
 	if len(h.opts.Addrs) > 0 && len(h.opts.Addrs[0]) > 0 {
 		h.address = h.opts.Addrs[0]
 	}
 	if len(h.id) == 0 {
-		h.id = "broker-" + uuid.NewUUID().String()
+		h.id = "broker-" + uuid.New().String()
 	}
 	// get registry
@ -415,6 +485,13 @@ func (h *httpBroker) Init(opts ...Option) error {
 	// set registry
 	h.r = rcache.New(reg)
 	// reconfigure tls config
 	if c := h.opts.TLSConfig; c != nil {
 		h.c = &http.Client{
 			Transport: newTransport(c),
 		}
 	}
 	return nil
 }
@ -423,14 +500,7 @@ func (h *httpBroker) Options() Options {
 }
 func (h *httpBroker) Publish(topic string, msg *Message, opts ...PublishOption) error {
-	h.RLock()
+	// create the message first
 	s, err := h.r.GetService("topic:" + topic)
 	if err != nil {
 		h.RUnlock()
 		return err
 	}
 	h.RUnlock()
 	m := &Message{
 		Header: make(map[string]string),
 		Body:   msg.Body,
@ -442,12 +512,26 @@ func (h *httpBroker) Publish(topic string, msg *Message, opts ...PublishOption)
 	m.Header[":topic"] = topic
 	// encode the message
 	b, err := h.opts.Codec.Marshal(m)
 	if err != nil {
 		return err
 	}
-	pub := func(node *registry.Node, b []byte) {
+	// save the message
 	h.saveMessage(topic, b)
 	// now attempt to get the service
 	h.RLock()
 	s, err := h.r.GetService("topic:" + topic)
 	if err != nil {
 		h.RUnlock()
 		// ignore error
 		return nil
 	}
 	h.RUnlock()
 	pub := func(node *registry.Node, t string, b []byte) error {
 		scheme := "http"
 		// check if secure is added in metadata
@ -460,12 +544,17 @@ func (h *httpBroker) Publish(topic string, msg *Message, opts ...PublishOption)
 		uri := fmt.Sprintf("%s://%s:%d%s?%s", scheme, node.Address, node.Port, DefaultSubPath, vals.Encode())
 		r, err := h.c.Post(uri, "application/json", bytes.NewReader(b))
-		if err == nil {
+		if err != nil {
-			io.Copy(ioutil.Discard, r.Body)
+			return err
 			r.Body.Close()
 		}
 		}
 		// discard response body
 		io.Copy(ioutil.Discard, r.Body)
 		r.Body.Close()
 		return nil
 	}
 	srv := func(s []*registry.Service, b []byte) {
 		for _, service := range s {
 			// only process if we have nodes
 			if len(service.Nodes) == 0 {
@ -475,24 +564,56 @@ func (h *httpBroker) Publish(topic string, msg *Message, opts ...PublishOption)
 			switch service.Version {
 			// broadcast version means broadcast to all nodes
 			case broadcastVersion:
 				var success bool
 				// publish to all nodes
 				for _, node := range service.Nodes {
 					// publish async
-				go pub(node, b)
+					if err := pub(node, topic, b); err == nil {
 						success = true
 					}
 				}
 				// save if it failed to publish at least once
 				if !success {
 					h.saveMessage(topic, b)
 				}
 			default:
 				// select node to publish to
 				node := service.Nodes[rand.Int()%len(service.Nodes)]
-			// publish async
+				// publish async to one node
-			go pub(node, b)
+				if err := pub(node, topic, b); err != nil {
 					// if failed save it
 					h.saveMessage(topic, b)
 				}
 			}
 		}
 	}
 	// do the rest async
 	go func() {
 		// get a third of the backlog
 		messages := h.getMessage(topic, 8)
 		delay := (len(messages) > 1)
 		// publish all the messages
 		for _, msg := range messages {
 			// serialize here
 			srv(s, msg)
 			// sending a backlog of messages
 			if delay {
 				time.Sleep(time.Millisecond * 100)
 			}
 		}
 	}()
 	return nil
 }
 func (h *httpBroker) Subscribe(topic string, handler Handler, opts ...SubscribeOption) (Subscriber, error) {
-	options := newSubscribeOptions(opts...)
+	options := NewSubscribeOptions(opts...)
 	// parse address for host, port
 	parts := strings.Split(h.Address(), ":")
@ -505,7 +626,7 @@ func (h *httpBroker) Subscribe(topic string, handler Handler, opts ...SubscribeO
 	}
 	// create unique id
-	id := h.id + "." + uuid.NewUUID().String()
+	id := h.id + "." + uuid.New().String()
 	var secure bool
--- a/broker/http_broker_test.go
+++ b/broker/http_broker_test.go
@ -5,15 +5,28 @@ import (
 	"testing"
 	"time"
-	"github.com/micro/go-micro/registry/mock"
+	glog "github.com/go-log/log"
-	"github.com/pborman/uuid"
+	"github.com/google/uuid"
 	"github.com/micro/go-log"
 	"github.com/micro/go-micro/registry/memory"
 )
 func newTestRegistry() *memory.Registry {
 	r := memory.NewRegistry()
 	m := r.(*memory.Registry)
 	m.Setup()
 	return m
 }
 func sub(be *testing.B, c int) {
 	// set no op logger
 	log.SetLogger(glog.DefaultLogger)
 	be.StopTimer()
-	m := mock.NewRegistry()
+	m := newTestRegistry()
 	b := NewBroker(Registry(m))
-	topic := uuid.NewUUID().String()
+	topic := uuid.New().String()
 	if err := b.Init(); err != nil {
 		be.Fatalf("Unexpected init error: %v", err)
@ -69,10 +82,13 @@ func sub(be *testing.B, c int) {
 }
 func pub(be *testing.B, c int) {
 	// set no op logger
 	log.SetLogger(glog.DefaultLogger)
 	be.StopTimer()
-	m := mock.NewRegistry()
+	m := newTestRegistry()
 	b := NewBroker(Registry(m))
-	topic := uuid.NewUUID().String()
+	topic := uuid.New().String()
 	if err := b.Init(); err != nil {
 		be.Fatalf("Unexpected init error: %v", err)
@ -139,7 +155,7 @@ func pub(be *testing.B, c int) {
 }
 func TestBroker(t *testing.T) {
-	m := mock.NewRegistry()
+	m := newTestRegistry()
 	b := NewBroker(Registry(m))
 	if err := b.Init(); err != nil {
@ -186,7 +202,7 @@ func TestBroker(t *testing.T) {
 }
 func TestConcurrentSubBroker(t *testing.T) {
-	m := mock.NewRegistry()
+	m := newTestRegistry()
 	b := NewBroker(Registry(m))
 	if err := b.Init(); err != nil {
@ -243,7 +259,7 @@ func TestConcurrentSubBroker(t *testing.T) {
 }
 func TestConcurrentPubBroker(t *testing.T) {
-	m := mock.NewRegistry()
+	m := newTestRegistry()
 	b := NewBroker(Registry(m))
 	if err := b.Init(); err != nil {
--- a/broker/memory/memory.go
+++ b/broker/memory/memory.go
@ -1,27 +1,28 @@
-package mock
+// Package memory provides a memory broker
 package memory
 import (
 	"errors"
 	"sync"
 	"github.com/google/uuid"
 	"github.com/micro/go-micro/broker"
 	"github.com/pborman/uuid"
 )
-type mockBroker struct {
+type memoryBroker struct {
 	opts broker.Options
 	sync.RWMutex
 	connected   bool
-	Subscribers map[string][]*mockSubscriber
+	Subscribers map[string][]*memorySubscriber
 }
-type mockPublication struct {
+type memoryPublication struct {
 	topic   string
 	message *broker.Message
 }
-type mockSubscriber struct {
+type memorySubscriber struct {
 	id      string
 	topic   string
 	exit    chan bool
@ -29,15 +30,15 @@ type mockSubscriber struct {
 	opts    broker.SubscribeOptions
 }
-func (m *mockBroker) Options() broker.Options {
+func (m *memoryBroker) Options() broker.Options {
 	return m.opts
 }
-func (m *mockBroker) Address() string {
+func (m *memoryBroker) Address() string {
 	return ""
 }
-func (m *mockBroker) Connect() error {
+func (m *memoryBroker) Connect() error {
 	m.Lock()
 	defer m.Unlock()
@ -50,7 +51,7 @@ func (m *mockBroker) Connect() error {
 	return nil
 }
-func (m *mockBroker) Disconnect() error {
+func (m *memoryBroker) Disconnect() error {
 	m.Lock()
 	defer m.Unlock()
@ -63,14 +64,14 @@ func (m *mockBroker) Disconnect() error {
 	return nil
 }
-func (m *mockBroker) Init(opts ...broker.Option) error {
+func (m *memoryBroker) Init(opts ...broker.Option) error {
 	for _, o := range opts {
 		o(&m.opts)
 	}
 	return nil
 }
-func (m *mockBroker) Publish(topic string, message *broker.Message, opts ...broker.PublishOption) error {
+func (m *memoryBroker) Publish(topic string, message *broker.Message, opts ...broker.PublishOption) error {
 	m.Lock()
 	defer m.Unlock()
@ -83,7 +84,7 @@ func (m *mockBroker) Publish(topic string, message *broker.Message, opts ...brok
 		return nil
 	}
-	p := &mockPublication{
+	p := &memoryPublication{
 		topic:   topic,
 		message: message,
 	}
@ -97,7 +98,7 @@ func (m *mockBroker) Publish(topic string, message *broker.Message, opts ...brok
 	return nil
 }
-func (m *mockBroker) Subscribe(topic string, handler broker.Handler, opts ...broker.SubscribeOption) (broker.Subscriber, error) {
+func (m *memoryBroker) Subscribe(topic string, handler broker.Handler, opts ...broker.SubscribeOption) (broker.Subscriber, error) {
 	m.Lock()
 	defer m.Unlock()
@ -110,9 +111,9 @@ func (m *mockBroker) Subscribe(topic string, handler broker.Handler, opts ...bro
 		o(&options)
 	}
-	sub := &mockSubscriber{
+	sub := &memorySubscriber{
 		exit:    make(chan bool, 1),
-		id:      uuid.NewUUID().String(),
+		id:      uuid.New().String(),
 		topic:   topic,
 		handler: handler,
 		opts:    options,
@ -123,7 +124,7 @@ func (m *mockBroker) Subscribe(topic string, handler broker.Handler, opts ...bro
 	go func() {
 		<-sub.exit
 		m.Lock()
-		var newSubscribers []*mockSubscriber
+		var newSubscribers []*memorySubscriber
 		for _, sb := range m.Subscribers[topic] {
 			if sb.id == sub.id {
 				continue
@ -137,31 +138,31 @@ func (m *mockBroker) Subscribe(topic string, handler broker.Handler, opts ...bro
 	return sub, nil
 }
-func (m *mockBroker) String() string {
+func (m *memoryBroker) String() string {
-	return "mock"
+	return "memory"
 }
-func (m *mockPublication) Topic() string {
+func (m *memoryPublication) Topic() string {
 	return m.topic
 }
-func (m *mockPublication) Message() *broker.Message {
+func (m *memoryPublication) Message() *broker.Message {
 	return m.message
 }
-func (m *mockPublication) Ack() error {
+func (m *memoryPublication) Ack() error {
 	return nil
 }
-func (m *mockSubscriber) Options() broker.SubscribeOptions {
+func (m *memorySubscriber) Options() broker.SubscribeOptions {
 	return m.opts
 }
-func (m *mockSubscriber) Topic() string {
+func (m *memorySubscriber) Topic() string {
 	return m.topic
 }
-func (m *mockSubscriber) Unsubscribe() error {
+func (m *memorySubscriber) Unsubscribe() error {
 	m.exit <- true
 	return nil
 }
@ -172,8 +173,8 @@ func NewBroker(opts ...broker.Option) broker.Broker {
 		o(&options)
 	}
-	return &mockBroker{
+	return &memoryBroker{
 		opts:        options,
-		Subscribers: make(map[string][]*mockSubscriber),
+		Subscribers: make(map[string][]*memorySubscriber),
 	}
 }
--- a/broker/memory/memory_test.go
+++ b/broker/memory/memory_test.go
@ -1,4 +1,4 @@
-package mock
+package memory
 import (
 	"fmt"
@ -7,7 +7,7 @@ import (
 	"github.com/micro/go-micro/broker"
 )
-func TestBroker(t *testing.T) {
+func TestMemoryBroker(t *testing.T) {
 	b := NewBroker()
 	if err := b.Connect(); err != nil {
--- a/broker/options.go
+++ b/broker/options.go
@ -4,14 +4,14 @@ import (
 	"context"
 	"crypto/tls"
-	"github.com/micro/go-micro/broker/codec"
+	"github.com/micro/go-micro/codec"
 	"github.com/micro/go-micro/registry"
 )
 type Options struct {
 	Addrs     []string
 	Secure    bool
-	Codec     codec.Codec
+	Codec     codec.Marshaler
 	TLSConfig *tls.Config
 	// Other options for implementations of the interface
 	// can be stored in a context
@ -50,7 +50,7 @@ var (
 	registryKey = contextKeyT("github.com/micro/go-micro/registry")
 )
-func newSubscribeOptions(opts ...SubscribeOption) SubscribeOptions {
+func NewSubscribeOptions(opts ...SubscribeOption) SubscribeOptions {
 	opt := SubscribeOptions{
 		AutoAck: true,
 	}
@ -71,7 +71,7 @@ func Addrs(addrs ...string) Option {
 // Codec sets the codec used for encoding/decoding used where
 // a broker does not support headers
-func Codec(c codec.Codec) Option {
+func Codec(c codec.Marshaler) Option {
 	return func(o *Options) {
 		o.Codec = c
 	}
@ -111,3 +111,10 @@ func TLSConfig(t *tls.Config) Option {
 		o.TLSConfig = t
 	}
 }
 // SubscribeContext set context
 func SubscribeContext(ctx context.Context) SubscribeOption {
 	return func(o *SubscribeOptions) {
 		o.Context = ctx
 	}
 }
--- a/client/client.go
+++ b/client/client.go
@ -4,6 +4,8 @@ package client
 import (
 	"context"
 	"time"
 	"github.com/micro/go-micro/codec"
 )
 // Client is the interface used to make requests to services.
@ -13,13 +15,18 @@ type Client interface {
 	Init(...Option) error
 	Options() Options
 	NewMessage(topic string, msg interface{}, opts ...MessageOption) Message
-	NewRequest(service, method string, req interface{}, reqOpts ...RequestOption) Request
+	NewRequest(service, endpoint string, req interface{}, reqOpts ...RequestOption) Request
 	Call(ctx context.Context, req Request, rsp interface{}, opts ...CallOption) error
 	Stream(ctx context.Context, req Request, opts ...CallOption) (Stream, error)
 	Publish(ctx context.Context, msg Message, opts ...PublishOption) error
 	String() string
 }
 // Router manages request routing
 type Router interface {
 	SendRequest(context.Context, Request) (Response, error)
 }
 // Message is the interface for publishing asynchronously
 type Message interface {
 	Topic() string
@ -29,21 +36,47 @@ type Message interface {
 // Request is the interface for a synchronous request used by Call or Stream
 type Request interface {
 	// The service to call
 	Service() string
 	// The action to take
 	Method() string
 	// The endpoint to invoke
 	Endpoint() string
 	// The content type
 	ContentType() string
-	Request() interface{}
+	// The unencoded request body
 	Body() interface{}
 	// Write to the encoded request writer. This is nil before a call is made
 	Codec() codec.Writer
 	// indicates whether the request will be a streaming one rather than unary
 	Stream() bool
 }
 // Response is the response received from a service
 type Response interface {
 	// Read the response
 	Codec() codec.Reader
 	// read the header
 	Header() map[string]string
 	// Read the undecoded response
 	Read() ([]byte, error)
 }
 // Stream is the inteface for a bidirectional synchronous stream
 type Stream interface {
 	// Context for the stream
 	Context() context.Context
 	// The request made
 	Request() Request
 	// The response read
 	Response() Response
 	// Send will encode and send a request
 	Send(interface{}) error
 	// Recv will decode and read a response
 	Recv(interface{}) error
 	// Error returns the stream error
 	Error() error
 	// Close closes the stream
 	Close() error
 }
@ -74,7 +107,7 @@ var (
 	// DefaultRequestTimeout is the default request timeout
 	DefaultRequestTimeout = time.Second * 5
 	// DefaultPoolSize sets the connection pool size
-	DefaultPoolSize = 1
+	DefaultPoolSize = 100
 	// DefaultPoolTTL sets the connection pool ttl
 	DefaultPoolTTL = time.Minute
 )
@ -102,8 +135,8 @@ func NewClient(opt ...Option) Client {
 // Creates a new request using the default client. Content Type will
 // be set to the default within options and use the appropriate codec
-func NewRequest(service, method string, request interface{}, reqOpts ...RequestOption) Request {
+func NewRequest(service, endpoint string, request interface{}, reqOpts ...RequestOption) Request {
-	return DefaultClient.NewRequest(service, method, request, reqOpts...)
+	return DefaultClient.NewRequest(service, endpoint, request, reqOpts...)
 }
 // Creates a streaming connection with a service and returns responses on the
--- a/client/mock/mock.go
+++ b/client/mock/mock.go
@ -1,3 +1,4 @@
 // Package mock provides a mock client for testing
 package mock
 import (
@ -15,7 +16,7 @@ var (
 )
 type MockResponse struct {
-	Method   string
+	Endpoint string
 	Response interface{}
 	Error    error
 }
@ -53,8 +54,8 @@ func (m *MockClient) NewMessage(topic string, msg interface{}, opts ...client.Me
 	return m.Client.NewMessage(topic, msg, opts...)
 }
-func (m *MockClient) NewRequest(service, method string, req interface{}, reqOpts ...client.RequestOption) client.Request {
+func (m *MockClient) NewRequest(service, endpoint string, req interface{}, reqOpts ...client.RequestOption) client.Request {
-	return m.Client.NewRequest(service, method, req, reqOpts...)
+	return m.Client.NewRequest(service, endpoint, req, reqOpts...)
 }
 func (m *MockClient) Call(ctx context.Context, req client.Request, rsp interface{}, opts ...client.CallOption) error {
@ -67,7 +68,7 @@ func (m *MockClient) Call(ctx context.Context, req client.Request, rsp interface
 	}
 	for _, r := range response {
-		if r.Method != req.Method() {
+		if r.Endpoint != req.Endpoint() {
 			continue
 		}
@ -82,7 +83,11 @@ func (m *MockClient) Call(ctx context.Context, req client.Request, rsp interface
 		}
 		response := r.Response
 		if t := reflect.TypeOf(r.Response); t.Kind() == reflect.Func {
-			response = reflect.ValueOf(r.Response).Call([]reflect.Value{})[0].Interface()
+			var request []reflect.Value
 			if t.NumIn() == 1 {
 				request = append(request, reflect.ValueOf(req.Body()))
 			}
 			response = reflect.ValueOf(r.Response).Call(request)[0].Interface()
 		}
 		v.Set(reflect.ValueOf(response))
@ -90,7 +95,7 @@ func (m *MockClient) Call(ctx context.Context, req client.Request, rsp interface
 		return nil
 	}
-	return fmt.Errorf("rpc: can't find service %s", req.Method())
+	return fmt.Errorf("rpc: can't find service %s", req.Endpoint())
 }
 func (m *MockClient) Stream(ctx context.Context, req client.Request, opts ...client.CallOption) (client.Stream, error) {
--- a/client/mock/mock_test.go
+++ b/client/mock/mock_test.go
@ -13,17 +13,23 @@ func TestClient(t *testing.T) {
 	}
 	response := []MockResponse{
-		{Method: "Foo.Bar", Response: map[string]interface{}{"foo": "bar"}},
+		{Endpoint: "Foo.Bar", Response: map[string]interface{}{"foo": "bar"}},
-		{Method: "Foo.Struct", Response: &TestResponse{Param: "aparam"}},
+		{Endpoint: "Foo.Struct", Response: &TestResponse{Param: "aparam"}},
-		{Method: "Foo.Fail", Error: errors.InternalServerError("go.mock", "failed")},
+		{Endpoint: "Foo.Fail", Error: errors.InternalServerError("go.mock", "failed")},
-		{Method: "Foo.Func", Response: func() string { return "string" }},
+		{Endpoint: "Foo.Func", Response: func() string { return "string" }},
-		{Method: "Foo.FuncStruct", Response: func() *TestResponse { return &TestResponse{Param: "aparam"} }},
+		{Endpoint: "Foo.FuncStruct", Response: func() *TestResponse { return &TestResponse{Param: "aparam"} }},
 		{Endpoint: "Foo.FuncWithReqBody", Response: func(req interface{}) string {
 			if req.(map[string]string)["foo"] == "bar" {
 				return "string"
 			}
 			return "wrong"
 		}},
 	}
 	c := NewClient(Response("go.mock", response))
 	for _, r := range response {
-		req := c.NewRequest("go.mock", r.Method, map[string]interface{}{"foo": "bar"})
+		req := c.NewRequest("go.mock", r.Endpoint, map[string]string{"foo": "bar"})
 		var rsp interface{}
 		err := c.Call(context.TODO(), req, &rsp)
@ -33,6 +39,20 @@ func TestClient(t *testing.T) {
 		}
 		t.Log(rsp)
 		if r.Endpoint == "Foo.FuncWithReqBody" {
 			req := c.NewRequest("go.mock", r.Endpoint, map[string]string{"foo": "wrong"})
 			var rsp interface{}
 			err := c.Call(context.TODO(), req, &rsp)
 			if err != r.Error {
 				t.Fatalf("Expecter error %v got %v", r.Error, err)
 			}
 			if rsp.(string) != "wrong" {
 				t.Fatalf("Expecter response 'wrong' got %v", rsp)
 			}
 			t.Log(rsp)
 		}
 	}
 }
--- a/client/options.go
+++ b/client/options.go
@ -22,6 +22,9 @@ type Options struct {
 	Selector  selector.Selector
 	Transport transport.Transport
 	// Router sets the router
 	Router Router
 	// Connection Pool
 	PoolSize int
 	PoolTTL  time.Duration
@ -62,6 +65,8 @@ type CallOptions struct {
 }
 type PublishOptions struct {
 	// Exchange is the routing exchange for the message
 	Exchange string
 	// Other options for implementations of the interface
 	// can be stored in a context
 	Context context.Context
@ -99,7 +104,7 @@ func newOptions(options ...Option) Options {
 	}
 	if len(opts.ContentType) == 0 {
-		opts.ContentType = defaultContentType
+		opts.ContentType = DefaultContentType
 	}
 	if opts.Broker == nil {
@ -233,6 +238,13 @@ func DialTimeout(d time.Duration) Option {
 // Call Options
 // WithExchange sets the exchange to route a message through
 func WithExchange(e string) PublishOption {
 	return func(o *PublishOptions) {
 		o.Exchange = e
 	}
 }
 // WithAddress sets the remote address to use rather than using service discovery
 func WithAddress(a string) CallOption {
 	return func(o *CallOptions) {
@ -306,3 +318,10 @@ func StreamingRequest() RequestOption {
 		o.Stream = true
 	}
 }
 // WithRouter sets the client router
 func WithRouter(r Router) Option {
 	return func(o *Options) {
 		o.Router = r
 	}
 }
--- a/client/rpc/rpc.go
+++ b/client/rpc/rpc.go
@ -1,9 +1,11 @@
 // Package rpc provides an rpc client
 package rpc
 import (
 	"github.com/micro/go-micro/client"
 )
 // NewClient returns a new micro client interface
 func NewClient(opts ...client.Option) client.Client {
 	return client.NewClient(opts...)
 }
--- a/client/rpc_client.go
+++ b/client/rpc_client.go
@ -4,9 +4,14 @@ 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/codec"
 	"github.com/micro/go-micro/errors"
@ -14,7 +19,6 @@ import (
 	"github.com/micro/go-micro/registry"
 	"github.com/micro/go-micro/selector"
 	"github.com/micro/go-micro/transport"
 	"sync/atomic"
 )
 type rpcClient struct {
@ -48,13 +52,18 @@ func (r *rpcClient) newCodec(contentType string) (codec.NewCodec, error) {
 	if c, ok := r.opts.Codecs[contentType]; ok {
 		return c, nil
 	}
-	if cf, ok := defaultCodecs[contentType]; ok {
+	if cf, ok := DefaultCodecs[contentType]; ok {
 		return cf, nil
 	}
 	return nil, fmt.Errorf("Unsupported Content-Type: %s", contentType)
 }
-func (r *rpcClient) call(ctx context.Context, address string, req Request, resp interface{}, opts CallOptions) error {
+func (r *rpcClient) call(ctx context.Context, node *registry.Node, req Request, resp interface{}, opts CallOptions) error {
 	address := node.Address
 	if node.Port > 0 {
 		address = fmt.Sprintf("%s:%d", address, node.Port)
 	}
 	msg := &transport.Message{
 		Header: make(map[string]string),
 	}
@ -73,10 +82,17 @@ func (r *rpcClient) call(ctx context.Context, address string, req Request, resp
 	// set the accept header
 	msg.Header["Accept"] = req.ContentType()
-	cf, err := r.newCodec(req.ContentType())
+	// setup old protocol
 	cf := setupProtocol(msg, node)
 	// no codec specified
 	if cf == nil {
 		var err error
 		cf, err = r.newCodec(req.ContentType())
 		if err != nil {
 			return errors.InternalServerError("go.micro.client", err.Error())
 		}
 	}
 	var grr error
 	c, err := r.pool.getConn(address, r.opts.Transport, transport.WithTimeout(opts.DialTimeout))
@ -88,15 +104,22 @@ func (r *rpcClient) call(ctx context.Context, address string, req Request, resp
 		r.pool.release(address, c, grr)
 	}()
-	seq := r.seq
+	seq := atomic.LoadUint64(&r.seq)
 	atomic.AddUint64(&r.seq, 1)
 	codec := newRpcCodec(msg, c, cf)
 	rsp := &rpcResponse{
 		socket: c,
 		codec:  codec,
 	}
 	stream := &rpcStream{
 		context:  ctx,
 		request:  req,
 		response: rsp,
 		codec:    codec,
 		closed:   make(chan bool),
-		codec:   newRpcPlusCodec(msg, c, cf),
+		id:       fmt.Sprintf("%v", seq),
 		seq:     seq,
 	}
 	defer stream.Close()
@ -110,7 +133,7 @@ func (r *rpcClient) call(ctx context.Context, address string, req Request, resp
 		}()
 		// send request
-		if err := stream.Send(req.Request()); err != nil {
+		if err := stream.Send(req.Body()); err != nil {
 			ch <- err
 			return
 		}
@ -131,11 +154,16 @@ func (r *rpcClient) call(ctx context.Context, address string, req Request, resp
 		return err
 	case <-ctx.Done():
 		grr = ctx.Err()
-		return errors.New("go.micro.client", fmt.Sprintf("request timeout: %v", ctx.Err()), 408)
+		return errors.Timeout("go.micro.client", fmt.Sprintf("%v", ctx.Err()))
 	}
 }
-func (r *rpcClient) stream(ctx context.Context, address string, req Request, opts CallOptions) (Stream, error) {
+func (r *rpcClient) stream(ctx context.Context, node *registry.Node, req Request, opts CallOptions) (Stream, error) {
 	address := node.Address
 	if node.Port > 0 {
 		address = fmt.Sprintf("%s:%d", address, node.Port)
 	}
 	msg := &transport.Message{
 		Header: make(map[string]string),
 	}
@ -154,10 +182,17 @@ func (r *rpcClient) stream(ctx context.Context, address string, req Request, opt
 	// set the accept header
 	msg.Header["Accept"] = req.ContentType()
-	cf, err := r.newCodec(req.ContentType())
+	// set old codecs
 	cf := setupProtocol(msg, node)
 	// no codec specified
 	if cf == nil {
 		var err error
 		cf, err = r.newCodec(req.ContentType())
 		if err != nil {
 			return nil, errors.InternalServerError("go.micro.client", err.Error())
 		}
 	}
 	dOpts := []transport.DialOption{
 		transport.WithStream(),
@ -172,17 +207,30 @@ func (r *rpcClient) stream(ctx context.Context, address string, req Request, opt
 		return nil, errors.InternalServerError("go.micro.client", "connection error: %v", err)
 	}
 	codec := newRpcCodec(msg, c, cf)
 	rsp := &rpcResponse{
 		socket: c,
 		codec:  codec,
 	}
 	// set request codec
 	if r, ok := req.(*rpcRequest); ok {
 		r.codec = codec
 	}
 	stream := &rpcStream{
 		context:  ctx,
 		request:  req,
 		response: rsp,
 		closed:   make(chan bool),
-		codec:   newRpcPlusCodec(msg, c, cf),
+		codec:    codec,
 	}
 	ch := make(chan error, 1)
 	go func() {
-		ch <- stream.Send(req.Request())
+		ch <- stream.Send(req.Body())
 	}()
 	var grr error
@ -191,7 +239,7 @@ func (r *rpcClient) stream(ctx context.Context, address string, req Request, opt
 	case err := <-ch:
 		grr = err
 	case <-ctx.Done():
-		grr = errors.New("go.micro.client", fmt.Sprintf("request timeout: %v", ctx.Err()), 408)
+		grr = errors.Timeout("go.micro.client", fmt.Sprintf("%v", ctx.Err()))
 	}
 	if grr != nil {
@ -226,21 +274,43 @@ func (r *rpcClient) Options() Options {
 }
 func (r *rpcClient) next(request Request, opts 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 = prx
 	}
 	// return remote address
 	if len(opts.Address) > 0 {
 		address := opts.Address
 		port := 0
 		host, sport, err := net.SplitHostPort(opts.Address)
 		if err == nil {
 			address = host
 			port, _ = strconv.Atoi(sport)
 		}
 		return func() (*registry.Node, error) {
 			return &registry.Node{
-				Address: opts.Address,
+				Address: address,
 				Port:    port,
 			}, nil
 		}, nil
 	}
 	// get next nodes from the selector
-	next, err := r.opts.Selector.Select(request.Service(), opts.SelectOptions...)
+	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", request.Service(), err.Error())
+		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", request.Service(), err.Error())
+		return nil, errors.InternalServerError("go.micro.client", "error selecting %s node: %v", service, err.Error())
 	}
 	return next, nil
@ -273,7 +343,7 @@ func (r *rpcClient) Call(ctx context.Context, request Request, response interfac
 	// should we noop right here?
 	select {
 	case <-ctx.Done():
-		return errors.New("go.micro.client", fmt.Sprintf("%v", ctx.Err()), 408)
+		return errors.Timeout("go.micro.client", fmt.Sprintf("%v", ctx.Err()))
 	default:
 	}
@ -306,29 +376,23 @@ func (r *rpcClient) Call(ctx context.Context, request Request, response interfac
 			return errors.InternalServerError("go.micro.client", "error getting next %s node: %v", request.Service(), err.Error())
 		}
 		// set the address
 		address := node.Address
 		if node.Port > 0 {
 			address = fmt.Sprintf("%s:%d", address, node.Port)
 		}
 		// make the call
-		err = rcall(ctx, address, request, response, callOpts)
+		err = rcall(ctx, node, request, response, callOpts)
 		r.opts.Selector.Mark(request.Service(), node, err)
 		return err
 	}
-	ch := make(chan error, callOpts.Retries)
+	ch := make(chan error, callOpts.Retries+1)
 	var gerr error
 	for i := 0; i <= callOpts.Retries; i++ {
-		go func() {
+		go func(i int) {
 			ch <- call(i)
-		}()
+		}(i)
 		select {
 		case <-ctx.Done():
-			return errors.New("go.micro.client", fmt.Sprintf("call timeout: %v", ctx.Err()), 408)
+			return errors.Timeout("go.micro.client", fmt.Sprintf("call timeout: %v", ctx.Err()))
 		case err := <-ch:
 			// if the call succeeded lets bail early
 			if err == nil {
@ -366,7 +430,7 @@ func (r *rpcClient) Stream(ctx context.Context, request Request, opts ...CallOpt
 	// should we noop right here?
 	select {
 	case <-ctx.Done():
-		return nil, errors.New("go.micro.client", fmt.Sprintf("%v", ctx.Err()), 408)
+		return nil, errors.Timeout("go.micro.client", fmt.Sprintf("%v", ctx.Err()))
 	default:
 	}
@ -389,12 +453,7 @@ func (r *rpcClient) Stream(ctx context.Context, request Request, opts ...CallOpt
 			return nil, errors.InternalServerError("go.micro.client", "error getting next %s node: %v", request.Service(), err.Error())
 		}
-		address := node.Address
+		stream, err := r.stream(ctx, node, request, callOpts)
 		if node.Port > 0 {
 			address = fmt.Sprintf("%s:%d", address, node.Port)
 		}
 		stream, err := r.stream(ctx, address, request, callOpts)
 		r.opts.Selector.Mark(request.Service(), node, err)
 		return stream, err
 	}
@ -404,7 +463,7 @@ func (r *rpcClient) Stream(ctx context.Context, request Request, opts ...CallOpt
 		err    error
 	}
-	ch := make(chan response, callOpts.Retries)
+	ch := make(chan response, callOpts.Retries+1)
 	var grr error
 	for i := 0; i <= callOpts.Retries; i++ {
@ -415,7 +474,7 @@ func (r *rpcClient) Stream(ctx context.Context, request Request, opts ...CallOpt
 		select {
 		case <-ctx.Done():
-			return nil, errors.New("go.micro.client", fmt.Sprintf("call timeout: %v", ctx.Err()), 408)
+			return nil, errors.Timeout("go.micro.client", fmt.Sprintf("call timeout: %v", ctx.Err()))
 		case rsp := <-ch:
 			// if the call succeeded lets bail early
 			if rsp.err == nil {
@ -439,11 +498,35 @@ func (r *rpcClient) Stream(ctx context.Context, request Request, opts ...CallOpt
 }
 func (r *rpcClient) Publish(ctx context.Context, msg Message, opts ...PublishOption) error {
 	options := PublishOptions{
 		Context: context.Background(),
 	}
 	for _, o := range opts {
 		o(&options)
 	}
 	md, ok := metadata.FromContext(ctx)
 	if !ok {
 		md = make(map[string]string)
 	}
 	id := uuid.New().String()
 	md["Content-Type"] = msg.ContentType()
 	md["Micro-Topic"] = msg.Topic()
 	md["Micro-Id"] = id
 	// set the topic
 	topic := msg.Topic()
 	// get proxy
 	if prx := os.Getenv("MICRO_PROXY"); len(prx) > 0 {
 		options.Exchange = prx
 	}
 	// get the exchange
 	if len(options.Exchange) > 0 {
 		topic = options.Exchange
 	}
 	// encode message body
 	cf, err := r.newCodec(msg.ContentType())
@ -451,14 +534,21 @@ func (r *rpcClient) Publish(ctx context.Context, msg Message, opts ...PublishOpt
 		return errors.InternalServerError("go.micro.client", err.Error())
 	}
 	b := &buffer{bytes.NewBuffer(nil)}
-	if err := cf(b).Write(&codec.Message{Type: codec.Publication}, msg.Payload()); err != nil {
+	if err := cf(b).Write(&codec.Message{
 		Target: topic,
 		Type:   codec.Publication,
 		Header: map[string]string{
 			"Micro-Id":    id,
 			"Micro-Topic": msg.Topic(),
 		},
 	}, msg.Payload()); err != nil {
 		return errors.InternalServerError("go.micro.client", err.Error())
 	}
 	r.once.Do(func() {
 		r.opts.Broker.Connect()
 	})
-	return r.opts.Broker.Publish(msg.Topic(), &broker.Message{
+	return r.opts.Broker.Publish(topic, &broker.Message{
 		Header: md,
 		Body:   b.Bytes(),
 	})
--- a/client/rpc_client_test.go
+++ b/client/rpc_client_test.go
@ -7,30 +7,41 @@ import (
 	"github.com/micro/go-micro/errors"
 	"github.com/micro/go-micro/registry"
-	"github.com/micro/go-micro/registry/mock"
+	"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
 }
 func TestCallAddress(t *testing.T) {
 	var called bool
 	service := "test.service"
-	method := "Test.Method"
+	endpoint := "Test.Endpoint"
-	address := "10.1.10.1:8080"
+	address := "10.1.10.1"
 	port := 8080
 	wrap := func(cf CallFunc) CallFunc {
-		return func(ctx context.Context, addr string, req Request, rsp interface{}, opts CallOptions) error {
+		return func(ctx context.Context, node *registry.Node, req Request, rsp interface{}, opts CallOptions) error {
 			called = true
 			if req.Service() != service {
 				return fmt.Errorf("expected service: %s got %s", service, req.Service())
 			}
-			if req.Method() != method {
+			if req.Endpoint() != endpoint {
-				return fmt.Errorf("expected service: %s got %s", method, req.Method())
+				return fmt.Errorf("expected service: %s got %s", endpoint, req.Endpoint())
 			}
-			if addr != address {
+			if node.Address != address {
-				return fmt.Errorf("expected address: %s got %s", address, addr)
+				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
@ -38,17 +49,17 @@ func TestCallAddress(t *testing.T) {
 		}
 	}
-	r := mock.NewRegistry()
+	r := newTestRegistry()
 	c := NewClient(
 		Registry(r),
 		WrapCall(wrap),
 	)
 	c.Options().Selector.Init(selector.Registry(r))
-	req := c.NewRequest(service, method, nil)
+	req := c.NewRequest(service, endpoint, nil)
 	// test calling remote address
-	if err := c.Call(context.Background(), req, nil, WithAddress(address)); err != nil {
+	if err := c.Call(context.Background(), req, nil, WithAddress(fmt.Sprintf("%s:%d", address, port))); err != nil {
 		t.Fatal("call with address error", err)
 	}
@ -60,13 +71,13 @@ func TestCallAddress(t *testing.T) {
 func TestCallRetry(t *testing.T) {
 	service := "test.service"
-	method := "Test.Method"
+	endpoint := "Test.Endpoint"
-	address := "10.1.10.1:8080"
+	address := "10.1.10.1"
 	var called int
 	wrap := func(cf CallFunc) CallFunc {
-		return func(ctx context.Context, addr string, req Request, rsp interface{}, opts CallOptions) error {
+		return func(ctx context.Context, node *registry.Node, req Request, rsp interface{}, opts CallOptions) error {
 			called++
 			if called == 1 {
 				return errors.InternalServerError("test.error", "retry request")
@ -77,14 +88,14 @@ func TestCallRetry(t *testing.T) {
 		}
 	}
-	r := mock.NewRegistry()
+	r := newTestRegistry()
 	c := NewClient(
 		Registry(r),
 		WrapCall(wrap),
 	)
 	c.Options().Selector.Init(selector.Registry(r))
-	req := c.NewRequest(service, method, nil)
+	req := c.NewRequest(service, endpoint, nil)
 	// test calling remote address
 	if err := c.Call(context.Background(), req, nil, WithAddress(address)); err != nil {
@ -101,25 +112,24 @@ func TestCallWrapper(t *testing.T) {
 	var called bool
 	id := "test.1"
 	service := "test.service"
-	method := "Test.Method"
+	endpoint := "Test.Endpoint"
-	host := "10.1.10.1"
+	address := "10.1.10.1"
 	port := 8080
 	address := "10.1.10.1:8080"
 	wrap := func(cf CallFunc) CallFunc {
-		return func(ctx context.Context, addr string, req Request, rsp interface{}, opts CallOptions) error {
+		return func(ctx context.Context, node *registry.Node, req Request, rsp interface{}, opts CallOptions) error {
 			called = true
 			if req.Service() != service {
 				return fmt.Errorf("expected service: %s got %s", service, req.Service())
 			}
-			if req.Method() != method {
+			if req.Endpoint() != endpoint {
-				return fmt.Errorf("expected service: %s got %s", method, req.Method())
+				return fmt.Errorf("expected service: %s got %s", endpoint, req.Endpoint())
 			}
-			if addr != address {
+			if node.Address != address {
-				return fmt.Errorf("expected address: %s got %s", address, addr)
+				return fmt.Errorf("expected address: %s got %s", address, node.Address)
 			}
 			// don't do the call
@ -127,7 +137,7 @@ func TestCallWrapper(t *testing.T) {
 		}
 	}
-	r := mock.NewRegistry()
+	r := newTestRegistry()
 	c := NewClient(
 		Registry(r),
 		WrapCall(wrap),
@ -140,13 +150,13 @@ func TestCallWrapper(t *testing.T) {
 		Nodes: []*registry.Node{
 			&registry.Node{
 				Id:      id,
-				Address: host,
+				Address: address,
 				Port:    port,
 			},
 		},
 	})
-	req := c.NewRequest(service, method, nil)
+	req := c.NewRequest(service, endpoint, nil)
 	if err := c.Call(context.Background(), req, nil); err != nil {
 		t.Fatal("call wrapper error", err)
 	}
--- a/client/rpc_codec.go
+++ b/client/rpc_codec.go
@ -5,9 +5,14 @@ import (
 	errs "errors"
 	"github.com/micro/go-micro/codec"
 	raw "github.com/micro/go-micro/codec/bytes"
 	"github.com/micro/go-micro/codec/grpc"
 	"github.com/micro/go-micro/codec/json"
 	"github.com/micro/go-micro/codec/jsonrpc"
 	"github.com/micro/go-micro/codec/proto"
 	"github.com/micro/go-micro/codec/protorpc"
 	"github.com/micro/go-micro/errors"
 	"github.com/micro/go-micro/registry"
 	"github.com/micro/go-micro/transport"
 )
@ -28,7 +33,7 @@ var (
 	errShutdown = errs.New("connection is shut down")
 )
-type rpcPlusCodec struct {
+type rpcCodec struct {
 	client transport.Client
 	codec  codec.Codec
@ -41,31 +46,21 @@ type readWriteCloser struct {
 	rbuf *bytes.Buffer
 }
 type clientCodec interface {
 	WriteRequest(*request, interface{}) error
 	ReadResponseHeader(*response) error
 	ReadResponseBody(interface{}) error
 	Close() error
 }
 type request struct {
 	Service       string
 	ServiceMethod string   // format: "Service.Method"
 	Seq           uint64   // sequence number chosen by client
 	next          *request // for free list in Server
 }
 type response struct {
 	ServiceMethod string    // echoes that of the Request
 	Seq           uint64    // echoes that of the request
 	Error         string    // error, if any.
 	next          *response // for free list in Server
 }
 var (
-	defaultContentType = "application/octet-stream"
+	DefaultContentType = "application/protobuf"
 	DefaultCodecs = map[string]codec.NewCodec{
 		"application/grpc":         grpc.NewCodec,
 		"application/grpc+json":    grpc.NewCodec,
 		"application/grpc+proto":   grpc.NewCodec,
 		"application/protobuf":     proto.NewCodec,
 		"application/json":         json.NewCodec,
 		"application/json-rpc":     jsonrpc.NewCodec,
 		"application/proto-rpc":    protorpc.NewCodec,
 		"application/octet-stream": raw.NewCodec,
 	}
 	// TODO: remove legacy codec list
 	defaultCodecs = map[string]codec.NewCodec{
 		"application/json":         jsonrpc.NewCodec,
 		"application/json-rpc":     jsonrpc.NewCodec,
@ -89,12 +84,77 @@ func (rwc *readWriteCloser) Close() error {
 	return nil
 }
-func newRpcPlusCodec(req *transport.Message, client transport.Client, c codec.NewCodec) *rpcPlusCodec {
+func getHeaders(m *codec.Message) {
 	get := func(hdr string) string {
 		if hd := m.Header[hdr]; len(hd) > 0 {
 			return hd
 		}
 		// old
 		return m.Header["X-"+hdr]
 	}
 	// check error in header
 	if len(m.Error) == 0 {
 		m.Error = get("Micro-Error")
 	}
 	// check endpoint in header
 	if len(m.Endpoint) == 0 {
 		m.Endpoint = get("Micro-Endpoint")
 	}
 	// check method in header
 	if len(m.Method) == 0 {
 		m.Method = get("Micro-Method")
 	}
 	if len(m.Id) == 0 {
 		m.Id = get("Micro-Id")
 	}
 }
 func setHeaders(m *codec.Message) {
 	set := func(hdr, v string) {
 		if len(v) == 0 {
 			return
 		}
 		m.Header[hdr] = v
 		m.Header["X-"+hdr] = v
 	}
 	set("Micro-Id", m.Id)
 	set("Micro-Service", m.Target)
 	set("Micro-Method", m.Method)
 	set("Micro-Endpoint", m.Endpoint)
 }
 // setupProtocol sets up the old protocol
 func setupProtocol(msg *transport.Message, node *registry.Node) codec.NewCodec {
 	protocol := node.Metadata["protocol"]
 	// got protocol
 	if len(protocol) > 0 {
 		return nil
 	}
 	// no protocol use old codecs
 	switch msg.Header["Content-Type"] {
 	case "application/json":
 		msg.Header["Content-Type"] = "application/json-rpc"
 	case "application/protobuf":
 		msg.Header["Content-Type"] = "application/proto-rpc"
 	}
 	// now return codec
 	return defaultCodecs[msg.Header["Content-Type"]]
 }
 func newRpcCodec(req *transport.Message, client transport.Client, c codec.NewCodec) codec.Codec {
 	rwc := &readWriteCloser{
 		wbuf: bytes.NewBuffer(nil),
 		rbuf: bytes.NewBuffer(nil),
 	}
-	r := &rpcPlusCodec{
+	r := &rpcCodec{
 		buf:    rwc,
 		client: client,
 		codec:  c(rwc),
@ -103,54 +163,90 @@ func newRpcPlusCodec(req *transport.Message, client transport.Client, c codec.Ne
 	return r
 }
-func (c *rpcPlusCodec) WriteRequest(req *request, body interface{}) error {
+func (c *rpcCodec) Write(m *codec.Message, body interface{}) error {
 	c.buf.wbuf.Reset()
-	m := &codec.Message{
+
-		Id:     req.Seq,
+	// create header
-		Target: req.Service,
+	if m.Header == nil {
-		Method: req.ServiceMethod,
+		m.Header = map[string]string{}
 		Type:   codec.Request,
 		Header: map[string]string{},
 	}
 	// copy original header
 	for k, v := range c.req.Header {
 		m.Header[k] = v
 	}
 	// set the mucp headers
 	setHeaders(m)
 	// if body is bytes Frame don't encode
 	if body != nil {
 		b, ok := body.(*raw.Frame)
 		if ok {
 			// set body
 			m.Body = b.Data
 			body = nil
 		}
 	}
 	if len(m.Body) == 0 {
 		// write to codec
 		if err := c.codec.Write(m, body); err != nil {
 			return errors.InternalServerError("go.micro.client.codec", err.Error())
 		}
-	c.req.Body = c.buf.wbuf.Bytes()
+		// set body
-	for k, v := range m.Header {
+		m.Body = c.buf.wbuf.Bytes()
 		c.req.Header[k] = v
 	}
-	if err := c.client.Send(c.req); err != nil {
+
 	// create new transport message
 	msg := transport.Message{
 		Header: m.Header,
 		Body:   m.Body,
 	}
 	// send the request
 	if err := c.client.Send(&msg); err != nil {
 		return errors.InternalServerError("go.micro.client.transport", err.Error())
 	}
 	return nil
 }
-func (c *rpcPlusCodec) ReadResponseHeader(r *response) error {
+func (c *rpcCodec) ReadHeader(m *codec.Message, r codec.MessageType) error {
-	var m transport.Message
+	var tm transport.Message
-	if err := c.client.Recv(&m); err != nil {
+
 	// read message from transport
 	if err := c.client.Recv(&tm); err != nil {
 		return errors.InternalServerError("go.micro.client.transport", err.Error())
 	}
 	c.buf.rbuf.Reset()
-	c.buf.rbuf.Write(m.Body)
+	c.buf.rbuf.Write(tm.Body)
-	var me codec.Message
+
-	err := c.codec.ReadHeader(&me, codec.Response)
+	// set headers from transport
-	r.ServiceMethod = me.Method
+	m.Header = tm.Header
-	r.Seq = me.Id
+
-	r.Error = me.Error
+	// read header
 	err := c.codec.ReadHeader(m, r)
 	// get headers
 	getHeaders(m)
 	// return header error
 	if err != nil {
 		return errors.InternalServerError("go.micro.client.codec", err.Error())
 	}
 	return nil
 }
-func (c *rpcPlusCodec) ReadResponseBody(b interface{}) error {
+func (c *rpcCodec) ReadBody(b interface{}) error {
 	// read body
 	if err := c.codec.ReadBody(b); err != nil {
 		return errors.InternalServerError("go.micro.client.codec", err.Error())
 	}
 	return nil
 }
-func (c *rpcPlusCodec) Close() error {
+func (c *rpcCodec) Close() error {
 	c.buf.Close()
 	c.codec.Close()
 	if err := c.client.Close(); err != nil {
@ -158,3 +254,7 @@ func (c *rpcPlusCodec) Close() error {
 	}
 	return nil
 }
 func (c *rpcCodec) String() string {
 	return "rpc"
 }
--- a/client/rpc_pool_test.go
+++ b/client/rpc_pool_test.go
@ -5,7 +5,7 @@ import (
 	"time"
 	"github.com/micro/go-micro/transport"
-	"github.com/micro/go-micro/transport/mock"
+	"github.com/micro/go-micro/transport/memory"
 )
 func testPool(t *testing.T, size int, ttl time.Duration) {
@ -13,7 +13,7 @@ func testPool(t *testing.T, size int, ttl time.Duration) {
 	p := newPool(size, ttl)
 	// mock transport
-	tr := mock.NewTransport()
+	tr := memory.NewTransport()
 	// listen
 	l, err := tr.Listen(":0")
--- a/client/rpc_request.go
+++ b/client/rpc_request.go
@ -1,14 +1,20 @@
 package client
 import (
 	"github.com/micro/go-micro/codec"
 )
 type rpcRequest struct {
 	service     string
 	method      string
 	endpoint    string
 	contentType string
-	request     interface{}
+	codec       codec.Codec
 	body        interface{}
 	opts        RequestOptions
 }
-func newRequest(service, method string, request interface{}, contentType string, reqOpts ...RequestOption) Request {
+func newRequest(service, endpoint string, request interface{}, contentType string, reqOpts ...RequestOption) Request {
 	var opts RequestOptions
 	for _, o := range reqOpts {
@ -22,8 +28,9 @@ func newRequest(service, method string, request interface{}, contentType string,
 	return &rpcRequest{
 		service:     service,
-		method:      method,
+		method:      endpoint,
-		request:     request,
+		endpoint:    endpoint,
 		body:        request,
 		contentType: contentType,
 		opts:        opts,
 	}
@ -41,8 +48,16 @@ func (r *rpcRequest) Method() string {
 	return r.method
 }
-func (r *rpcRequest) Request() interface{} {
+func (r *rpcRequest) Endpoint() string {
-	return r.request
+	return r.endpoint
 }
 func (r *rpcRequest) Body() interface{} {
 	return r.body
 }
 func (r *rpcRequest) Codec() codec.Writer {
 	return r.codec
 }
 func (r *rpcRequest) Stream() bool {
--- a/client/rpc_request_test.go
+++ b/client/rpc_request_test.go
@ -5,19 +5,19 @@ import (
 )
 func TestRequestOptions(t *testing.T) {
-	r := newRequest("service", "method", nil, "application/json")
+	r := newRequest("service", "endpoint", nil, "application/json")
 	if r.Service() != "service" {
 		t.Fatalf("expected 'service' got %s", r.Service())
 	}
-	if r.Method() != "method" {
+	if r.Endpoint() != "endpoint" {
-		t.Fatalf("expected 'method' got %s", r.Method())
+		t.Fatalf("expected 'endpoint' got %s", r.Endpoint())
 	}
 	if r.ContentType() != "application/json" {
-		t.Fatalf("expected 'method' got %s", r.ContentType())
+		t.Fatalf("expected 'endpoint' got %s", r.ContentType())
 	}
-	r2 := newRequest("service", "method", nil, "application/json", WithContentType("application/protobuf"))
+	r2 := newRequest("service", "endpoint", nil, "application/json", WithContentType("application/protobuf"))
 	if r2.ContentType() != "application/protobuf" {
-		t.Fatalf("expected 'method' got %s", r2.ContentType())
+		t.Fatalf("expected 'endpoint' got %s", r2.ContentType())
 	}
 }
--- a/client/rpc_response.go
+++ b/client/rpc_response.go
@ -0,0 +1,35 @@
 package client
 import (
 	"github.com/micro/go-micro/codec"
 	"github.com/micro/go-micro/transport"
 )
 type rpcResponse struct {
 	header map[string]string
 	body   []byte
 	socket transport.Socket
 	codec  codec.Codec
 }
 func (r *rpcResponse) Codec() codec.Reader {
 	return r.codec
 }
 func (r *rpcResponse) Header() map[string]string {
 	return r.header
 }
 func (r *rpcResponse) Read() ([]byte, error) {
 	var msg transport.Message
 	if err := r.socket.Recv(&msg); err != nil {
 		return nil, err
 	}
 	// set internals
 	r.header = msg.Header
 	r.body = msg.Body
 	return msg.Body, nil
 }
--- a/client/rpc_stream.go
+++ b/client/rpc_stream.go
@ -4,16 +4,19 @@ import (
 	"context"
 	"io"
 	"sync"
 	"github.com/micro/go-micro/codec"
 )
 // Implements the streamer interface
 type rpcStream struct {
 	sync.RWMutex
-	seq     uint64
+	id       string
 	closed   chan bool
 	err      error
 	request  Request
-	codec   clientCodec
+	response Response
 	codec    codec.Codec
 	context  context.Context
 }
@ -34,6 +37,10 @@ func (r *rpcStream) Request() Request {
 	return r.request
 }
 func (r *rpcStream) Response() Response {
 	return r.response
 }
 func (r *rpcStream) Send(msg interface{}) error {
 	r.Lock()
 	defer r.Unlock()
@ -43,18 +50,19 @@ func (r *rpcStream) Send(msg interface{}) error {
 		return errShutdown
 	}
-	seq := r.seq
+	req := codec.Message{
-
+		Id:       r.id,
-	req := request{
+		Target:   r.request.Service(),
-		Service:       r.request.Service(),
+		Method:   r.request.Method(),
-		Seq:           seq,
+		Endpoint: r.request.Endpoint(),
-		ServiceMethod: r.request.Method(),
+		Type:     codec.Request,
 	}
-	if err := r.codec.WriteRequest(&req, msg); err != nil {
+	if err := r.codec.Write(&req, msg); err != nil {
 		r.err = err
 		return err
 	}
 	return nil
 }
@ -67,8 +75,9 @@ func (r *rpcStream) Recv(msg interface{}) error {
 		return errShutdown
 	}
-	var resp response
+	var resp codec.Message
-	if err := r.codec.ReadResponseHeader(&resp); err != nil {
+
 	if err := r.codec.ReadHeader(&resp, codec.Response); err != nil {
 		if err == io.EOF && !r.isClosed() {
 			r.err = io.ErrUnexpectedEOF
 			return io.ErrUnexpectedEOF
@ -87,11 +96,11 @@ func (r *rpcStream) Recv(msg interface{}) error {
 		} else {
 			r.err = io.EOF
 		}
-		if err := r.codec.ReadResponseBody(nil); err != nil {
+		if err := r.codec.ReadBody(nil); err != nil {
 			r.err = err
 		}
 	default:
-		if err := r.codec.ReadResponseBody(msg); err != nil {
+		if err := r.codec.ReadBody(msg); err != nil {
 			r.err = err
 		}
 	}
--- a/client/wrapper.go
+++ b/client/wrapper.go
@ -2,10 +2,12 @@ package client
 import (
 	"context"
 	"github.com/micro/go-micro/registry"
 )
 // CallFunc represents the individual call func
-type CallFunc func(ctx context.Context, address string, req Request, rsp interface{}, opts CallOptions) error
+type CallFunc func(ctx context.Context, node *registry.Node, req Request, rsp interface{}, opts CallOptions) error
 // CallWrapper is a low level wrapper for the CallFunc
 type CallWrapper func(CallFunc) CallFunc
--- a/cmd/cmd.go
+++ b/cmd/cmd.go
@ -10,25 +10,31 @@ import (
 	"time"
 	"github.com/micro/cli"
 	"github.com/micro/go-log"
 	"github.com/micro/go-micro/client"
 	"github.com/micro/go-micro/server"
 	// brokers
 	"github.com/micro/go-micro/broker"
 	"github.com/micro/go-micro/broker/http"
 	"github.com/micro/go-micro/broker/memory"
 	// registries
 	"github.com/micro/go-micro/registry"
 	"github.com/micro/go-micro/registry/consul"
 	"github.com/micro/go-micro/registry/gossip"
 	"github.com/micro/go-micro/registry/mdns"
 	rmem "github.com/micro/go-micro/registry/memory"
 	// selectors
 	"github.com/micro/go-micro/selector"
-	"github.com/micro/go-micro/selector/cache"
+	"github.com/micro/go-micro/selector/dns"
 	"github.com/micro/go-micro/selector/static"
 	// transports
 	"github.com/micro/go-micro/transport"
 	thttp "github.com/micro/go-micro/transport/http"
 	tmem "github.com/micro/go-micro/transport/memory"
 )
 type Cmd interface {
@ -65,6 +71,7 @@ var (
 		cli.IntFlag{
 			Name:   "client_retries",
 			EnvVar: "MICRO_CLIENT_RETRIES",
 			Value:  client.DefaultRetries,
 			Usage:  "Sets the client retries. Default: 1",
 		},
 		cli.IntFlag{
@ -87,6 +94,11 @@ var (
 			EnvVar: "MICRO_REGISTER_INTERVAL",
 			Usage:  "Register interval in seconds",
 		},
 		cli.StringFlag{
 			Name:   "server",
 			EnvVar: "MICRO_SERVER",
 			Usage:  "Server for go-micro; rpc",
 		},
 		cli.StringFlag{
 			Name:   "server_name",
 			EnvVar: "MICRO_SERVER_NAME",
@ -142,12 +154,6 @@ var (
 			Name:   "selector",
 			EnvVar: "MICRO_SELECTOR",
 			Usage:  "Selector used to pick nodes for querying",
 			Value:  "cache",
 		},
 		cli.StringFlag{
 			Name:   "server",
 			EnvVar: "MICRO_SERVER",
 			Usage:  "Server for go-micro; rpc",
 		},
 		cli.StringFlag{
 			Name:   "transport",
@ -163,6 +169,7 @@ var (
 	DefaultBrokers = map[string]func(...broker.Option) broker.Broker{
 		"http":   http.NewBroker,
 		"memory": memory.NewBroker,
 	}
 	DefaultClients = map[string]func(...client.Option) client.Client{
@ -171,12 +178,16 @@ var (
 	DefaultRegistries = map[string]func(...registry.Option) registry.Registry{
 		"consul": consul.NewRegistry,
 		"gossip": gossip.NewRegistry,
 		"mdns":   mdns.NewRegistry,
 		"memory": rmem.NewRegistry,
 	}
 	DefaultSelectors = map[string]func(...selector.Option) selector.Selector{
 		"default": selector.NewSelector,
-		"cache":   cache.NewSelector,
+		"dns":     dns.NewSelector,
 		"cache":   selector.NewSelector,
 		"static":  static.NewSelector,
 	}
 	DefaultServers = map[string]func(...server.Option) server.Server{
@ -184,6 +195,7 @@ var (
 	}
 	DefaultTransports = map[string]func(...transport.Option) transport.Transport{
 		"memory": tmem.NewTransport,
 		"http":   thttp.NewTransport,
 	}
@ -191,8 +203,8 @@ var (
 	defaultClient    = "rpc"
 	defaultServer    = "rpc"
 	defaultBroker    = "http"
-	defaultRegistry  = "consul"
+	defaultRegistry  = "mdns"
-	defaultSelector  = "cache"
+	defaultSelector  = "registry"
 	defaultTransport = "http"
 )
@ -299,10 +311,15 @@ func (c *cmd) Before(ctx *cli.Context) error {
 		serverOpts = append(serverOpts, server.Registry(*c.opts.Registry))
 		clientOpts = append(clientOpts, client.Registry(*c.opts.Registry))
-		(*c.opts.Selector).Init(selector.Registry(*c.opts.Registry))
+		if err := (*c.opts.Selector).Init(selector.Registry(*c.opts.Registry)); err != nil {
 			log.Fatalf("Error configuring registry: %v", err)
 		}
 		clientOpts = append(clientOpts, client.Selector(*c.opts.Selector))
-		(*c.opts.Broker).Init(broker.Registry(*c.opts.Registry))
+		if err := (*c.opts.Broker).Init(broker.Registry(*c.opts.Registry)); err != nil {
 			log.Fatalf("Error configuring broker: %v", err)
 		}
 	}
 	// Set the selector
@ -347,15 +364,21 @@ func (c *cmd) Before(ctx *cli.Context) error {
 	}
 	if len(ctx.String("broker_address")) > 0 {
-		(*c.opts.Broker).Init(broker.Addrs(strings.Split(ctx.String("broker_address"), ",")...))
+		if err := (*c.opts.Broker).Init(broker.Addrs(strings.Split(ctx.String("broker_address"), ",")...)); err != nil {
 			log.Fatalf("Error configuring broker: %v", err)
 		}
 	}
 	if len(ctx.String("registry_address")) > 0 {
-		(*c.opts.Registry).Init(registry.Addrs(strings.Split(ctx.String("registry_address"), ",")...))
+		if err := (*c.opts.Registry).Init(registry.Addrs(strings.Split(ctx.String("registry_address"), ",")...)); err != nil {
 			log.Fatalf("Error configuring registry: %v", err)
 		}
 	}
 	if len(ctx.String("transport_address")) > 0 {
-		(*c.opts.Transport).Init(transport.Addrs(strings.Split(ctx.String("transport_address"), ",")...))
+		if err := (*c.opts.Transport).Init(transport.Addrs(strings.Split(ctx.String("transport_address"), ",")...)); err != nil {
 			log.Fatalf("Error configuring transport: %v", err)
 		}
 	}
 	if len(ctx.String("server_name")) > 0 {
@ -382,6 +405,10 @@ func (c *cmd) Before(ctx *cli.Context) error {
 		serverOpts = append(serverOpts, server.RegisterTTL(ttl*time.Second))
 	}
 	if val := time.Duration(ctx.GlobalInt("register_interval")); val > 0 {
 		serverOpts = append(serverOpts, server.RegisterInterval(val*time.Second))
 	}
 	// client opts
 	if r := ctx.Int("client_retries"); r >= 0 {
 		clientOpts = append(clientOpts, client.Retries(r))
@ -410,12 +437,16 @@ func (c *cmd) Before(ctx *cli.Context) error {
 	// We have some command line opts for the server.
 	// Lets set it up
 	if len(serverOpts) > 0 {
-		(*c.opts.Server).Init(serverOpts...)
+		if err := (*c.opts.Server).Init(serverOpts...); err != nil {
 			log.Fatalf("Error configuring server: %v", err)
 		}
 	}
 	// Use an init option?
 	if len(clientOpts) > 0 {
-		(*c.opts.Client).Init(clientOpts...)
+		if err := (*c.opts.Client).Init(clientOpts...); err != nil {
 			log.Fatalf("Error configuring client: %v", err)
 		}
 	}
 	return nil
--- a/codec/bytes/bytes.go
+++ b/codec/bytes/bytes.go
@ -0,0 +1,75 @@
 // Package bytes provides a bytes codec which does not encode or decode anything
 package bytes
 import (
 	"fmt"
 	"io"
 	"io/ioutil"
 	"github.com/micro/go-micro/codec"
 )
 type Codec struct {
 	Conn io.ReadWriteCloser
 }
 // Frame gives us the ability to define raw data to send over the pipes
 type Frame struct {
 	Data []byte
 }
 func (c *Codec) ReadHeader(m *codec.Message, t codec.MessageType) error {
 	return nil
 }
 func (c *Codec) ReadBody(b interface{}) error {
 	// read bytes
 	buf, err := ioutil.ReadAll(c.Conn)
 	if err != nil {
 		return err
 	}
 	switch b.(type) {
 	case *[]byte:
 		v := b.(*[]byte)
 		*v = buf
 	case *Frame:
 		v := b.(*Frame)
 		v.Data = buf
 	default:
 		return fmt.Errorf("failed to read body: %v is not type of *[]byte", b)
 	}
 	return nil
 }
 func (c *Codec) Write(m *codec.Message, b interface{}) error {
 	var v []byte
 	switch b.(type) {
 	case *Frame:
 		v = b.(*Frame).Data
 	case *[]byte:
 		ve := b.(*[]byte)
 		v = *ve
 	case []byte:
 		v = b.([]byte)
 	default:
 		return fmt.Errorf("failed to write: %v is not type of *[]byte or []byte", b)
 	}
 	_, err := c.Conn.Write(v)
 	return err
 }
 func (c *Codec) Close() error {
 	return c.Conn.Close()
 }
 func (c *Codec) String() string {
 	return "bytes"
 }
 func NewCodec(c io.ReadWriteCloser) codec.Codec {
 	return &Codec{
 		Conn: c,
 	}
 }
--- a/codec/bytes/marshaler.go
+++ b/codec/bytes/marshaler.go
@ -0,0 +1,41 @@
 package bytes
 import (
 	"errors"
 )
 type Marshaler struct{}
 type Message struct {
 	Header map[string]string
 	Body   []byte
 }
 func (n Marshaler) Marshal(v interface{}) ([]byte, error) {
 	switch v.(type) {
 	case *[]byte:
 		ve := v.(*[]byte)
 		return *ve, nil
 	case []byte:
 		return v.([]byte), nil
 	case *Message:
 		return v.(*Message).Body, nil
 	}
 	return nil, errors.New("invalid message")
 }
 func (n Marshaler) Unmarshal(d []byte, v interface{}) error {
 	switch v.(type) {
 	case *[]byte:
 		ve := v.(*[]byte)
 		*ve = d
 	case *Message:
 		ve := v.(*Message)
 		ve.Body = d
 	}
 	return errors.New("invalid message")
 }
 func (n Marshaler) String() string {
 	return "bytes"
 }
--- a/codec/codec.go
+++ b/codec/codec.go
@ -23,10 +23,26 @@ type NewCodec func(io.ReadWriteCloser) Codec
 // connection. ReadBody may be called with a nil argument to force the
 // body to be read and discarded.
 type Codec interface {
 	Reader
 	Writer
 	Close() error
 	String() string
 }
 type Reader interface {
 	ReadHeader(*Message, MessageType) error
 	ReadBody(interface{}) error
 }
 type Writer interface {
 	Write(*Message, interface{}) error
-	Close() error
+}
 // Marshaler is a simple encoding interface used for the broker/transport
 // where headers are not supported by the underlying implementation.
 type Marshaler interface {
 	Marshal(interface{}) ([]byte, error)
 	Unmarshal([]byte, interface{}) error
 	String() string
 }
@ -34,10 +50,14 @@ type Codec interface {
 // the communication, likely followed by the body.
 // In the case of an error, body may be nil.
 type Message struct {
-	Id     uint64
+	Id       string
 	Type     MessageType
 	Target   string
 	Method   string
 	Endpoint string
 	Error    string
 	// The values read from the socket
 	Header map[string]string
 	Body   []byte
 }
--- a/codec/grpc/grpc.go
+++ b/codec/grpc/grpc.go
@ -0,0 +1,132 @@
 // Package grpc provides a grpc codec
 package grpc
 import (
 	"encoding/json"
 	"errors"
 	"fmt"
 	"io"
 	"strings"
 	"github.com/golang/protobuf/proto"
 	"github.com/micro/go-micro/codec"
 )
 type Codec struct {
 	Conn        io.ReadWriteCloser
 	ContentType string
 }
 func (c *Codec) ReadHeader(m *codec.Message, t codec.MessageType) error {
 	if ct := m.Header["Content-Type"]; len(ct) > 0 {
 		c.ContentType = ct
 	}
 	if ct := m.Header["content-type"]; len(ct) > 0 {
 		c.ContentType = ct
 	}
 	// service method
 	path := m.Header[":path"]
 	if len(path) == 0 || path[0] != '/' {
 		m.Target = m.Header["Micro-Service"]
 		m.Endpoint = m.Header["Micro-Endpoint"]
 	} else {
 		// [ , a.package.Foo, Bar]
 		parts := strings.Split(path, "/")
 		if len(parts) != 3 {
 			return errors.New("Unknown request path")
 		}
 		service := strings.Split(parts[1], ".")
 		m.Endpoint = strings.Join([]string{service[len(service)-1], parts[2]}, ".")
 		m.Target = strings.Join(service[:len(service)-1], ".")
 	}
 	return nil
 }
 func (c *Codec) ReadBody(b interface{}) error {
 	// no body
 	if b == nil {
 		return nil
 	}
 	_, buf, err := decode(c.Conn)
 	if err != nil {
 		return err
 	}
 	switch c.ContentType {
 	case "application/grpc+json":
 		return json.Unmarshal(buf, b)
 	case "application/grpc+proto", "application/grpc":
 		return proto.Unmarshal(buf, b.(proto.Message))
 	}
 	return errors.New("Unsupported Content-Type")
 }
 func (c *Codec) Write(m *codec.Message, b interface{}) error {
 	var buf []byte
 	var err error
 	if ct := m.Header["Content-Type"]; len(ct) > 0 {
 		c.ContentType = ct
 	}
 	if ct := m.Header["content-type"]; len(ct) > 0 {
 		c.ContentType = ct
 	}
 	switch m.Type {
 	case codec.Request:
 		parts := strings.Split(m.Endpoint, ".")
 		m.Header[":method"] = "POST"
 		m.Header[":path"] = fmt.Sprintf("/%s.%s/%s", m.Target, parts[0], parts[1])
 		m.Header[":proto"] = "HTTP/2.0"
 		m.Header["te"] = "trailers"
 		m.Header["user-agent"] = "grpc-go/1.0.0"
 		m.Header[":authority"] = m.Target
 		m.Header["content-type"] = c.ContentType
 	case codec.Response:
 		m.Header["Trailer"] = "grpc-status, grpc-message"
 		m.Header["grpc-status"] = "0"
 		m.Header["grpc-message"] = ""
 	}
 	// marshal content
 	switch c.ContentType {
 	case "application/grpc+json":
 		buf, err = json.Marshal(b)
 	case "application/grpc+proto", "application/grpc":
 		pb, ok := b.(proto.Message)
 		if ok {
 			buf, err = proto.Marshal(pb)
 		}
 	default:
 		err = errors.New("Unsupported Content-Type")
 	}
 	// check error
 	if err != nil {
 		m.Header["grpc-status"] = "8"
 		m.Header["grpc-message"] = err.Error()
 		return err
 	}
 	return encode(0, buf, c.Conn)
 }
 func (c *Codec) Close() error {
 	return c.Conn.Close()
 }
 func (c *Codec) String() string {
 	return "grpc"
 }
 func NewCodec(c io.ReadWriteCloser) codec.Codec {
 	return &Codec{
 		Conn:        c,
 		ContentType: "application/grpc",
 	}
 }
--- a/codec/grpc/util.go
+++ b/codec/grpc/util.go
@ -0,0 +1,70 @@
 package grpc
 import (
 	"encoding/binary"
 	"fmt"
 	"io"
 )
 var (
 	maxMessageSize = 1024 * 1024 * 4
 	maxInt         = int(^uint(0) >> 1)
 )
 func decode(r io.Reader) (uint8, []byte, error) {
 	header := make([]byte, 5)
 	// read the header
 	if _, err := r.Read(header[:]); err != nil {
 		return uint8(0), nil, err
 	}
 	// get encoding format e.g compressed
 	cf := uint8(header[0])
 	// get message length
 	length := binary.BigEndian.Uint32(header[1:])
 	// no encoding format
 	if length == 0 {
 		return cf, nil, nil
 	}
 	//
 	if int64(length) > int64(maxInt) {
 		return cf, nil, fmt.Errorf("grpc: received message larger than max length allowed on current machine (%d vs. %d)", length, maxInt)
 	}
 	if int(length) > maxMessageSize {
 		return cf, nil, fmt.Errorf("grpc: received message larger than max (%d vs. %d)", length, maxMessageSize)
 	}
 	msg := make([]byte, int(length))
 	if _, err := r.Read(msg); err != nil {
 		if err == io.EOF {
 			err = io.ErrUnexpectedEOF
 		}
 		return cf, nil, err
 	}
 	return cf, msg, nil
 }
 func encode(cf uint8, buf []byte, w io.Writer) error {
 	header := make([]byte, 5)
 	// set compression
 	header[0] = byte(cf)
 	// write length as header
 	binary.BigEndian.PutUint32(header[1:], uint32(len(buf)))
 	// read the header
 	if _, err := w.Write(header[:]); err != nil {
 		return err
 	}
 	// write the buffer
 	_, err := w.Write(buf)
 	return err
 }
--- a/codec/json/json.go
+++ b/codec/json/json.go
@ -0,0 +1,49 @@
 // Package json provides a json codec
 package json
 import (
 	"encoding/json"
 	"io"
 	"github.com/micro/go-micro/codec"
 )
 type Codec struct {
 	Conn    io.ReadWriteCloser
 	Encoder *json.Encoder
 	Decoder *json.Decoder
 }
 func (c *Codec) ReadHeader(m *codec.Message, t codec.MessageType) error {
 	return nil
 }
 func (c *Codec) ReadBody(b interface{}) error {
 	if b == nil {
 		return nil
 	}
 	return c.Decoder.Decode(b)
 }
 func (c *Codec) Write(m *codec.Message, b interface{}) error {
 	if b == nil {
 		return nil
 	}
 	return c.Encoder.Encode(b)
 }
 func (c *Codec) Close() error {
 	return c.Conn.Close()
 }
 func (c *Codec) String() string {
 	return "json"
 }
 func NewCodec(c io.ReadWriteCloser) codec.Codec {
 	return &Codec{
 		Conn:    c,
 		Decoder: json.NewDecoder(c),
 		Encoder: json.NewEncoder(c),
 	}
 }
--- a/codec/json/marshaler.go
+++ b/codec/json/marshaler.go
@ -0,0 +1,19 @@
 package json
 import (
 	"encoding/json"
 )
 type Marshaler struct{}
 func (j Marshaler) Marshal(v interface{}) ([]byte, error) {
 	return json.Marshal(v)
 }
 func (j Marshaler) Unmarshal(d []byte, v interface{}) error {
 	return json.Unmarshal(d, v)
 }
 func (j Marshaler) String() string {
 	return "json"
 }
--- a/codec/jsonrpc/client.go
+++ b/codec/jsonrpc/client.go
@ -19,17 +19,17 @@ type clientCodec struct {
 	resp clientResponse
 	sync.Mutex
-	pending map[uint64]string
+	pending map[interface{}]string
 }
 type clientRequest struct {
 	Method string         `json:"method"`
 	Params [1]interface{} `json:"params"`
-	ID     uint64         `json:"id"`
+	ID     interface{}    `json:"id"`
 }
 type clientResponse struct {
-	ID     uint64           `json:"id"`
+	ID     interface{}      `json:"id"`
 	Result *json.RawMessage `json:"result"`
 	Error  interface{}      `json:"error"`
 }
@ -39,7 +39,7 @@ func newClientCodec(conn io.ReadWriteCloser) *clientCodec {
 		dec:     json.NewDecoder(conn),
 		enc:     json.NewEncoder(conn),
 		c:       conn,
-		pending: make(map[uint64]string),
+		pending: make(map[interface{}]string),
 	}
 }
@ -71,7 +71,7 @@ func (c *clientCodec) ReadHeader(m *codec.Message) error {
 	c.Unlock()
 	m.Error = ""
-	m.Id = c.resp.ID
+	m.Id = fmt.Sprintf("%v", c.resp.ID)
 	if c.resp.Error != nil {
 		x, ok := c.resp.Error.(string)
 		if !ok {
--- a/codec/jsonrpc/jsonrpc.go
+++ b/codec/jsonrpc/jsonrpc.go
@ -1,3 +1,4 @@
 // Package jsonrpc provides a json-rpc 1.0 codec
 package jsonrpc
 import (
@ -30,7 +31,7 @@ func (j *jsonCodec) Write(m *codec.Message, b interface{}) error {
 	switch m.Type {
 	case codec.Request:
 		return j.c.Write(m, b)
-	case codec.Response:
+	case codec.Response, codec.Error:
 		return j.s.Write(m, b)
 	case codec.Publication:
 		data, err := json.Marshal(b)
@ -54,7 +55,8 @@ func (j *jsonCodec) ReadHeader(m *codec.Message, mt codec.MessageType) error {
 	case codec.Response:
 		return j.c.ReadHeader(m)
 	case codec.Publication:
-		io.Copy(j.buf, j.rwc)
+		_, err := io.Copy(j.buf, j.rwc)
 		return err
 	default:
 		return fmt.Errorf("Unrecognised message type: %v", mt)
 	}
--- a/codec/jsonrpc/server.go
+++ b/codec/jsonrpc/server.go
@ -2,9 +2,8 @@ package jsonrpc
 import (
 	"encoding/json"
-	"errors"
+	"fmt"
 	"io"
 	"sync"
 	"github.com/micro/go-micro/codec"
 )
@ -17,20 +16,16 @@ type serverCodec struct {
 	// temporary work space
 	req  serverRequest
 	resp serverResponse
 	sync.Mutex
 	seq     uint64
 	pending map[uint64]*json.RawMessage
 }
 type serverRequest struct {
 	Method string           `json:"method"`
 	Params *json.RawMessage `json:"params"`
-	ID     *json.RawMessage `json:"id"`
+	ID     interface{}      `json:"id"`
 }
 type serverResponse struct {
-	ID     *json.RawMessage `json:"id"`
+	ID     interface{} `json:"id"`
 	Result interface{} `json:"result"`
 	Error  interface{} `json:"error"`
 }
@ -40,7 +35,6 @@ func newServerCodec(conn io.ReadWriteCloser) *serverCodec {
 		dec: json.NewDecoder(conn),
 		enc: json.NewEncoder(conn),
 		c:   conn,
 		pending: make(map[uint64]*json.RawMessage),
 	}
 }
@ -50,7 +44,7 @@ func (r *serverRequest) reset() {
 		*r.Params = (*r.Params)[0:0]
 	}
 	if r.ID != nil {
-		*r.ID = (*r.ID)[0:0]
+		r.ID = nil
 	}
 }
@ -60,14 +54,8 @@ func (c *serverCodec) ReadHeader(m *codec.Message) error {
 		return err
 	}
 	m.Method = c.req.Method
-
+	m.Id = fmt.Sprintf("%v", c.req.ID)
 	c.Lock()
 	c.seq++
 	c.pending[c.seq] = c.req.ID
 	c.req.ID = nil
 	m.Id = c.seq
 	c.Unlock()
 	return nil
 }
@ -84,19 +72,7 @@ var null = json.RawMessage([]byte("null"))
 func (c *serverCodec) Write(m *codec.Message, x interface{}) error {
 	var resp serverResponse
-	c.Lock()
+	resp.ID = m.Id
 	b, ok := c.pending[m.Id]
 	if !ok {
 		c.Unlock()
 		return errors.New("invalid sequence number in response")
 	}
 	c.Unlock()
 	if b == nil {
 		// Invalid request so no id.  Use JSON null.
 		b = &null
 	}
 	resp.ID = b
 	resp.Result = x
 	if m.Error == "" {
 		resp.Error = nil
--- a/codec/proto/marshaler.go
+++ b/codec/proto/marshaler.go
@ -0,0 +1,19 @@
 package proto
 import (
 	"github.com/golang/protobuf/proto"
 )
 type Marshaler struct{}
 func (Marshaler) Marshal(v interface{}) ([]byte, error) {
 	return proto.Marshal(v.(proto.Message))
 }
 func (Marshaler) Unmarshal(data []byte, v interface{}) error {
 	return proto.Unmarshal(data, v.(proto.Message))
 }
 func (Marshaler) Name() string {
 	return "proto"
 }
--- a/codec/proto/proto.go
+++ b/codec/proto/proto.go
@ -0,0 +1,56 @@
 // Package proto provides a proto codec
 package proto
 import (
 	"io"
 	"io/ioutil"
 	"github.com/golang/protobuf/proto"
 	"github.com/micro/go-micro/codec"
 )
 type Codec struct {
 	Conn io.ReadWriteCloser
 }
 func (c *Codec) ReadHeader(m *codec.Message, t codec.MessageType) error {
 	return nil
 }
 func (c *Codec) ReadBody(b interface{}) error {
 	if b == nil {
 		return nil
 	}
 	buf, err := ioutil.ReadAll(c.Conn)
 	if err != nil {
 		return err
 	}
 	return proto.Unmarshal(buf, b.(proto.Message))
 }
 func (c *Codec) Write(m *codec.Message, b interface{}) error {
 	p, ok := b.(proto.Message)
 	if !ok {
 		return nil
 	}
 	buf, err := proto.Marshal(p)
 	if err != nil {
 		return err
 	}
 	_, err = c.Conn.Write(buf)
 	return err
 }
 func (c *Codec) Close() error {
 	return c.Conn.Close()
 }
 func (c *Codec) String() string {
 	return "proto"
 }
 func NewCodec(c io.ReadWriteCloser) codec.Codec {
 	return &Codec{
 		Conn: c,
 	}
 }
--- a/codec/protorpc/protorpc.go
+++ b/codec/protorpc/protorpc.go
@ -1,9 +1,11 @@
 // Protorpc provides a net/rpc proto-rpc codec. See envelope.proto for the format.
 package protorpc
 import (
 	"bytes"
 	"fmt"
 	"io"
 	"strconv"
 	"sync"
 	"github.com/golang/protobuf/proto"
@ -30,13 +32,22 @@ func (c *protoCodec) String() string {
 	return "proto-rpc"
 }
 func id(id string) *uint64 {
 	p, err := strconv.ParseInt(id, 10, 64)
 	if err != nil {
 		p = 0
 	}
 	i := uint64(p)
 	return &i
 }
 func (c *protoCodec) Write(m *codec.Message, b interface{}) error {
 	switch m.Type {
 	case codec.Request:
 		c.Lock()
 		defer c.Unlock()
 		// This is protobuf, of course we copy it.
-		pbr := &Request{ServiceMethod: &m.Method, Seq: &m.Id}
+		pbr := &Request{ServiceMethod: &m.Method, Seq: id(m.Id)}
 		data, err := proto.Marshal(pbr)
 		if err != nil {
 			return err
@ -55,12 +66,14 @@ func (c *protoCodec) Write(m *codec.Message, b interface{}) error {
 			return err
 		}
 		if flusher, ok := c.rwc.(flusher); ok {
-			err = flusher.Flush()
+			if err = flusher.Flush(); err != nil {
 				return err
 			}
-	case codec.Response:
+		}
 	case codec.Response, codec.Error:
 		c.Lock()
 		defer c.Unlock()
-		rtmp := &Response{ServiceMethod: &m.Method, Seq: &m.Id, Error: &m.Error}
+		rtmp := &Response{ServiceMethod: &m.Method, Seq: id(m.Id), Error: &m.Error}
 		data, err := proto.Marshal(rtmp)
 		if err != nil {
 			return err
@ -82,7 +95,9 @@ func (c *protoCodec) Write(m *codec.Message, b interface{}) error {
 			return err
 		}
 		if flusher, ok := c.rwc.(flusher); ok {
-			err = flusher.Flush()
+			if err = flusher.Flush(); err != nil {
 				return err
 			}
 		}
 	case codec.Publication:
 		data, err := proto.Marshal(b.(proto.Message))
@ -112,7 +127,7 @@ func (c *protoCodec) ReadHeader(m *codec.Message, mt codec.MessageType) error {
 			return err
 		}
 		m.Method = rtmp.GetServiceMethod()
-		m.Id = rtmp.GetSeq()
+		m.Id = fmt.Sprintf("%d", rtmp.GetSeq())
 	case codec.Response:
 		data, err := ReadNetString(c.rwc)
 		if err != nil {
@ -124,10 +139,11 @@ func (c *protoCodec) ReadHeader(m *codec.Message, mt codec.MessageType) error {
 			return err
 		}
 		m.Method = rtmp.GetServiceMethod()
-		m.Id = rtmp.GetSeq()
+		m.Id = fmt.Sprintf("%d", rtmp.GetSeq())
 		m.Error = rtmp.GetError()
 	case codec.Publication:
-		io.Copy(c.buf, c.rwc)
+		_, err := io.Copy(c.buf, c.rwc)
 		return err
 	default:
 		return fmt.Errorf("Unrecognised message type: %v", mt)
 	}
--- a/errors/errors.go
+++ b/errors/errors.go
@ -82,13 +82,23 @@ func NotFound(id, format string, a ...interface{}) error {
 	}
 }
-// InternalServerError generates a 500 error.
+// MethodNotAllowed generates a 405 error.
-func InternalServerError(id, format string, a ...interface{}) error {
+func MethodNotAllowed(id, format string, a ...interface{}) error {
 	return &Error{
 		Id:     id,
-		Code:   500,
+		Code:   405,
 		Detail: fmt.Sprintf(format, a...),
-		Status: http.StatusText(500),
+		Status: http.StatusText(405),
 	}
 }
 // Timeout generates a 408 error.
 func Timeout(id, format string, a ...interface{}) error {
 	return &Error{
 		Id:     id,
 		Code:   408,
 		Detail: fmt.Sprintf(format, a...),
 		Status: http.StatusText(408),
 	}
 }
@ -101,3 +111,13 @@ func Conflict(id, format string, a ...interface{}) error {
 		Status: http.StatusText(409),
 	}
 }
 // InternalServerError generates a 500 error.
 func InternalServerError(id, format string, a ...interface{}) error {
 	return &Error{
 		Id:     id,
 		Code:   500,
 		Detail: fmt.Sprintf(format, a...),
 		Status: http.StatusText(500),
 	}
 }
--- a/function_test.go
+++ b/function_test.go
@ -5,7 +5,7 @@ import (
 	"sync"
 	"testing"
-	"github.com/micro/go-micro/registry/mock"
+	"github.com/micro/go-micro/registry/memory"
 	proto "github.com/micro/go-micro/server/debug/proto"
 )
@ -13,9 +13,12 @@ func TestFunction(t *testing.T) {
 	var wg sync.WaitGroup
 	wg.Add(1)
 	r := memory.NewRegistry()
 	r.(*memory.Registry).Setup()
 	// create service
 	fn := NewFunction(
-		Registry(mock.NewRegistry()),
+		Registry(r),
 		Name("test.function"),
 		AfterStart(func() error {
 			wg.Done()
--- a/go.mod
+++ b/go.mod
@ -0,0 +1,176 @@
 module github.com/micro/go-micro
 require (
 	cloud.google.com/go v0.39.0 // indirect
 	contrib.go.opencensus.io/exporter/ocagent v0.5.0 // indirect
 	github.com/Azure/azure-sdk-for-go v29.0.0+incompatible // indirect
 	github.com/Azure/go-autorest v12.1.0+incompatible // indirect
 	github.com/DataDog/dd-trace-go v1.14.0 // indirect
 	github.com/DataDog/zstd v1.4.0 // indirect
 	github.com/Jeffail/gabs v1.4.0 // indirect
 	github.com/Microsoft/go-winio v0.4.12 // indirect
 	github.com/NYTimes/gziphandler v1.1.1 // indirect
 	github.com/OneOfOne/xxhash v1.2.5 // indirect
 	github.com/PuerkitoBio/purell v1.1.1 // indirect
 	github.com/SAP/go-hdb v0.14.1 // indirect
 	github.com/Shopify/sarama v1.22.1 // indirect
 	github.com/StackExchange/wmi v0.0.0-20181212234831-e0a55b97c705 // indirect
 	github.com/aliyun/alibaba-cloud-sdk-go v0.0.0-20190522081930-582d16a078d0 // indirect
 	github.com/aliyun/aliyun-oss-go-sdk v1.9.6 // indirect
 	github.com/araddon/gou v0.0.0-20190110011759-c797efecbb61 // indirect
 	github.com/armon/go-metrics v0.0.0-20190430140413-ec5e00d3c878 // indirect
 	github.com/asaskevich/govalidator v0.0.0-20190424111038-f61b66f89f4a // indirect
 	github.com/aws/aws-sdk-go v1.19.35 // indirect
 	github.com/boombuler/barcode v1.0.0 // indirect
 	github.com/chrismalek/oktasdk-go v0.0.0-20181212195951-3430665dfaa0 // indirect
 	github.com/containerd/continuity v0.0.0-20190426062206-aaeac12a7ffc // indirect
 	github.com/coredns/coredns v1.5.0 // indirect
 	github.com/coreos/etcd v3.3.13+incompatible // indirect
 	github.com/coreos/go-semver v0.3.0 // indirect
 	github.com/coreos/go-systemd v0.0.0-20190321100706-95778dfbb74e // indirect
 	github.com/dancannon/gorethink v4.0.0+incompatible // indirect
 	github.com/denisenkom/go-mssqldb v0.0.0-20190515213511-eb9f6a1743f3 // indirect
 	github.com/denverdino/aliyungo v0.0.0-20190410085603-611ead8a6fed // indirect
 	github.com/dgryski/go-sip13 v0.0.0-20190329191031-25c5027a8c7b // indirect
 	github.com/digitalocean/godo v1.15.0 // indirect
 	github.com/dnaeon/go-vcr v1.0.1 // indirect
 	github.com/dnstap/golang-dnstap v0.0.0-20190521061535-1a0dab85b926 // indirect
 	github.com/docker/go-connections v0.4.0 // indirect
 	github.com/docker/go-units v0.4.0 // indirect
 	github.com/docker/spdystream v0.0.0-20181023171402-6480d4af844c // indirect
 	github.com/elazarl/go-bindata-assetfs v1.0.0 // indirect
 	github.com/elazarl/goproxy v0.0.0-20190421051319-9d40249d3c2f // indirect
 	github.com/emicklei/go-restful v2.9.5+incompatible // indirect
 	github.com/envoyproxy/go-control-plane v0.8.0 // indirect
 	github.com/evanphx/json-patch v4.2.0+incompatible // indirect
 	github.com/farsightsec/golang-framestream v0.0.0-20190425193708-fa4b164d59b8 // indirect
 	github.com/fullsailor/pkcs7 v0.0.0-20190404230743-d7302db945fa // indirect
 	github.com/gammazero/workerpool v0.0.0-20190521015540-3b91a70bc0a1 // indirect
 	github.com/garyburd/redigo v1.6.0 // indirect
 	github.com/go-ldap/ldap v3.0.3+incompatible // indirect
 	github.com/go-log/log v0.1.0
 	github.com/go-ole/go-ole v1.2.4 // indirect
 	github.com/go-openapi/jsonpointer v0.19.0 // indirect
 	github.com/go-openapi/jsonreference v0.19.0 // indirect
 	github.com/go-openapi/spec v0.19.0 // indirect
 	github.com/go-openapi/swag v0.19.0 // indirect
 	github.com/go-sql-driver/mysql v1.4.1 // indirect
 	github.com/go-stomp/stomp v2.0.3+incompatible // indirect
 	github.com/gocql/gocql v0.0.0-20190423091413-b99afaf3b163 // indirect
 	github.com/gogo/googleapis v1.2.0 // indirect
 	github.com/golang/mock v1.3.1 // indirect
 	github.com/golang/protobuf v1.3.1
 	github.com/google/btree v1.0.0 // indirect
 	github.com/google/gofuzz v1.0.0 // indirect
 	github.com/google/pprof v0.0.0-20190515194954-54271f7e092f // indirect
 	github.com/google/uuid v1.1.1
 	github.com/gophercloud/gophercloud v0.0.0-20190520235722-e87e5f90e7e6 // indirect
 	github.com/gopherjs/gopherjs v0.0.0-20190430165422-3e4dfb77656c // indirect
 	github.com/gorilla/mux v1.7.2 // indirect
 	github.com/grpc-ecosystem/grpc-gateway v1.9.0 // indirect
 	github.com/hashicorp/consul v1.5.0
 	github.com/hashicorp/consul/api v1.1.0
 	github.com/hashicorp/go-checkpoint v0.5.0 // indirect
 	github.com/hashicorp/go-discover v0.0.0-20190522154730-8aba54d36e17 // indirect
 	github.com/hashicorp/go-hclog v0.9.2 // indirect
 	github.com/hashicorp/go-memdb v1.0.2 // indirect
 	github.com/hashicorp/go-msgpack v0.5.5 // indirect
 	github.com/hashicorp/go-version v1.2.0 // indirect
 	github.com/hashicorp/hil v0.0.0-20190212132231-97b3a9cdfa93 // indirect
 	github.com/hashicorp/memberlist v0.1.4
 	github.com/hashicorp/nomad/api v0.0.0-20190522160243-df84e07c1a46 // indirect
 	github.com/hashicorp/raft v1.0.1 // indirect
 	github.com/hashicorp/raft-boltdb v0.0.0-20171010151810-6e5ba93211ea // indirect
 	github.com/hashicorp/serf v0.8.3 // indirect
 	github.com/hashicorp/vault v1.1.2 // indirect
 	github.com/hashicorp/vault-plugin-auth-alicloud v0.5.1 // indirect
 	github.com/hashicorp/vault-plugin-auth-azure v0.5.1 // indirect
 	github.com/hashicorp/vault-plugin-auth-centrify v0.5.1 // indirect
 	github.com/hashicorp/vault-plugin-auth-jwt v0.5.1 // indirect
 	github.com/hashicorp/vault-plugin-auth-kubernetes v0.5.1 // indirect
 	github.com/hashicorp/vault-plugin-secrets-ad v0.5.1 // indirect
 	github.com/hashicorp/vault-plugin-secrets-alicloud v0.5.1 // indirect
 	github.com/hashicorp/vault-plugin-secrets-azure v0.5.1 // indirect
 	github.com/hashicorp/vault-plugin-secrets-gcp v0.5.2 // indirect
 	github.com/hashicorp/vault-plugin-secrets-gcpkms v0.5.1 // indirect
 	github.com/hashicorp/vault-plugin-secrets-kv v0.5.1 // indirect
 	github.com/hashicorp/vault/api v1.0.2 // indirect
 	github.com/hashicorp/vault/sdk v0.1.11 // indirect
 	github.com/influxdata/influxdb v1.7.6 // indirect
 	github.com/jarcoal/httpmock v1.0.4 // indirect
 	github.com/jefferai/jsonx v1.0.0 // indirect
 	github.com/joyent/triton-go v0.0.0-20190112182421-51ffac552869 // indirect
 	github.com/keybase/go-crypto v0.0.0-20190416182011-b785b22cc757 // indirect
 	github.com/kisielk/errcheck v1.2.0 // indirect
 	github.com/klauspost/cpuid v1.2.1 // indirect
 	github.com/konsorten/go-windows-terminal-sequences v1.0.2 // indirect
 	github.com/kr/pty v1.1.4 // indirect
 	github.com/kylelemons/godebug v1.1.0 // indirect
 	github.com/lib/pq v1.1.1 // indirect
 	github.com/linode/linodego v0.8.1 // indirect
 	github.com/lucas-clemente/quic-go v0.11.1 // indirect
 	github.com/lyft/protoc-gen-validate v0.0.14 // indirect
 	github.com/mailru/easyjson v0.0.0-20190403194419-1ea4449da983 // indirect
 	github.com/mattbaird/elastigo v0.0.0-20170123220020-2fe47fd29e4b // indirect
 	github.com/mattn/go-isatty v0.0.8 // indirect
 	github.com/mholt/caddy v1.0.0 // indirect
 	github.com/mholt/certmagic v0.5.1 // indirect
 	github.com/michaelklishin/rabbit-hole v1.5.0 // indirect
 	github.com/micro/cli v0.1.0
 	github.com/micro/go-log v0.1.0
 	github.com/micro/go-rcache v0.3.0
 	github.com/micro/mdns v0.1.0
 	github.com/micro/util v0.2.0
 	github.com/miekg/dns v1.1.12 // indirect
 	github.com/mitchellh/hashstructure v1.0.0
 	github.com/mitchellh/pointerstructure v0.0.0-20190430161007-f252a8fd71c8 // indirect
 	github.com/munnerz/goautoneg v0.0.0-20190414153302-2ae31c8b6b30 // indirect
 	github.com/opentracing/opentracing-go v1.1.0 // indirect
 	github.com/openzipkin/zipkin-go-opentracing v0.3.5 // indirect
 	github.com/ory-am/common v0.4.0 // indirect
 	github.com/pborman/uuid v1.2.0 // indirect
 	github.com/pkg/errors v0.8.1
 	github.com/pquerna/otp v1.1.0 // indirect
 	github.com/prometheus/client_golang v0.9.3 // indirect
 	github.com/prometheus/common v0.4.1 // indirect
 	github.com/prometheus/procfs v0.0.0-20190522114515-bc1a522cf7b1 // indirect
 	github.com/prometheus/tsdb v0.8.0 // indirect
 	github.com/rogpeppe/fastuuid v1.1.0 // indirect
 	github.com/russross/blackfriday v2.0.0+incompatible // indirect
 	github.com/samuel/go-zookeeper v0.0.0-20180130194729-c4fab1ac1bec // indirect
 	github.com/shirou/gopsutil v2.18.12+incompatible // indirect
 	github.com/sirupsen/logrus v1.4.2 // indirect
 	github.com/smartystreets/assertions v0.0.0-20190401211740-f487f9de1cd3 // indirect
 	github.com/softlayer/softlayer-go v0.0.0-20190508182157-7c592eb2559c // indirect
 	github.com/spaolacci/murmur3 v1.1.0 // indirect
 	github.com/streadway/amqp v0.0.0-20190404075320-75d898a42a94 // indirect
 	github.com/stretchr/objx v0.2.0 // indirect
 	github.com/ugorji/go v1.1.4 // indirect
 	github.com/vmware/govmomi v0.20.1 // indirect
 	go.uber.org/atomic v1.4.0 // indirect
 	go.uber.org/zap v1.10.0 // indirect
 	golang.org/x/crypto v0.0.0-20190513172903-22d7a77e9e5f // indirect
 	golang.org/x/exp v0.0.0-20190510132918-efd6b22b2522 // indirect
 	golang.org/x/image v0.0.0-20190516052701-61b8692d9a5c // indirect
 	golang.org/x/lint v0.0.0-20190409202823-959b441ac422 // indirect
 	golang.org/x/mobile v0.0.0-20190509164839-32b2708ab171 // indirect
 	golang.org/x/net v0.0.0-20190522155817-f3200d17e092
 	golang.org/x/oauth2 v0.0.0-20190517181255-950ef44c6e07 // indirect
 	golang.org/x/sys v0.0.0-20190522044717-8097e1b27ff5 // indirect
 	golang.org/x/tools v0.0.0-20190521203540-521d6ed310dd // indirect
 	google.golang.org/appengine v1.6.0 // indirect
 	google.golang.org/genproto v0.0.0-20190516172635-bb713bdc0e52 // indirect
 	gopkg.in/gorethink/gorethink.v4 v4.1.0 // indirect
 	gopkg.in/mgo.v2 v2.0.0-20180705113604-9856a29383ce // indirect
 	gopkg.in/ory-am/dockertest.v2 v2.2.3 // indirect
 	honnef.co/go/tools v0.0.0-20190522022531-bad1bd262ba8 // indirect
 	k8s.io/api v0.0.0-20190515023547-db5a9d1c40eb // indirect
 	k8s.io/client-go v11.0.0+incompatible // indirect
 	k8s.io/gengo v0.0.0-20190327210449-e17681d19d3a // indirect
 	k8s.io/kube-openapi v0.0.0-20190510232812-a01b7d5d6c22 // indirect
 	k8s.io/utils v0.0.0-20190520173318-324c5df7d3f0 // indirect
 	layeh.com/radius v0.0.0-20190322222518-890bc1058917 // indirect
 	sigs.k8s.io/structured-merge-diff v0.0.0-20190521201008-1c46bef2e9c8 // indirect
 )
 replace github.com/golang/lint => github.com/golang/lint v0.0.0-20190227174305-8f45f776aaf1
--- a/go.sum
+++ b/go.sum
--- a/metadata/metadata.go
+++ b/metadata/metadata.go
@ -12,6 +12,14 @@ type metaKey struct{}
 // from Transport headers.
 type Metadata map[string]string
 func Copy(md Metadata) Metadata {
 	cmd := make(Metadata)
 	for k, v := range md {
 		cmd[k] = v
 	}
 	return cmd
 }
 func FromContext(ctx context.Context) (Metadata, bool) {
 	md, ok := ctx.Value(metaKey{}).(Metadata)
 	return md, ok
--- a/metadata/metadata_test.go
+++ b/metadata/metadata_test.go
@ -5,6 +5,21 @@ import (
 	"testing"
 )
 func TestMetadataCopy(t *testing.T) {
 	md := Metadata{
 		"foo": "bar",
 		"bar": "baz",
 	}
 	cp := Copy(md)
 	for k, v := range md {
 		if cv := cp[k]; cv != v {
 			t.Fatalf("Got %s:%s for %s:%s", k, cv, k, v)
 		}
 	}
 }
 func TestMetadataContext(t *testing.T) {
 	md := Metadata{
 		"foo": "bar",
--- a/go-micro.go
+++ b/go-micro.go
@ -1,4 +1,4 @@
-// Package micro is a pluggable RPC framework for microservices
+// Package micro is a pluggable framework for microservices
 package micro
 import (
@ -42,7 +42,7 @@ type Publisher interface {
 type Option func(*Options)
 var (
-	HeaderPrefix = "X-Micro-"
+	HeaderPrefix = "Micro-"
 )
 // NewService creates and returns a new Service based on the packages within.
--- a/go-micro.png
+++ b/go-micro.png
--- a/options.go
+++ b/options.go
@ -22,9 +22,6 @@ type Options struct {
 	Registry  registry.Registry
 	Transport transport.Transport
 	// Register loop interval
 	RegisterInterval time.Duration
 	// Before and After funcs
 	BeforeStart []func() error
 	BeforeStop  []func() error
@ -125,6 +122,13 @@ func Transport(t transport.Transport) Option {
 // Convenience options
 // Address sets the address of the server
 func Address(addr string) Option {
 	return func(o *Options) {
 		o.Server.Init(server.Address(addr))
 	}
 }
 // Name of the service
 func Name(n string) Option {
 	return func(o *Options) {
@ -168,12 +172,13 @@ func RegisterTTL(t time.Duration) Option {
 // RegisterInterval specifies the interval on which to re-register
 func RegisterInterval(t time.Duration) Option {
 	return func(o *Options) {
-		o.RegisterInterval = t
+		o.Server.Init(server.RegisterInterval(t))
 	}
 }
 // WrapClient is a convenience method for wrapping a Client with
 // some middleware component. A list of wrappers can be provided.
 // Wrappers are applied in reverse order so the last is executed first.
 func WrapClient(w ...client.Wrapper) Option {
 	return func(o *Options) {
 		// apply in reverse
--- a/publisher.go
+++ b/publisher.go
@ -12,5 +12,5 @@ type publisher struct {
 }
 func (p *publisher) Publish(ctx context.Context, msg interface{}, opts ...client.PublishOption) error {
-	return p.c.Publish(ctx, p.c.NewMessage(p.topic, msg))
+	return p.c.Publish(ctx, p.c.NewMessage(p.topic, msg), opts...)
 }
--- a/registry/consul/consul.go
+++ b/registry/consul/consul.go
@ -1,9 +1,388 @@
 package consul
 import (
 	"crypto/tls"
 	"errors"
 	"fmt"
 	"net"
 	"net/http"
 	"runtime"
 	"sync"
 	"time"
 	consul "github.com/hashicorp/consul/api"
 	"github.com/micro/go-micro/registry"
 	hash "github.com/mitchellh/hashstructure"
 )
-func NewRegistry(opts ...registry.Option) registry.Registry {
+type consulRegistry struct {
-	return registry.NewRegistry(opts...)
+	Address string
 	Client  *consul.Client
 	opts    registry.Options
 	// connect enabled
 	connect bool
 	queryOptions *consul.QueryOptions
 	sync.Mutex
 	register map[string]uint64
 	// lastChecked tracks when a node was last checked as existing in Consul
 	lastChecked map[string]time.Time
 }
 func getDeregisterTTL(t time.Duration) time.Duration {
 	// splay slightly for the watcher?
 	splay := time.Second * 5
 	deregTTL := t + splay
 	// consul has a minimum timeout on deregistration of 1 minute.
 	if t < time.Minute {
 		deregTTL = time.Minute + splay
 	}
 	return deregTTL
 }
 func newTransport(config *tls.Config) *http.Transport {
 	if config == nil {
 		config = &tls.Config{
 			InsecureSkipVerify: true,
 		}
 	}
 	t := &http.Transport{
 		Proxy: http.ProxyFromEnvironment,
 		Dial: (&net.Dialer{
 			Timeout:   30 * time.Second,
 			KeepAlive: 30 * time.Second,
 		}).Dial,
 		TLSHandshakeTimeout: 10 * time.Second,
 		TLSClientConfig:     config,
 	}
 	runtime.SetFinalizer(&t, func(tr **http.Transport) {
 		(*tr).CloseIdleConnections()
 	})
 	return t
 }
 func configure(c *consulRegistry, opts ...registry.Option) {
 	// set opts
 	for _, o := range opts {
 		o(&c.opts)
 	}
 	// use default config
 	config := consul.DefaultConfig()
 	if c.opts.Context != nil {
 		// Use the consul config passed in the options, if available
 		if co, ok := c.opts.Context.Value("consul_config").(*consul.Config); ok {
 			config = co
 		}
 		if cn, ok := c.opts.Context.Value("consul_connect").(bool); ok {
 			c.connect = cn
 		}
 		// Use the consul query options passed in the options, if available
 		if qo, ok := c.opts.Context.Value("consul_query_options").(*consul.QueryOptions); ok && qo != nil {
 			c.queryOptions = qo
 		}
 		if as, ok := c.opts.Context.Value("consul_allow_stale").(bool); ok {
 			c.queryOptions.AllowStale = as
 		}
 	}
 	// check if there are any addrs
 	if len(c.opts.Addrs) > 0 {
 		addr, port, err := net.SplitHostPort(c.opts.Addrs[0])
 		if ae, ok := err.(*net.AddrError); ok && ae.Err == "missing port in address" {
 			port = "8500"
 			addr = c.opts.Addrs[0]
 			config.Address = fmt.Sprintf("%s:%s", addr, port)
 		} else if err == nil {
 			config.Address = fmt.Sprintf("%s:%s", addr, port)
 		}
 	}
 	if config.HttpClient == nil {
 		config.HttpClient = new(http.Client)
 	}
 	// requires secure connection?
 	if c.opts.Secure || c.opts.TLSConfig != nil {
 		config.Scheme = "https"
 		// We're going to support InsecureSkipVerify
 		config.HttpClient.Transport = newTransport(c.opts.TLSConfig)
 	}
 	// set timeout
 	if c.opts.Timeout > 0 {
 		config.HttpClient.Timeout = c.opts.Timeout
 	}
 	// create the client
 	client, _ := consul.NewClient(config)
 	// set address/client
 	c.Address = config.Address
 	c.Client = client
 }
 func (c *consulRegistry) Init(opts ...registry.Option) error {
 	configure(c, opts...)
 	return nil
 }
 func (c *consulRegistry) Deregister(s *registry.Service) error {
 	if len(s.Nodes) == 0 {
 		return errors.New("Require at least one node")
 	}
 	// delete our hash and time check of the service
 	c.Lock()
 	delete(c.register, s.Name)
 	delete(c.lastChecked, s.Name)
 	c.Unlock()
 	node := s.Nodes[0]
 	return c.Client.Agent().ServiceDeregister(node.Id)
 }
 func (c *consulRegistry) Register(s *registry.Service, opts ...registry.RegisterOption) error {
 	if len(s.Nodes) == 0 {
 		return errors.New("Require at least one node")
 	}
 	var regTCPCheck bool
 	var regInterval time.Duration
 	var options registry.RegisterOptions
 	for _, o := range opts {
 		o(&options)
 	}
 	if c.opts.Context != nil {
 		if tcpCheckInterval, ok := c.opts.Context.Value("consul_tcp_check").(time.Duration); ok {
 			regTCPCheck = true
 			regInterval = tcpCheckInterval
 		}
 	}
 	// create hash of service; uint64
 	h, err := hash.Hash(s, nil)
 	if err != nil {
 		return err
 	}
 	// use first node
 	node := s.Nodes[0]
 	// get existing hash and last checked time
 	c.Lock()
 	v, ok := c.register[s.Name]
 	lastChecked := c.lastChecked[s.Name]
 	c.Unlock()
 	// if it's already registered and matches then just pass the check
 	if ok && v == h {
 		if options.TTL == time.Duration(0) {
 			// ensure that our service hasn't been deregistered by Consul
 			if time.Since(lastChecked) <= getDeregisterTTL(regInterval) {
 				return nil
 			}
 			services, _, err := c.Client.Health().Checks(s.Name, c.queryOptions)
 			if err == nil {
 				for _, v := range services {
 					if v.ServiceID == node.Id {
 						return nil
 					}
 				}
 			}
 		} else {
 			// if the err is nil we're all good, bail out
 			// if not, we don't know what the state is, so full re-register
 			if err := c.Client.Agent().PassTTL("service:"+node.Id, ""); err == nil {
 				return nil
 			}
 		}
 	}
 	// encode the tags
 	tags := encodeMetadata(node.Metadata)
 	tags = append(tags, encodeEndpoints(s.Endpoints)...)
 	tags = append(tags, encodeVersion(s.Version)...)
 	var check *consul.AgentServiceCheck
 	if regTCPCheck {
 		deregTTL := getDeregisterTTL(regInterval)
 		check = &consul.AgentServiceCheck{
 			TCP:                            fmt.Sprintf("%s:%d", node.Address, node.Port),
 			Interval:                       fmt.Sprintf("%v", regInterval),
 			DeregisterCriticalServiceAfter: fmt.Sprintf("%v", deregTTL),
 		}
 		// if the TTL is greater than 0 create an associated check
 	} else if options.TTL > time.Duration(0) {
 		deregTTL := getDeregisterTTL(options.TTL)
 		check = &consul.AgentServiceCheck{
 			TTL:                            fmt.Sprintf("%v", options.TTL),
 			DeregisterCriticalServiceAfter: fmt.Sprintf("%v", deregTTL),
 		}
 	}
 	// register the service
 	asr := &consul.AgentServiceRegistration{
 		ID:      node.Id,
 		Name:    s.Name,
 		Tags:    tags,
 		Port:    node.Port,
 		Address: node.Address,
 		Check:   check,
 	}
 	// Specify consul connect
 	if c.connect {
 		asr.Connect = &consul.AgentServiceConnect{
 			Native: true,
 		}
 	}
 	if err := c.Client.Agent().ServiceRegister(asr); err != nil {
 		return err
 	}
 	// save our hash and time check of the service
 	c.Lock()
 	c.register[s.Name] = h
 	c.lastChecked[s.Name] = time.Now()
 	c.Unlock()
 	// if the TTL is 0 we don't mess with the checks
 	if options.TTL == time.Duration(0) {
 		return nil
 	}
 	// pass the healthcheck
 	return c.Client.Agent().PassTTL("service:"+node.Id, "")
 }
 func (c *consulRegistry) GetService(name string) ([]*registry.Service, error) {
 	var rsp []*consul.ServiceEntry
 	var err error
 	// if we're connect enabled only get connect services
 	if c.connect {
 		rsp, _, err = c.Client.Health().Connect(name, "", false, c.queryOptions)
 	} else {
 		rsp, _, err = c.Client.Health().Service(name, "", false, c.queryOptions)
 	}
 	if err != nil {
 		return nil, err
 	}
 	serviceMap := map[string]*registry.Service{}
 	for _, s := range rsp {
 		if s.Service.Service != name {
 			continue
 		}
 		// version is now a tag
 		version, _ := decodeVersion(s.Service.Tags)
 		// service ID is now the node id
 		id := s.Service.ID
 		// key is always the version
 		key := version
 		// address is service address
 		address := s.Service.Address
 		// use node address
 		if len(address) == 0 {
 			address = s.Node.Address
 		}
 		svc, ok := serviceMap[key]
 		if !ok {
 			svc = &registry.Service{
 				Endpoints: decodeEndpoints(s.Service.Tags),
 				Name:      s.Service.Service,
 				Version:   version,
 			}
 			serviceMap[key] = svc
 		}
 		var del bool
 		for _, check := range s.Checks {
 			// delete the node if the status is critical
 			if check.Status == "critical" {
 				del = true
 				break
 			}
 		}
 		// if delete then skip the node
 		if del {
 			continue
 		}
 		svc.Nodes = append(svc.Nodes, &registry.Node{
 			Id:       id,
 			Address:  address,
 			Port:     s.Service.Port,
 			Metadata: decodeMetadata(s.Service.Tags),
 		})
 	}
 	var services []*registry.Service
 	for _, service := range serviceMap {
 		services = append(services, service)
 	}
 	return services, nil
 }
 func (c *consulRegistry) ListServices() ([]*registry.Service, error) {
 	rsp, _, err := c.Client.Catalog().Services(c.queryOptions)
 	if err != nil {
 		return nil, err
 	}
 	var services []*registry.Service
 	for service := range rsp {
 		services = append(services, &registry.Service{Name: service})
 	}
 	return services, nil
 }
 func (c *consulRegistry) Watch(opts ...registry.WatchOption) (registry.Watcher, error) {
 	return newConsulWatcher(c, opts...)
 }
 func (c *consulRegistry) String() string {
 	return "consul"
 }
 func (c *consulRegistry) Options() registry.Options {
 	return c.opts
 }
 func NewRegistry(opts ...registry.Option) registry.Registry {
 	cr := &consulRegistry{
 		opts:        registry.Options{},
 		register:    make(map[string]uint64),
 		lastChecked: make(map[string]time.Time),
 		queryOptions: &consul.QueryOptions{
 			AllowStale: true,
 		},
 	}
 	configure(cr, opts...)
 	return cr
 }
--- a/registry/consul/encoding.go
+++ b/registry/consul/encoding.go
@ -0,0 +1,170 @@
 package consul
 import (
 	"bytes"
 	"compress/zlib"
 	"encoding/hex"
 	"encoding/json"
 	"io/ioutil"
 	"github.com/micro/go-micro/registry"
 )
 func encode(buf []byte) string {
 	var b bytes.Buffer
 	defer b.Reset()
 	w := zlib.NewWriter(&b)
 	if _, err := w.Write(buf); err != nil {
 		return ""
 	}
 	w.Close()
 	return hex.EncodeToString(b.Bytes())
 }
 func decode(d string) []byte {
 	hr, err := hex.DecodeString(d)
 	if err != nil {
 		return nil
 	}
 	br := bytes.NewReader(hr)
 	zr, err := zlib.NewReader(br)
 	if err != nil {
 		return nil
 	}
 	rbuf, err := ioutil.ReadAll(zr)
 	if err != nil {
 		return nil
 	}
 	return rbuf
 }
 func encodeEndpoints(en []*registry.Endpoint) []string {
 	var tags []string
 	for _, e := range en {
 		if b, err := json.Marshal(e); err == nil {
 			tags = append(tags, "e-"+encode(b))
 		}
 	}
 	return tags
 }
 func decodeEndpoints(tags []string) []*registry.Endpoint {
 	var en []*registry.Endpoint
 	// use the first format you find
 	var ver byte
 	for _, tag := range tags {
 		if len(tag) == 0 || tag[0] != 'e' {
 			continue
 		}
 		// check version
 		if ver > 0 && tag[1] != ver {
 			continue
 		}
 		var e *registry.Endpoint
 		var buf []byte
 		// Old encoding was plain
 		if tag[1] == '=' {
 			buf = []byte(tag[2:])
 		}
 		// New encoding is hex
 		if tag[1] == '-' {
 			buf = decode(tag[2:])
 		}
 		if err := json.Unmarshal(buf, &e); err == nil {
 			en = append(en, e)
 		}
 		// set version
 		ver = tag[1]
 	}
 	return en
 }
 func encodeMetadata(md map[string]string) []string {
 	var tags []string
 	for k, v := range md {
 		if b, err := json.Marshal(map[string]string{
 			k: v,
 		}); err == nil {
 			// new encoding
 			tags = append(tags, "t-"+encode(b))
 		}
 	}
 	return tags
 }
 func decodeMetadata(tags []string) map[string]string {
 	md := make(map[string]string)
 	var ver byte
 	for _, tag := range tags {
 		if len(tag) == 0 || tag[0] != 't' {
 			continue
 		}
 		// check version
 		if ver > 0 && tag[1] != ver {
 			continue
 		}
 		var kv map[string]string
 		var buf []byte
 		// Old encoding was plain
 		if tag[1] == '=' {
 			buf = []byte(tag[2:])
 		}
 		// New encoding is hex
 		if tag[1] == '-' {
 			buf = decode(tag[2:])
 		}
 		// Now unmarshal
 		if err := json.Unmarshal(buf, &kv); err == nil {
 			for k, v := range kv {
 				md[k] = v
 			}
 		}
 		// set version
 		ver = tag[1]
 	}
 	return md
 }
 func encodeVersion(v string) []string {
 	return []string{"v-" + encode([]byte(v))}
 }
 func decodeVersion(tags []string) (string, bool) {
 	for _, tag := range tags {
 		if len(tag) < 2 || tag[0] != 'v' {
 			continue
 		}
 		// Old encoding was plain
 		if tag[1] == '=' {
 			return tag[2:], true
 		}
 		// New encoding is hex
 		if tag[1] == '-' {
 			return string(decode(tag[2:])), true
 		}
 	}
 	return "", false
 }
--- a/registry/consul/encoding_test.go
+++ b/registry/consul/encoding_test.go
@ -0,0 +1,147 @@
 package consul
 import (
 	"encoding/json"
 	"testing"
 	"github.com/micro/go-micro/registry"
 )
 func TestEncodingEndpoints(t *testing.T) {
 	eps := []*registry.Endpoint{
 		&registry.Endpoint{
 			Name: "endpoint1",
 			Request: &registry.Value{
 				Name: "request",
 				Type: "request",
 			},
 			Response: &registry.Value{
 				Name: "response",
 				Type: "response",
 			},
 			Metadata: map[string]string{
 				"foo1": "bar1",
 			},
 		},
 		&registry.Endpoint{
 			Name: "endpoint2",
 			Request: &registry.Value{
 				Name: "request",
 				Type: "request",
 			},
 			Response: &registry.Value{
 				Name: "response",
 				Type: "response",
 			},
 			Metadata: map[string]string{
 				"foo2": "bar2",
 			},
 		},
 		&registry.Endpoint{
 			Name: "endpoint3",
 			Request: &registry.Value{
 				Name: "request",
 				Type: "request",
 			},
 			Response: &registry.Value{
 				Name: "response",
 				Type: "response",
 			},
 			Metadata: map[string]string{
 				"foo3": "bar3",
 			},
 		},
 	}
 	testEp := func(ep *registry.Endpoint, enc string) {
 		// encode endpoint
 		e := encodeEndpoints([]*registry.Endpoint{ep})
 		// check there are two tags; old and new
 		if len(e) != 1 {
 			t.Fatalf("Expected 1 encoded tags, got %v", e)
 		}
 		// check old encoding
 		var seen bool
 		for _, en := range e {
 			if en == enc {
 				seen = true
 				break
 			}
 		}
 		if !seen {
 			t.Fatalf("Expected %s but not found", enc)
 		}
 		// decode
 		d := decodeEndpoints([]string{enc})
 		if len(d) == 0 {
 			t.Fatalf("Expected %v got %v", ep, d)
 		}
 		// check name
 		if d[0].Name != ep.Name {
 			t.Fatalf("Expected ep %s got %s", ep.Name, d[0].Name)
 		}
 		// check all the metadata exists
 		for k, v := range ep.Metadata {
 			if gv := d[0].Metadata[k]; gv != v {
 				t.Fatalf("Expected key %s val %s got val %s", k, v, gv)
 			}
 		}
 	}
 	for _, ep := range eps {
 		// JSON encoded
 		jencoded, err := json.Marshal(ep)
 		if err != nil {
 			t.Fatal(err)
 		}
 		// HEX encoded
 		hencoded := encode(jencoded)
 		// endpoint tag
 		hepTag := "e-" + hencoded
 		testEp(ep, hepTag)
 	}
 }
 func TestEncodingVersion(t *testing.T) {
 	testData := []struct {
 		decoded string
 		encoded string
 	}{
 		{"1.0.0", "v-789c32d433d03300040000ffff02ce00ee"},
 		{"latest", "v-789cca492c492d2e01040000ffff08cc028e"},
 	}
 	for _, data := range testData {
 		e := encodeVersion(data.decoded)
 		if e[0] != data.encoded {
 			t.Fatalf("Expected %s got %s", data.encoded, e)
 		}
 		d, ok := decodeVersion(e)
 		if !ok {
 			t.Fatalf("Unexpected %t for %s", ok, data.encoded)
 		}
 		if d != data.decoded {
 			t.Fatalf("Expected %s got %s", data.decoded, d)
 		}
 		d, ok = decodeVersion([]string{data.encoded})
 		if !ok {
 			t.Fatalf("Unexpected %t for %s", ok, data.encoded)
 		}
 		if d != data.decoded {
 			t.Fatalf("Expected %s got %s", data.decoded, d)
 		}
 	}
 }
--- a/registry/consul/options.go
+++ b/registry/consul/options.go
@ -27,6 +27,40 @@ func Config(c *consul.Config) registry.Option {
 	}
 }
 // AllowStale sets whether any Consul server (non-leader) can service
 // a read. This allows for lower latency and higher throughput
 // at the cost of potentially stale data.
 // Works similar to Consul DNS Config option [1].
 // Defaults to true.
 //
 // [1] https://www.consul.io/docs/agent/options.html#allow_stale
 //
 func AllowStale(v bool) registry.Option {
 	return func(o *registry.Options) {
 		if o.Context == nil {
 			o.Context = context.Background()
 		}
 		o.Context = context.WithValue(o.Context, "consul_allow_stale", v)
 	}
 }
 // QueryOptions specifies the QueryOptions to be used when calling
 // Consul. See `Consul API` for more information [1].
 //
 // [1] https://godoc.org/github.com/hashicorp/consul/api#QueryOptions
 //
 func QueryOptions(q *consul.QueryOptions) registry.Option {
 	return func(o *registry.Options) {
 		if q == nil {
 			return
 		}
 		if o.Context == nil {
 			o.Context = context.Background()
 		}
 		o.Context = context.WithValue(o.Context, "consul_query_options", q)
 	}
 }
 //
 // TCPCheck will tell the service provider to check the service address
 // and port every `t` interval. It will enabled only if `t` is greater than 0.
--- a/registry/consul/registry_test.go
+++ b/registry/consul/registry_test.go
@ -1,4 +1,4 @@
-package registry
+package consul
 import (
 	"bytes"
@ -7,8 +7,10 @@ import (
 	"net"
 	"net/http"
 	"testing"
 	"time"
 	consul "github.com/hashicorp/consul/api"
 	"github.com/micro/go-micro/registry"
 )
 type mockRegistry struct {
@ -55,7 +57,12 @@ func newConsulTestRegistry(r *mockRegistry) (*consulRegistry, func()) {
 	return &consulRegistry{
 			Address:     cfg.Address,
 			Client:      cl,
 			opts:        registry.Options{},
 			register:    make(map[string]uint64),
 			lastChecked: make(map[string]time.Time),
 			queryOptions: &consul.QueryOptions{
 				AllowStale: true,
 			},
 		}, func() {
 			l.Close()
 		}
--- a/registry/consul/watcher.go
+++ b/registry/consul/watcher.go
@ -1,28 +1,31 @@
-package registry
+package consul
 import (
 	"errors"
 	"log"
 	"os"
 	"sync"
 	"github.com/hashicorp/consul/api"
-	"github.com/hashicorp/consul/watch"
+	"github.com/hashicorp/consul/api/watch"
 	"github.com/micro/go-micro/registry"
 )
 type consulWatcher struct {
 	r        *consulRegistry
-	wo       WatchOptions
+	wo       registry.WatchOptions
 	wp       *watch.Plan
 	watchers map[string]*watch.Plan
-	next chan *Result
+	next chan *registry.Result
 	exit chan bool
 	sync.RWMutex
-	services map[string][]*Service
+	services map[string][]*registry.Service
 }
-func newConsulWatcher(cr *consulRegistry, opts ...WatchOption) (Watcher, error) {
+func newConsulWatcher(cr *consulRegistry, opts ...registry.WatchOption) (registry.Watcher, error) {
-	var wo WatchOptions
+	var wo registry.WatchOptions
 	for _, o := range opts {
 		o(&wo)
 	}
@ -31,9 +34,9 @@ func newConsulWatcher(cr *consulRegistry, opts ...WatchOption) (Watcher, error)
 		r:        cr,
 		wo:       wo,
 		exit:     make(chan bool),
-		next:     make(chan *Result, 10),
+		next:     make(chan *registry.Result, 10),
 		watchers: make(map[string]*watch.Plan),
-		services: make(map[string][]*Service),
+		services: make(map[string][]*registry.Service),
 	}
 	wp, err := watch.Parse(map[string]interface{}{"type": "services"})
@ -42,7 +45,7 @@ func newConsulWatcher(cr *consulRegistry, opts ...WatchOption) (Watcher, error)
 	}
 	wp.Handler = cw.handle
-	go wp.Run(cr.Address)
+	go wp.RunWithClientAndLogger(cr.Client, log.New(os.Stderr, "", log.LstdFlags))
 	cw.wp = wp
 	return cw, nil
@ -54,7 +57,7 @@ func (cw *consulWatcher) serviceHandler(idx uint64, data interface{}) {
 		return
 	}
-	serviceMap := map[string]*Service{}
+	serviceMap := map[string]*registry.Service{}
 	serviceName := ""
 	for _, e := range entries {
@ -75,7 +78,7 @@ func (cw *consulWatcher) serviceHandler(idx uint64, data interface{}) {
 		svc, ok := serviceMap[key]
 		if !ok {
-			svc = &Service{
+			svc = &registry.Service{
 				Endpoints: decodeEndpoints(e.Service.Tags),
 				Name:      e.Service.Service,
 				Version:   version,
@ -98,7 +101,7 @@ func (cw *consulWatcher) serviceHandler(idx uint64, data interface{}) {
 			continue
 		}
-		svc.Nodes = append(svc.Nodes, &Node{
+		svc.Nodes = append(svc.Nodes, &registry.Node{
 			Id:       id,
 			Address:  address,
 			Port:     e.Service.Port,
@ -108,13 +111,13 @@ func (cw *consulWatcher) serviceHandler(idx uint64, data interface{}) {
 	cw.RLock()
 	// make a copy
-	rservices := make(map[string][]*Service)
+	rservices := make(map[string][]*registry.Service)
 	for k, v := range cw.services {
 		rservices[k] = v
 	}
 	cw.RUnlock()
-	var newServices []*Service
+	var newServices []*registry.Service
 	// serviceMap is the new set of services keyed by name+version
 	for _, newService := range serviceMap {
@ -125,7 +128,7 @@ func (cw *consulWatcher) serviceHandler(idx uint64, data interface{}) {
 		oldServices, ok := rservices[serviceName]
 		if !ok {
 			// does not exist? then we're creating brand new entries
-			cw.next <- &Result{Action: "create", Service: newService}
+			cw.next <- &registry.Result{Action: "create", Service: newService}
 			continue
 		}
@ -142,7 +145,7 @@ func (cw *consulWatcher) serviceHandler(idx uint64, data interface{}) {
 			// yes? then it's an update
 			action = "update"
-			var nodes []*Node
+			var nodes []*registry.Node
 			// check the old nodes to see if they've been deleted
 			for _, oldNode := range oldService.Nodes {
 				var seen bool
@ -163,11 +166,11 @@ func (cw *consulWatcher) serviceHandler(idx uint64, data interface{}) {
 			if len(nodes) > 0 {
 				delService := oldService
 				delService.Nodes = nodes
-				cw.next <- &Result{Action: "delete", Service: delService}
+				cw.next <- &registry.Result{Action: "delete", Service: delService}
 			}
 		}
-		cw.next <- &Result{Action: action, Service: newService}
+		cw.next <- &registry.Result{Action: action, Service: newService}
 	}
 	// Now check old versions that may not be in new services map
@ -175,7 +178,7 @@ func (cw *consulWatcher) serviceHandler(idx uint64, data interface{}) {
 		// old version does not exist in new version map
 		// kill it with fire!
 		if _, ok := serviceMap[old.Version]; !ok {
-			cw.next <- &Result{Action: "delete", Service: old}
+			cw.next <- &registry.Result{Action: "delete", Service: old}
 		}
 	}
@ -207,15 +210,15 @@ func (cw *consulWatcher) handle(idx uint64, data interface{}) {
 		})
 		if err == nil {
 			wp.Handler = cw.serviceHandler
-			go wp.Run(cw.r.Address)
+			go wp.RunWithClientAndLogger(cw.r.Client, log.New(os.Stderr, "", log.LstdFlags))
 			cw.watchers[service] = wp
-			cw.next <- &Result{Action: "create", Service: &Service{Name: service}}
+			cw.next <- &registry.Result{Action: "create", Service: &registry.Service{Name: service}}
 		}
 	}
 	cw.RLock()
 	// make a copy
-	rservices := make(map[string][]*Service)
+	rservices := make(map[string][]*registry.Service)
 	for k, v := range cw.services {
 		rservices[k] = v
 	}
@ -235,12 +238,12 @@ func (cw *consulWatcher) handle(idx uint64, data interface{}) {
 		if _, ok := services[service]; !ok {
 			w.Stop()
 			delete(cw.watchers, service)
-			cw.next <- &Result{Action: "delete", Service: &Service{Name: service}}
+			cw.next <- &registry.Result{Action: "delete", Service: &registry.Service{Name: service}}
 		}
 	}
 }
-func (cw *consulWatcher) Next() (*Result, error) {
+func (cw *consulWatcher) Next() (*registry.Result, error) {
 	select {
 	case <-cw.exit:
 		return nil, errors.New("result chan closed")
--- a/registry/consul/watcher_test.go
+++ b/registry/consul/watcher_test.go
@ -1,9 +1,10 @@
-package registry
+package consul
 import (
 	"testing"
 	"github.com/hashicorp/consul/api"
 	"github.com/micro/go-micro/registry"
 )
 func TestHealthyServiceHandler(t *testing.T) {
@ -58,8 +59,8 @@ func TestUnhealthyNodeServiceHandler(t *testing.T) {
 func newWatcher() *consulWatcher {
 	return &consulWatcher{
 		exit:     make(chan bool),
-		next:     make(chan *Result, 10),
+		next:     make(chan *registry.Result, 10),
-		services: make(map[string][]*Service),
+		services: make(map[string][]*registry.Service),
 	}
 }
--- a/registry/consul_registry.go
+++ b/registry/consul_registry.go
@ -1,352 +0,0 @@
 package registry
 import (
 	"crypto/tls"
 	"errors"
 	"fmt"
 	"net"
 	"net/http"
 	"runtime"
 	"sync"
 	"time"
 	consul "github.com/hashicorp/consul/api"
 	hash "github.com/mitchellh/hashstructure"
 )
 type consulRegistry struct {
 	Address string
 	Client  *consul.Client
 	opts    Options
 	// connect enabled
 	connect bool
 	sync.Mutex
 	register map[string]uint64
 }
 func getDeregisterTTL(t time.Duration) time.Duration {
 	// splay slightly for the watcher?
 	splay := time.Second * 5
 	deregTTL := t + splay
 	// consul has a minimum timeout on deregistration of 1 minute.
 	if t < time.Minute {
 		deregTTL = time.Minute + splay
 	}
 	return deregTTL
 }
 func newTransport(config *tls.Config) *http.Transport {
 	if config == nil {
 		config = &tls.Config{
 			InsecureSkipVerify: true,
 		}
 	}
 	t := &http.Transport{
 		Proxy: http.ProxyFromEnvironment,
 		Dial: (&net.Dialer{
 			Timeout:   30 * time.Second,
 			KeepAlive: 30 * time.Second,
 		}).Dial,
 		TLSHandshakeTimeout: 10 * time.Second,
 		TLSClientConfig:     config,
 	}
 	runtime.SetFinalizer(&t, func(tr **http.Transport) {
 		(*tr).CloseIdleConnections()
 	})
 	return t
 }
 func configure(c *consulRegistry, opts ...Option) {
 	// set opts
 	for _, o := range opts {
 		o(&c.opts)
 	}
 	// use default config
 	config := consul.DefaultConfig()
 	if c.opts.Context != nil {
 		// Use the consul config passed in the options, if available
 		if co, ok := c.opts.Context.Value("consul_config").(*consul.Config); ok {
 			config = co
 		}
 		if cn, ok := c.opts.Context.Value("consul_connect").(bool); ok {
 			c.connect = cn
 		}
 	}
 	// check if there are any addrs
 	if len(c.opts.Addrs) > 0 {
 		addr, port, err := net.SplitHostPort(c.opts.Addrs[0])
 		if ae, ok := err.(*net.AddrError); ok && ae.Err == "missing port in address" {
 			port = "8500"
 			addr = c.opts.Addrs[0]
 			config.Address = fmt.Sprintf("%s:%s", addr, port)
 		} else if err == nil {
 			config.Address = fmt.Sprintf("%s:%s", addr, port)
 		}
 	}
 	// requires secure connection?
 	if c.opts.Secure || c.opts.TLSConfig != nil {
 		if config.HttpClient == nil {
 			config.HttpClient = new(http.Client)
 		}
 		config.Scheme = "https"
 		// We're going to support InsecureSkipVerify
 		config.HttpClient.Transport = newTransport(c.opts.TLSConfig)
 	}
 	// set timeout
 	if c.opts.Timeout > 0 {
 		config.HttpClient.Timeout = c.opts.Timeout
 	}
 	// create the client
 	client, _ := consul.NewClient(config)
 	// set address/client
 	c.Address = config.Address
 	c.Client = client
 }
 func newConsulRegistry(opts ...Option) Registry {
 	cr := &consulRegistry{
 		opts:     Options{},
 		register: make(map[string]uint64),
 	}
 	configure(cr, opts...)
 	return cr
 }
 func (c *consulRegistry) Init(opts ...Option) error {
 	configure(c, opts...)
 	return nil
 }
 func (c *consulRegistry) Deregister(s *Service) error {
 	if len(s.Nodes) == 0 {
 		return errors.New("Require at least one node")
 	}
 	// delete our hash of the service
 	c.Lock()
 	delete(c.register, s.Name)
 	c.Unlock()
 	node := s.Nodes[0]
 	return c.Client.Agent().ServiceDeregister(node.Id)
 }
 func (c *consulRegistry) Register(s *Service, opts ...RegisterOption) error {
 	if len(s.Nodes) == 0 {
 		return errors.New("Require at least one node")
 	}
 	var regTCPCheck bool
 	var regInterval time.Duration
 	var options RegisterOptions
 	for _, o := range opts {
 		o(&options)
 	}
 	if c.opts.Context != nil {
 		if tcpCheckInterval, ok := c.opts.Context.Value("consul_tcp_check").(time.Duration); ok {
 			regTCPCheck = true
 			regInterval = tcpCheckInterval
 		}
 	}
 	// create hash of service; uint64
 	h, err := hash.Hash(s, nil)
 	if err != nil {
 		return err
 	}
 	// use first node
 	node := s.Nodes[0]
 	// get existing hash
 	c.Lock()
 	v, ok := c.register[s.Name]
 	c.Unlock()
 	// if it's already registered and matches then just pass the check
 	if ok && v == h {
 		// if the err is nil we're all good, bail out
 		// if not, we don't know what the state is, so full re-register
 		if err := c.Client.Agent().PassTTL("service:"+node.Id, ""); err == nil {
 			return nil
 		}
 	}
 	// encode the tags
 	tags := encodeMetadata(node.Metadata)
 	tags = append(tags, encodeEndpoints(s.Endpoints)...)
 	tags = append(tags, encodeVersion(s.Version)...)
 	var check *consul.AgentServiceCheck
 	if regTCPCheck {
 		deregTTL := getDeregisterTTL(regInterval)
 		check = &consul.AgentServiceCheck{
 			TCP:                            fmt.Sprintf("%s:%d", node.Address, node.Port),
 			Interval:                       fmt.Sprintf("%v", regInterval),
 			DeregisterCriticalServiceAfter: fmt.Sprintf("%v", deregTTL),
 		}
 		// if the TTL is greater than 0 create an associated check
 	} else if options.TTL > time.Duration(0) {
 		deregTTL := getDeregisterTTL(options.TTL)
 		check = &consul.AgentServiceCheck{
 			TTL: fmt.Sprintf("%v", options.TTL),
 			DeregisterCriticalServiceAfter: fmt.Sprintf("%v", deregTTL),
 		}
 	}
 	// register the service
 	asr := &consul.AgentServiceRegistration{
 		ID:      node.Id,
 		Name:    s.Name,
 		Tags:    tags,
 		Port:    node.Port,
 		Address: node.Address,
 		Check:   check,
 	}
 	// Specify consul connect
 	if c.connect {
 		asr.Connect = &consul.AgentServiceConnect{
 			Native: true,
 		}
 	}
 	if err := c.Client.Agent().ServiceRegister(asr); err != nil {
 		return err
 	}
 	// save our hash of the service
 	c.Lock()
 	c.register[s.Name] = h
 	c.Unlock()
 	// if the TTL is 0 we don't mess with the checks
 	if options.TTL == time.Duration(0) {
 		return nil
 	}
 	// pass the healthcheck
 	return c.Client.Agent().PassTTL("service:"+node.Id, "")
 }
 func (c *consulRegistry) GetService(name string) ([]*Service, error) {
 	var rsp []*consul.ServiceEntry
 	var err error
 	// if we're connect enabled only get connect services
 	if c.connect {
 		rsp, _, err = c.Client.Health().Connect(name, "", false, nil)
 	} else {
 		rsp, _, err = c.Client.Health().Service(name, "", false, nil)
 	}
 	if err != nil {
 		return nil, err
 	}
 	serviceMap := map[string]*Service{}
 	for _, s := range rsp {
 		if s.Service.Service != name {
 			continue
 		}
 		// version is now a tag
 		version, _ := decodeVersion(s.Service.Tags)
 		// service ID is now the node id
 		id := s.Service.ID
 		// key is always the version
 		key := version
 		// address is service address
 		address := s.Service.Address
 		// use node address
 		if len(address) == 0 {
 			address = s.Node.Address
 		}
 		svc, ok := serviceMap[key]
 		if !ok {
 			svc = &Service{
 				Endpoints: decodeEndpoints(s.Service.Tags),
 				Name:      s.Service.Service,
 				Version:   version,
 			}
 			serviceMap[key] = svc
 		}
 		var del bool
 		for _, check := range s.Checks {
 			// delete the node if the status is critical
 			if check.Status == "critical" {
 				del = true
 				break
 			}
 		}
 		// if delete then skip the node
 		if del {
 			continue
 		}
 		svc.Nodes = append(svc.Nodes, &Node{
 			Id:       id,
 			Address:  address,
 			Port:     s.Service.Port,
 			Metadata: decodeMetadata(s.Service.Tags),
 		})
 	}
 	var services []*Service
 	for _, service := range serviceMap {
 		services = append(services, service)
 	}
 	return services, nil
 }
 func (c *consulRegistry) ListServices() ([]*Service, error) {
 	rsp, _, err := c.Client.Catalog().Services(nil)
 	if err != nil {
 		return nil, err
 	}
 	var services []*Service
 	for service := range rsp {
 		services = append(services, &Service{Name: service})
 	}
 	return services, nil
 }
 func (c *consulRegistry) Watch(opts ...WatchOption) (Watcher, error) {
 	return newConsulWatcher(c, opts...)
 }
 func (c *consulRegistry) String() string {
 	return "consul"
 }
 func (c *consulRegistry) Options() Options {
 	return c.opts
 }
--- a/registry/encoding.go
+++ b/registry/encoding.go
@ -6,163 +6,68 @@ import (
 	"encoding/hex"
 	"encoding/json"
 	"io/ioutil"
 	"strings"
 )
-func encode(buf []byte) string {
+func encode(txt *mdnsTxt) ([]string, error) {
-	var b bytes.Buffer
+	b, err := json.Marshal(txt)
-	defer b.Reset()
+	if err != nil {
 		return nil, err
 	}
-	w := zlib.NewWriter(&b)
+	var buf bytes.Buffer
-	if _, err := w.Write(buf); err != nil {
+	defer buf.Reset()
-		return ""
+
 	w := zlib.NewWriter(&buf)
 	if _, err := w.Write(b); err != nil {
 		return nil, err
 	}
 	w.Close()
-	return hex.EncodeToString(b.Bytes())
+	encoded := hex.EncodeToString(buf.Bytes())
 	// individual txt limit
 	if len(encoded) <= 255 {
 		return []string{encoded}, nil
 	}
 	// split encoded string
 	var record []string
 	for len(encoded) > 255 {
 		record = append(record, encoded[:255])
 		encoded = encoded[255:]
 	}
 	record = append(record, encoded)
 	return record, nil
 }
-func decode(d string) []byte {
+func decode(record []string) (*mdnsTxt, error) {
-	hr, err := hex.DecodeString(d)
+	encoded := strings.Join(record, "")
 	hr, err := hex.DecodeString(encoded)
 	if err != nil {
-		return nil
+		return nil, err
 	}
 	br := bytes.NewReader(hr)
 	zr, err := zlib.NewReader(br)
 	if err != nil {
-		return nil
+		return nil, err
 	}
 	rbuf, err := ioutil.ReadAll(zr)
 	if err != nil {
-		return nil
+		return nil, err
 	}
-	return rbuf
+	var txt *mdnsTxt
-}
+
-
+	if err := json.Unmarshal(rbuf, &txt); err != nil {
-func encodeEndpoints(en []*Endpoint) []string {
+		return nil, err
-	var tags []string
+	}
-	for _, e := range en {
+
-		if b, err := json.Marshal(e); err == nil {
+	return txt, nil
 			tags = append(tags, "e-"+encode(b))
 		}
 	}
 	return tags
 }
 func decodeEndpoints(tags []string) []*Endpoint {
 	var en []*Endpoint
 	// use the first format you find
 	var ver byte
 	for _, tag := range tags {
 		if len(tag) == 0 || tag[0] != 'e' {
 			continue
 		}
 		// check version
 		if ver > 0 && tag[1] != ver {
 			continue
 		}
 		var e *Endpoint
 		var buf []byte
 		// Old encoding was plain
 		if tag[1] == '=' {
 			buf = []byte(tag[2:])
 		}
 		// New encoding is hex
 		if tag[1] == '-' {
 			buf = decode(tag[2:])
 		}
 		if err := json.Unmarshal(buf, &e); err == nil {
 			en = append(en, e)
 		}
 		// set version
 		ver = tag[1]
 	}
 	return en
 }
 func encodeMetadata(md map[string]string) []string {
 	var tags []string
 	for k, v := range md {
 		if b, err := json.Marshal(map[string]string{
 			k: v,
 		}); err == nil {
 			// new encoding
 			tags = append(tags, "t-"+encode(b))
 		}
 	}
 	return tags
 }
 func decodeMetadata(tags []string) map[string]string {
 	md := make(map[string]string)
 	var ver byte
 	for _, tag := range tags {
 		if len(tag) == 0 || tag[0] != 't' {
 			continue
 		}
 		// check version
 		if ver > 0 && tag[1] != ver {
 			continue
 		}
 		var kv map[string]string
 		var buf []byte
 		// Old encoding was plain
 		if tag[1] == '=' {
 			buf = []byte(tag[2:])
 		}
 		// New encoding is hex
 		if tag[1] == '-' {
 			buf = decode(tag[2:])
 		}
 		// Now unmarshal
 		if err := json.Unmarshal(buf, &kv); err == nil {
 			for k, v := range kv {
 				md[k] = v
 			}
 		}
 		// set version
 		ver = tag[1]
 	}
 	return md
 }
 func encodeVersion(v string) []string {
 	return []string{"v-" + encode([]byte(v))}
 }
 func decodeVersion(tags []string) (string, bool) {
 	for _, tag := range tags {
 		if len(tag) < 2 || tag[0] != 'v' {
 			continue
 		}
 		// Old encoding was plain
 		if tag[1] == '=' {
 			return tag[2:], true
 		}
 		// New encoding is hex
 		if tag[1] == '-' {
 			return string(decode(tag[2:])), true
 		}
 	}
 	return "", false
 }
--- a/registry/encoding_test.go
+++ b/registry/encoding_test.go
@ -1,13 +1,17 @@
 package registry
 import (
 	"encoding/json"
 	"testing"
 )
-func TestEncodingEndpoints(t *testing.T) {
+func TestEncoding(t *testing.T) {
-	eps := []*Endpoint{
+	testData := []*mdnsTxt{
 		&mdnsTxt{
 			Version: "1.0.0",
 			Metadata: map[string]string{
 				"foo": "bar",
 			},
 			Endpoints: []*Endpoint{
 				&Endpoint{
 					Name: "endpoint1",
 					Request: &Value{
@ -22,125 +26,40 @@ func TestEncodingEndpoints(t *testing.T) {
 						"foo1": "bar1",
 					},
 				},
 		&Endpoint{
 			Name: "endpoint2",
 			Request: &Value{
 				Name: "request",
 				Type: "request",
 			},
 			Response: &Value{
 				Name: "response",
 				Type: "response",
 			},
 			Metadata: map[string]string{
 				"foo2": "bar2",
 			},
 		},
 		&Endpoint{
 			Name: "endpoint3",
 			Request: &Value{
 				Name: "request",
 				Type: "request",
 			},
 			Response: &Value{
 				Name: "response",
 				Type: "response",
 			},
 			Metadata: map[string]string{
 				"foo3": "bar3",
 			},
 		},
 	}
-	testEp := func(ep *Endpoint, enc string) {
+	for _, d := range testData {
-		// encode endpoint
+		encoded, err := encode(d)
 		e := encodeEndpoints([]*Endpoint{ep})
 		// check there are two tags; old and new
 		if len(e) != 1 {
 			t.Fatalf("Expected 1 encoded tags, got %v", e)
 		}
 		// check old encoding
 		var seen bool
 		for _, en := range e {
 			if en == enc {
 				seen = true
 				break
 			}
 		}
 		if !seen {
 			t.Fatalf("Expected %s but not found", enc)
 		}
 		// decode
 		d := decodeEndpoints([]string{enc})
 		if len(d) == 0 {
 			t.Fatalf("Expected %v got %v", ep, d)
 		}
 		// check name
 		if d[0].Name != ep.Name {
 			t.Fatalf("Expected ep %s got %s", ep.Name, d[0].Name)
 		}
 		// check all the metadata exists
 		for k, v := range ep.Metadata {
 			if gv := d[0].Metadata[k]; gv != v {
 				t.Fatalf("Expected key %s val %s got val %s", k, v, gv)
 			}
 		}
 	}
 	for _, ep := range eps {
 		// JSON encoded
 		jencoded, err := json.Marshal(ep)
 		if err != nil {
 			t.Fatal(err)
 		}
-		// HEX encoded
+		for _, txt := range encoded {
-		hencoded := encode(jencoded)
+			if len(txt) > 255 {
-		// endpoint tag
+				t.Fatalf("One of parts for txt is %d characters", len(txt))
 		hepTag := "e-" + hencoded
 		testEp(ep, hepTag)
 	}
 }
 func TestEncodingVersion(t *testing.T) {
 	testData := []struct {
 		decoded string
 		encoded string
 	}{
 		{"1.0.0", "v-789c32d433d03300040000ffff02ce00ee"},
 		{"latest", "v-789cca492c492d2e01040000ffff08cc028e"},
 	}
 	for _, data := range testData {
 		e := encodeVersion(data.decoded)
 		if e[0] != data.encoded {
 			t.Fatalf("Expected %s got %s", data.encoded, e)
 		}
 		d, ok := decodeVersion(e)
 		if !ok {
 			t.Fatalf("Unexpected %t for %s", ok, data.encoded)
 		}
 		if d != data.decoded {
 			t.Fatalf("Expected %s got %s", data.decoded, d)
 		}
 		d, ok = decodeVersion([]string{data.encoded})
 		if !ok {
 			t.Fatalf("Unexpected %t for %s", ok, data.encoded)
 		}
 		if d != data.decoded {
 			t.Fatalf("Expected %s got %s", data.decoded, d)
 		}
 			}
 		}
 		decoded, err := decode(encoded)
 		if err != nil {
 			t.Fatal(err)
 		}
 		if decoded.Version != d.Version {
 			t.Fatalf("Expected version %s got %s", d.Version, decoded.Version)
 		}
 		if len(decoded.Endpoints) != len(d.Endpoints) {
 			t.Fatalf("Expected %d endpoints, got %d", len(d.Endpoints), len(decoded.Endpoints))
 		}
 		for k, v := range d.Metadata {
 			if val := decoded.Metadata[k]; val != v {
 				t.Fatalf("Expected %s=%s got %s=%s", k, v, k, val)
 			}
 		}
 	}
 }
--- a/registry/gossip/README.md
+++ b/registry/gossip/README.md
@ -0,0 +1,24 @@
 # Gossip Registry
 Gossip is a zero dependency registry which uses github.com/hashicorp/memberlist to broadcast registry information 
 via the SWIM protocol. 
 ## Usage
 Start with the registry flag or env var
 ```bash
 MICRO_REGISTRY=gossip go run service.go
 ```
 On startup you'll see something like
 ```bash
 2018/12/06 18:17:48 Registry Listening on 192.168.1.65:56390
 ```
 To join this gossip ring set the registry address using flag or env var
 ```bash
 MICRO_REGISTRY_ADDRESS=192.168.1.65:56390
 ```
--- a/registry/gossip/gossip.go
+++ b/registry/gossip/gossip.go
@ -0,0 +1,831 @@
 // Package gossip provides a gossip registry based on hashicorp/memberlist
 package gossip
 import (
 	"context"
 	"encoding/json"
 	"fmt"
 	"io/ioutil"
 	"net"
 	"os"
 	"strconv"
 	"strings"
 	"sync"
 	"time"
 	"github.com/golang/protobuf/proto"
 	"github.com/google/uuid"
 	"github.com/hashicorp/memberlist"
 	log "github.com/micro/go-log"
 	"github.com/micro/go-micro/registry"
 	pb "github.com/micro/go-micro/registry/gossip/proto"
 	"github.com/mitchellh/hashstructure"
 )
 // use registry.Result int32 values after it switches from string to int32 types
 // type actionType int32
 // type updateType int32
 const (
 	actionTypeInvalid int32 = iota
 	actionTypeCreate
 	actionTypeDelete
 	actionTypeUpdate
 	actionTypeSync
 )
 const (
 	nodeActionUnknown int32 = iota
 	nodeActionJoin
 	nodeActionLeave
 	nodeActionUpdate
 )
 func actionTypeString(t int32) string {
 	switch t {
 	case actionTypeCreate:
 		return "create"
 	case actionTypeDelete:
 		return "delete"
 	case actionTypeUpdate:
 		return "update"
 	case actionTypeSync:
 		return "sync"
 	}
 	return "invalid"
 }
 const (
 	updateTypeInvalid int32 = iota
 	updateTypeService
 )
 type broadcast struct {
 	update *pb.Update
 	notify chan<- struct{}
 }
 type delegate struct {
 	queue   *memberlist.TransmitLimitedQueue
 	updates chan *update
 }
 type event struct {
 	action int32
 	node   string
 }
 type eventDelegate struct {
 	events chan *event
 }
 func (ed *eventDelegate) NotifyJoin(n *memberlist.Node) {
 	ed.events <- &event{action: nodeActionJoin, node: n.Address()}
 }
 func (ed *eventDelegate) NotifyLeave(n *memberlist.Node) {
 	ed.events <- &event{action: nodeActionLeave, node: n.Address()}
 }
 func (ed *eventDelegate) NotifyUpdate(n *memberlist.Node) {
 	ed.events <- &event{action: nodeActionUpdate, node: n.Address()}
 }
 type gossipRegistry struct {
 	queue       *memberlist.TransmitLimitedQueue
 	updates     chan *update
 	events      chan *event
 	options     registry.Options
 	member      *memberlist.Memberlist
 	interval    time.Duration
 	tcpInterval time.Duration
 	connectRetry   bool
 	connectTimeout time.Duration
 	sync.RWMutex
 	services map[string][]*registry.Service
 	watchers map[string]chan *registry.Result
 	mtu     int
 	addrs   []string
 	members map[string]int32
 	done    chan bool
 }
 type update struct {
 	Update  *pb.Update
 	Service *registry.Service
 	sync    chan *registry.Service
 }
 type updates struct {
 	sync.RWMutex
 	services map[uint64]*update
 }
 var (
 	// You should change this if using secure
 	DefaultSecret = []byte("micro-gossip-key") // exactly 16 bytes
 	ExpiryTick    = time.Second * 1            // needs to be smaller than registry.RegisterTTL
 	MaxPacketSize = 512
 )
 func configure(g *gossipRegistry, opts ...registry.Option) error {
 	// loop through address list and get valid entries
 	addrs := func(curAddrs []string) []string {
 		var newAddrs []string
 		for _, addr := range curAddrs {
 			if trimAddr := strings.TrimSpace(addr); len(trimAddr) > 0 {
 				newAddrs = append(newAddrs, trimAddr)
 			}
 		}
 		return newAddrs
 	}
 	// current address list
 	curAddrs := addrs(g.options.Addrs)
 	// parse options
 	for _, o := range opts {
 		o(&g.options)
 	}
 	// new address list
 	newAddrs := addrs(g.options.Addrs)
 	// no new nodes and existing member. no configure
 	if (len(newAddrs) == len(curAddrs)) && g.member != nil {
 		return nil
 	}
 	// shutdown old member
 	g.Stop()
 	// lock internals
 	g.Lock()
 	// new done chan
 	g.done = make(chan bool)
 	// replace addresses
 	curAddrs = newAddrs
 	// create a new default config
 	c := memberlist.DefaultLocalConfig()
 	// sane good default options
 	c.LogOutput = ioutil.Discard // log to /dev/null
 	c.PushPullInterval = 0       // disable expensive tcp push/pull
 	c.ProtocolVersion = 4        // suport latest stable features
 	// set config from options
 	if config, ok := g.options.Context.Value(configKey{}).(*memberlist.Config); ok && config != nil {
 		c = config
 	}
 	// set address
 	if address, ok := g.options.Context.Value(addressKey{}).(string); ok {
 		host, port, err := net.SplitHostPort(address)
 		if err == nil {
 			p, err := strconv.Atoi(port)
 			if err == nil {
 				c.BindPort = p
 			}
 			c.BindAddr = host
 		}
 	} else {
 		// set bind to random port
 		c.BindPort = 0
 	}
 	// set the advertise address
 	if advertise, ok := g.options.Context.Value(advertiseKey{}).(string); ok {
 		host, port, err := net.SplitHostPort(advertise)
 		if err == nil {
 			p, err := strconv.Atoi(port)
 			if err == nil {
 				c.AdvertisePort = p
 			}
 			c.AdvertiseAddr = host
 		}
 	}
 	// machine hostname
 	hostname, _ := os.Hostname()
 	// set the name
 	c.Name = strings.Join([]string{"micro", hostname, uuid.New().String()}, "-")
 	// set a secret key if secure
 	if g.options.Secure {
 		k, ok := g.options.Context.Value(secretKey{}).([]byte)
 		if !ok {
 			// use the default secret
 			k = DefaultSecret
 		}
 		c.SecretKey = k
 	}
 	// set connect retry
 	if v, ok := g.options.Context.Value(connectRetryKey{}).(bool); ok && v {
 		g.connectRetry = true
 	}
 	// set connect timeout
 	if td, ok := g.options.Context.Value(connectTimeoutKey{}).(time.Duration); ok {
 		g.connectTimeout = td
 	}
 	// create a queue
 	queue := &memberlist.TransmitLimitedQueue{
 		NumNodes: func() int {
 			return len(curAddrs)
 		},
 		RetransmitMult: 3,
 	}
 	// set the delegate
 	c.Delegate = &delegate{
 		updates: g.updates,
 		queue:   queue,
 	}
 	if g.connectRetry {
 		c.Events = &eventDelegate{
 			events: g.events,
 		}
 	}
 	// create the memberlist
 	m, err := memberlist.Create(c)
 	if err != nil {
 		return err
 	}
 	if len(curAddrs) > 0 {
 		for _, addr := range curAddrs {
 			g.members[addr] = nodeActionUnknown
 		}
 	}
 	g.tcpInterval = c.PushPullInterval
 	g.addrs = curAddrs
 	g.queue = queue
 	g.member = m
 	g.interval = c.GossipInterval
 	g.Unlock()
 	log.Logf("[gossip] Registry Listening on %s", m.LocalNode().Address())
 	// try connect
 	return g.connect(curAddrs)
 }
 func (*broadcast) UniqueBroadcast() {}
 func (b *broadcast) Invalidates(other memberlist.Broadcast) bool {
 	return false
 }
 func (b *broadcast) Message() []byte {
 	up, err := proto.Marshal(b.update)
 	if err != nil {
 		return nil
 	}
 	if l := len(up); l > MaxPacketSize {
 		log.Logf("[gossip] broadcast message size %d bigger then MaxPacketSize %d", l, MaxPacketSize)
 	}
 	return up
 }
 func (b *broadcast) Finished() {
 	if b.notify != nil {
 		close(b.notify)
 	}
 }
 func (d *delegate) NodeMeta(limit int) []byte {
 	return []byte{}
 }
 func (d *delegate) NotifyMsg(b []byte) {
 	if len(b) == 0 {
 		return
 	}
 	go func() {
 		up := new(pb.Update)
 		if err := proto.Unmarshal(b, up); err != nil {
 			return
 		}
 		// only process service action
 		if up.Type != updateTypeService {
 			return
 		}
 		var service *registry.Service
 		switch up.Metadata["Content-Type"] {
 		case "application/json":
 			if err := json.Unmarshal(up.Data, &service); err != nil {
 				return
 			}
 		// no other content type
 		default:
 			return
 		}
 		// send update
 		d.updates <- &update{
 			Update:  up,
 			Service: service,
 		}
 	}()
 }
 func (d *delegate) GetBroadcasts(overhead, limit int) [][]byte {
 	return d.queue.GetBroadcasts(overhead, limit)
 }
 func (d *delegate) LocalState(join bool) []byte {
 	if !join {
 		return []byte{}
 	}
 	syncCh := make(chan *registry.Service, 1)
 	services := map[string][]*registry.Service{}
 	d.updates <- &update{
 		Update: &pb.Update{
 			Action: actionTypeSync,
 		},
 		sync: syncCh,
 	}
 	for srv := range syncCh {
 		services[srv.Name] = append(services[srv.Name], srv)
 	}
 	b, _ := json.Marshal(services)
 	return b
 }
 func (d *delegate) MergeRemoteState(buf []byte, join bool) {
 	if len(buf) == 0 {
 		return
 	}
 	if !join {
 		return
 	}
 	var services map[string][]*registry.Service
 	if err := json.Unmarshal(buf, &services); err != nil {
 		return
 	}
 	for _, service := range services {
 		for _, srv := range service {
 			d.updates <- &update{
 				Update:  &pb.Update{Action: actionTypeCreate},
 				Service: srv,
 				sync:    nil,
 			}
 		}
 	}
 }
 func (g *gossipRegistry) connect(addrs []string) error {
 	if len(addrs) == 0 {
 		return nil
 	}
 	timeout := make(<-chan time.Time)
 	if g.connectTimeout > 0 {
 		timeout = time.After(g.connectTimeout)
 	}
 	ticker := time.NewTicker(1 * time.Second)
 	defer ticker.Stop()
 	fn := func() (int, error) {
 		return g.member.Join(addrs)
 	}
 	// don't wait for first try
 	if _, err := fn(); err == nil {
 		return nil
 	}
 	// wait loop
 	for {
 		select {
 		// context closed
 		case <-g.options.Context.Done():
 			return nil
 		// call close, don't wait anymore
 		case <-g.done:
 			return nil
 		//  in case of timeout fail with a timeout error
 		case <-timeout:
 			return fmt.Errorf("[gossip] connect timeout %v", g.addrs)
 		// got a tick, try to connect
 		case <-ticker.C:
 			if _, err := fn(); err == nil {
 				log.Logf("[gossip] connect success for %v", g.addrs)
 				return nil
 			} else {
 				log.Logf("[gossip] connect failed for %v", g.addrs)
 			}
 		}
 	}
 	return nil
 }
 func (g *gossipRegistry) publish(action string, services []*registry.Service) {
 	g.RLock()
 	for _, sub := range g.watchers {
 		go func(sub chan *registry.Result) {
 			for _, service := range services {
 				sub <- &registry.Result{Action: action, Service: service}
 			}
 		}(sub)
 	}
 	g.RUnlock()
 }
 func (g *gossipRegistry) subscribe() (chan *registry.Result, chan bool) {
 	next := make(chan *registry.Result, 10)
 	exit := make(chan bool)
 	id := uuid.New().String()
 	g.Lock()
 	g.watchers[id] = next
 	g.Unlock()
 	go func() {
 		<-exit
 		g.Lock()
 		delete(g.watchers, id)
 		close(next)
 		g.Unlock()
 	}()
 	return next, exit
 }
 func (g *gossipRegistry) Stop() error {
 	select {
 	case <-g.done:
 		return nil
 	default:
 		close(g.done)
 		g.Lock()
 		if g.member != nil {
 			g.member.Leave(g.interval * 2)
 			g.member.Shutdown()
 			g.member = nil
 		}
 		g.Unlock()
 	}
 	return nil
 }
 // connectLoop attempts to reconnect to the memberlist
 func (g *gossipRegistry) connectLoop() {
 	// try every second
 	ticker := time.NewTicker(1 * time.Second)
 	defer ticker.Stop()
 	for {
 		select {
 		case <-g.done:
 			return
 		case <-g.options.Context.Done():
 			g.Stop()
 			return
 		case <-ticker.C:
 			var addrs []string
 			g.RLock()
 			// only process if we have a memberlist
 			if g.member == nil {
 				g.RUnlock()
 				continue
 			}
 			// self
 			local := g.member.LocalNode().Address()
 			// operate on each member
 			for node, action := range g.members {
 				switch action {
 				// process leave event
 				case nodeActionLeave:
 					// don't process self
 					if node == local {
 						continue
 					}
 					addrs = append(addrs, node)
 				}
 			}
 			g.RUnlock()
 			// connect to all the members
 			// TODO: only connect to new members
 			if len(addrs) > 0 {
 				g.connect(addrs)
 			}
 		}
 	}
 }
 func (g *gossipRegistry) expiryLoop(updates *updates) {
 	ticker := time.NewTicker(ExpiryTick)
 	defer ticker.Stop()
 	g.RLock()
 	done := g.done
 	g.RUnlock()
 	for {
 		select {
 		case <-done:
 			return
 		case <-ticker.C:
 			now := uint64(time.Now().UnixNano())
 			updates.Lock()
 			// process all the updates
 			for k, v := range updates.services {
 				// check if expiry time has passed
 				if d := (v.Update.Expires); d < now {
 					// delete from records
 					delete(updates.services, k)
 					// set to delete
 					v.Update.Action = actionTypeDelete
 					// fire a new update
 					g.updates <- v
 				}
 			}
 			updates.Unlock()
 		}
 	}
 }
 // process member events
 func (g *gossipRegistry) eventLoop() {
 	g.RLock()
 	done := g.done
 	g.RUnlock()
 	for {
 		select {
 		// return when done
 		case <-done:
 			return
 		case ev := <-g.events:
 			// TODO: nonblocking update
 			g.Lock()
 			if _, ok := g.members[ev.node]; ok {
 				g.members[ev.node] = ev.action
 			}
 			g.Unlock()
 		}
 	}
 }
 func (g *gossipRegistry) run() {
 	updates := &updates{
 		services: make(map[uint64]*update),
 	}
 	// expiry loop
 	go g.expiryLoop(updates)
 	// event loop
 	go g.eventLoop()
 	g.RLock()
 	// connect loop
 	if g.connectRetry {
 		go g.connectLoop()
 	}
 	g.RUnlock()
 	// process the updates
 	for u := range g.updates {
 		switch u.Update.Action {
 		case actionTypeCreate:
 			g.Lock()
 			if service, ok := g.services[u.Service.Name]; !ok {
 				g.services[u.Service.Name] = []*registry.Service{u.Service}
 			} else {
 				g.services[u.Service.Name] = addServices(service, []*registry.Service{u.Service})
 			}
 			g.Unlock()
 			// publish update to watchers
 			go g.publish(actionTypeString(actionTypeCreate), []*registry.Service{u.Service})
 			// we need to expire the node at some point in the future
 			if u.Update.Expires > 0 {
 				// create a hash of this service
 				if hash, err := hashstructure.Hash(u.Service, nil); err == nil {
 					updates.Lock()
 					updates.services[hash] = u
 					updates.Unlock()
 				}
 			}
 		case actionTypeDelete:
 			g.Lock()
 			if service, ok := g.services[u.Service.Name]; ok {
 				if services := delServices(service, []*registry.Service{u.Service}); len(services) == 0 {
 					delete(g.services, u.Service.Name)
 				} else {
 					g.services[u.Service.Name] = services
 				}
 			}
 			g.Unlock()
 			// publish update to watchers
 			go g.publish(actionTypeString(actionTypeDelete), []*registry.Service{u.Service})
 			// delete from expiry checks
 			if hash, err := hashstructure.Hash(u.Service, nil); err == nil {
 				updates.Lock()
 				delete(updates.services, hash)
 				updates.Unlock()
 			}
 		case actionTypeSync:
 			// no sync channel provided
 			if u.sync == nil {
 				continue
 			}
 			g.RLock()
 			// push all services through the sync chan
 			for _, service := range g.services {
 				for _, srv := range service {
 					u.sync <- srv
 				}
 				// publish to watchers
 				go g.publish(actionTypeString(actionTypeCreate), service)
 			}
 			g.RUnlock()
 			// close the sync chan
 			close(u.sync)
 		}
 	}
 }
 func (g *gossipRegistry) Init(opts ...registry.Option) error {
 	return configure(g, opts...)
 }
 func (g *gossipRegistry) Options() registry.Options {
 	return g.options
 }
 func (g *gossipRegistry) Register(s *registry.Service, opts ...registry.RegisterOption) error {
 	b, err := json.Marshal(s)
 	if err != nil {
 		return err
 	}
 	g.Lock()
 	if service, ok := g.services[s.Name]; !ok {
 		g.services[s.Name] = []*registry.Service{s}
 	} else {
 		g.services[s.Name] = addServices(service, []*registry.Service{s})
 	}
 	g.Unlock()
 	var options registry.RegisterOptions
 	for _, o := range opts {
 		o(&options)
 	}
 	if options.TTL == 0 && g.tcpInterval == 0 {
 		return fmt.Errorf("Require register TTL or interval for memberlist.Config")
 	}
 	up := &pb.Update{
 		Expires: uint64(time.Now().Add(options.TTL).UnixNano()),
 		Action:  actionTypeCreate,
 		Type:    updateTypeService,
 		Metadata: map[string]string{
 			"Content-Type": "application/json",
 		},
 		Data: b,
 	}
 	g.queue.QueueBroadcast(&broadcast{
 		update: up,
 		notify: nil,
 	})
 	// wait
 	<-time.After(g.interval * 2)
 	return nil
 }
 func (g *gossipRegistry) Deregister(s *registry.Service) error {
 	b, err := json.Marshal(s)
 	if err != nil {
 		return err
 	}
 	g.Lock()
 	if service, ok := g.services[s.Name]; ok {
 		if services := delServices(service, []*registry.Service{s}); len(services) == 0 {
 			delete(g.services, s.Name)
 		} else {
 			g.services[s.Name] = services
 		}
 	}
 	g.Unlock()
 	up := &pb.Update{
 		Action: actionTypeDelete,
 		Type:   updateTypeService,
 		Metadata: map[string]string{
 			"Content-Type": "application/json",
 		},
 		Data: b,
 	}
 	g.queue.QueueBroadcast(&broadcast{
 		update: up,
 		notify: nil,
 	})
 	// wait
 	<-time.After(g.interval * 2)
 	return nil
 }
 func (g *gossipRegistry) GetService(name string) ([]*registry.Service, error) {
 	g.RLock()
 	service, ok := g.services[name]
 	g.RUnlock()
 	if !ok {
 		return nil, registry.ErrNotFound
 	}
 	return service, nil
 }
 func (g *gossipRegistry) ListServices() ([]*registry.Service, error) {
 	var services []*registry.Service
 	g.RLock()
 	for _, service := range g.services {
 		services = append(services, service...)
 	}
 	g.RUnlock()
 	return services, nil
 }
 func (g *gossipRegistry) Watch(opts ...registry.WatchOption) (registry.Watcher, error) {
 	n, e := g.subscribe()
 	return newGossipWatcher(n, e, opts...)
 }
 func (g *gossipRegistry) String() string {
 	return "gossip"
 }
 func NewRegistry(opts ...registry.Option) registry.Registry {
 	g := &gossipRegistry{
 		options: registry.Options{
 			Context: context.Background(),
 		},
 		done:     make(chan bool),
 		events:   make(chan *event, 100),
 		updates:  make(chan *update, 100),
 		services: make(map[string][]*registry.Service),
 		watchers: make(map[string]chan *registry.Result),
 		members:  make(map[string]int32),
 	}
 	// run the updater
 	go g.run()
 	// configure the gossiper
 	if err := configure(g, opts...); err != nil {
 		log.Fatalf("[gossip] Error configuring registry: %v", err)
 	}
 	// wait for setup
 	<-time.After(g.interval * 2)
 	return g
 }
--- a/registry/gossip/gossip_test.go
+++ b/registry/gossip/gossip_test.go
@ -0,0 +1,214 @@
 package gossip
 import (
 	"os"
 	"sync"
 	"testing"
 	"time"
 	"github.com/google/uuid"
 	"github.com/hashicorp/memberlist"
 	"github.com/micro/go-micro/registry"
 )
 func newMemberlistConfig() *memberlist.Config {
 	mc := memberlist.DefaultLANConfig()
 	mc.DisableTcpPings = false
 	mc.GossipVerifyIncoming = false
 	mc.GossipVerifyOutgoing = false
 	mc.EnableCompression = false
 	mc.PushPullInterval = 3 * time.Second
 	mc.LogOutput = os.Stderr
 	mc.ProtocolVersion = 4
 	mc.Name = uuid.New().String()
 	return mc
 }
 func newRegistry(opts ...registry.Option) registry.Registry {
 	options := []registry.Option{
 		ConnectRetry(true),
 		ConnectTimeout(60 * time.Second),
 	}
 	options = append(options, opts...)
 	r := NewRegistry(options...)
 	return r
 }
 func TestGossipRegistryBroadcast(t *testing.T) {
 	mc1 := newMemberlistConfig()
 	r1 := newRegistry(Config(mc1), Address("127.0.0.1:54321"))
 	mc2 := newMemberlistConfig()
 	r2 := newRegistry(Config(mc2), Address("127.0.0.2:54321"), registry.Addrs("127.0.0.1:54321"))
 	defer r1.(*gossipRegistry).Stop()
 	defer r2.(*gossipRegistry).Stop()
 	svc1 := &registry.Service{Name: "service.1", Version: "0.0.0.1"}
 	svc2 := &registry.Service{Name: "service.2", Version: "0.0.0.2"}
 	if err := r1.Register(svc1, registry.RegisterTTL(10*time.Second)); err != nil {
 		t.Fatal(err)
 	}
 	if err := r2.Register(svc2, registry.RegisterTTL(10*time.Second)); err != nil {
 		t.Fatal(err)
 	}
 	var found bool
 	svcs, err := r1.ListServices()
 	if err != nil {
 		t.Fatal(err)
 	}
 	for _, svc := range svcs {
 		if svc.Name == "service.2" {
 			found = true
 		}
 	}
 	if !found {
 		t.Fatalf("[gossip registry] service.2 not found in r1, broadcast not work")
 	}
 	found = false
 	svcs, err = r2.ListServices()
 	if err != nil {
 		t.Fatal(err)
 	}
 	for _, svc := range svcs {
 		if svc.Name == "service.1" {
 			found = true
 		}
 	}
 	if !found {
 		t.Fatalf("[gossip registry] broadcast failed: service.1 not found in r2")
 	}
 	if err := r1.Deregister(svc1); err != nil {
 		t.Fatal(err)
 	}
 	if err := r2.Deregister(svc2); err != nil {
 		t.Fatal(err)
 	}
 }
 func TestGossipRegistryRetry(t *testing.T) {
 	mc1 := newMemberlistConfig()
 	r1 := newRegistry(Config(mc1), Address("127.0.0.1:54321"))
 	mc2 := newMemberlistConfig()
 	r2 := newRegistry(Config(mc2), Address("127.0.0.2:54321"), registry.Addrs("127.0.0.1:54321"))
 	defer r1.(*gossipRegistry).Stop()
 	defer r2.(*gossipRegistry).Stop()
 	svc1 := &registry.Service{Name: "service.1", Version: "0.0.0.1"}
 	svc2 := &registry.Service{Name: "service.2", Version: "0.0.0.2"}
 	var mu sync.Mutex
 	ch := make(chan struct{})
 	ticker := time.NewTicker(1 * time.Second)
 	defer ticker.Stop()
 	go func() {
 		for {
 			select {
 			case <-ticker.C:
 				mu.Lock()
 				if r1 != nil {
 					r1.Register(svc1, registry.RegisterTTL(2*time.Second))
 				}
 				if r2 != nil {
 					r2.Register(svc2, registry.RegisterTTL(2*time.Second))
 				}
 				if ch != nil {
 					close(ch)
 					ch = nil
 				}
 				mu.Unlock()
 			}
 		}
 	}()
 	<-ch
 	var found bool
 	svcs, err := r2.ListServices()
 	if err != nil {
 		t.Fatal(err)
 	}
 	for _, svc := range svcs {
 		if svc.Name == "service.1" {
 			found = true
 		}
 	}
 	if !found {
 		t.Fatalf("[gossip registry] broadcast failed: service.1 not found in r2")
 	}
 	if err = r1.(*gossipRegistry).Stop(); err != nil {
 		t.Fatalf("[gossip registry] failed to stop registry: %v", err)
 	}
 	mu.Lock()
 	r1 = nil
 	mu.Unlock()
 	<-time.After(3 * time.Second)
 	found = false
 	svcs, err = r2.ListServices()
 	if err != nil {
 		t.Fatal(err)
 	}
 	for _, svc := range svcs {
 		if svc.Name == "service.1" {
 			found = true
 		}
 	}
 	if found {
 		t.Fatalf("[gossip registry] service.1 found in r2")
 	}
 	if tr := os.Getenv("TRAVIS"); len(tr) > 0 {
 		t.Logf("[gossip registry] skip test on travis")
 		t.Skip()
 		return
 	}
 	r1 = newRegistry(Config(mc1), Address("127.0.0.1:54321"))
 	<-time.After(2 * time.Second)
 	found = false
 	svcs, err = r2.ListServices()
 	if err != nil {
 		t.Fatal(err)
 	}
 	for _, svc := range svcs {
 		if svc.Name == "service.1" {
 			found = true
 		}
 	}
 	if !found {
 		t.Fatalf("[gossip registry] connect retry failed: service.1 not found in r2")
 	}
 	if err := r1.Deregister(svc1); err != nil {
 		t.Fatal(err)
 	}
 	if err := r2.Deregister(svc2); err != nil {
 		t.Fatal(err)
 	}
 	r1.(*gossipRegistry).Stop()
 	r2.(*gossipRegistry).Stop()
 }
--- a/registry/gossip/options.go
+++ b/registry/gossip/options.go
@ -0,0 +1,58 @@
 package gossip
 import (
 	"context"
 	"time"
 	"github.com/hashicorp/memberlist"
 	"github.com/micro/go-micro/registry"
 )
 type secretKey struct{}
 type addressKey struct{}
 type configKey struct{}
 type advertiseKey struct{}
 type connectTimeoutKey struct{}
 type connectRetryKey struct{}
 // helper for setting registry options
 func setRegistryOption(k, v interface{}) registry.Option {
 	return func(o *registry.Options) {
 		if o.Context == nil {
 			o.Context = context.Background()
 		}
 		o.Context = context.WithValue(o.Context, k, v)
 	}
 }
 // Secret specifies an encryption key. The value should be either
 // 16, 24, or 32 bytes to select AES-128, AES-192, or AES-256.
 func Secret(k []byte) registry.Option {
 	return setRegistryOption(secretKey{}, k)
 }
 // Address to bind to - host:port
 func Address(a string) registry.Option {
 	return setRegistryOption(addressKey{}, a)
 }
 // Config sets *memberlist.Config for configuring gossip
 func Config(c *memberlist.Config) registry.Option {
 	return setRegistryOption(configKey{}, c)
 }
 // The address to advertise for other gossip members to connect to - host:port
 func Advertise(a string) registry.Option {
 	return setRegistryOption(advertiseKey{}, a)
 }
 // ConnectTimeout sets the registry connect timeout. Use -1 to specify infinite timeout
 func ConnectTimeout(td time.Duration) registry.Option {
 	return setRegistryOption(connectTimeoutKey{}, td)
 }
 // ConnectRetry enables reconnect to registry then connection closed,
 // use with ConnectTimeout to specify how long retry
 func ConnectRetry(v bool) registry.Option {
 	return setRegistryOption(connectRetryKey{}, v)
 }
--- a/registry/gossip/proto/gossip.micro.go
+++ b/registry/gossip/proto/gossip.micro.go
@ -0,0 +1,28 @@
 // Code generated by protoc-gen-micro. DO NOT EDIT.
 // source: github.com/micro/go-micro/registry/gossip/proto/gossip.proto
 /*
 Package gossip is a generated protocol buffer package.
 It is generated from these files:
 	github.com/micro/go-micro/registry/gossip/proto/gossip.proto
 It has these top-level messages:
 	Update
 */
 package gossip
 import proto "github.com/golang/protobuf/proto"
 import fmt "fmt"
 import 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.ProtoPackageIsVersion2 // please upgrade the proto package
--- a/registry/gossip/proto/gossip.pb.go
+++ b/registry/gossip/proto/gossip.pb.go
@ -0,0 +1,127 @@
 // Code generated by protoc-gen-go. DO NOT EDIT.
 // source: github.com/micro/go-micro/registry/gossip/proto/gossip.proto
 package gossip
 import (
 	fmt "fmt"
 	math "math"
 	proto "github.com/golang/protobuf/proto"
 )
 // 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.ProtoPackageIsVersion2 // please upgrade the proto package
 // Update is the message broadcast
 type Update struct {
 	// time to live for entry
 	Expires uint64 `protobuf:"varint,1,opt,name=expires,proto3" json:"expires,omitempty"`
 	// type of update
 	Type int32 `protobuf:"varint,2,opt,name=type,proto3" json:"type,omitempty"`
 	// what action is taken
 	Action int32 `protobuf:"varint,3,opt,name=action,proto3" json:"action,omitempty"`
 	// any other associated metadata about the data
 	Metadata map[string]string `protobuf:"bytes,6,rep,name=metadata,proto3" json:"metadata,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
 	// the payload data;
 	Data                 []byte   `protobuf:"bytes,7,opt,name=data,proto3" json:"data,omitempty"`
 	XXX_NoUnkeyedLiteral struct{} `json:"-"`
 	XXX_unrecognized     []byte   `json:"-"`
 	XXX_sizecache        int32    `json:"-"`
 }
 func (m *Update) Reset()         { *m = Update{} }
 func (m *Update) String() string { return proto.CompactTextString(m) }
 func (*Update) ProtoMessage()    {}
 func (*Update) Descriptor() ([]byte, []int) {
 	return fileDescriptor_18cba623e76e57f3, []int{0}
 }
 func (m *Update) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_Update.Unmarshal(m, b)
 }
 func (m *Update) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 	return xxx_messageInfo_Update.Marshal(b, m, deterministic)
 }
 func (m *Update) XXX_Merge(src proto.Message) {
 	xxx_messageInfo_Update.Merge(m, src)
 }
 func (m *Update) XXX_Size() int {
 	return xxx_messageInfo_Update.Size(m)
 }
 func (m *Update) XXX_DiscardUnknown() {
 	xxx_messageInfo_Update.DiscardUnknown(m)
 }
 var xxx_messageInfo_Update proto.InternalMessageInfo
 func (m *Update) GetExpires() uint64 {
 	if m != nil {
 		return m.Expires
 	}
 	return 0
 }
 func (m *Update) GetType() int32 {
 	if m != nil {
 		return m.Type
 	}
 	return 0
 }
 func (m *Update) GetAction() int32 {
 	if m != nil {
 		return m.Action
 	}
 	return 0
 }
 func (m *Update) GetMetadata() map[string]string {
 	if m != nil {
 		return m.Metadata
 	}
 	return nil
 }
 func (m *Update) GetData() []byte {
 	if m != nil {
 		return m.Data
 	}
 	return nil
 }
 func init() {
 	proto.RegisterType((*Update)(nil), "gossip.Update")
 	proto.RegisterMapType((map[string]string)(nil), "gossip.Update.MetadataEntry")
 }
 func init() {
 	proto.RegisterFile("github.com/micro/go-micro/registry/gossip/proto/gossip.proto", fileDescriptor_18cba623e76e57f3)
 }
 var fileDescriptor_18cba623e76e57f3 = []byte{
 	// 227 bytes of a gzipped FileDescriptorProto
 	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x54, 0x8f, 0xc1, 0x4a, 0x03, 0x31,
 	0x14, 0x45, 0x49, 0xa7, 0x4d, 0xed, 0x53, 0x41, 0x1e, 0x22, 0x41, 0x5c, 0x0c, 0xae, 0x66, 0xe3,
 	0x0c, 0xe8, 0xa6, 0xa8, 0x5b, 0x97, 0x6e, 0x02, 0x7e, 0x40, 0x3a, 0x0d, 0x31, 0xe8, 0x34, 0x21,
 	0x79, 0x15, 0xf3, 0xa9, 0xfe, 0x8d, 0x34, 0x89, 0x42, 0x77, 0xe7, 0x24, 0x37, 0xdc, 0x1b, 0x78,
 	0x36, 0x96, 0xde, 0xf7, 0x9b, 0x7e, 0x74, 0xd3, 0x30, 0xd9, 0x31, 0xb8, 0xc1, 0xb8, 0xbb, 0x02,
 	0x41, 0x1b, 0x1b, 0x29, 0xa4, 0xc1, 0xb8, 0x18, 0xad, 0x1f, 0x7c, 0x70, 0xe4, 0xaa, 0xf4, 0x59,
 	0x90, 0x17, 0xbb, 0xfd, 0x61, 0xc0, 0xdf, 0xfc, 0x56, 0x91, 0x46, 0x01, 0x4b, 0xfd, 0xed, 0x6d,
 	0xd0, 0x51, 0xb0, 0x96, 0x75, 0x73, 0xf9, 0xa7, 0x88, 0x30, 0xa7, 0xe4, 0xb5, 0x98, 0xb5, 0xac,
 	0x5b, 0xc8, 0xcc, 0x78, 0x05, 0x5c, 0x8d, 0x64, 0xdd, 0x4e, 0x34, 0xf9, 0xb4, 0x1a, 0xae, 0xe1,
 	0x64, 0xd2, 0xa4, 0xb6, 0x8a, 0x94, 0xe0, 0x6d, 0xd3, 0x9d, 0xde, 0xdf, 0xf4, 0xb5, 0xb9, 0xf4,
 	0xf4, 0xaf, 0xf5, 0xfa, 0x65, 0x47, 0x21, 0xc9, 0xff, 0xf4, 0xa1, 0x25, 0xbf, 0x5a, 0xb6, 0xac,
 	0x3b, 0x93, 0x99, 0xaf, 0x9f, 0xe0, 0xfc, 0x28, 0x8e, 0x17, 0xd0, 0x7c, 0xe8, 0x94, 0x07, 0xae,
 	0xe4, 0x01, 0xf1, 0x12, 0x16, 0x5f, 0xea, 0x73, 0x5f, 0xd6, 0xad, 0x64, 0x91, 0xc7, 0xd9, 0x9a,
 	0x6d, 0x78, 0xfe, 0xea, 0xc3, 0x6f, 0x00, 0x00, 0x00, 0xff, 0xff, 0xd6, 0x63, 0x7b, 0x1b, 0x2a,
 	0x01, 0x00, 0x00,
 }
--- a/registry/gossip/proto/gossip.proto
+++ b/registry/gossip/proto/gossip.proto
@ -0,0 +1,17 @@
 syntax = "proto3";
 package gossip;
 // Update is the message broadcast
 message Update {
 	// time to live for entry
 	uint64 expires = 1;
 	// type of update
 	int32 type = 2;
 	// what action is taken
 	int32 action = 3;
 	// any other associated metadata about the data
 	map<string, string> metadata = 6;
 	// the payload data;
 	bytes data = 7;
 }
--- a/registry/gossip/util.go
+++ b/registry/gossip/util.go
@ -0,0 +1,141 @@
 package gossip
 import (
 	"github.com/micro/go-micro/registry"
 )
 func cp(current []*registry.Service) []*registry.Service {
 	var services []*registry.Service
 	for _, service := range current {
 		// copy service
 		s := new(registry.Service)
 		*s = *service
 		// copy nodes
 		var nodes []*registry.Node
 		for _, node := range service.Nodes {
 			n := new(registry.Node)
 			*n = *node
 			nodes = append(nodes, n)
 		}
 		s.Nodes = nodes
 		// copy endpoints
 		var eps []*registry.Endpoint
 		for _, ep := range service.Endpoints {
 			e := new(registry.Endpoint)
 			*e = *ep
 			eps = append(eps, e)
 		}
 		s.Endpoints = eps
 		// append service
 		services = append(services, s)
 	}
 	return services
 }
 func addNodes(old, neu []*registry.Node) []*registry.Node {
 	var nodes []*registry.Node
 	// add all new nodes
 	for _, n := range neu {
 		node := *n
 		nodes = append(nodes, &node)
 	}
 	// look at old nodes
 	for _, o := range old {
 		var exists bool
 		// check against new nodes
 		for _, n := range nodes {
 			// ids match then skip
 			if o.Id == n.Id {
 				exists = true
 				break
 			}
 		}
 		// keep old node
 		if !exists {
 			node := *o
 			nodes = append(nodes, &node)
 		}
 	}
 	return nodes
 }
 func addServices(old, neu []*registry.Service) []*registry.Service {
 	var srv []*registry.Service
 	for _, s := range neu {
 		var seen bool
 		for _, o := range old {
 			if o.Version == s.Version {
 				sp := new(registry.Service)
 				// make copy
 				*sp = *o
 				// set nodes
 				sp.Nodes = addNodes(o.Nodes, s.Nodes)
 				// mark as seen
 				seen = true
 				srv = append(srv, sp)
 				break
 			}
 		}
 		if !seen {
 			srv = append(srv, cp([]*registry.Service{s})...)
 		}
 	}
 	return srv
 }
 func delNodes(old, del []*registry.Node) []*registry.Node {
 	var nodes []*registry.Node
 	for _, o := range old {
 		var rem bool
 		for _, n := range del {
 			if o.Id == n.Id {
 				rem = true
 				break
 			}
 		}
 		if !rem {
 			nodes = append(nodes, o)
 		}
 	}
 	return nodes
 }
 func delServices(old, del []*registry.Service) []*registry.Service {
 	var services []*registry.Service
 	for _, o := range old {
 		srv := new(registry.Service)
 		*srv = *o
 		var rem bool
 		for _, s := range del {
 			if srv.Version == s.Version {
 				srv.Nodes = delNodes(srv.Nodes, s.Nodes)
 				if len(srv.Nodes) == 0 {
 					rem = true
 				}
 			}
 		}
 		if !rem {
 			services = append(services, srv)
 		}
 	}
 	return services
 }
--- a/registry/gossip/util_test.go
+++ b/registry/gossip/util_test.go
@ -0,0 +1,78 @@
 package gossip
 import (
 	"testing"
 	"github.com/micro/go-micro/registry"
 )
 func TestDelServices(t *testing.T) {
 	services := []*registry.Service{
 		{
 			Name:    "foo",
 			Version: "1.0.0",
 			Nodes: []*registry.Node{
 				{
 					Id:      "foo-123",
 					Address: "localhost",
 					Port:    9999,
 				},
 			},
 		},
 		{
 			Name:    "foo",
 			Version: "1.0.0",
 			Nodes: []*registry.Node{
 				{
 					Id:      "foo-123",
 					Address: "localhost",
 					Port:    6666,
 				},
 			},
 		},
 	}
 	servs := delServices([]*registry.Service{services[0]}, []*registry.Service{services[1]})
 	if i := len(servs); i > 0 {
 		t.Errorf("Expected 0 nodes, got %d: %+v", i, servs)
 	}
 	t.Logf("Services %+v", servs)
 }
 func TestDelNodes(t *testing.T) {
 	services := []*registry.Service{
 		{
 			Name:    "foo",
 			Version: "1.0.0",
 			Nodes: []*registry.Node{
 				{
 					Id:      "foo-123",
 					Address: "localhost",
 					Port:    9999,
 				},
 				{
 					Id:      "foo-321",
 					Address: "localhost",
 					Port:    6666,
 				},
 			},
 		},
 		{
 			Name:    "foo",
 			Version: "1.0.0",
 			Nodes: []*registry.Node{
 				{
 					Id:      "foo-123",
 					Address: "localhost",
 					Port:    6666,
 				},
 			},
 		},
 	}
 	nodes := delNodes(services[0].Nodes, services[1].Nodes)
 	if i := len(nodes); i != 1 {
 		t.Errorf("Expected only 1 node, got %d: %+v", i, nodes)
 	}
 	t.Logf("Nodes %+v", nodes)
 }
--- a/registry/gossip/watcher.go
+++ b/registry/gossip/watcher.go
@ -0,0 +1,53 @@
 package gossip
 import (
 	"github.com/micro/go-micro/registry"
 )
 type gossipWatcher struct {
 	wo   registry.WatchOptions
 	next chan *registry.Result
 	stop chan bool
 }
 func newGossipWatcher(ch chan *registry.Result, stop chan bool, opts ...registry.WatchOption) (registry.Watcher, error) {
 	var wo registry.WatchOptions
 	for _, o := range opts {
 		o(&wo)
 	}
 	return &gossipWatcher{
 		wo:   wo,
 		next: ch,
 		stop: stop,
 	}, nil
 }
 func (m *gossipWatcher) Next() (*registry.Result, error) {
 	for {
 		select {
 		case r, ok := <-m.next:
 			if !ok {
 				return nil, registry.ErrWatcherStopped
 			}
 			// check watch options
 			if len(m.wo.Service) > 0 && r.Service.Name != m.wo.Service {
 				continue
 			}
 			nr := &registry.Result{}
 			*nr = *r
 			return nr, nil
 		case <-m.stop:
 			return nil, registry.ErrWatcherStopped
 		}
 	}
 }
 func (m *gossipWatcher) Stop() {
 	select {
 	case <-m.stop:
 		return
 	default:
 		close(m.stop)
 	}
 }
--- a/registry/mdns/encoding.go
+++ b/registry/mdns/encoding.go
@ -1,73 +0,0 @@
 package mdns
 import (
 	"bytes"
 	"compress/zlib"
 	"encoding/hex"
 	"encoding/json"
 	"io/ioutil"
 	"strings"
 )
 func encode(txt *mdnsTxt) ([]string, error) {
 	b, err := json.Marshal(txt)
 	if err != nil {
 		return nil, err
 	}
 	var buf bytes.Buffer
 	defer buf.Reset()
 	w := zlib.NewWriter(&buf)
 	if _, err := w.Write(b); err != nil {
 		return nil, err
 	}
 	w.Close()
 	encoded := hex.EncodeToString(buf.Bytes())
 	// individual txt limit
 	if len(encoded) <= 255 {
 		return []string{encoded}, nil
 	}
 	// split encoded string
 	var record []string
 	for len(encoded) > 255 {
 		record = append(record, encoded[:255])
 		encoded = encoded[255:]
 	}
 	record = append(record, encoded)
 	return record, nil
 }
 func decode(record []string) (*mdnsTxt, error) {
 	encoded := strings.Join(record, "")
 	hr, err := hex.DecodeString(encoded)
 	if err != nil {
 		return nil, err
 	}
 	br := bytes.NewReader(hr)
 	zr, err := zlib.NewReader(br)
 	if err != nil {
 		return nil, err
 	}
 	rbuf, err := ioutil.ReadAll(zr)
 	if err != nil {
 		return nil, err
 	}
 	var txt *mdnsTxt
 	if err := json.Unmarshal(rbuf, &txt); err != nil {
 		return nil, err
 	}
 	return txt, nil
 }
--- a/registry/mdns/encoding_test.go
+++ b/registry/mdns/encoding_test.go
@ -1,67 +0,0 @@
 package mdns
 import (
 	"testing"
 	"github.com/micro/go-micro/registry"
 )
 func TestEncoding(t *testing.T) {
 	testData := []*mdnsTxt{
 		&mdnsTxt{
 			Version: "1.0.0",
 			Metadata: map[string]string{
 				"foo": "bar",
 			},
 			Endpoints: []*registry.Endpoint{
 				&registry.Endpoint{
 					Name: "endpoint1",
 					Request: &registry.Value{
 						Name: "request",
 						Type: "request",
 					},
 					Response: &registry.Value{
 						Name: "response",
 						Type: "response",
 					},
 					Metadata: map[string]string{
 						"foo1": "bar1",
 					},
 				},
 			},
 		},
 	}
 	for _, d := range testData {
 		encoded, err := encode(d)
 		if err != nil {
 			t.Fatal(err)
 		}
 		for _, txt := range encoded {
 			if len(txt) > 255 {
 				t.Fatalf("One of parts for txt is %d characters", len(txt))
 			}
 		}
 		decoded, err := decode(encoded)
 		if err != nil {
 			t.Fatal(err)
 		}
 		if decoded.Version != d.Version {
 			t.Fatalf("Expected version %s got %s", d.Version, decoded.Version)
 		}
 		if len(decoded.Endpoints) != len(d.Endpoints) {
 			t.Fatalf("Expected %d endpoints, got %d", len(d.Endpoints), len(decoded.Endpoints))
 		}
 		for k, v := range d.Metadata {
 			if val := decoded.Metadata[k]; val != v {
 				t.Fatalf("Expected %s=%s got %s=%s", k, v, k, val)
 			}
 		}
 	}
 }
--- a/registry/mdns/mdns.go
+++ b/registry/mdns/mdns.go
@ -1,338 +1,11 @@
 // Package mdns provides a multicast dns registry
 package mdns
 /*
 	MDNS is a multicast dns registry for service discovery
 	This creates a zero dependency system which is great
 	where multicast dns is available. This usually depends
 	on the ability to leverage udp and multicast/broadcast.
 */
 import (
 	"net"
 	"strings"
 	"sync"
 	"time"
 	"github.com/micro/go-micro/registry"
 	"github.com/micro/mdns"
 	hash "github.com/mitchellh/hashstructure"
 )
-type mdnsTxt struct {
+// NewRegistry returns a new mdns registry
 	Service   string
 	Version   string
 	Endpoints []*registry.Endpoint
 	Metadata  map[string]string
 }
 type mdnsEntry struct {
 	hash uint64
 	id   string
 	node *mdns.Server
 }
 type mdnsRegistry struct {
 	opts registry.Options
 	sync.Mutex
 	services map[string][]*mdnsEntry
 }
 func newRegistry(opts ...registry.Option) registry.Registry {
 	options := registry.Options{
 		Timeout: time.Millisecond * 100,
 	}
 	return &mdnsRegistry{
 		opts:     options,
 		services: make(map[string][]*mdnsEntry),
 	}
 }
 func (m *mdnsRegistry) Init(opts ...registry.Option) error {
 	for _, o := range opts {
 		o(&m.opts)
 	}
 	return nil
 }
 func (m *mdnsRegistry) Options() registry.Options {
 	return m.opts
 }
 func (m *mdnsRegistry) Register(service *registry.Service, opts ...registry.RegisterOption) error {
 	m.Lock()
 	defer m.Unlock()
 	entries, ok := m.services[service.Name]
 	// first entry, create wildcard used for list queries
 	if !ok {
 		s, err := mdns.NewMDNSService(
 			service.Name,
 			"_services",
 			"",
 			"",
 			9999,
 			[]net.IP{net.ParseIP("0.0.0.0")},
 			nil,
 		)
 		if err != nil {
 			return err
 		}
 		srv, err := mdns.NewServer(&mdns.Config{Zone: &mdns.DNSSDService{s}})
 		if err != nil {
 			return err
 		}
 		// append the wildcard entry
 		entries = append(entries, &mdnsEntry{id: "*", node: srv})
 	}
 	var gerr error
 	for _, node := range service.Nodes {
 		// create hash of service; uint64
 		h, err := hash.Hash(node, nil)
 		if err != nil {
 			gerr = err
 			continue
 		}
 		var seen bool
 		var e *mdnsEntry
 		for _, entry := range entries {
 			if node.Id == entry.id {
 				seen = true
 				e = entry
 				break
 			}
 		}
 		// already registered, continue
 		if seen && e.hash == h {
 			continue
 			// hash doesn't match, shutdown
 		} else if seen {
 			e.node.Shutdown()
 			// doesn't exist
 		} else {
 			e = &mdnsEntry{hash: h}
 		}
 		txt, err := encode(&mdnsTxt{
 			Service:   service.Name,
 			Version:   service.Version,
 			Endpoints: service.Endpoints,
 			Metadata:  node.Metadata,
 		})
 		if err != nil {
 			gerr = err
 			continue
 		}
 		// we got here, new node
 		s, err := mdns.NewMDNSService(
 			node.Id,
 			service.Name,
 			"",
 			"",
 			node.Port,
 			[]net.IP{net.ParseIP(node.Address)},
 			txt,
 		)
 		if err != nil {
 			gerr = err
 			continue
 		}
 		srv, err := mdns.NewServer(&mdns.Config{Zone: s})
 		if err != nil {
 			gerr = err
 			continue
 		}
 		e.id = node.Id
 		e.node = srv
 		entries = append(entries, e)
 	}
 	// save
 	m.services[service.Name] = entries
 	return gerr
 }
 func (m *mdnsRegistry) Deregister(service *registry.Service) error {
 	m.Lock()
 	defer m.Unlock()
 	var newEntries []*mdnsEntry
 	// loop existing entries, check if any match, shutdown those that do
 	for _, entry := range m.services[service.Name] {
 		var remove bool
 		for _, node := range service.Nodes {
 			if node.Id == entry.id {
 				entry.node.Shutdown()
 				remove = true
 				break
 			}
 		}
 		// keep it?
 		if !remove {
 			newEntries = append(newEntries, entry)
 		}
 	}
 	// last entry is the wildcard for list queries. Remove it.
 	if len(newEntries) == 1 && newEntries[0].id == "*" {
 		newEntries[0].node.Shutdown()
 		delete(m.services, service.Name)
 	} else {
 		m.services[service.Name] = newEntries
 	}
 	return nil
 }
 func (m *mdnsRegistry) GetService(service string) ([]*registry.Service, error) {
 	p := mdns.DefaultParams(service)
 	p.Timeout = m.opts.Timeout
 	entryCh := make(chan *mdns.ServiceEntry, 10)
 	p.Entries = entryCh
 	exit := make(chan bool)
 	defer close(exit)
 	serviceMap := make(map[string]*registry.Service)
 	go func() {
 		for {
 			select {
 			case e := <-entryCh:
 				// list record so skip
 				if p.Service == "_services" {
 					continue
 				}
 				if e.TTL == 0 {
 					continue
 				}
 				txt, err := decode(e.InfoFields)
 				if err != nil {
 					continue
 				}
 				if txt.Service != service {
 					continue
 				}
 				s, ok := serviceMap[txt.Version]
 				if !ok {
 					s = &registry.Service{
 						Name:      txt.Service,
 						Version:   txt.Version,
 						Endpoints: txt.Endpoints,
 					}
 				}
 				s.Nodes = append(s.Nodes, &registry.Node{
 					Id:       strings.TrimSuffix(e.Name, "."+p.Service+"."+p.Domain+"."),
 					Address:  e.AddrV4.String(),
 					Port:     e.Port,
 					Metadata: txt.Metadata,
 				})
 				serviceMap[txt.Version] = s
 			case <-exit:
 				return
 			}
 		}
 	}()
 	if err := mdns.Query(p); err != nil {
 		return nil, err
 	}
 	// create list and return
 	var services []*registry.Service
 	for _, service := range serviceMap {
 		services = append(services, service)
 	}
 	return services, nil
 }
 func (m *mdnsRegistry) ListServices() ([]*registry.Service, error) {
 	p := mdns.DefaultParams("_services")
 	p.Timeout = m.opts.Timeout
 	entryCh := make(chan *mdns.ServiceEntry, 10)
 	p.Entries = entryCh
 	exit := make(chan bool)
 	defer close(exit)
 	serviceMap := make(map[string]bool)
 	var services []*registry.Service
 	go func() {
 		for {
 			select {
 			case e := <-entryCh:
 				if e.TTL == 0 {
 					continue
 				}
 				name := strings.TrimSuffix(e.Name, "."+p.Service+"."+p.Domain+".")
 				if !serviceMap[name] {
 					serviceMap[name] = true
 					services = append(services, &registry.Service{Name: name})
 				}
 			case <-exit:
 				return
 			}
 		}
 	}()
 	if err := mdns.Query(p); err != nil {
 		return nil, err
 	}
 	return services, nil
 }
 func (m *mdnsRegistry) Watch(opts ...registry.WatchOption) (registry.Watcher, error) {
 	var wo registry.WatchOptions
 	for _, o := range opts {
 		o(&wo)
 	}
 	md := &mdnsWatcher{
 		wo:   wo,
 		ch:   make(chan *mdns.ServiceEntry, 32),
 		exit: make(chan struct{}),
 	}
 	go func() {
 		if err := mdns.Listen(md.ch, md.exit); err != nil {
 			md.Stop()
 		}
 	}()
 	return md, nil
 }
 func (m *mdnsRegistry) String() string {
 	return "mdns"
 }
 func NewRegistry(opts ...registry.Option) registry.Registry {
-	return newRegistry(opts...)
+	return registry.NewRegistry(opts...)
 }
--- a/registry/mdns_registry.go
+++ b/registry/mdns_registry.go
@ -0,0 +1,344 @@
 // Package mdns is a multicast dns registry
 package registry
 import (
 	"context"
 	"net"
 	"strings"
 	"sync"
 	"time"
 	"github.com/micro/mdns"
 	hash "github.com/mitchellh/hashstructure"
 )
 type mdnsTxt struct {
 	Service   string
 	Version   string
 	Endpoints []*Endpoint
 	Metadata  map[string]string
 }
 type mdnsEntry struct {
 	hash uint64
 	id   string
 	node *mdns.Server
 }
 type mdnsRegistry struct {
 	opts Options
 	sync.Mutex
 	services map[string][]*mdnsEntry
 }
 func newRegistry(opts ...Option) Registry {
 	options := Options{
 		Timeout: time.Millisecond * 100,
 	}
 	return &mdnsRegistry{
 		opts:     options,
 		services: make(map[string][]*mdnsEntry),
 	}
 }
 func (m *mdnsRegistry) Init(opts ...Option) error {
 	for _, o := range opts {
 		o(&m.opts)
 	}
 	return nil
 }
 func (m *mdnsRegistry) Options() Options {
 	return m.opts
 }
 func (m *mdnsRegistry) Register(service *Service, opts ...RegisterOption) error {
 	m.Lock()
 	defer m.Unlock()
 	entries, ok := m.services[service.Name]
 	// first entry, create wildcard used for list queries
 	if !ok {
 		s, err := mdns.NewMDNSService(
 			service.Name,
 			"_services",
 			"",
 			"",
 			9999,
 			[]net.IP{net.ParseIP("0.0.0.0")},
 			nil,
 		)
 		if err != nil {
 			return err
 		}
 		srv, err := mdns.NewServer(&mdns.Config{Zone: &mdns.DNSSDService{s}})
 		if err != nil {
 			return err
 		}
 		// append the wildcard entry
 		entries = append(entries, &mdnsEntry{id: "*", node: srv})
 	}
 	var gerr error
 	for _, node := range service.Nodes {
 		// create hash of service; uint64
 		h, err := hash.Hash(node, nil)
 		if err != nil {
 			gerr = err
 			continue
 		}
 		var seen bool
 		var e *mdnsEntry
 		for _, entry := range entries {
 			if node.Id == entry.id {
 				seen = true
 				e = entry
 				break
 			}
 		}
 		// already registered, continue
 		if seen && e.hash == h {
 			continue
 			// hash doesn't match, shutdown
 		} else if seen {
 			e.node.Shutdown()
 			// doesn't exist
 		} else {
 			e = &mdnsEntry{hash: h}
 		}
 		txt, err := encode(&mdnsTxt{
 			Service:   service.Name,
 			Version:   service.Version,
 			Endpoints: service.Endpoints,
 			Metadata:  node.Metadata,
 		})
 		if err != nil {
 			gerr = err
 			continue
 		}
 		// we got here, new node
 		s, err := mdns.NewMDNSService(
 			node.Id,
 			service.Name,
 			"",
 			"",
 			node.Port,
 			[]net.IP{net.ParseIP(node.Address)},
 			txt,
 		)
 		if err != nil {
 			gerr = err
 			continue
 		}
 		srv, err := mdns.NewServer(&mdns.Config{Zone: s})
 		if err != nil {
 			gerr = err
 			continue
 		}
 		e.id = node.Id
 		e.node = srv
 		entries = append(entries, e)
 	}
 	// save
 	m.services[service.Name] = entries
 	return gerr
 }
 func (m *mdnsRegistry) Deregister(service *Service) error {
 	m.Lock()
 	defer m.Unlock()
 	var newEntries []*mdnsEntry
 	// loop existing entries, check if any match, shutdown those that do
 	for _, entry := range m.services[service.Name] {
 		var remove bool
 		for _, node := range service.Nodes {
 			if node.Id == entry.id {
 				entry.node.Shutdown()
 				remove = true
 				break
 			}
 		}
 		// keep it?
 		if !remove {
 			newEntries = append(newEntries, entry)
 		}
 	}
 	// last entry is the wildcard for list queries. Remove it.
 	if len(newEntries) == 1 && newEntries[0].id == "*" {
 		newEntries[0].node.Shutdown()
 		delete(m.services, service.Name)
 	} else {
 		m.services[service.Name] = newEntries
 	}
 	return nil
 }
 func (m *mdnsRegistry) GetService(service string) ([]*Service, error) {
 	serviceMap := make(map[string]*Service)
 	entries := make(chan *mdns.ServiceEntry, 10)
 	done := make(chan bool)
 	p := mdns.DefaultParams(service)
 	// set context with timeout
 	p.Context, _ = context.WithTimeout(context.Background(), m.opts.Timeout)
 	// set entries channel
 	p.Entries = entries
 	go func() {
 		for {
 			select {
 			case e := <-entries:
 				// list record so skip
 				if p.Service == "_services" {
 					continue
 				}
 				if e.TTL == 0 {
 					continue
 				}
 				txt, err := decode(e.InfoFields)
 				if err != nil {
 					continue
 				}
 				if txt.Service != service {
 					continue
 				}
 				s, ok := serviceMap[txt.Version]
 				if !ok {
 					s = &Service{
 						Name:      txt.Service,
 						Version:   txt.Version,
 						Endpoints: txt.Endpoints,
 					}
 				}
 				s.Nodes = append(s.Nodes, &Node{
 					Id:       strings.TrimSuffix(e.Name, "."+p.Service+"."+p.Domain+"."),
 					Address:  e.AddrV4.String(),
 					Port:     e.Port,
 					Metadata: txt.Metadata,
 				})
 				serviceMap[txt.Version] = s
 			case <-p.Context.Done():
 				close(done)
 				return
 			}
 		}
 	}()
 	// execute the query
 	if err := mdns.Query(p); err != nil {
 		return nil, err
 	}
 	// wait for completion
 	<-done
 	// create list and return
 	var services []*Service
 	for _, service := range serviceMap {
 		services = append(services, service)
 	}
 	return services, nil
 }
 func (m *mdnsRegistry) ListServices() ([]*Service, error) {
 	serviceMap := make(map[string]bool)
 	entries := make(chan *mdns.ServiceEntry, 10)
 	done := make(chan bool)
 	p := mdns.DefaultParams("_services")
 	// set context with timeout
 	p.Context, _ = context.WithTimeout(context.Background(), m.opts.Timeout)
 	// set entries channel
 	p.Entries = entries
 	var services []*Service
 	go func() {
 		for {
 			select {
 			case e := <-entries:
 				if e.TTL == 0 {
 					continue
 				}
 				name := strings.TrimSuffix(e.Name, "."+p.Service+"."+p.Domain+".")
 				if !serviceMap[name] {
 					serviceMap[name] = true
 					services = append(services, &Service{Name: name})
 				}
 			case <-p.Context.Done():
 				close(done)
 				return
 			}
 		}
 	}()
 	// execute query
 	if err := mdns.Query(p); err != nil {
 		return nil, err
 	}
 	// wait till done
 	<-done
 	return services, nil
 }
 func (m *mdnsRegistry) Watch(opts ...WatchOption) (Watcher, error) {
 	var wo WatchOptions
 	for _, o := range opts {
 		o(&wo)
 	}
 	md := &mdnsWatcher{
 		wo:   wo,
 		ch:   make(chan *mdns.ServiceEntry, 32),
 		exit: make(chan struct{}),
 	}
 	go func() {
 		if err := mdns.Listen(md.ch, md.exit); err != nil {
 			md.Stop()
 		}
 	}()
 	return md, nil
 }
 func (m *mdnsRegistry) String() string {
 	return "mdns"
 }
 // NewRegistry returns a new default registry which is mdns
 func NewRegistry(opts ...Option) Registry {
 	return newRegistry(opts...)
 }
--- a/registry/mdns/mdns_test.go
+++ b/registry/mdns/mdns_test.go
@ -1,19 +1,17 @@
-package mdns
+package registry
 import (
 	"testing"
 	"time"
 	"github.com/micro/go-micro/registry"
 )
 func TestMDNS(t *testing.T) {
-	testData := []*registry.Service{
+	testData := []*Service{
-		&registry.Service{
+		&Service{
 			Name:    "test1",
 			Version: "1.0.1",
-			Nodes: []*registry.Node{
+			Nodes: []*Node{
-				&registry.Node{
+				&Node{
 					Id:      "test1-1",
 					Address: "10.0.0.1",
 					Port:    10001,
@ -23,11 +21,11 @@ func TestMDNS(t *testing.T) {
 				},
 			},
 		},
-		&registry.Service{
+		&Service{
 			Name:    "test2",
 			Version: "1.0.2",
-			Nodes: []*registry.Node{
+			Nodes: []*Node{
-				&registry.Node{
+				&Node{
 					Id:      "test2-1",
 					Address: "10.0.0.2",
 					Port:    10002,
@ -37,11 +35,11 @@ func TestMDNS(t *testing.T) {
 				},
 			},
 		},
-		&registry.Service{
+		&Service{
 			Name:    "test3",
 			Version: "1.0.3",
-			Nodes: []*registry.Node{
+			Nodes: []*Node{
-				&registry.Node{
+				&Node{
 					Id:      "test3-1",
 					Address: "10.0.0.3",
 					Port:    10003,
--- a/registry/mdns_watcher.go
+++ b/registry/mdns_watcher.go
@ -1,20 +1,19 @@
-package mdns
+package registry
 import (
 	"errors"
 	"strings"
 	"github.com/micro/go-micro/registry"
 	"github.com/micro/mdns"
 )
 type mdnsWatcher struct {
-	wo   registry.WatchOptions
+	wo   WatchOptions
 	ch   chan *mdns.ServiceEntry
 	exit chan struct{}
 }
-func (m *mdnsWatcher) Next() (*registry.Result, error) {
+func (m *mdnsWatcher) Next() (*Result, error) {
 	for {
 		select {
 		case e := <-m.ch:
@ -41,7 +40,7 @@ func (m *mdnsWatcher) Next() (*registry.Result, error) {
 				action = "create"
 			}
-			service := &registry.Service{
+			service := &Service{
 				Name:      txt.Service,
 				Version:   txt.Version,
 				Endpoints: txt.Endpoints,
@ -52,14 +51,14 @@ func (m *mdnsWatcher) Next() (*registry.Result, error) {
 				continue
 			}
-			service.Nodes = append(service.Nodes, &registry.Node{
+			service.Nodes = append(service.Nodes, &Node{
 				Id:       strings.TrimSuffix(e.Name, "."+service.Name+".local."),
 				Address:  e.AddrV4.String(),
 				Port:     e.Port,
 				Metadata: txt.Metadata,
 			})
-			return &registry.Result{
+			return &Result{
 				Action:  action,
 				Service: service,
 			}, nil
--- a/registry/memory/data.go
+++ b/registry/memory/data.go
@ -0,0 +1,51 @@
 package memory
 import (
 	"github.com/micro/go-micro/registry"
 )
 var (
 	// mock data
 	Data = map[string][]*registry.Service{
 		"foo": []*registry.Service{
 			{
 				Name:    "foo",
 				Version: "1.0.0",
 				Nodes: []*registry.Node{
 					{
 						Id:      "foo-1.0.0-123",
 						Address: "localhost",
 						Port:    9999,
 					},
 					{
 						Id:      "foo-1.0.0-321",
 						Address: "localhost",
 						Port:    9999,
 					},
 				},
 			},
 			{
 				Name:    "foo",
 				Version: "1.0.1",
 				Nodes: []*registry.Node{
 					{
 						Id:      "foo-1.0.1-321",
 						Address: "localhost",
 						Port:    6666,
 					},
 				},
 			},
 			{
 				Name:    "foo",
 				Version: "1.0.3",
 				Nodes: []*registry.Node{
 					{
 						Id:      "foo-1.0.3-345",
 						Address: "localhost",
 						Port:    8888,
 					},
 				},
 			},
 		},
 	}
 )
--- a/registry/memory/helper.go
+++ b/registry/memory/helper.go
@ -1,4 +1,4 @@
-package mock
+package memory
 import (
 	"github.com/micro/go-micro/registry"
--- a/registry/memory/helper_test.go
+++ b/registry/memory/helper_test.go
@ -1,4 +1,4 @@
-package mock
+package memory
 import (
 	"testing"
--- a/registry/memory/memory.go
+++ b/registry/memory/memory.go
@ -0,0 +1,160 @@
 // Package memory provides an in-memory registry
 package memory
 import (
 	"context"
 	"sync"
 	"time"
 	"github.com/google/uuid"
 	"github.com/micro/go-micro/registry"
 )
 type Registry struct {
 	options registry.Options
 	sync.RWMutex
 	Services map[string][]*registry.Service
 	Watchers map[string]*Watcher
 }
 var (
 	timeout = time.Millisecond * 10
 )
 // Setup sets mock data
 func (m *Registry) Setup() {
 	m.Lock()
 	defer m.Unlock()
 	// add some memory data
 	m.Services = Data
 }
 func (m *Registry) watch(r *registry.Result) {
 	var watchers []*Watcher
 	m.RLock()
 	for _, w := range m.Watchers {
 		watchers = append(watchers, w)
 	}
 	m.RUnlock()
 	for _, w := range watchers {
 		select {
 		case <-w.exit:
 			m.Lock()
 			delete(m.Watchers, w.id)
 			m.Unlock()
 		default:
 			select {
 			case w.res <- r:
 			case <-time.After(timeout):
 			}
 		}
 	}
 }
 func (m *Registry) Init(opts ...registry.Option) error {
 	for _, o := range opts {
 		o(&m.options)
 	}
 	// add services
 	m.Lock()
 	for k, v := range getServices(m.options.Context) {
 		s := m.Services[k]
 		m.Services[k] = addServices(s, v)
 	}
 	m.Unlock()
 	return nil
 }
 func (m *Registry) Options() registry.Options {
 	return m.options
 }
 func (m *Registry) GetService(service string) ([]*registry.Service, error) {
 	m.RLock()
 	s, ok := m.Services[service]
 	if !ok || len(s) == 0 {
 		m.RUnlock()
 		return nil, registry.ErrNotFound
 	}
 	m.RUnlock()
 	return s, nil
 }
 func (m *Registry) ListServices() ([]*registry.Service, error) {
 	m.RLock()
 	var services []*registry.Service
 	for _, service := range m.Services {
 		services = append(services, service...)
 	}
 	m.RUnlock()
 	return services, nil
 }
 func (m *Registry) Register(s *registry.Service, opts ...registry.RegisterOption) error {
 	go m.watch(&registry.Result{Action: "update", Service: s})
 	m.Lock()
 	services := addServices(m.Services[s.Name], []*registry.Service{s})
 	m.Services[s.Name] = services
 	m.Unlock()
 	return nil
 }
 func (m *Registry) Deregister(s *registry.Service) error {
 	go m.watch(&registry.Result{Action: "delete", Service: s})
 	m.Lock()
 	services := delServices(m.Services[s.Name], []*registry.Service{s})
 	m.Services[s.Name] = services
 	m.Unlock()
 	return nil
 }
 func (m *Registry) Watch(opts ...registry.WatchOption) (registry.Watcher, error) {
 	var wo registry.WatchOptions
 	for _, o := range opts {
 		o(&wo)
 	}
 	w := &Watcher{
 		exit: make(chan bool),
 		res:  make(chan *registry.Result),
 		id:   uuid.New().String(),
 		wo:   wo,
 	}
 	m.Lock()
 	m.Watchers[w.id] = w
 	m.Unlock()
 	return w, nil
 }
 func (m *Registry) String() string {
 	return "memory"
 }
 func NewRegistry(opts ...registry.Option) registry.Registry {
 	options := registry.Options{
 		Context: context.Background(),
 	}
 	for _, o := range opts {
 		o(&options)
 	}
 	services := getServices(options.Context)
 	if services == nil {
 		services = make(map[string][]*registry.Service)
 	}
 	return &Registry{
 		options:  options,
 		Services: services,
 		Watchers: make(map[string]*Watcher),
 	}
 }
--- a/registry/memory/memory_test.go
+++ b/registry/memory/memory_test.go
@ -1,4 +1,4 @@
-package mock
+package memory
 import (
 	"testing"
@ -80,7 +80,7 @@ var (
 	}
 )
-func TestMockRegistry(t *testing.T) {
+func TestMemoryRegistry(t *testing.T) {
 	m := NewRegistry()
 	fn := func(k string, v []*registry.Service) {
@ -107,11 +107,6 @@ func TestMockRegistry(t *testing.T) {
 		}
 	}
 	// test existing mock data
 	for k, v := range mockData {
 		fn(k, v)
 	}
 	// register data
 	for _, v := range testData {
 		for _, service := range v {
@ -123,7 +118,6 @@ func TestMockRegistry(t *testing.T) {
 	// using test data
 	for k, v := range testData {
 		fn(k, v)
 	}
--- a/registry/memory/memory_watcher.go
+++ b/registry/memory/memory_watcher.go
@ -1,4 +1,4 @@
-package mock
+package memory
 import (
 	"errors"
@ -6,12 +6,12 @@ import (
 	"github.com/micro/go-micro/registry"
 )
-type mockWatcher struct {
+type memoryWatcher struct {
 	exit chan bool
 	opts registry.WatchOptions
 }
-func (m *mockWatcher) Next() (*registry.Result, error) {
+func (m *memoryWatcher) Next() (*registry.Result, error) {
 	// not implement so we just block until exit
 	select {
 	case <-m.exit:
@ -19,7 +19,7 @@ func (m *mockWatcher) Next() (*registry.Result, error) {
 	}
 }
-func (m *mockWatcher) Stop() {
+func (m *memoryWatcher) Stop() {
 	select {
 	case <-m.exit:
 		return
--- a/registry/memory/options.go
+++ b/registry/memory/options.go
@ -0,0 +1,27 @@
 package memory
 import (
 	"context"
 	"github.com/micro/go-micro/registry"
 )
 type servicesKey struct{}
 func getServices(ctx context.Context) map[string][]*registry.Service {
 	s, ok := ctx.Value(servicesKey{}).(map[string][]*registry.Service)
 	if !ok {
 		return nil
 	}
 	return s
 }
 // Services is an option that preloads service data
 func Services(s map[string][]*registry.Service) registry.Option {
 	return func(o *registry.Options) {
 		if o.Context == nil {
 			o.Context = context.Background()
 		}
 		o.Context = context.WithValue(o.Context, servicesKey{}, s)
 	}
 }
--- a/registry/memory/watcher.go
+++ b/registry/memory/watcher.go
@ -0,0 +1,37 @@
 package memory
 import (
 	"errors"
 	"github.com/micro/go-micro/registry"
 )
 type Watcher struct {
 	id   string
 	wo   registry.WatchOptions
 	res  chan *registry.Result
 	exit chan bool
 }
 func (m *Watcher) Next() (*registry.Result, error) {
 	for {
 		select {
 		case r := <-m.res:
 			if len(m.wo.Service) > 0 && m.wo.Service != r.Service.Name {
 				continue
 			}
 			return r, nil
 		case <-m.exit:
 			return nil, errors.New("watcher stopped")
 		}
 	}
 }
 func (m *Watcher) Stop() {
 	select {
 	case <-m.exit:
 		return
 	default:
 		close(m.exit)
 	}
 }
--- a/registry/memory/watcher_test.go
+++ b/registry/memory/watcher_test.go
@ -0,0 +1,30 @@
 package memory
 import (
 	"testing"
 	"github.com/micro/go-micro/registry"
 )
 func TestWatcher(t *testing.T) {
 	w := &Watcher{
 		id:   "test",
 		res:  make(chan *registry.Result),
 		exit: make(chan bool),
 	}
 	go func() {
 		w.res <- &registry.Result{}
 	}()
 	_, err := w.Next()
 	if err != nil {
 		t.Fatal("unexpected err", err)
 	}
 	w.Stop()
 	if _, err := w.Next(); err == nil {
 		t.Fatal("expected error on Next()")
 	}
 }
--- a/registry/mock/mock.go
+++ b/registry/mock/mock.go
@ -1,114 +0,0 @@
 package mock
 import (
 	"github.com/micro/go-micro/registry"
 )
 type mockRegistry struct {
 	Services map[string][]*registry.Service
 }
 var (
 	mockData = map[string][]*registry.Service{
 		"foo": []*registry.Service{
 			{
 				Name:    "foo",
 				Version: "1.0.0",
 				Nodes: []*registry.Node{
 					{
 						Id:      "foo-1.0.0-123",
 						Address: "localhost",
 						Port:    9999,
 					},
 					{
 						Id:      "foo-1.0.0-321",
 						Address: "localhost",
 						Port:    9999,
 					},
 				},
 			},
 			{
 				Name:    "foo",
 				Version: "1.0.1",
 				Nodes: []*registry.Node{
 					{
 						Id:      "foo-1.0.1-321",
 						Address: "localhost",
 						Port:    6666,
 					},
 				},
 			},
 			{
 				Name:    "foo",
 				Version: "1.0.3",
 				Nodes: []*registry.Node{
 					{
 						Id:      "foo-1.0.3-345",
 						Address: "localhost",
 						Port:    8888,
 					},
 				},
 			},
 		},
 	}
 )
 func (m *mockRegistry) init() {
 	// add some mock data
 	m.Services = mockData
 }
 func (m *mockRegistry) GetService(service string) ([]*registry.Service, error) {
 	s, ok := m.Services[service]
 	if !ok || len(s) == 0 {
 		return nil, registry.ErrNotFound
 	}
 	return s, nil
 }
 func (m *mockRegistry) ListServices() ([]*registry.Service, error) {
 	var services []*registry.Service
 	for _, service := range m.Services {
 		services = append(services, service...)
 	}
 	return services, nil
 }
 func (m *mockRegistry) Register(s *registry.Service, opts ...registry.RegisterOption) error {
 	services := addServices(m.Services[s.Name], []*registry.Service{s})
 	m.Services[s.Name] = services
 	return nil
 }
 func (m *mockRegistry) Deregister(s *registry.Service) error {
 	services := delServices(m.Services[s.Name], []*registry.Service{s})
 	m.Services[s.Name] = services
 	return nil
 }
 func (m *mockRegistry) Watch(opts ...registry.WatchOption) (registry.Watcher, error) {
 	var wopts registry.WatchOptions
 	for _, o := range opts {
 		o(&wopts)
 	}
 	return &mockWatcher{exit: make(chan bool), opts: wopts}, nil
 }
 func (m *mockRegistry) String() string {
 	return "mock"
 }
 func (m *mockRegistry) Init(opts ...registry.Option) error {
 	return nil
 }
 func (m *mockRegistry) Options() registry.Options {
 	return registry.Options{}
 }
 func NewRegistry(opts ...registry.Options) registry.Registry {
 	m := &mockRegistry{Services: make(map[string][]*registry.Service)}
 	m.init()
 	return m
 }
--- a/registry/options.go
+++ b/registry/options.go
@ -11,7 +11,6 @@ type Options struct {
 	Timeout   time.Duration
 	Secure    bool
 	TLSConfig *tls.Config
 	// Other options for implementations of the interface
 	// can be stored in a context
 	Context context.Context
--- a/registry/registry.go
+++ b/registry/registry.go
@ -26,15 +26,14 @@ type RegisterOption func(*RegisterOptions)
 type WatchOption func(*WatchOptions)
 var (
-	DefaultRegistry = newConsulRegistry()
+	DefaultRegistry = NewRegistry()
 	// Not found error when GetService is called
 	ErrNotFound = errors.New("not found")
 	// Watcher stopped error when watcher is stopped
 	ErrWatcherStopped = errors.New("watcher stopped")
 )
 func NewRegistry(opts ...Option) Registry {
 	return newConsulRegistry(opts...)
 }
 // Register a service node. Additionally supply options such as TTL.
 func Register(s *Service, opts ...RegisterOption) error {
 	return DefaultRegistry.Register(s, opts...)
--- a/registry/mdns/watcher_test.go
+++ b/registry/mdns/watcher_test.go
@ -1,18 +1,16 @@
-package mdns
+package registry
 import (
 	"testing"
 	"github.com/micro/go-micro/registry"
 )
 func TestWatcher(t *testing.T) {
-	testData := []*registry.Service{
+	testData := []*Service{
-		&registry.Service{
+		&Service{
 			Name:    "test1",
 			Version: "1.0.1",
-			Nodes: []*registry.Node{
+			Nodes: []*Node{
-				&registry.Node{
+				&Node{
 					Id:      "test1-1",
 					Address: "10.0.0.1",
 					Port:    10001,
@ -22,11 +20,11 @@ func TestWatcher(t *testing.T) {
 				},
 			},
 		},
-		&registry.Service{
+		&Service{
 			Name:    "test2",
 			Version: "1.0.2",
-			Nodes: []*registry.Node{
+			Nodes: []*Node{
-				&registry.Node{
+				&Node{
 					Id:      "test2-1",
 					Address: "10.0.0.2",
 					Port:    10002,
@ -36,11 +34,11 @@ func TestWatcher(t *testing.T) {
 				},
 			},
 		},
-		&registry.Service{
+		&Service{
 			Name:    "test3",
 			Version: "1.0.3",
-			Nodes: []*registry.Node{
+			Nodes: []*Node{
-				&registry.Node{
+				&Node{
 					Id:      "test3-1",
 					Address: "10.0.0.3",
 					Port:    10003,
@ -52,7 +50,7 @@ func TestWatcher(t *testing.T) {
 		},
 	}
-	testFn := func(service, s *registry.Service) {
+	testFn := func(service, s *Service) {
 		if s == nil {
 			t.Fatalf("Expected one result for %s got nil", service.Name)
--- a/selector/cache/cache.go
+++ b/selector/cache/cache.go
@ -1,426 +0,0 @@
 // Package cache is a caching selector. It uses the registry watcher.
 package cache
 import (
 	"sync"
 	"time"
 	"github.com/micro/go-log"
 	"github.com/micro/go-micro/registry"
 	"github.com/micro/go-micro/selector"
 )
 type cacheSelector struct {
 	so  selector.Options
 	ttl time.Duration
 	// registry cache
 	sync.Mutex
 	cache map[string][]*registry.Service
 	ttls  map[string]time.Time
 	watched map[string]bool
 	// used to close or reload watcher
 	reload chan bool
 	exit   chan bool
 }
 var (
 	DefaultTTL = time.Minute
 )
 func (c *cacheSelector) quit() bool {
 	select {
 	case <-c.exit:
 		return true
 	default:
 		return false
 	}
 }
 // cp copies a service. Because we're caching handing back pointers would
 // create a race condition, so we do this instead
 // its fast enough
 func (c *cacheSelector) cp(current []*registry.Service) []*registry.Service {
 	var services []*registry.Service
 	for _, service := range current {
 		// copy service
 		s := new(registry.Service)
 		*s = *service
 		// copy nodes
 		var nodes []*registry.Node
 		for _, node := range service.Nodes {
 			n := new(registry.Node)
 			*n = *node
 			nodes = append(nodes, n)
 		}
 		s.Nodes = nodes
 		// copy endpoints
 		var eps []*registry.Endpoint
 		for _, ep := range service.Endpoints {
 			e := new(registry.Endpoint)
 			*e = *ep
 			eps = append(eps, e)
 		}
 		s.Endpoints = eps
 		// append service
 		services = append(services, s)
 	}
 	return services
 }
 func (c *cacheSelector) del(service string) {
 	delete(c.cache, service)
 	delete(c.ttls, service)
 }
 func (c *cacheSelector) get(service string) ([]*registry.Service, error) {
 	c.Lock()
 	defer c.Unlock()
 	// watch service if not watched
 	if _, ok := c.watched[service]; !ok {
 		go c.run(service)
 		c.watched[service] = true
 	}
 	// get does the actual request for a service
 	// it also caches it
 	get := func(service string) ([]*registry.Service, error) {
 		// ask the registry
 		services, err := c.so.Registry.GetService(service)
 		if err != nil {
 			return nil, err
 		}
 		// cache results
 		c.set(service, c.cp(services))
 		return services, nil
 	}
 	// check the cache first
 	services, ok := c.cache[service]
 	// cache miss or no services
 	if !ok || len(services) == 0 {
 		return get(service)
 	}
 	// got cache but lets check ttl
 	ttl, kk := c.ttls[service]
 	// within ttl so return cache
 	if kk && time.Since(ttl) < c.ttl {
 		return c.cp(services), nil
 	}
 	// expired entry so get service
 	services, err := get(service)
 	// no error then return error
 	if err == nil {
 		return services, nil
 	}
 	// not found error then return
 	if err == registry.ErrNotFound {
 		return nil, selector.ErrNotFound
 	}
 	// other error
 	// return expired cache as last resort
 	return c.cp(services), nil
 }
 func (c *cacheSelector) set(service string, services []*registry.Service) {
 	c.cache[service] = services
 	c.ttls[service] = time.Now().Add(c.ttl)
 }
 func (c *cacheSelector) update(res *registry.Result) {
 	if res == nil || res.Service == nil {
 		return
 	}
 	c.Lock()
 	defer c.Unlock()
 	services, ok := c.cache[res.Service.Name]
 	if !ok {
 		// we're not going to cache anything
 		// unless there was already a lookup
 		return
 	}
 	if len(res.Service.Nodes) == 0 {
 		switch res.Action {
 		case "delete":
 			c.del(res.Service.Name)
 		}
 		return
 	}
 	// existing service found
 	var service *registry.Service
 	var index int
 	for i, s := range services {
 		if s.Version == res.Service.Version {
 			service = s
 			index = i
 		}
 	}
 	switch res.Action {
 	case "create", "update":
 		if service == nil {
 			c.set(res.Service.Name, append(services, res.Service))
 			return
 		}
 		// append old nodes to new service
 		for _, cur := range service.Nodes {
 			var seen bool
 			for _, node := range res.Service.Nodes {
 				if cur.Id == node.Id {
 					seen = true
 					break
 				}
 			}
 			if !seen {
 				res.Service.Nodes = append(res.Service.Nodes, cur)
 			}
 		}
 		services[index] = res.Service
 		c.set(res.Service.Name, services)
 	case "delete":
 		if service == nil {
 			return
 		}
 		var nodes []*registry.Node
 		// filter cur nodes to remove the dead one
 		for _, cur := range service.Nodes {
 			var seen bool
 			for _, del := range res.Service.Nodes {
 				if del.Id == cur.Id {
 					seen = true
 					break
 				}
 			}
 			if !seen {
 				nodes = append(nodes, cur)
 			}
 		}
 		// still got nodes, save and return
 		if len(nodes) > 0 {
 			service.Nodes = nodes
 			services[index] = service
 			c.set(service.Name, services)
 			return
 		}
 		// zero nodes left
 		// only have one thing to delete
 		// nuke the thing
 		if len(services) == 1 {
 			c.del(service.Name)
 			return
 		}
 		// still have more than 1 service
 		// check the version and keep what we know
 		var srvs []*registry.Service
 		for _, s := range services {
 			if s.Version != service.Version {
 				srvs = append(srvs, s)
 			}
 		}
 		// save
 		c.set(service.Name, srvs)
 	}
 }
 // run starts the cache watcher loop
 // it creates a new watcher if there's a problem
 // reloads the watcher if Init is called
 // and returns when Close is called
 func (c *cacheSelector) run(name string) {
 	for {
 		// exit early if already dead
 		if c.quit() {
 			return
 		}
 		// create new watcher
 		w, err := c.so.Registry.Watch(
 			registry.WatchService(name),
 		)
 		if err != nil {
 			if c.quit() {
 				return
 			}
 			log.Log(err)
 			time.Sleep(time.Second)
 			continue
 		}
 		// watch for events
 		if err := c.watch(w); err != nil {
 			if c.quit() {
 				return
 			}
 			log.Log(err)
 			continue
 		}
 	}
 }
 // watch loops the next event and calls update
 // it returns if there's an error
 func (c *cacheSelector) watch(w registry.Watcher) error {
 	defer w.Stop()
 	// manage this loop
 	go func() {
 		// wait for exit or reload signal
 		select {
 		case <-c.exit:
 		case <-c.reload:
 		}
 		// stop the watcher
 		w.Stop()
 	}()
 	for {
 		res, err := w.Next()
 		if err != nil {
 			return err
 		}
 		c.update(res)
 	}
 }
 func (c *cacheSelector) Init(opts ...selector.Option) error {
 	for _, o := range opts {
 		o(&c.so)
 	}
 	// reload the watcher
 	go func() {
 		select {
 		case <-c.exit:
 			return
 		default:
 			c.reload <- true
 		}
 	}()
 	return nil
 }
 func (c *cacheSelector) Options() selector.Options {
 	return c.so
 }
 func (c *cacheSelector) Select(service string, opts ...selector.SelectOption) (selector.Next, error) {
 	sopts := selector.SelectOptions{
 		Strategy: c.so.Strategy,
 	}
 	for _, opt := range opts {
 		opt(&sopts)
 	}
 	// get the service
 	// try the cache first
 	// if that fails go directly to the registry
 	services, err := c.get(service)
 	if err != nil {
 		return nil, err
 	}
 	// apply the filters
 	for _, filter := range sopts.Filters {
 		services = filter(services)
 	}
 	// if there's nothing left, return
 	if len(services) == 0 {
 		return nil, selector.ErrNoneAvailable
 	}
 	return sopts.Strategy(services), nil
 }
 func (c *cacheSelector) Mark(service string, node *registry.Node, err error) {
 	return
 }
 func (c *cacheSelector) Reset(service string) {
 	return
 }
 // Close stops the watcher and destroys the cache
 func (c *cacheSelector) Close() error {
 	c.Lock()
 	c.cache = make(map[string][]*registry.Service)
 	c.watched = make(map[string]bool)
 	c.Unlock()
 	select {
 	case <-c.exit:
 		return nil
 	default:
 		close(c.exit)
 	}
 	return nil
 }
 func (c *cacheSelector) String() string {
 	return "cache"
 }
 func NewSelector(opts ...selector.Option) selector.Selector {
 	sopts := selector.Options{
 		Strategy: selector.Random,
 	}
 	for _, opt := range opts {
 		opt(&sopts)
 	}
 	if sopts.Registry == nil {
 		sopts.Registry = registry.DefaultRegistry
 	}
 	ttl := DefaultTTL
 	if sopts.Context != nil {
 		if t, ok := sopts.Context.Value(ttlKey{}).(time.Duration); ok {
 			ttl = t
 		}
 	}
 	return &cacheSelector{
 		so:      sopts,
 		ttl:     ttl,
 		watched: make(map[string]bool),
 		cache:   make(map[string][]*registry.Service),
 		ttls:    make(map[string]time.Time),
 		reload:  make(chan bool, 1),
 		exit:    make(chan bool),
 	}
 }
--- a/selector/cache/cache_test.go
+++ b/selector/cache/cache_test.go
@ -1,29 +0,0 @@
 package cache
 import (
 	"testing"
 	"github.com/micro/go-micro/registry/mock"
 	"github.com/micro/go-micro/selector"
 )
 func TestCacheSelector(t *testing.T) {
 	counts := map[string]int{}
 	cache := NewSelector(selector.Registry(mock.NewRegistry()))
 	next, err := cache.Select("foo")
 	if err != nil {
 		t.Errorf("Unexpected error calling cache select: %v", err)
 	}
 	for i := 0; i < 100; i++ {
 		node, err := next()
 		if err != nil {
 			t.Errorf("Expected node err, got err: %v", err)
 		}
 		counts[node.Id]++
 	}
 	t.Logf("Cache Counts %v", counts)
 }
--- a/selector/default.go
+++ b/selector/default.go
@ -1,27 +1,45 @@
 package selector
 import (
 	"time"
 	"github.com/micro/go-micro/registry"
 	"github.com/micro/go-rcache"
 )
-type defaultSelector struct {
+type registrySelector struct {
 	so Options
 	rc rcache.Cache
 }
-func (r *defaultSelector) Init(opts ...Option) error {
+func (c *registrySelector) newRCache() rcache.Cache {
-	for _, o := range opts {
+	ropts := []rcache.Option{}
-		o(&r.so)
+	if c.so.Context != nil {
 		if t, ok := c.so.Context.Value("selector_ttl").(time.Duration); ok {
 			ropts = append(ropts, rcache.WithTTL(t))
 		}
 	}
 	return rcache.New(c.so.Registry, ropts...)
 }
 func (c *registrySelector) Init(opts ...Option) error {
 	for _, o := range opts {
 		o(&c.so)
 	}
 	c.rc.Stop()
 	c.rc = c.newRCache()
 	return nil
 }
-func (r *defaultSelector) Options() Options {
+func (c *registrySelector) Options() Options {
-	return r.so
+	return c.so
 }
-func (r *defaultSelector) Select(service string, opts ...SelectOption) (Next, error) {
+func (c *registrySelector) Select(service string, opts ...SelectOption) (Next, error) {
 	sopts := SelectOptions{
-		Strategy: r.so.Strategy,
+		Strategy: c.so.Strategy,
 	}
 	for _, opt := range opts {
@ -29,7 +47,9 @@ func (r *defaultSelector) Select(service string, opts ...SelectOption) (Next, er
 	}
 	// get the service
-	services, err := r.so.Registry.GetService(service)
+	// try the cache first
 	// if that fails go directly to the registry
 	services, err := c.rc.GetService(service)
 	if err != nil {
 		return nil, err
 	}
@ -47,23 +67,24 @@ func (r *defaultSelector) Select(service string, opts ...SelectOption) (Next, er
 	return sopts.Strategy(services), nil
 }
-func (r *defaultSelector) Mark(service string, node *registry.Node, err error) {
+func (c *registrySelector) Mark(service string, node *registry.Node, err error) {
 	return
 }
-func (r *defaultSelector) Reset(service string) {
+func (c *registrySelector) Reset(service string) {
 	return
 }
-func (r *defaultSelector) Close() error {
+// Close stops the watcher and destroys the cache
 func (c *registrySelector) Close() error {
 	c.rc.Stop()
 	return nil
 }
-func (r *defaultSelector) String() string {
+func (c *registrySelector) String() string {
-	return "default"
+	return "registry"
 }
-func newDefaultSelector(opts ...Option) Selector {
+func NewSelector(opts ...Option) Selector {
 	sopts := Options{
 		Strategy: Random,
 	}
@ -76,7 +97,10 @@ func newDefaultSelector(opts ...Option) Selector {
 		sopts.Registry = registry.DefaultRegistry
 	}
-	return &defaultSelector{
+	s := &registrySelector{
 		so: sopts,
 	}
 	s.rc = s.newRCache()
 	return s
 }
--- a/selector/default_test.go
+++ b/selector/default_test.go
@ -3,17 +3,19 @@ package selector
 import (
 	"testing"
-	"github.com/micro/go-micro/registry/mock"
+	"github.com/micro/go-micro/registry/memory"
 )
-func TestDefaultSelector(t *testing.T) {
+func TestRegistrySelector(t *testing.T) {
 	counts := map[string]int{}
-	rs := newDefaultSelector(Registry(mock.NewRegistry()))
+	r := memory.NewRegistry()
 	r.(*memory.Registry).Setup()
 	cache := NewSelector(Registry(r))
-	next, err := rs.Select("foo")
+	next, err := cache.Select("foo")
 	if err != nil {
-		t.Errorf("Unexpected error calling default select: %v", err)
+		t.Errorf("Unexpected error calling cache select: %v", err)
 	}
 	for i := 0; i < 100; i++ {
@ -24,5 +26,5 @@ func TestDefaultSelector(t *testing.T) {
 		counts[node.Id]++
 	}
-	t.Logf("Default Counts %v", counts)
+	t.Logf("Selector Counts %v", counts)
 }
--- a/selector/dns/dns.go
+++ b/selector/dns/dns.go
@ -0,0 +1,128 @@
 // Package dns provides a dns SRV selector
 package dns
 import (
 	"net"
 	"strconv"
 	"github.com/micro/go-micro/registry"
 	"github.com/micro/go-micro/selector"
 )
 type dnsSelector struct {
 	options selector.Options
 	domain  string
 }
 var (
 	DefaultDomain = "local"
 )
 func (d *dnsSelector) Init(opts ...selector.Option) error {
 	for _, o := range opts {
 		o(&d.options)
 	}
 	return nil
 }
 func (d *dnsSelector) Options() selector.Options {
 	return d.options
 }
 func (d *dnsSelector) Select(service string, opts ...selector.SelectOption) (selector.Next, error) {
 	var srv []*net.SRV
 	// check if its host:port
 	host, port, err := net.SplitHostPort(service)
 	// not host:port
 	if err != nil {
 		// lookup the SRV record
 		_, srvs, err := net.LookupSRV(service, "tcp", d.domain)
 		if err != nil {
 			return nil, err
 		}
 		// set SRV records
 		srv = srvs
 		// got host:port
 	} else {
 		p, _ := strconv.Atoi(port)
 		// lookup the A record
 		ips, err := net.LookupHost(host)
 		if err != nil {
 			return nil, err
 		}
 		// create SRV records
 		for _, ip := range ips {
 			srv = append(srv, &net.SRV{
 				Target: ip,
 				Port:   uint16(p),
 			})
 		}
 	}
 	var nodes []*registry.Node
 	for _, node := range srv {
 		nodes = append(nodes, &registry.Node{
 			Id:      node.Target,
 			Address: node.Target,
 			Port:    int(node.Port),
 		})
 	}
 	services := []*registry.Service{
 		&registry.Service{
 			Name:  service,
 			Nodes: nodes,
 		},
 	}
 	sopts := selector.SelectOptions{
 		Strategy: d.options.Strategy,
 	}
 	for _, opt := range opts {
 		opt(&sopts)
 	}
 	// apply the filters
 	for _, filter := range sopts.Filters {
 		services = filter(services)
 	}
 	// if there's nothing left, return
 	if len(services) == 0 {
 		return nil, selector.ErrNoneAvailable
 	}
 	return sopts.Strategy(services), nil
 }
 func (d *dnsSelector) Mark(service string, node *registry.Node, err error) {
 	return
 }
 func (d *dnsSelector) Reset(service string) {
 	return
 }
 func (d *dnsSelector) Close() error {
 	return nil
 }
 func (d *dnsSelector) String() string {
 	return "dns"
 }
 func NewSelector(opts ...selector.Option) selector.Selector {
 	options := selector.Options{
 		Strategy: selector.Random,
 	}
 	for _, o := range opts {
 		o(&options)
 	}
 	return &dnsSelector{options: options, domain: DefaultDomain}
 }
--- a/selector/filter_test.go
+++ b/selector/filter_test.go
@ -80,7 +80,7 @@ func TestFilterEndpoint(t *testing.T) {
 				}
 			}
-			if seen == false && data.count > 0 {
+			if !seen && data.count > 0 {
 				t.Fatalf("Expected %d services but seen is %t; result %+v", data.count, seen, services)
 			}
 		}
@ -232,7 +232,7 @@ func TestFilterVersion(t *testing.T) {
 			seen = true
 		}
-		if seen == false && data.count > 0 {
+		if !seen && data.count > 0 {
 			t.Fatalf("Expected %d services but seen is %t; result %+v", data.count, seen, services)
 		}
 	}
--- a/selector/registry/options.go
+++ b/selector/registry/options.go
@ -1,4 +1,4 @@
-package cache
+package registry
 import (
 	"context"
@ -7,14 +7,12 @@ import (
 	"github.com/micro/go-micro/selector"
 )
-type ttlKey struct{}
+// Set the registry cache ttl
 // Set the cache ttl
 func TTL(t time.Duration) selector.Option {
 	return func(o *selector.Options) {
 		if o.Context == nil {
 			o.Context = context.Background()
 		}
-		o.Context = context.WithValue(o.Context, ttlKey{}, t)
+		o.Context = context.WithValue(o.Context, "selector_ttl", t)
 	}
 }
--- a/selector/registry/registry.go
+++ b/selector/registry/registry.go
@ -0,0 +1,11 @@
 // Package registry uses the go-micro registry for selection
 package registry
 import (
 	"github.com/micro/go-micro/selector"
 )
 // NewSelector returns a new registry selector
 func NewSelector(opts ...selector.Option) selector.Selector {
 	return selector.NewSelector(opts...)
 }
--- a/selector/selector.go
+++ b/selector/selector.go
@ -1,4 +1,4 @@
-// Package selector is a way to load balance service nodes
+// Package selector is a way to pick a list of service nodes
 package selector
 import (
@ -35,12 +35,8 @@ type Filter func([]*registry.Service) []*registry.Service
 type Strategy func([]*registry.Service) Next
 var (
-	DefaultSelector = newDefaultSelector()
+	DefaultSelector = NewSelector()
 	ErrNotFound      = errors.New("not found")
 	ErrNoneAvailable = errors.New("none available")
 )
 func NewSelector(opts ...Option) Selector {
 	return newDefaultSelector(opts...)
 }
--- a/selector/static/static.go
+++ b/selector/static/static.go
@ -0,0 +1,71 @@
 // Package static provides a static resolver which returns the name/ip passed in without any change
 package static
 import (
 	"net"
 	"strconv"
 	"github.com/micro/go-micro/registry"
 	"github.com/micro/go-micro/selector"
 )
 // staticSelector is a static selector
 type staticSelector struct {
 	opts selector.Options
 }
 func (s *staticSelector) Init(opts ...selector.Option) error {
 	for _, o := range opts {
 		o(&s.opts)
 	}
 	return nil
 }
 func (s *staticSelector) Options() selector.Options {
 	return s.opts
 }
 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,
 		}, nil
 	}, nil
 }
 func (s *staticSelector) Mark(service string, node *registry.Node, err error) {
 	return
 }
 func (s *staticSelector) Reset(service string) {
 	return
 }
 func (s *staticSelector) Close() error {
 	return nil
 }
 func (s *staticSelector) String() string {
 	return "static"
 }
 func NewSelector(opts ...selector.Option) selector.Selector {
 	var options selector.Options
 	for _, o := range opts {
 		o(&options)
 	}
 	return &staticSelector{
 		opts: options,
 	}
 }
--- a/Show More
+++ b/Show More