update readme

Gossip

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 pluggable framework for micro service 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.png" />
 
 Plugins are available at [github.com/micro/go-plugins](https://github.com/micro/go-plugins).
 
@@ -12,443 +18,33 @@ 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
-- **Load Balancing** - Client side load balancing built on discovery
-- **Message Encoding** - Dynamic encoding based on content-type with protobuf and json support
-- **Sync Streaming** - RPC based communication with support for bidirectional streaming
-- **Async Messaging** - Native PubSub messaging built in for event driven architectures
+- **Service Discovery** - Automatic service registration and name resolution. Service discovery is at the core of micro service 
+development. When service A needs to speak to service B it needs the location of that service. Consul is the default discovery 
+system with multicast DNS (mdns) as a local option or the SWIM protocol (gossip) for zero dependency p2p networks.
 
-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 proto-rpc and json-rpc by default.
 
-For more detailed information on the architecture, installation and use of go-micro checkout the [docs](https://micro.mu/docs).
+- **Sync Streaming** - 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.
-
-## 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
+See the [docs](https://micro.mu/docs/go-micro.html) for detailed information on the architecture, installation and use of go-micro.
 
 ## Sponsors
 

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...)
 }

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)
+	}
+}

broker/http_broker.go

@@ -18,6 +18,7 @@ import (
 	"sync"
 	"time"
 
+	"github.com/google/uuid"
 	"github.com/micro/go-log"
 	"github.com/micro/go-micro/broker/codec/json"
 	merr "github.com/micro/go-micro/errors"
@@ -26,7 +27,7 @@ import (
 	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
@@ -78,6 +79,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,11 +90,15 @@ 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
 }
 
@@ -116,7 +125,7 @@ func newHttpBroker(opts ...Option) Broker {
 	}
 
 	h := &httpBroker{
-		id:          "broker-" + uuid.NewUUID().String(),
+		id:          "broker-" + uuid.New().String(),
 		address:     addr,
 		opts:        options,
 		r:           reg,
@@ -126,7 +135,19 @@ func newHttpBroker(opts ...Option) Broker {
 		mux:         http.NewServeMux(),
 	}
 
+	// 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
 }
 
@@ -176,7 +197,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 +221,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 +231,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()
@@ -401,7 +422,7 @@ func (h *httpBroker) Init(opts ...Option) error {
 	}
 
 	if len(h.id) == 0 {
-		h.id = "broker-" + uuid.NewUUID().String()
+		h.id = "broker-" + uuid.New().String()
 	}
 
 	// get registry
@@ -418,6 +439,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
 }
 
@@ -495,7 +523,7 @@ func (h *httpBroker) Publish(topic string, msg *Message, opts ...PublishOption)
 }
 
 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(), ":")
@@ -508,7 +536,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
 

broker/http_broker_test.go

@@ -5,15 +5,15 @@ import (
 	"testing"
 	"time"
 
+	"github.com/google/uuid"
 	"github.com/micro/go-micro/registry/mock"
-	"github.com/pborman/uuid"
 )
 
 func sub(be *testing.B, c int) {
 	be.StopTimer()
 	m := mock.NewRegistry()
 	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)
@@ -72,7 +72,7 @@ func pub(be *testing.B, c int) {
 	be.StopTimer()
 	m := mock.NewRegistry()
 	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)

broker/mock/mock.go

@@ -1,11 +1,12 @@
+// Package mock provides a mock broker for testing
 package mock
 
 import (
 	"errors"
 	"sync"
 
+	"github.com/google/uuid"
 	"github.com/micro/go-micro/broker"
-	"github.com/pborman/uuid"
 )
 
 type mockBroker struct {
@@ -112,7 +113,7 @@ func (m *mockBroker) Subscribe(topic string, handler broker.Handler, opts ...bro
 
 	sub := &mockSubscriber{
 		exit:    make(chan bool, 1),
-		id:      uuid.NewUUID().String(),
+		id:      uuid.New().String(),
 		topic:   topic,
 		handler: handler,
 		opts:    options,

broker/options.go

@@ -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,
 	}

client/mock/mock.go

@@ -1,3 +1,4 @@
+// Package mock provides a mock client for testing
 package mock
 
 import (

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...)
 }

client/rpc_client.go

@@ -132,7 +132,7 @@ 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()))
 	}
 }
 
@@ -192,7 +192,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 {
@@ -274,7 +274,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:
 	}
 
@@ -329,7 +329,7 @@ func (r *rpcClient) Call(ctx context.Context, request Request, response interfac
 
 		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 {
@@ -367,7 +367,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:
 	}
 
@@ -416,7 +416,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 {

cmd/cmd.go

@@ -10,6 +10,7 @@ import (
 	"time"
 
 	"github.com/micro/cli"
+	"github.com/micro/go-log"
 	"github.com/micro/go-micro/client"
 	"github.com/micro/go-micro/server"
 
@@ -20,6 +21,7 @@ import (
 	// 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"
 
 	// selectors
@@ -171,6 +173,7 @@ var (
 
 	DefaultRegistries = map[string]func(...registry.Option) registry.Registry{
 		"consul": consul.NewRegistry,
+		"gossip": gossip.NewRegistry,
 		"mdns":   mdns.NewRegistry,
 	}
 
@@ -299,10 +302,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 +355,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 {
@@ -410,12 +424,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

codec/jsonrpc/jsonrpc.go

@@ -1,3 +1,4 @@
+// Package jsonrpc provides a json-rpc 1.0 codec
 package jsonrpc
 
 import (
@@ -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)
 	}

codec/protorpc/protorpc.go

@@ -1,3 +1,4 @@
+// Protorpc provides a net/rpc proto-rpc codec. See envelope.proto for the format.
 package protorpc
 
 import (
@@ -55,7 +56,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.Response:
 		c.Lock()
@@ -82,7 +85,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))
@@ -127,7 +132,8 @@ func (c *protoCodec) ReadHeader(m *codec.Message, mt codec.MessageType) error {
 		m.Id = 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)
 	}

errors/errors.go

@@ -92,13 +92,13 @@ func MethodNotAllowed(id, format string, a ...interface{}) error {
 	}
 }
 
-// InternalServerError generates a 500 error.
-func InternalServerError(id, format string, a ...interface{}) error {
+// Timeout generates a 408 error.
+func Timeout(id, format string, a ...interface{}) error {
 	return &Error{
 		Id:     id,
-		Code:   500,
+		Code:   408,
 		Detail: fmt.Sprintf(format, a...),
-		Status: http.StatusText(500),
+		Status: http.StatusText(408),
 	}
 }
 
@@ -111,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),
+	}
+}

options.go

@@ -174,6 +174,7 @@ func RegisterInterval(t time.Duration) Option {
 
 // 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

registry/consul/consul.go

@@ -1,9 +1,11 @@
+// Package consul provides a consul based registry and is the default discovery system
 package consul
 
 import (
 	"github.com/micro/go-micro/registry"
 )
 
+// NewRegistry returns a new consul registry
 func NewRegistry(opts ...registry.Option) registry.Registry {
 	return registry.NewRegistry(opts...)
 }

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.

registry/consul_registry.go

@@ -22,8 +22,12 @@ type consulRegistry struct {
 	// 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 {
@@ -78,6 +82,14 @@ func configure(c *consulRegistry, opts ...Option) {
 		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
@@ -118,8 +130,12 @@ func configure(c *consulRegistry, opts ...Option) {
 
 func newConsulRegistry(opts ...Option) Registry {
 	cr := &consulRegistry{
-		opts:     Options{},
-		register: make(map[string]uint64),
+		opts:        Options{},
+		register:    make(map[string]uint64),
+		lastChecked: make(map[string]time.Time),
+		queryOptions: &consul.QueryOptions{
+			AllowStale: true,
+		},
 	}
 	configure(cr, opts...)
 	return cr
@@ -135,9 +151,10 @@ func (c *consulRegistry) Deregister(s *Service) error {
 		return errors.New("Require at least one node")
 	}
 
-	// delete our hash of the service
+	// 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]
@@ -173,17 +190,33 @@ func (c *consulRegistry) Register(s *Service, opts ...RegisterOption) error {
 	// use first node
 	node := s.Nodes[0]
 
-	// get existing hash
+	// 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 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
+		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
+			}
 		}
 	}
 
@@ -208,7 +241,7 @@ func (c *consulRegistry) Register(s *Service, opts ...RegisterOption) error {
 		deregTTL := getDeregisterTTL(options.TTL)
 
 		check = &consul.AgentServiceCheck{
-			TTL: fmt.Sprintf("%v", options.TTL),
+			TTL:                            fmt.Sprintf("%v", options.TTL),
 			DeregisterCriticalServiceAfter: fmt.Sprintf("%v", deregTTL),
 		}
 	}
@@ -234,9 +267,10 @@ func (c *consulRegistry) Register(s *Service, opts ...RegisterOption) error {
 		return err
 	}
 
-	// save our hash of the service
+	// 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
@@ -254,9 +288,9 @@ func (c *consulRegistry) GetService(name string) ([]*Service, error) {
 
 	// if we're connect enabled only get connect services
 	if c.connect {
-		rsp, _, err = c.Client.Health().Connect(name, "", false, nil)
+		rsp, _, err = c.Client.Health().Connect(name, "", false, c.queryOptions)
 	} else {
-		rsp, _, err = c.Client.Health().Service(name, "", false, nil)
+		rsp, _, err = c.Client.Health().Service(name, "", false, c.queryOptions)
 	}
 	if err != nil {
 		return nil, err
@@ -325,7 +359,7 @@ func (c *consulRegistry) GetService(name string) ([]*Service, error) {
 }
 
 func (c *consulRegistry) ListServices() ([]*Service, error) {
-	rsp, _, err := c.Client.Catalog().Services(nil)
+	rsp, _, err := c.Client.Catalog().Services(c.queryOptions)
 	if err != nil {
 		return nil, err
 	}

registry/consul_registry_test.go

@@ -7,6 +7,7 @@ import (
 	"net"
 	"net/http"
 	"testing"
+	"time"
 
 	consul "github.com/hashicorp/consul/api"
 )
@@ -53,9 +54,14 @@ func newConsulTestRegistry(r *mockRegistry) (*consulRegistry, func()) {
 	go newMockServer(r, l)
 
 	return &consulRegistry{
-			Address:  cfg.Address,
-			Client:   cl,
-			register: make(map[string]uint64),
+			Address:     cfg.Address,
+			Client:      cl,
+			opts:        Options{},
+			register:    make(map[string]uint64),
+			lastChecked: make(map[string]time.Time),
+			queryOptions: &consul.QueryOptions{
+				AllowStale: true,
+			},
 		}, func() {
 			l.Close()
 		}

registry/gossip/README.md

@@ -0,0 +1,24 @@
+# Gossip Registry
+
+Gossip is a zero dependency registry which uses 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 
+```

registry/gossip/gossip.go

@@ -0,0 +1,565 @@
+// Package Gossip provides a gossip registry based on hashicorp/memberlist
+package gossip
+
+import (
+	"encoding/json"
+	"io/ioutil"
+	"os"
+	"strings"
+	"sync"
+	"time"
+
+	"github.com/golang/protobuf/proto"
+	"github.com/google/uuid"
+	"github.com/hashicorp/memberlist"
+	"github.com/micro/go-log"
+	"github.com/micro/go-micro/registry"
+	pb "github.com/micro/go-micro/registry/gossip/proto"
+	"github.com/mitchellh/hashstructure"
+)
+
+const (
+	addAction  = "update"
+	delAction  = "delete"
+	syncAction = "sync"
+)
+
+type broadcast struct {
+	update *pb.Update
+	notify chan<- struct{}
+}
+
+type delegate struct {
+	queue   *memberlist.TransmitLimitedQueue
+	updates chan *update
+}
+
+type gossipRegistry struct {
+	queue    *memberlist.TransmitLimitedQueue
+	updates  chan *update
+	options  registry.Options
+	member   *memberlist.Memberlist
+	interval time.Duration
+
+	sync.RWMutex
+	services map[string][]*registry.Service
+
+	s        sync.RWMutex
+	watchers map[string]chan *registry.Result
+}
+
+type update struct {
+	Update  *pb.Update
+	Service *registry.Service
+	sync    chan *registry.Service
+}
+
+var (
+	// You should change this if using secure
+	DefaultSecret = []byte("gossip")
+	ExpiryTick    = time.Second * 5
+)
+
+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
+	if g.member != nil {
+		g.member.Shutdown()
+	}
+
+	// replace addresses
+	curAddrs = newAddrs
+
+	// create a queue
+	queue := &memberlist.TransmitLimitedQueue{
+		NumNodes: func() int {
+			return len(curAddrs)
+		},
+		RetransmitMult: 3,
+	}
+
+	// machine hostname
+	hostname, _ := os.Hostname()
+
+	// create a new default config
+	c := memberlist.DefaultLocalConfig()
+
+	// set bind to random port
+	c.BindPort = 0
+
+	// set the name
+	c.Name = strings.Join([]string{"micro", hostname, uuid.New().String()}, "-")
+
+	// set the delegate
+	c.Delegate = &delegate{
+		updates: g.updates,
+		queue:   queue,
+	}
+
+	// log to dev null
+	c.LogOutput = ioutil.Discard
+
+	// set a secret key if secure
+	if g.options.Secure {
+		k, ok := g.options.Context.Value(contextSecretKey{}).([]byte)
+		if !ok {
+			// use the default secret
+			k = DefaultSecret
+		}
+		c.SecretKey = k
+	}
+
+	// TODO: set advertise addr to advertise behind nat
+
+	// create the memberlist
+	m, err := memberlist.Create(c)
+	if err != nil {
+		return err
+	}
+
+	// join the memberlist
+	if len(curAddrs) > 0 {
+		_, err := m.Join(curAddrs)
+		if err != nil {
+			return err
+		}
+	}
+
+	// set internals
+	g.queue = queue
+	g.member = m
+	g.interval = c.GossipInterval
+
+	log.Logf("Registry Listening on %s", m.LocalNode().Address())
+	return nil
+}
+
+func (b *broadcast) Invalidates(other memberlist.Broadcast) bool {
+	up := new(pb.Update)
+	if err := proto.Unmarshal(other.Message(), up); err != nil {
+		return false
+	}
+
+	// ids do not match
+	if b.update.Id == up.Id {
+		return false
+	}
+
+	// timestamps do not match
+	if b.update.Timestamp != up.Timestamp {
+		return false
+	}
+
+	// type does not match
+	if b.update.Type != up.Type {
+		return false
+	}
+
+	// invalidates
+	return true
+}
+
+func (b *broadcast) Message() []byte {
+	up, err := proto.Marshal(b.update)
+	if err != nil {
+		return nil
+	}
+	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 != "service" {
+			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: syncAction,
+		},
+		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: addAction},
+				Service: srv,
+				sync:    nil,
+			}
+		}
+	}
+}
+
+func (g *gossipRegistry) publish(action string, services []*registry.Service) {
+	g.s.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.s.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.s.Lock()
+	g.watchers[id] = next
+	g.s.Unlock()
+
+	go func() {
+		<-exit
+		g.s.Lock()
+		delete(g.watchers, id)
+		close(next)
+		g.s.Unlock()
+	}()
+
+	return next, exit
+}
+
+func (g *gossipRegistry) run() {
+	var mtx sync.Mutex
+	updates := map[uint64]*update{}
+
+	// expiry loop
+	go func() {
+		t := time.NewTicker(ExpiryTick)
+		defer t.Stop()
+
+		for _ = range t.C {
+			now := uint64(time.Now().UnixNano())
+
+			mtx.Lock()
+
+			// process all the updates
+			for k, v := range updates {
+				// check if expiry time has passed
+				if d := (v.Update.Timestamp + v.Update.Expires); d < now {
+					// delete from records
+					delete(updates, k)
+					// set to delete
+					v.Update.Action = delAction
+					// fire a new update
+					g.updates <- v
+				}
+			}
+
+			mtx.Unlock()
+		}
+	}()
+
+	// process the updates
+	for u := range g.updates {
+		switch u.Update.Action {
+		case addAction:
+			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(addAction, []*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 {
+					mtx.Lock()
+					updates[hash] = u
+					mtx.Unlock()
+				}
+			}
+		case delAction:
+			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(delAction, []*registry.Service{u.Service})
+
+			// delete from expiry checks
+			if hash, err := hashstructure.Hash(u.Service, nil); err == nil {
+				mtx.Lock()
+				delete(updates, hash)
+				mtx.Unlock()
+			}
+		case syncAction:
+			// 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(addAction, 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)
+	}
+
+	up := &pb.Update{
+		Id:        uuid.New().String(),
+		Timestamp: uint64(time.Now().UnixNano()),
+		Expires:   uint64(options.TTL.Nanoseconds()),
+		Action:    "update",
+		Type:      "service",
+		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{
+		Id:        uuid.New().String(),
+		Timestamp: uint64(time.Now().UnixNano()),
+		Action:    "delete",
+		Type:      "service",
+		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 {
+	gossip := &gossipRegistry{
+		options:  registry.Options{},
+		updates:  make(chan *update, 100),
+		services: make(map[string][]*registry.Service),
+		watchers: make(map[string]chan *registry.Result),
+	}
+
+	// configure the gossiper
+	if err := configure(gossip, opts...); err != nil {
+		log.Fatal("Error configuring registry: %v", err)
+	}
+
+	// run the updater
+	go gossip.run()
+
+	// wait for setup
+	<-time.After(gossip.interval * 2)
+
+	return gossip
+}

registry/gossip/options.go

@@ -0,0 +1,17 @@
+package gossip
+
+import (
+	"context"
+
+	"github.com/micro/go-micro/registry"
+)
+
+type contextSecretKey struct{}
+
+// 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 func(o *registry.Options) {
+		o.Context = context.WithValue(o.Context, contextSecretKey{}, k)
+	}
+}

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

registry/gossip/proto/gossip.pb.go

@@ -0,0 +1,145 @@
+// 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"
+	proto "github.com/golang/protobuf/proto"
+	math "math"
+)
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ = proto.Marshal
+var _ = fmt.Errorf
+var _ = math.Inf
+
+// This is a compile-time assertion to ensure that this generated file
+// is compatible with the proto package it is being compiled against.
+// A compilation error at this line likely means your copy of the
+// proto package needs to be updated.
+const _ = proto.ProtoPackageIsVersion3 // please upgrade the proto package
+
+// Update is the message broadcast
+type Update struct {
+	// unique id of update
+	Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
+	// unix nano timestamp of update
+	Timestamp uint64 `protobuf:"varint,2,opt,name=timestamp,proto3" json:"timestamp,omitempty"`
+	// time to live for entry
+	Expires uint64 `protobuf:"varint,3,opt,name=expires,proto3" json:"expires,omitempty"`
+	// type of update; service
+	Type string `protobuf:"bytes,4,opt,name=type,proto3" json:"type,omitempty"`
+	// what action is taken; add, del, put
+	Action string `protobuf:"bytes,5,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) GetId() string {
+	if m != nil {
+		return m.Id
+	}
+	return ""
+}
+
+func (m *Update) GetTimestamp() uint64 {
+	if m != nil {
+		return m.Timestamp
+	}
+	return 0
+}
+
+func (m *Update) GetExpires() uint64 {
+	if m != nil {
+		return m.Expires
+	}
+	return 0
+}
+
+func (m *Update) GetType() string {
+	if m != nil {
+		return m.Type
+	}
+	return ""
+}
+
+func (m *Update) GetAction() string {
+	if m != nil {
+		return m.Action
+	}
+	return ""
+}
+
+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{
+	// 251 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x54, 0x90, 0xcf, 0x4a, 0xc4, 0x30,
+	0x10, 0x87, 0x69, 0xb6, 0x9b, 0xb5, 0xe3, 0x1f, 0x64, 0x10, 0x09, 0xb2, 0x87, 0xe2, 0xa9, 0x17,
+	0x5b, 0xd0, 0xcb, 0xa2, 0x5e, 0x3d, 0x7a, 0x09, 0xf8, 0x00, 0xd9, 0x36, 0xd4, 0xa0, 0xd9, 0x84,
+	0x64, 0x56, 0xec, 0x13, 0xf8, 0xda, 0xb2, 0x69, 0x54, 0xbc, 0x7d, 0xdf, 0xcc, 0x24, 0x99, 0x5f,
+	0xe0, 0x71, 0x34, 0xf4, 0xba, 0xdf, 0xb6, 0xbd, 0xb3, 0x9d, 0x35, 0x7d, 0x70, 0xdd, 0xe8, 0x6e,
+	0x66, 0x08, 0x7a, 0x34, 0x91, 0xc2, 0xd4, 0x8d, 0x2e, 0x46, 0xe3, 0x3b, 0x1f, 0x1c, 0xb9, 0x2c,
+	0x6d, 0x12, 0xe4, 0xb3, 0x5d, 0x7f, 0x31, 0xe0, 0x2f, 0x7e, 0x50, 0xa4, 0xf1, 0x0c, 0x98, 0x19,
+	0x44, 0x51, 0x17, 0x4d, 0x25, 0x99, 0x19, 0x70, 0x0d, 0x15, 0x19, 0xab, 0x23, 0x29, 0xeb, 0x05,
+	0xab, 0x8b, 0xa6, 0x94, 0x7f, 0x05, 0x14, 0xb0, 0xd2, 0x9f, 0xde, 0x04, 0x1d, 0xc5, 0x22, 0xf5,
+	0x7e, 0x14, 0x11, 0x4a, 0x9a, 0xbc, 0x16, 0x65, 0xba, 0x29, 0x31, 0x5e, 0x02, 0x57, 0x3d, 0x19,
+	0xb7, 0x13, 0xcb, 0x54, 0xcd, 0x86, 0x1b, 0x38, 0xb2, 0x9a, 0xd4, 0xa0, 0x48, 0x09, 0x5e, 0x2f,
+	0x9a, 0xe3, 0xdb, 0x75, 0x9b, 0xf7, 0x9c, 0xb7, 0x6a, 0x9f, 0x73, 0xfb, 0x69, 0x47, 0x61, 0x92,
+	0xbf, 0xd3, 0x87, 0x57, 0xd2, 0xa9, 0x55, 0x5d, 0x34, 0x27, 0x32, 0xf1, 0xd5, 0x03, 0x9c, 0xfe,
+	0x1b, 0xc7, 0x73, 0x58, 0xbc, 0xe9, 0x29, 0x67, 0x3a, 0x20, 0x5e, 0xc0, 0xf2, 0x43, 0xbd, 0xef,
+	0x75, 0x0a, 0x54, 0xc9, 0x59, 0xee, 0xd9, 0xa6, 0xd8, 0xf2, 0xf4, 0x31, 0x77, 0xdf, 0x01, 0x00,
+	0x00, 0xff, 0xff, 0x06, 0x6e, 0x00, 0x3c, 0x58, 0x01, 0x00, 0x00,
+}

registry/gossip/proto/gossip.proto

@@ -0,0 +1,21 @@
+syntax = "proto3";
+
+package gossip;
+
+// Update is the message broadcast
+message Update {
+	// unique id of update
+	string id = 1;
+	// unix nano timestamp of update
+	uint64 timestamp = 2;
+	// time to live for entry
+	uint64 expires = 3;
+	// type of update; service
+	string type = 4;
+	// what action is taken; add, del, put
+	string action = 5;
+	// any other associated metadata about the data
+	map<string, string> metadata = 6;
+	// the payload data;
+	bytes data = 7;
+}

registry/gossip/util.go

@@ -0,0 +1,109 @@
+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 {
+	for _, n := range neu {
+		var seen bool
+		for i, o := range old {
+			if o.Id == n.Id {
+				seen = true
+				old[i] = n
+				break
+			}
+		}
+		if !seen {
+			old = append(old, n)
+		}
+	}
+	return old
+}
+
+func addServices(old, neu []*registry.Service) []*registry.Service {
+	for _, s := range neu {
+		var seen bool
+		for i, o := range old {
+			if o.Version == s.Version {
+				s.Nodes = addNodes(o.Nodes, s.Nodes)
+				seen = true
+				old[i] = s
+				break
+			}
+		}
+		if !seen {
+			old = append(old, s)
+		}
+	}
+	return old
+}
+
+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 i, o := range old {
+		var rem bool
+		for _, s := range del {
+			if o.Version == s.Version {
+				old[i].Nodes = delNodes(o.Nodes, s.Nodes)
+				if len(old[i].Nodes) == 0 {
+					rem = true
+				}
+			}
+		}
+		if !rem {
+			services = append(services, o)
+		}
+	}
+	return services
+}

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)
+}

registry/gossip/watcher.go

@@ -0,0 +1,51 @@
+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
+			}
+			return r, nil
+		case <-m.stop:
+			return nil, registry.ErrWatcherStopped
+		}
+	}
+}
+
+func (m *gossipWatcher) Stop() {
+	select {
+	case <-m.stop:
+		return
+	default:
+		close(m.stop)
+	}
+}

registry/mdns/mdns.go

@@ -1,3 +1,4 @@
+// Package mdns is a multicast dns registry
 package mdns
 
 /*

registry/mock/mock.go

@@ -1,3 +1,4 @@
+// Package mock provides a mock registry for testing
 package mock
 
 import (

registry/registry.go

@@ -28,7 +28,10 @@ type WatchOption func(*WatchOptions)
 var (
 	DefaultRegistry = newConsulRegistry()
 
+	// 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 {

selector/cache/cache.go

@@ -366,11 +366,9 @@ func (c *cacheSelector) Select(service string, opts ...selector.SelectOption) (s
 }
 
 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

selector/default.go

@@ -48,11 +48,9 @@ func (r *defaultSelector) Select(service string, opts ...SelectOption) (Next, er
 }
 
 func (r *defaultSelector) Mark(service string, node *registry.Node, err error) {
-	return
 }
 
 func (r *defaultSelector) Reset(service string) {
-	return
 }
 
 func (r *defaultSelector) Close() error {

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)
 		}
 	}

server/handler.go

@@ -1,37 +1,5 @@
 package server
 
-import (
-	"github.com/micro/go-micro/registry"
-)
-
-// Handler interface represents a Service request handler. It's generated
-// by passing any type of public concrete object with methods into server.NewHandler.
-// Most will pass in a struct.
-//
-// Example:
-//
-//	type Service struct {}
-//
-//	func (s *Service) Method(context, request, response) error {
-//		return nil
-//	}
-//
-type Handler interface {
-	Name() string
-	Handler() interface{}
-	Endpoints() []*registry.Endpoint
-	Options() HandlerOptions
-}
-
-// Subscriber interface represents a subscription to a given topic using
-// a specific subscriber function or object with methods.
-type Subscriber interface {
-	Topic() string
-	Subscriber() interface{}
-	Endpoints() []*registry.Endpoint
-	Options() SubscriberOptions
-}
-
 type HandlerOptions struct {
 	Internal bool
 	Metadata map[string]map[string]string

server/mock/mock.go

@@ -4,8 +4,8 @@ import (
 	"errors"
 	"sync"
 
+	"github.com/google/uuid"
 	"github.com/micro/go-micro/server"
-	"github.com/pborman/uuid"
 )
 
 type MockServer struct {
@@ -69,7 +69,7 @@ func (m *MockServer) NewHandler(h interface{}, opts ...server.HandlerOption) ser
 	}
 
 	return &MockHandler{
-		Id:   uuid.NewUUID().String(),
+		Id:   uuid.New().String(),
 		Hdlr: h,
 		Opts: options,
 	}

server/rpc/rpc.go

@@ -1,9 +1,11 @@
+// Package rpc provides an rpc server
 package rpc
 
 import (
 	"github.com/micro/go-micro/server"
 )
 
+// NewServer returns a micro server interface
 func NewServer(opts ...server.Option) server.Server {
 	return server.NewServer(opts...)
 }

server/rpc_codec.go

@@ -10,7 +10,7 @@ import (
 	"github.com/pkg/errors"
 )
 
-type rpcPlusCodec struct {
+type rpcCodec struct {
 	socket transport.Socket
 	codec  codec.Codec
 
@@ -47,12 +47,12 @@ func (rwc *readWriteCloser) Close() error {
 	return nil
 }
 
-func newRpcPlusCodec(req *transport.Message, socket transport.Socket, c codec.NewCodec) serverCodec {
+func newRpcCodec(req *transport.Message, socket transport.Socket, c codec.NewCodec) serverCodec {
 	rwc := &readWriteCloser{
 		rbuf: bytes.NewBuffer(req.Body),
 		wbuf: bytes.NewBuffer(nil),
 	}
-	r := &rpcPlusCodec{
+	r := &rpcCodec{
 		buf:    rwc,
 		codec:  c(rwc),
 		req:    req,
@@ -61,7 +61,7 @@ func newRpcPlusCodec(req *transport.Message, socket transport.Socket, c codec.Ne
 	return r
 }
 
-func (c *rpcPlusCodec) ReadRequestHeader(r *request, first bool) error {
+func (c *rpcCodec) ReadRequestHeader(r *request, first bool) error {
 	m := codec.Message{Header: c.req.Header}
 
 	if !first {
@@ -83,11 +83,11 @@ func (c *rpcPlusCodec) ReadRequestHeader(r *request, first bool) error {
 	return err
 }
 
-func (c *rpcPlusCodec) ReadRequestBody(b interface{}) error {
+func (c *rpcCodec) ReadRequestBody(b interface{}) error {
 	return c.codec.ReadBody(b)
 }
 
-func (c *rpcPlusCodec) WriteResponse(r *response, body interface{}, last bool) error {
+func (c *rpcCodec) WriteResponse(r *response, body interface{}, last bool) error {
 	c.buf.wbuf.Reset()
 	m := &codec.Message{
 		Method: r.ServiceMethod,
@@ -111,7 +111,7 @@ func (c *rpcPlusCodec) WriteResponse(r *response, body interface{}, last bool) e
 	})
 }
 
-func (c *rpcPlusCodec) Close() error {
+func (c *rpcCodec) Close() error {
 	c.buf.Close()
 	c.codec.Close()
 	return c.socket.Close()

server/rpc_codec_test.go

@@ -15,6 +15,8 @@ type testCodec struct {
 }
 
 type testSocket struct {
+	local  string
+	remote string
 }
 
 // TestCodecWriteError simulates what happens when a codec is unable
@@ -36,7 +38,7 @@ func TestCodecWriteError(t *testing.T) {
 		wbuf: new(bytes.Buffer),
 	}
 
-	c := rpcPlusCodec{
+	c := rpcCodec{
 		buf: &rwc,
 		codec: &testCodec{
 			buf: rwc.wbuf,
@@ -87,6 +89,14 @@ func (c *testCodec) String() string {
 	return "string"
 }
 
+func (s testSocket) Local() string {
+	return s.local
+}
+
+func (s testSocket) Remote() string {
+	return s.remote
+}
+
 func (s testSocket) Recv(message *transport.Message) error {
 	return nil
 }

server/rpc_server.go

@@ -87,7 +87,7 @@ func (s *rpcServer) accept(sock transport.Socket) {
 			return
 		}
 
-		codec := newRpcPlusCodec(&msg, sock, cf)
+		codec := newRpcCodec(&msg, sock, cf)
 
 		// strip our headers
 		hdr := make(map[string]string)
@@ -97,6 +97,10 @@ func (s *rpcServer) accept(sock transport.Socket) {
 		delete(hdr, "Content-Type")
 		delete(hdr, "Timeout")
 
+		// set local/remote ips
+		hdr["Local"] = sock.Local()
+		hdr["Remote"] = sock.Remote()
+
 		ctx := metadata.NewContext(context.Background(), hdr)
 
 		// set the timeout if we have it
@@ -393,11 +397,35 @@ func (s *rpcServer) Start() error {
 	s.opts.Address = ts.Addr()
 	s.Unlock()
 
-	go ts.Accept(s.accept)
+	exit := make(chan bool, 1)
+
+	go func() {
+		for {
+			err := ts.Accept(s.accept)
+
+			// check if we're supposed to exit
+			select {
+			case <-exit:
+				return
+			default:
+			}
+
+			// check the error and backoff
+			if err != nil {
+				log.Logf("Accept error: %v", err)
+				time.Sleep(time.Second)
+				continue
+			}
+
+			// no error just exit
+			return
+		}
+	}()
 
 	go func() {
 		// wait for exit
 		ch := <-s.exit
+		exit <- true
 
 		// wait for requests to finish
 		if wait(s.opts.Context) {

server/rpc_service.go

@@ -199,7 +199,7 @@ func (server *server) register(rcvr interface{}) error {
 	return nil
 }
 
-func (server *server) sendResponse(sending *sync.Mutex, req *request, reply interface{}, codec serverCodec, errmsg string, last bool) (err error) {
+func (server *server) sendResponse(sending sync.Locker, req *request, reply interface{}, codec serverCodec, errmsg string, last bool) (err error) {
 	resp := server.getResponse()
 	// Encode the response header
 	resp.ServiceMethod = req.ServiceMethod

server/server.go

@@ -7,10 +7,12 @@ import (
 	"os/signal"
 	"syscall"
 
+	"github.com/google/uuid"
 	"github.com/micro/go-log"
-	"github.com/pborman/uuid"
+	"github.com/micro/go-micro/registry"
 )
 
+// Server is a simple micro server abstraction
 type Server interface {
 	Options() Options
 	Init(...Option) error
@@ -25,12 +27,14 @@ type Server interface {
 	String() string
 }
 
+// Message is an async message interface
 type Message interface {
 	Topic() string
 	Payload() interface{}
 	ContentType() string
 }
 
+// Request is a synchronous request interface
 type Request interface {
 	Service() string
 	Method() string
@@ -43,7 +47,7 @@ type Request interface {
 // Stream represents a stream established with a client.
 // A stream can be bidirectional which is indicated by the request.
 // The last error will be left in Error().
-// EOF indicated end of the stream.
+// EOF indicates end of the stream.
 type Stream interface {
 	Context() context.Context
 	Request() Request
@@ -53,6 +57,34 @@ type Stream interface {
 	Close() error
 }
 
+// Handler interface represents a request handler. It's generated
+// by passing any type of public concrete object with methods into server.NewHandler.
+// Most will pass in a struct.
+//
+// Example:
+//
+//      type Greeter struct {}
+//
+//      func (g *Greeter) Hello(context, request, response) error {
+//              return nil
+//      }
+//
+type Handler interface {
+	Name() string
+	Handler() interface{}
+	Endpoints() []*registry.Endpoint
+	Options() HandlerOptions
+}
+
+// Subscriber interface represents a subscription to a given topic using
+// a specific subscriber function or object with methods.
+type Subscriber interface {
+	Topic() string
+	Subscriber() interface{}
+	Endpoints() []*registry.Endpoint
+	Options() SubscriberOptions
+}
+
 type Option func(*Options)
 
 type HandlerOption func(*HandlerOptions)
@@ -63,7 +95,7 @@ var (
 	DefaultAddress        = ":0"
 	DefaultName           = "go-server"
 	DefaultVersion        = "1.0.0"
-	DefaultId             = uuid.NewUUID().String()
+	DefaultId             = uuid.New().String()
 	DefaultServer  Server = newRpcServer()
 )
 

transport/http/http.go

@@ -1,9 +1,11 @@
+// Package http returns a http2 transport using net/http
 package http
 
 import (
 	"github.com/micro/go-micro/transport"
 )
 
+// NewTransport returns a new http transport using net/http and supporting http2
 func NewTransport(opts ...transport.Option) transport.Transport {
 	return transport.NewTransport(opts...)
 }

transport/http/options.go

@@ -0,0 +1,23 @@
+package http
+
+import (
+	"context"
+	"net/http"
+
+	"github.com/micro/go-micro/transport"
+)
+
+// Handle registers the handler for the given pattern.
+func Handle(pattern string, handler http.Handler) transport.Option {
+	return func(o *transport.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)
+	}
+}

transport/http_transport.go

@@ -1,6 +1,7 @@
 package transport
 
 import (
+	//"fmt"
 	"bufio"
 	"bytes"
 	"crypto/tls"
@@ -13,10 +14,11 @@ import (
 	"sync"
 	"time"
 
-	"github.com/micro/go-log"
+	"github.com/micro/h2c"
 	maddr "github.com/micro/util/go/lib/addr"
 	mnet "github.com/micro/util/go/lib/net"
 	mls "github.com/micro/util/go/lib/tls"
+	"golang.org/x/net/http2"
 )
 
 type buffer struct {
@@ -38,16 +40,25 @@ type httpTransportClient struct {
 	r    chan *http.Request
 	bl   []*http.Request
 	buff *bufio.Reader
+
+	// local/remote ip
+	local  string
+	remote string
 }
 
 type httpTransportSocket struct {
-	ht   *httpTransport
-	r    chan *http.Request
-	conn net.Conn
-	once sync.Once
+	ht *httpTransport
+	w  http.ResponseWriter
+	r  *http.Request
+	rw *bufio.ReadWriter
 
-	sync.Mutex
-	buff *bufio.Reader
+	conn net.Conn
+	// for the first request
+	ch chan *http.Request
+
+	// local/remote ip
+	local  string
+	remote string
 }
 
 type httpTransportListener struct {
@@ -59,6 +70,14 @@ func (b *buffer) Close() error {
 	return nil
 }
 
+func (h *httpTransportClient) Local() string {
+	return h.local
+}
+
+func (h *httpTransportClient) Remote() string {
+	return h.remote
+}
+
 func (h *httpTransportClient) Send(m *Message) error {
 	header := make(http.Header)
 
@@ -170,33 +189,87 @@ func (h *httpTransportClient) Close() error {
 	return err
 }
 
+func (h *httpTransportSocket) Local() string {
+	return h.local
+}
+
+func (h *httpTransportSocket) Remote() string {
+	return h.remote
+}
+
 func (h *httpTransportSocket) Recv(m *Message) error {
 	if m == nil {
 		return errors.New("message passed in is nil")
 	}
 
-	// set timeout if its greater than 0
-	if h.ht.opts.Timeout > time.Duration(0) {
-		h.conn.SetDeadline(time.Now().Add(h.ht.opts.Timeout))
-	}
-
-	r, err := http.ReadRequest(h.buff)
-	if err != nil {
-		return err
-	}
-
-	b, err := ioutil.ReadAll(r.Body)
-	if err != nil {
-		return err
-	}
-	r.Body.Close()
-	m.Body = b
-
 	if m.Header == nil {
 		m.Header = make(map[string]string)
 	}
 
-	for k, v := range r.Header {
+	// process http 1
+	if h.r.ProtoMajor == 1 {
+		// set timeout if its greater than 0
+		if h.ht.opts.Timeout > time.Duration(0) {
+			h.conn.SetDeadline(time.Now().Add(h.ht.opts.Timeout))
+		}
+
+		var r *http.Request
+
+		select {
+		// get first request
+		case r = <-h.ch:
+		// read next request
+		default:
+			rr, err := http.ReadRequest(h.rw.Reader)
+			if err != nil {
+				return err
+			}
+			r = rr
+		}
+
+		// read body
+		b, err := ioutil.ReadAll(r.Body)
+		if err != nil {
+			return err
+		}
+
+		// set body
+		r.Body.Close()
+		m.Body = b
+
+		// set headers
+		for k, v := range r.Header {
+			if len(v) > 0 {
+				m.Header[k] = v[0]
+			} else {
+				m.Header[k] = ""
+			}
+		}
+
+		// return early early
+		return nil
+	}
+
+	// processing http2 request
+	// read streaming body
+
+	// set max buffer size
+	buf := make([]byte, 4*1024)
+
+	// read the request body
+	n, err := h.r.Body.Read(buf)
+	// not an eof error
+	if err != nil {
+		return err
+	}
+
+	// check if we have data
+	if n > 0 {
+		m.Body = buf[:n]
+	}
+
+	// set headers
+	for k, v := range h.r.Header {
 		if len(v) > 0 {
 			m.Header[k] = v[0]
 		} else {
@@ -204,78 +277,73 @@ func (h *httpTransportSocket) Recv(m *Message) error {
 		}
 	}
 
-	select {
-	case h.r <- r:
-	default:
-	}
-
 	return nil
 }
 
 func (h *httpTransportSocket) Send(m *Message) error {
-	b := bytes.NewBuffer(m.Body)
-	defer b.Reset()
+	if h.r.ProtoMajor == 1 {
+		rsp := &http.Response{
+			Header:        h.r.Header,
+			Body:          ioutil.NopCloser(bytes.NewReader(m.Body)),
+			Status:        "200 OK",
+			StatusCode:    200,
+			Proto:         "HTTP/1.1",
+			ProtoMajor:    1,
+			ProtoMinor:    1,
+			ContentLength: int64(len(m.Body)),
+		}
 
-	r := <-h.r
+		for k, v := range m.Header {
+			rsp.Header.Set(k, v)
+		}
 
-	rsp := &http.Response{
-		Header:        r.Header,
-		Body:          &buffer{b},
-		Status:        "200 OK",
-		StatusCode:    200,
-		Proto:         "HTTP/1.1",
-		ProtoMajor:    1,
-		ProtoMinor:    1,
-		ContentLength: int64(len(m.Body)),
+		// set timeout if its greater than 0
+		if h.ht.opts.Timeout > time.Duration(0) {
+			h.conn.SetDeadline(time.Now().Add(h.ht.opts.Timeout))
+		}
+
+		return rsp.Write(h.conn)
 	}
 
+	// http2 request
+
+	// set headers
 	for k, v := range m.Header {
-		rsp.Header.Set(k, v)
+		h.w.Header().Set(k, v)
 	}
 
-	select {
-	case h.r <- r:
-	default:
-	}
-
-	// set timeout if its greater than 0
-	if h.ht.opts.Timeout > time.Duration(0) {
-		h.conn.SetDeadline(time.Now().Add(h.ht.opts.Timeout))
-	}
-
-	return rsp.Write(h.conn)
+	// write request
+	_, err := h.w.Write(m.Body)
+	return err
 }
 
 func (h *httpTransportSocket) error(m *Message) error {
-	b := bytes.NewBuffer(m.Body)
-	defer b.Reset()
-	rsp := &http.Response{
-		Header:        make(http.Header),
-		Body:          &buffer{b},
-		Status:        "500 Internal Server Error",
-		StatusCode:    500,
-		Proto:         "HTTP/1.1",
-		ProtoMajor:    1,
-		ProtoMinor:    1,
-		ContentLength: int64(len(m.Body)),
-	}
+	if h.r.ProtoMajor == 1 {
+		rsp := &http.Response{
+			Header:        make(http.Header),
+			Body:          ioutil.NopCloser(bytes.NewReader(m.Body)),
+			Status:        "500 Internal Server Error",
+			StatusCode:    500,
+			Proto:         "HTTP/1.1",
+			ProtoMajor:    1,
+			ProtoMinor:    1,
+			ContentLength: int64(len(m.Body)),
+		}
 
-	for k, v := range m.Header {
-		rsp.Header.Set(k, v)
-	}
+		for k, v := range m.Header {
+			rsp.Header.Set(k, v)
+		}
 
-	return rsp.Write(h.conn)
+		return rsp.Write(h.conn)
+	}
+	return nil
 }
 
 func (h *httpTransportSocket) Close() error {
-	err := h.conn.Close()
-	h.once.Do(func() {
-		h.Lock()
-		h.buff.Reset(nil)
-		h.buff = nil
-		h.Unlock()
-	})
-	return err
+	if h.r.ProtoMajor == 1 {
+		return h.conn.Close()
+	}
+	return nil
 }
 
 func (h *httpTransportListener) Addr() string {
@@ -287,46 +355,81 @@ func (h *httpTransportListener) Close() error {
 }
 
 func (h *httpTransportListener) Accept(fn func(Socket)) error {
-	var tempDelay time.Duration
+	// create handler mux
+	mux := http.NewServeMux()
 
-	for {
-		c, err := h.listener.Accept()
-		if err != nil {
-			if ne, ok := err.(net.Error); ok && ne.Temporary() {
-				if tempDelay == 0 {
-					tempDelay = 5 * time.Millisecond
-				} else {
-					tempDelay *= 2
-				}
-				if max := 1 * time.Second; tempDelay > max {
-					tempDelay = max
-				}
-				log.Logf("http: Accept error: %v; retrying in %v\n", err, tempDelay)
-				time.Sleep(tempDelay)
-				continue
+	// register our transport handler
+	mux.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
+		var buf *bufio.ReadWriter
+		var con net.Conn
+
+		// read a regular request
+		if r.ProtoMajor == 1 {
+			b, err := ioutil.ReadAll(r.Body)
+			if err != nil {
+				http.Error(w, err.Error(), http.StatusInternalServerError)
+				return
 			}
-			return err
+			r.Body = ioutil.NopCloser(bytes.NewReader(b))
+			// hijack the conn
+			hj, ok := w.(http.Hijacker)
+			if !ok {
+				// we're screwed
+				http.Error(w, "cannot serve conn", http.StatusInternalServerError)
+				return
+			}
+
+			conn, bufrw, err := hj.Hijack()
+			if err != nil {
+				http.Error(w, err.Error(), http.StatusInternalServerError)
+				return
+			}
+			defer conn.Close()
+			buf = bufrw
+			con = conn
 		}
 
-		sock := &httpTransportSocket{
-			ht:   h.ht,
-			conn: c,
-			buff: bufio.NewReader(c),
-			r:    make(chan *http.Request, 1),
+		// save the request
+		ch := make(chan *http.Request, 1)
+		ch <- r
+
+		fn(&httpTransportSocket{
+			ht:     h.ht,
+			w:      w,
+			r:      r,
+			rw:     buf,
+			ch:     ch,
+			conn:   con,
+			local:  h.Addr(),
+			remote: r.RemoteAddr,
+		})
+	})
+
+	// get optional handlers
+	if h.ht.opts.Context != nil {
+		handlers, ok := h.ht.opts.Context.Value("http_handlers").(map[string]http.Handler)
+		if ok {
+			for pattern, handler := range handlers {
+				mux.Handle(pattern, handler)
+			}
 		}
-
-		go func() {
-			// TODO: think of a better error response strategy
-			defer func() {
-				if r := recover(); r != nil {
-					log.Log("panic recovered: ", r)
-					sock.Close()
-				}
-			}()
-
-			fn(sock)
-		}()
 	}
+
+	// default http2 server
+	srv := &http.Server{
+		Handler: mux,
+	}
+
+	// insecure connection use h2c
+	if !(h.ht.opts.Secure || h.ht.opts.TLSConfig != nil) {
+		srv.Handler = &h2c.HandlerH2C{
+			Handler:  mux,
+			H2Server: &http2.Server{},
+		}
+	}
+
+	// begin serving
+	return srv.Serve(h.listener)
 }
 
 func (h *httpTransport) Dial(addr string, opts ...DialOption) (Client, error) {
@@ -365,6 +468,8 @@ func (h *httpTransport) Dial(addr string, opts ...DialOption) (Client, error) {
 		buff:     bufio.NewReader(conn),
 		dialOpts: dopts,
 		r:        make(chan *http.Request, 1),
+		local:    conn.LocalAddr().String(),
+		remote:   conn.RemoteAddr().String(),
 	}, nil
 }
 

transport/mock/mock.go

@@ -18,6 +18,9 @@ type mockSocket struct {
 	exit chan bool
 	// listener exit
 	lexit chan bool
+
+	local  string
+	remote string
 }
 
 type mockClient struct {
@@ -51,6 +54,14 @@ func (ms *mockSocket) Recv(m *transport.Message) error {
 	return nil
 }
 
+func (ms *mockSocket) Local() string {
+	return ms.local
+}
+
+func (ms *mockSocket) Remote() string {
+	return ms.remote
+}
+
 func (ms *mockSocket) Send(m *transport.Message) error {
 	select {
 	case <-ms.exit:
@@ -93,10 +104,12 @@ func (m *mockListener) Accept(fn func(transport.Socket)) error {
 			return nil
 		case c := <-m.conn:
 			go fn(&mockSocket{
-				lexit: c.lexit,
-				exit:  c.exit,
-				send:  c.recv,
-				recv:  c.send,
+				lexit:  c.lexit,
+				exit:   c.exit,
+				send:   c.recv,
+				recv:   c.send,
+				local:  c.Remote(),
+				remote: c.Local(),
 			})
 		}
 	}
@@ -118,10 +131,12 @@ func (m *mockTransport) Dial(addr string, opts ...transport.DialOption) (transpo
 
 	client := &mockClient{
 		&mockSocket{
-			send:  make(chan *transport.Message),
-			recv:  make(chan *transport.Message),
-			exit:  make(chan bool),
-			lexit: listener.exit,
+			send:   make(chan *transport.Message),
+			recv:   make(chan *transport.Message),
+			exit:   make(chan bool),
+			lexit:  listener.exit,
+			local:  addr,
+			remote: addr,
 		},
 		options,
 	}

transport/transport.go

@@ -1,4 +1,4 @@
-// Package is an interface for synchronous communication
+// Package transport is an interface for synchronous communication
 package transport
 
 import (
@@ -14,6 +14,8 @@ type Socket interface {
 	Recv(*Message) error
 	Send(*Message) error
 	Close() error
+	Local() string
+	Remote() string
 }
 
 type Client interface {