update readme

add quic transport

.travis.yml

@@ -1,7 +1,9 @@
 language: go
 go:
-- 1.10.x
 - 1.11.x
+- 1.12.x
+env:
+  - GO111MODULE=on
 notifications:
   slack:
     secure: aEvhLbhujaGaKSrOokiG3//PaVHTIrc3fBpoRbCRqfZpyq6WREoapJJhF+tIpWWOwaC9GmChbD6aHo/jMUgwKXVyPSaNjiEL87YzUUpL8B2zslNp1rgfTg/LrzthOx3Q1TYwpaAl3to0fuHUVFX4yMeC2vuThq7WSXgMMxFCtbc=

README.md

@@ -1,8 +1,15 @@
 # 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 framework for distributed systems development.
+Go Micro is a framework for microservice development.
+
+## 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" />
 
-The **micro** philosophy is sane defaults with a pluggable architecture. We provide defaults to get you started quickly but everything can be swapped out. 
 Plugins are available at [github.com/micro/go-plugins](https://github.com/micro/go-plugins).
 
 Follow us on [Twitter](https://twitter.com/microhq) or join the [Slack](http://slack.micro.mu/) community.
@@ -11,20 +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
-- **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 request/response 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. The default discovery mechanism is 
+multicast DNS (mdns), a zeroconf system. You can optionally set gossip using the SWIM protocol for p2p networks or consul for a
+resilient cloud-native setup.
+
+- **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. 
+
+- **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.
+
+- **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.
+
+- **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.
+
+- **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).
 
 ## Getting Started
 
 See the [docs](https://micro.mu/docs/go-micro.html) for detailed information on the architecture, installation and use of go-micro.
 
-## 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)

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

agent/README.md

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

agent/agent.go

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

agent/command/command.go

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

agent/command/command_test.go

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

agent/input/discord/README.md

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

agent/input/discord/conn.go

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

agent/input/discord/discord.go

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

agent/input/input.go

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

agent/input/slack/conn.go

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

agent/input/slack/slack.go

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

agent/input/telegram/README.md

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

agent/input/telegram/conn.go

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

agent/input/telegram/telegram.go

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

agent/proto/bot.micro.go

@@ -0,0 +1,118 @@
+// Code generated by protoc-gen-micro. DO NOT EDIT.
+// source: github.com/micro/go-bot/proto/bot.proto
+
+/*
+Package go_micro_bot is a generated protocol buffer package.
+
+It is generated from these files:
+	github.com/micro/go-bot/proto/bot.proto
+
+It has these top-level messages:
+	HelpRequest
+	HelpResponse
+	ExecRequest
+	ExecResponse
+*/
+package go_micro_bot
+
+import proto "github.com/golang/protobuf/proto"
+import fmt "fmt"
+import math "math"
+
+import (
+	context "context"
+	client "github.com/micro/go-micro/client"
+	server "github.com/micro/go-micro/server"
+)
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ = proto.Marshal
+var _ = fmt.Errorf
+var _ = math.Inf
+
+// This is a compile-time assertion to ensure that this generated file
+// is compatible with the proto package it is being compiled against.
+// A compilation error at this line likely means your copy of the
+// proto package needs to be updated.
+const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ context.Context
+var _ client.Option
+var _ server.Option
+
+// Client API for Command service
+
+type CommandService interface {
+	Help(ctx context.Context, in *HelpRequest, opts ...client.CallOption) (*HelpResponse, error)
+	Exec(ctx context.Context, in *ExecRequest, opts ...client.CallOption) (*ExecResponse, error)
+}
+
+type commandService struct {
+	c    client.Client
+	name string
+}
+
+func NewCommandService(name string, c client.Client) CommandService {
+	if c == nil {
+		c = client.NewClient()
+	}
+	if len(name) == 0 {
+		name = "go.micro.bot"
+	}
+	return &commandService{
+		c:    c,
+		name: name,
+	}
+}
+
+func (c *commandService) Help(ctx context.Context, in *HelpRequest, opts ...client.CallOption) (*HelpResponse, error) {
+	req := c.c.NewRequest(c.name, "Command.Help", in)
+	out := new(HelpResponse)
+	err := c.c.Call(ctx, req, out, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *commandService) Exec(ctx context.Context, in *ExecRequest, opts ...client.CallOption) (*ExecResponse, error) {
+	req := c.c.NewRequest(c.name, "Command.Exec", in)
+	out := new(ExecResponse)
+	err := c.c.Call(ctx, req, out, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+// Server API for Command service
+
+type CommandHandler interface {
+	Help(context.Context, *HelpRequest, *HelpResponse) error
+	Exec(context.Context, *ExecRequest, *ExecResponse) error
+}
+
+func RegisterCommandHandler(s server.Server, hdlr CommandHandler, opts ...server.HandlerOption) error {
+	type _command interface {
+		Help(ctx context.Context, in *HelpRequest, out *HelpResponse) error
+		Exec(ctx context.Context, in *ExecRequest, out *ExecResponse) error
+	}
+	type Command struct {
+		_command
+	}
+	h := &commandHandler{hdlr}
+	return s.Handle(s.NewHandler(&Command{h}, opts...))
+}
+
+type commandHandler struct {
+	CommandHandler
+}
+
+func (h *commandHandler) Help(ctx context.Context, in *HelpRequest, out *HelpResponse) error {
+	return h.CommandHandler.Help(ctx, in, out)
+}
+
+func (h *commandHandler) Exec(ctx context.Context, in *ExecRequest, out *ExecResponse) error {
+	return h.CommandHandler.Exec(ctx, in, out)
+}

agent/proto/bot.pb.go

@@ -0,0 +1,210 @@
+// Code generated by protoc-gen-go. DO NOT EDIT.
+// source: github.com/micro/go-bot/proto/bot.proto
+
+package go_micro_bot
+
+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
+
+type HelpRequest struct {
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *HelpRequest) Reset()         { *m = HelpRequest{} }
+func (m *HelpRequest) String() string { return proto.CompactTextString(m) }
+func (*HelpRequest) ProtoMessage()    {}
+func (*HelpRequest) Descriptor() ([]byte, []int) {
+	return fileDescriptor_bot_654832eab83ed4b5, []int{0}
+}
+func (m *HelpRequest) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_HelpRequest.Unmarshal(m, b)
+}
+func (m *HelpRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_HelpRequest.Marshal(b, m, deterministic)
+}
+func (dst *HelpRequest) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_HelpRequest.Merge(dst, src)
+}
+func (m *HelpRequest) XXX_Size() int {
+	return xxx_messageInfo_HelpRequest.Size(m)
+}
+func (m *HelpRequest) XXX_DiscardUnknown() {
+	xxx_messageInfo_HelpRequest.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_HelpRequest proto.InternalMessageInfo
+
+type HelpResponse struct {
+	Usage                string   `protobuf:"bytes,1,opt,name=usage,proto3" json:"usage,omitempty"`
+	Description          string   `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *HelpResponse) Reset()         { *m = HelpResponse{} }
+func (m *HelpResponse) String() string { return proto.CompactTextString(m) }
+func (*HelpResponse) ProtoMessage()    {}
+func (*HelpResponse) Descriptor() ([]byte, []int) {
+	return fileDescriptor_bot_654832eab83ed4b5, []int{1}
+}
+func (m *HelpResponse) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_HelpResponse.Unmarshal(m, b)
+}
+func (m *HelpResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_HelpResponse.Marshal(b, m, deterministic)
+}
+func (dst *HelpResponse) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_HelpResponse.Merge(dst, src)
+}
+func (m *HelpResponse) XXX_Size() int {
+	return xxx_messageInfo_HelpResponse.Size(m)
+}
+func (m *HelpResponse) XXX_DiscardUnknown() {
+	xxx_messageInfo_HelpResponse.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_HelpResponse proto.InternalMessageInfo
+
+func (m *HelpResponse) GetUsage() string {
+	if m != nil {
+		return m.Usage
+	}
+	return ""
+}
+
+func (m *HelpResponse) GetDescription() string {
+	if m != nil {
+		return m.Description
+	}
+	return ""
+}
+
+type ExecRequest struct {
+	Args                 []string `protobuf:"bytes,1,rep,name=args,proto3" json:"args,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *ExecRequest) Reset()         { *m = ExecRequest{} }
+func (m *ExecRequest) String() string { return proto.CompactTextString(m) }
+func (*ExecRequest) ProtoMessage()    {}
+func (*ExecRequest) Descriptor() ([]byte, []int) {
+	return fileDescriptor_bot_654832eab83ed4b5, []int{2}
+}
+func (m *ExecRequest) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_ExecRequest.Unmarshal(m, b)
+}
+func (m *ExecRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_ExecRequest.Marshal(b, m, deterministic)
+}
+func (dst *ExecRequest) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_ExecRequest.Merge(dst, src)
+}
+func (m *ExecRequest) XXX_Size() int {
+	return xxx_messageInfo_ExecRequest.Size(m)
+}
+func (m *ExecRequest) XXX_DiscardUnknown() {
+	xxx_messageInfo_ExecRequest.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_ExecRequest proto.InternalMessageInfo
+
+func (m *ExecRequest) GetArgs() []string {
+	if m != nil {
+		return m.Args
+	}
+	return nil
+}
+
+type ExecResponse struct {
+	Result               []byte   `protobuf:"bytes,1,opt,name=result,proto3" json:"result,omitempty"`
+	Error                string   `protobuf:"bytes,2,opt,name=error,proto3" json:"error,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *ExecResponse) Reset()         { *m = ExecResponse{} }
+func (m *ExecResponse) String() string { return proto.CompactTextString(m) }
+func (*ExecResponse) ProtoMessage()    {}
+func (*ExecResponse) Descriptor() ([]byte, []int) {
+	return fileDescriptor_bot_654832eab83ed4b5, []int{3}
+}
+func (m *ExecResponse) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_ExecResponse.Unmarshal(m, b)
+}
+func (m *ExecResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_ExecResponse.Marshal(b, m, deterministic)
+}
+func (dst *ExecResponse) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_ExecResponse.Merge(dst, src)
+}
+func (m *ExecResponse) XXX_Size() int {
+	return xxx_messageInfo_ExecResponse.Size(m)
+}
+func (m *ExecResponse) XXX_DiscardUnknown() {
+	xxx_messageInfo_ExecResponse.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_ExecResponse proto.InternalMessageInfo
+
+func (m *ExecResponse) GetResult() []byte {
+	if m != nil {
+		return m.Result
+	}
+	return nil
+}
+
+func (m *ExecResponse) GetError() string {
+	if m != nil {
+		return m.Error
+	}
+	return ""
+}
+
+func init() {
+	proto.RegisterType((*HelpRequest)(nil), "go.micro.bot.HelpRequest")
+	proto.RegisterType((*HelpResponse)(nil), "go.micro.bot.HelpResponse")
+	proto.RegisterType((*ExecRequest)(nil), "go.micro.bot.ExecRequest")
+	proto.RegisterType((*ExecResponse)(nil), "go.micro.bot.ExecResponse")
+}
+
+func init() {
+	proto.RegisterFile("github.com/micro/go-bot/proto/bot.proto", fileDescriptor_bot_654832eab83ed4b5)
+}
+
+var fileDescriptor_bot_654832eab83ed4b5 = []byte{
+	// 246 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x6c, 0x90, 0x41, 0x4b, 0xc4, 0x30,
+	0x10, 0x85, 0xb7, 0xba, 0xae, 0xec, 0xb4, 0x5e, 0x82, 0x48, 0xdd, 0x53, 0xcd, 0xc5, 0xbd, 0x98,
+	0x82, 0x5e, 0x05, 0x0f, 0xa2, 0x78, 0xee, 0x3f, 0x68, 0xba, 0x43, 0x2c, 0x6c, 0x3b, 0x35, 0x99,
+	0x82, 0xff, 0xc1, 0x3f, 0x2d, 0x4d, 0x72, 0x08, 0xcb, 0xde, 0xe6, 0x65, 0x86, 0xf7, 0xbe, 0x17,
+	0x78, 0x34, 0x3d, 0x7f, 0xcf, 0x5a, 0x75, 0x34, 0xd4, 0x43, 0xdf, 0x59, 0xaa, 0x0d, 0x3d, 0x69,
+	0xe2, 0x7a, 0xb2, 0xc4, 0x54, 0x6b, 0x62, 0xe5, 0x27, 0x51, 0x18, 0x52, 0xfe, 0x40, 0x69, 0x62,
+	0x79, 0x03, 0xf9, 0x17, 0x1e, 0xa7, 0x06, 0x7f, 0x66, 0x74, 0x2c, 0x3f, 0xa1, 0x08, 0xd2, 0x4d,
+	0x34, 0x3a, 0x14, 0xb7, 0x70, 0x35, 0xbb, 0xd6, 0x60, 0x99, 0x55, 0xd9, 0x7e, 0xdb, 0x04, 0x21,
+	0x2a, 0xc8, 0x0f, 0xe8, 0x3a, 0xdb, 0x4f, 0xdc, 0xd3, 0x58, 0x5e, 0xf8, 0x5d, 0xfa, 0x24, 0x1f,
+	0x20, 0xff, 0xf8, 0xc5, 0x2e, 0xda, 0x0a, 0x01, 0xeb, 0xd6, 0x1a, 0x57, 0x66, 0xd5, 0xe5, 0x7e,
+	0xdb, 0xf8, 0x59, 0xbe, 0x42, 0x11, 0x4e, 0x62, 0xd4, 0x1d, 0x6c, 0x2c, 0xba, 0xf9, 0xc8, 0x3e,
+	0xab, 0x68, 0xa2, 0x5a, 0x10, 0xd0, 0x5a, 0xb2, 0x31, 0x26, 0x88, 0xe7, 0xbf, 0x0c, 0xae, 0xdf,
+	0x69, 0x18, 0xda, 0xf1, 0x20, 0xde, 0x60, 0xbd, 0x40, 0x8b, 0x7b, 0x95, 0x56, 0x53, 0x49, 0xaf,
+	0xdd, 0xee, 0xdc, 0x2a, 0x04, 0xcb, 0xd5, 0x62, 0xb0, 0xa0, 0x9c, 0x1a, 0x24, 0x0d, 0x4e, 0x0d,
+	0x52, 0x72, 0xb9, 0xd2, 0x1b, 0xff, 0xb5, 0x2f, 0xff, 0x01, 0x00, 0x00, 0xff, 0xff, 0xcb, 0x77,
+	0xdf, 0x28, 0x85, 0x01, 0x00, 0x00,
+}

agent/proto/bot.proto

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

api/README.md

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

api/api.go

@@ -0,0 +1,144 @@
+package api
+
+import (
+	"errors"
+	"regexp"
+	"strings"
+
+	"github.com/micro/go-micro/registry"
+	"github.com/micro/go-micro/server"
+)
+
+// Endpoint is a mapping between an RPC method and HTTP endpoint
+type Endpoint struct {
+	// RPC Method e.g. Greeter.Hello
+	Name string
+	// Description e.g what's this endpoint for
+	Description string
+	// API Handler e.g rpc, proxy
+	Handler string
+	// HTTP Host e.g example.com
+	Host []string
+	// HTTP Methods e.g GET, POST
+	Method []string
+	// HTTP Path e.g /greeter. Expect POSIX regex
+	Path []string
+}
+
+// Service represents an API service
+type Service struct {
+	// Name of service
+	Name string
+	// The endpoint for this service
+	Endpoint *Endpoint
+	// Versions of this service
+	Services []*registry.Service
+}
+
+func strip(s string) string {
+	return strings.TrimSpace(s)
+}
+
+func slice(s string) []string {
+	var sl []string
+
+	for _, p := range strings.Split(s, ",") {
+		if str := strip(p); len(str) > 0 {
+			sl = append(sl, strip(p))
+		}
+	}
+
+	return sl
+}
+
+// Encode encodes an endpoint to endpoint metadata
+func Encode(e *Endpoint) map[string]string {
+	if e == nil {
+		return nil
+	}
+
+	return map[string]string{
+		"endpoint":    e.Name,
+		"description": e.Description,
+		"method":      strings.Join(e.Method, ","),
+		"path":        strings.Join(e.Path, ","),
+		"host":        strings.Join(e.Host, ","),
+		"handler":     e.Handler,
+	}
+}
+
+// Decode decodes endpoint metadata into an endpoint
+func Decode(e map[string]string) *Endpoint {
+	if e == nil {
+		return nil
+	}
+
+	return &Endpoint{
+		Name:        e["endpoint"],
+		Description: e["description"],
+		Method:      slice(e["method"]),
+		Path:        slice(e["path"]),
+		Host:        slice(e["host"]),
+		Handler:     e["handler"],
+	}
+}
+
+// Validate validates an endpoint to guarantee it won't blow up when being served
+func Validate(e *Endpoint) error {
+	if e == nil {
+		return errors.New("endpoint is nil")
+	}
+
+	if len(e.Name) == 0 {
+		return errors.New("name required")
+	}
+
+	for _, p := range e.Path {
+		_, err := regexp.CompilePOSIX(p)
+		if err != nil {
+			return err
+		}
+	}
+
+	if len(e.Handler) == 0 {
+		return errors.New("invalid handler")
+	}
+
+	return nil
+}
+
+/*
+Design ideas
+
+// Gateway is an api gateway interface
+type Gateway interface {
+	// Register a http handler
+	Handle(pattern string, http.Handler)
+	// Register a route
+	RegisterRoute(r Route)
+	// Init initialises the command line.
+	// It also parses further options.
+	Init(...Option) error
+	// Run the gateway
+	Run() error
+}
+
+// NewGateway returns a new api gateway
+func NewGateway() Gateway {
+	return newGateway()
+}
+*/
+
+// WithEndpoint returns a server.HandlerOption with endpoint metadata set
+//
+// Usage:
+//
+// 	proto.RegisterHandler(service.Server(), new(Handler), api.WithEndpoint(
+//		&api.Endpoint{
+//			Name: "Greeter.Hello",
+//			Path: []string{"/greeter"},
+//		},
+//	))
+func WithEndpoint(e *Endpoint) server.HandlerOption {
+	return server.EndpointMetadata(e.Name, Encode(e))
+}

api/api_test.go

@@ -0,0 +1,113 @@
+package api
+
+import (
+	"strings"
+	"testing"
+)
+
+func TestEncoding(t *testing.T) {
+	testData := []*Endpoint{
+		nil,
+		{
+			Name:        "Foo.Bar",
+			Description: "A test endpoint",
+			Handler:     "meta",
+			Host:        []string{"foo.com"},
+			Method:      []string{"GET"},
+			Path:        []string{"/test"},
+		},
+	}
+
+	compare := func(expect, got []string) bool {
+		// no data to compare, return true
+		if len(expect) == 0 && len(got) == 0 {
+			return true
+		}
+		// no data expected but got some return false
+		if len(expect) == 0 && len(got) > 0 {
+			return false
+		}
+
+		// compare expected with what we got
+		for _, e := range expect {
+			var seen bool
+			for _, g := range got {
+				if e == g {
+					seen = true
+					break
+				}
+			}
+			if !seen {
+				return false
+			}
+		}
+
+		// we're done, return true
+		return true
+	}
+
+	for _, d := range testData {
+		// encode
+		e := Encode(d)
+		// decode
+		de := Decode(e)
+
+		// nil endpoint returns nil
+		if d == nil {
+			if e != nil {
+				t.Fatalf("expected nil got %v", e)
+			}
+			if de != nil {
+				t.Fatalf("expected nil got %v", de)
+			}
+
+			continue
+		}
+
+		// check encoded map
+		name := e["endpoint"]
+		desc := e["description"]
+		method := strings.Split(e["method"], ",")
+		path := strings.Split(e["path"], ",")
+		host := strings.Split(e["host"], ",")
+		handler := e["handler"]
+
+		if name != d.Name {
+			t.Fatalf("expected %v got %v", d.Name, name)
+		}
+		if desc != d.Description {
+			t.Fatalf("expected %v got %v", d.Description, desc)
+		}
+		if handler != d.Handler {
+			t.Fatalf("expected %v got %v", d.Handler, handler)
+		}
+		if ok := compare(d.Method, method); !ok {
+			t.Fatalf("expected %v got %v", d.Method, method)
+		}
+		if ok := compare(d.Path, path); !ok {
+			t.Fatalf("expected %v got %v", d.Path, path)
+		}
+		if ok := compare(d.Host, host); !ok {
+			t.Fatalf("expected %v got %v", d.Host, host)
+		}
+
+		if de.Name != d.Name {
+			t.Fatalf("expected %v got %v", d.Name, de.Name)
+		}
+		if de.Description != d.Description {
+			t.Fatalf("expected %v got %v", d.Description, de.Description)
+		}
+		if de.Handler != d.Handler {
+			t.Fatalf("expected %v got %v", d.Handler, de.Handler)
+		}
+		if ok := compare(d.Method, de.Method); !ok {
+			t.Fatalf("expected %v got %v", d.Method, de.Method)
+		}
+		if ok := compare(d.Path, de.Path); !ok {
+			t.Fatalf("expected %v got %v", d.Path, de.Path)
+		}
+		if ok := compare(d.Host, de.Host); !ok {
+			t.Fatalf("expected %v got %v", d.Host, de.Host)
+		}
+	}
+}

api/handler/api/api.go

@@ -0,0 +1,117 @@
+// Package api provides an http-rpc handler which provides the entire http request over rpc
+package api
+
+import (
+	"net/http"
+
+	goapi "github.com/micro/go-micro/api"
+	"github.com/micro/go-micro/api/handler"
+	"github.com/micro/go-micro/client"
+	"github.com/micro/go-micro/errors"
+	"github.com/micro/go-micro/selector"
+	"github.com/micro/go-micro/util/ctx"
+	api "github.com/micro/micro/api/proto"
+)
+
+type apiHandler struct {
+	opts handler.Options
+	s    *goapi.Service
+}
+
+const (
+	Handler = "api"
+)
+
+// API handler is the default handler which takes api.Request and returns api.Response
+func (a *apiHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
+	request, err := requestToProto(r)
+	if err != nil {
+		er := errors.InternalServerError("go.micro.api", err.Error())
+		w.Header().Set("Content-Type", "application/json")
+		w.WriteHeader(500)
+		w.Write([]byte(er.Error()))
+		return
+	}
+
+	var service *goapi.Service
+
+	if a.s != nil {
+		// we were given the service
+		service = a.s
+	} else if a.opts.Router != nil {
+		// try get service from router
+		s, err := a.opts.Router.Route(r)
+		if err != nil {
+			er := errors.InternalServerError("go.micro.api", err.Error())
+			w.Header().Set("Content-Type", "application/json")
+			w.WriteHeader(500)
+			w.Write([]byte(er.Error()))
+			return
+		}
+		service = s
+	} else {
+		// we have no way of routing the request
+		er := errors.InternalServerError("go.micro.api", "no route found")
+		w.Header().Set("Content-Type", "application/json")
+		w.WriteHeader(500)
+		w.Write([]byte(er.Error()))
+		return
+	}
+
+	// create request and response
+	c := a.opts.Service.Client()
+	req := c.NewRequest(service.Name, service.Endpoint.Name, request)
+	rsp := &api.Response{}
+
+	// create the context from headers
+	cx := ctx.FromRequest(r)
+	// create strategy
+	so := selector.WithStrategy(strategy(service.Services))
+
+	if err := c.Call(cx, req, rsp, client.WithSelectOption(so)); err != nil {
+		w.Header().Set("Content-Type", "application/json")
+		ce := errors.Parse(err.Error())
+		switch ce.Code {
+		case 0:
+			w.WriteHeader(500)
+		default:
+			w.WriteHeader(int(ce.Code))
+		}
+		w.Write([]byte(ce.Error()))
+		return
+	} else if rsp.StatusCode == 0 {
+		rsp.StatusCode = http.StatusOK
+	}
+
+	for _, header := range rsp.GetHeader() {
+		for _, val := range header.Values {
+			w.Header().Add(header.Key, val)
+		}
+	}
+
+	if len(w.Header().Get("Content-Type")) == 0 {
+		w.Header().Set("Content-Type", "application/json")
+	}
+
+	w.WriteHeader(int(rsp.StatusCode))
+	w.Write([]byte(rsp.Body))
+}
+
+func (a *apiHandler) String() string {
+	return "api"
+}
+
+func NewHandler(opts ...handler.Option) handler.Handler {
+	options := handler.NewOptions(opts...)
+	return &apiHandler{
+		opts: options,
+	}
+}
+
+func WithService(s *goapi.Service, opts ...handler.Option) handler.Handler {
+	options := handler.NewOptions(opts...)
+	return &apiHandler{
+		opts: options,
+		s:    s,
+	}
+}

api/handler/api/util.go

@@ -0,0 +1,107 @@
+package api
+
+import (
+	"fmt"
+	"io/ioutil"
+	"mime"
+	"net"
+	"net/http"
+	"strings"
+
+	"github.com/micro/go-micro/registry"
+	"github.com/micro/go-micro/selector"
+	api "github.com/micro/micro/api/proto"
+)
+
+func requestToProto(r *http.Request) (*api.Request, error) {
+	if err := r.ParseForm(); err != nil {
+		return nil, fmt.Errorf("Error parsing form: %v", err)
+	}
+
+	req := &api.Request{
+		Path:   r.URL.Path,
+		Method: r.Method,
+		Header: make(map[string]*api.Pair),
+		Get:    make(map[string]*api.Pair),
+		Post:   make(map[string]*api.Pair),
+		Url:    r.URL.String(),
+	}
+
+	ct, _, err := mime.ParseMediaType(r.Header.Get("Content-Type"))
+	if err != nil {
+		ct = "application/x-www-form-urlencoded"
+		r.Header.Set("Content-Type", ct)
+	}
+
+	switch ct {
+	case "application/x-www-form-urlencoded":
+		// expect form vals
+	default:
+		data, _ := ioutil.ReadAll(r.Body)
+		req.Body = string(data)
+	}
+
+	// Set X-Forwarded-For if it does not exist
+	if ip, _, err := net.SplitHostPort(r.RemoteAddr); err == nil {
+		if prior, ok := r.Header["X-Forwarded-For"]; ok {
+			ip = strings.Join(prior, ", ") + ", " + ip
+		}
+
+		// Set the header
+		req.Header["X-Forwarded-For"] = &api.Pair{
+			Key:    "X-Forwarded-For",
+			Values: []string{ip},
+		}
+	}
+
+	// Host is stripped from net/http Headers so let's add it
+	req.Header["Host"] = &api.Pair{
+		Key:    "Host",
+		Values: []string{r.Host},
+	}
+
+	// Get data
+	for key, vals := range r.URL.Query() {
+		header, ok := req.Get[key]
+		if !ok {
+			header = &api.Pair{
+				Key: key,
+			}
+			req.Get[key] = header
+		}
+		header.Values = vals
+	}
+
+	// Post data
+	for key, vals := range r.PostForm {
+		header, ok := req.Post[key]
+		if !ok {
+			header = &api.Pair{
+				Key: key,
+			}
+			req.Post[key] = header
+		}
+		header.Values = vals
+	}
+
+	for key, vals := range r.Header {
+		header, ok := req.Header[key]
+		if !ok {
+			header = &api.Pair{
+				Key: key,
+			}
+			req.Header[key] = header
+		}
+		header.Values = vals
+	}
+
+	return req, nil
+}
+
+// strategy is a hack for selection
+func strategy(services []*registry.Service) selector.Strategy {
+	return func(_ []*registry.Service) selector.Next {
+		// ignore input to this function, use services above
+		return selector.Random(services)
+	}
+}

api/handler/api/util_test.go

@@ -0,0 +1,46 @@
+package api
+
+import (
+	"net/http"
+	"net/url"
+	"testing"
+)
+
+func TestRequestToProto(t *testing.T) {
+	testData := []*http.Request{
+		&http.Request{
+			Method: "GET",
+			Header: http.Header{
+				"Header": []string{"test"},
+			},
+			URL: &url.URL{
+				Scheme:   "http",
+				Host:     "localhost",
+				Path:     "/foo/bar",
+				RawQuery: "param1=value1",
+			},
+		},
+	}
+
+	for _, d := range testData {
+		p, err := requestToProto(d)
+		if err != nil {
+			t.Fatal(err)
+		}
+		if p.Path != d.URL.Path {
+			t.Fatalf("Expected path %s got %s", d.URL.Path, p.Path)
+		}
+		if p.Method != d.Method {
+			t.Fatalf("Expected method %s got %s", d.Method, p.Method)
+		}
+		for k, v := range d.Header {
+			if val, ok := p.Header[k]; !ok {
+				t.Fatalf("Expected header %s", k)
+			} else {
+				if val.Values[0] != v[0] {
+					t.Fatalf("Expected val %s, got %s", val.Values[0], v[0])
+				}
+			}
+		}
+	}
+}

api/handler/broker/broker.go

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

api/handler/cloudevents/cloudevents.go

@@ -0,0 +1,94 @@
+// Package cloudevents provides a cloudevents handler publishing the event using the go-micro/client
+package cloudevents
+
+import (
+	"net/http"
+	"path"
+	"regexp"
+	"strings"
+
+	"github.com/micro/go-micro/api/handler"
+	"github.com/micro/go-micro/util/ctx"
+)
+
+type event struct {
+	options handler.Options
+}
+
+var (
+	Handler   = "cloudevents"
+	versionRe = regexp.MustCompilePOSIX("^v[0-9]+$")
+)
+
+func eventName(parts []string) string {
+	return strings.Join(parts, ".")
+}
+
+func evRoute(ns, p string) (string, string) {
+	p = path.Clean(p)
+	p = strings.TrimPrefix(p, "/")
+
+	if len(p) == 0 {
+		return ns, "event"
+	}
+
+	parts := strings.Split(p, "/")
+
+	// no path
+	if len(parts) == 0 {
+		// topic: namespace
+		// action: event
+		return strings.Trim(ns, "."), "event"
+	}
+
+	// Treat /v[0-9]+ as versioning
+	// /v1/foo/bar => topic: v1.foo action: bar
+	if len(parts) >= 2 && versionRe.Match([]byte(parts[0])) {
+		topic := ns + "." + strings.Join(parts[:2], ".")
+		action := eventName(parts[1:])
+		return topic, action
+	}
+
+	// /foo => topic: ns.foo action: foo
+	// /foo/bar => topic: ns.foo action: bar
+	topic := ns + "." + strings.Join(parts[:1], ".")
+	action := eventName(parts[1:])
+
+	return topic, action
+}
+
+func (e *event) ServeHTTP(w http.ResponseWriter, r *http.Request) {
+	// request to topic:event
+	// create event
+	// publish to topic
+	topic, _ := evRoute(e.options.Namespace, r.URL.Path)
+
+	// create event
+	ev, err := FromRequest(r)
+	if err != nil {
+		http.Error(w, err.Error(), 500)
+		return
+	}
+
+	// get client
+	c := e.options.Service.Client()
+
+	// create publication
+	p := c.NewMessage(topic, ev)
+
+	// publish event
+	if err := c.Publish(ctx.FromRequest(r), p); err != nil {
+		http.Error(w, err.Error(), 500)
+		return
+	}
+}
+
+func (e *event) String() string {
+	return "cloudevents"
+}
+
+func NewHandler(opts ...handler.Option) handler.Handler {
+	return &event{
+		options: handler.NewOptions(opts...),
+	}
+}

api/handler/cloudevents/event.go

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

api/handler/event/event.go

@@ -0,0 +1,122 @@
+// Package event provides a handler which publishes an event
+package event
+
+import (
+	"fmt"
+	"io/ioutil"
+	"net/http"
+	"path"
+	"regexp"
+	"strings"
+	"time"
+
+	"github.com/micro/go-micro/api/handler"
+	proto "github.com/micro/go-micro/api/proto"
+	"github.com/micro/go-micro/util/ctx"
+	"github.com/pborman/uuid"
+)
+
+type event struct {
+	options handler.Options
+}
+
+var (
+	Handler   = "event"
+	versionRe = regexp.MustCompilePOSIX("^v[0-9]+$")
+)
+
+func eventName(parts []string) string {
+	return strings.Join(parts, ".")
+}
+
+func evRoute(ns, p string) (string, string) {
+	p = path.Clean(p)
+	p = strings.TrimPrefix(p, "/")
+
+	if len(p) == 0 {
+		return ns, "event"
+	}
+
+	parts := strings.Split(p, "/")
+
+	// no path
+	if len(parts) == 0 {
+		// topic: namespace
+		// action: event
+		return strings.Trim(ns, "."), "event"
+	}
+
+	// Treat /v[0-9]+ as versioning
+	// /v1/foo/bar => topic: v1.foo action: bar
+	if len(parts) >= 2 && versionRe.Match([]byte(parts[0])) {
+		topic := ns + "." + strings.Join(parts[:2], ".")
+		action := eventName(parts[1:])
+		return topic, action
+	}
+
+	// /foo => topic: ns.foo action: foo
+	// /foo/bar => topic: ns.foo action: bar
+	topic := ns + "." + strings.Join(parts[:1], ".")
+	action := eventName(parts[1:])
+
+	return topic, action
+}
+
+func (e *event) ServeHTTP(w http.ResponseWriter, r *http.Request) {
+	// request to topic:event
+	// create event
+	// publish to topic
+
+	topic, action := evRoute(e.options.Namespace, r.URL.Path)
+
+	// create event
+	ev := &proto.Event{
+		Name: action,
+		// TODO: dedupe event
+		Id:        fmt.Sprintf("%s-%s-%s", topic, action, uuid.NewUUID().String()),
+		Header:    make(map[string]*proto.Pair),
+		Timestamp: time.Now().Unix(),
+	}
+
+	// set headers
+	for key, vals := range r.Header {
+		header, ok := ev.Header[key]
+		if !ok {
+			header = &proto.Pair{
+				Key: key,
+			}
+			ev.Header[key] = header
+		}
+		header.Values = vals
+	}
+
+	// set body
+	b, err := ioutil.ReadAll(r.Body)
+	if err != nil {
+		http.Error(w, err.Error(), 500)
+		return
+	}
+	ev.Data = string(b)
+
+	// get client
+	c := e.options.Service.Client()
+
+	// create publication
+	p := c.NewMessage(topic, ev)
+
+	// publish event
+	if err := c.Publish(ctx.FromRequest(r), p); err != nil {
+		http.Error(w, err.Error(), 500)
+		return
+	}
+}
+
+func (e *event) String() string {
+	return "event"
+}
+
+func NewHandler(opts ...handler.Option) handler.Handler {
+	return &event{
+		options: handler.NewOptions(opts...),
+	}
+}

api/handler/file/file.go

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

api/handler/handler.go

@@ -0,0 +1,14 @@
+// Package handler provides http handlers
+package handler
+
+import (
+	"net/http"
+)
+
+// Handler represents a HTTP handler that manages a request
+type Handler interface {
+	// standard http handler
+	http.Handler
+	// name of handler
+	String() string
+}

api/handler/http/http.go

@@ -0,0 +1,100 @@
+// Package http is a http reverse proxy handler
+package http
+
+import (
+	"errors"
+	"fmt"
+	"net/http"
+	"net/http/httputil"
+	"net/url"
+
+	"github.com/micro/go-micro/api"
+	"github.com/micro/go-micro/api/handler"
+	"github.com/micro/go-micro/selector"
+)
+
+const (
+	Handler = "http"
+)
+
+type httpHandler struct {
+	options handler.Options
+
+	// set with different initialiser
+	s *api.Service
+}
+
+func (h *httpHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
+	service, err := h.getService(r)
+	if err != nil {
+		w.WriteHeader(500)
+		return
+	}
+
+	if len(service) == 0 {
+		w.WriteHeader(404)
+		return
+	}
+
+	rp, err := url.Parse(service)
+	if err != nil {
+		w.WriteHeader(500)
+		return
+	}
+
+	httputil.NewSingleHostReverseProxy(rp).ServeHTTP(w, r)
+}
+
+// getService returns the service for this request from the selector
+func (h *httpHandler) getService(r *http.Request) (string, error) {
+	var service *api.Service
+
+	if h.s != nil {
+		// we were given the service
+		service = h.s
+	} else if h.options.Router != nil {
+		// try get service from router
+		s, err := h.options.Router.Route(r)
+		if err != nil {
+			return "", err
+		}
+		service = s
+	} else {
+		// we have no way of routing the request
+		return "", errors.New("no route found")
+	}
+
+	// create a random selector
+	next := selector.Random(service.Services)
+
+	// get the next node
+	s, err := next()
+	if err != nil {
+		return "", nil
+	}
+
+	return fmt.Sprintf("http://%s:%d", s.Address, s.Port), nil
+}
+
+func (h *httpHandler) String() string {
+	return "http"
+}
+
+// NewHandler returns a http proxy handler
+func NewHandler(opts ...handler.Option) handler.Handler {
+	options := handler.NewOptions(opts...)
+
+	return &httpHandler{
+		options: options,
+	}
+}
+
+// WithService creates a handler with a service
+func WithService(s *api.Service, opts ...handler.Option) handler.Handler {
+	options := handler.NewOptions(opts...)
+
+	return &httpHandler{
+		options: options,
+		s:       s,
+	}
+}

api/handler/http/http_test.go

@@ -0,0 +1,133 @@
+package http
+
+import (
+	"net"
+	"net/http"
+	"net/http/httptest"
+	"strconv"
+	"strings"
+	"testing"
+
+	"github.com/micro/go-micro/api/handler"
+	"github.com/micro/go-micro/api/router"
+	regRouter "github.com/micro/go-micro/api/router/registry"
+	"github.com/micro/go-micro/cmd"
+	"github.com/micro/go-micro/registry"
+	"github.com/micro/go-micro/registry/memory"
+)
+
+func testHttp(t *testing.T, path, service, ns string) {
+	r := memory.NewRegistry()
+	cmd.DefaultCmd = cmd.NewCmd(cmd.Registry(&r))
+
+	l, err := net.Listen("tcp", "127.0.0.1:0")
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer l.Close()
+
+	parts := strings.Split(l.Addr().String(), ":")
+
+	var host string
+	var port int
+
+	host = parts[0]
+	port, _ = strconv.Atoi(parts[1])
+
+	s := &registry.Service{
+		Name: service,
+		Nodes: []*registry.Node{
+			&registry.Node{
+				Id:      service + "-1",
+				Address: host,
+				Port:    port,
+			},
+		},
+	}
+
+	r.Register(s)
+	defer r.Deregister(s)
+
+	// setup the test handler
+	m := http.NewServeMux()
+	m.HandleFunc(path, func(w http.ResponseWriter, r *http.Request) {
+		w.Write([]byte(`you got served`))
+	})
+
+	// start http test serve
+	go http.Serve(l, m)
+
+	// create new request and writer
+	w := httptest.NewRecorder()
+	req, err := http.NewRequest("POST", path, nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	// initialise the handler
+	rt := regRouter.NewRouter(
+		router.WithHandler("http"),
+		router.WithNamespace(ns),
+	)
+
+	p := NewHandler(handler.WithRouter(rt))
+
+	// execute the handler
+	p.ServeHTTP(w, req)
+
+	if w.Code != 200 {
+		t.Fatalf("Expected 200 response got %d %s", w.Code, w.Body.String())
+	}
+
+	if w.Body.String() != "you got served" {
+		t.Fatalf("Expected body: you got served. Got: %s", w.Body.String())
+	}
+}
+
+func TestHttpHandler(t *testing.T) {
+	testData := []struct {
+		path      string
+		service   string
+		namespace string
+	}{
+		{
+			"/test/foo",
+			"go.micro.api.test",
+			"go.micro.api",
+		},
+		{
+			"/test/foo/baz",
+			"go.micro.api.test",
+			"go.micro.api",
+		},
+		{
+			"/v1/foo",
+			"go.micro.api.v1.foo",
+			"go.micro.api",
+		},
+		{
+			"/v1/foo/bar",
+			"go.micro.api.v1.foo",
+			"go.micro.api",
+		},
+		{
+			"/v2/baz",
+			"go.micro.api.v2.baz",
+			"go.micro.api",
+		},
+		{
+			"/v2/baz/bar",
+			"go.micro.api.v2.baz",
+			"go.micro.api",
+		},
+		{
+			"/v2/baz/bar",
+			"v2.baz",
+			"",
+		},
+	}
+
+	for _, d := range testData {
+		testHttp(t, d.path, d.service, d.namespace)
+	}
+}

api/handler/options.go

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

api/handler/registry/registry.go

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

api/handler/rpc/rpc.go

@@ -0,0 +1,307 @@
+// Package rpc is a go-micro rpc handler.
+package rpc
+
+import (
+	"encoding/json"
+	"io"
+	"io/ioutil"
+	"net/http"
+	"strconv"
+	"strings"
+
+	"github.com/joncalhoun/qson"
+	"github.com/micro/go-micro/api"
+	"github.com/micro/go-micro/api/handler"
+	proto "github.com/micro/go-micro/api/internal/proto"
+	"github.com/micro/go-micro/client"
+	"github.com/micro/go-micro/codec"
+	"github.com/micro/go-micro/codec/jsonrpc"
+	"github.com/micro/go-micro/codec/protorpc"
+	"github.com/micro/go-micro/errors"
+	"github.com/micro/go-micro/registry"
+	"github.com/micro/go-micro/selector"
+	"github.com/micro/go-micro/util/ctx"
+)
+
+const (
+	Handler = "rpc"
+)
+
+var (
+	// supported json codecs
+	jsonCodecs = []string{
+		"application/grpc+json",
+		"application/json",
+		"application/json-rpc",
+	}
+
+	// support proto codecs
+	protoCodecs = []string{
+		"application/grpc",
+		"application/grpc+proto",
+		"application/proto",
+		"application/protobuf",
+		"application/proto-rpc",
+		"application/octet-stream",
+	}
+)
+
+type rpcHandler struct {
+	opts handler.Options
+	s    *api.Service
+}
+
+type buffer struct {
+	io.ReadCloser
+}
+
+func (b *buffer) Write(_ []byte) (int, error) {
+	return 0, nil
+}
+
+// strategy is a hack for selection
+func strategy(services []*registry.Service) selector.Strategy {
+	return func(_ []*registry.Service) selector.Next {
+		// ignore input to this function, use services above
+		return selector.Random(services)
+	}
+}
+
+func (h *rpcHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
+	defer r.Body.Close()
+	var service *api.Service
+
+	if h.s != nil {
+		// we were given the service
+		service = h.s
+	} else if h.opts.Router != nil {
+		// try get service from router
+		s, err := h.opts.Router.Route(r)
+		if err != nil {
+			writeError(w, r, errors.InternalServerError("go.micro.api", err.Error()))
+			return
+		}
+		service = s
+	} else {
+		// we have no way of routing the request
+		writeError(w, r, errors.InternalServerError("go.micro.api", "no route found"))
+		return
+	}
+
+	// only allow post when we have the router
+	if r.Method != "GET" && (h.opts.Router != nil && r.Method != "POST") {
+		http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)
+		return
+	}
+
+	ct := r.Header.Get("Content-Type")
+
+	// Strip charset from Content-Type (like `application/json; charset=UTF-8`)
+	if idx := strings.IndexRune(ct, ';'); idx >= 0 {
+		ct = ct[:idx]
+	}
+
+	// micro client
+	c := h.opts.Service.Client()
+
+	// create strategy
+	so := selector.WithStrategy(strategy(service.Services))
+
+	// get payload
+	br, err := requestPayload(r)
+	if err != nil {
+		writeError(w, r, err)
+		return
+	}
+
+	// create context
+	cx := ctx.FromRequest(r)
+
+	var rsp []byte
+
+	switch {
+	// json codecs
+	case hasCodec(ct, jsonCodecs):
+		var request json.RawMessage
+		// if the extracted payload isn't empty lets use it
+		if len(br) > 0 {
+			request = json.RawMessage(br)
+		}
+
+		// create request/response
+		var response json.RawMessage
+
+		req := c.NewRequest(
+			service.Name,
+			service.Endpoint.Name,
+			&request,
+			client.WithContentType(ct),
+		)
+
+		// make the call
+		if err := c.Call(cx, req, &response, client.WithSelectOption(so)); err != nil {
+			writeError(w, r, err)
+			return
+		}
+
+		// marshall response
+		rsp, _ = response.MarshalJSON()
+	// proto codecs
+	case hasCodec(ct, protoCodecs):
+		request := &proto.Message{}
+		// if the extracted payload isn't empty lets use it
+		if len(br) > 0 {
+			request = proto.NewMessage(br)
+		}
+
+		// create request/response
+		response := &proto.Message{}
+
+		req := c.NewRequest(
+			service.Name,
+			service.Endpoint.Name,
+			request,
+			client.WithContentType(ct),
+		)
+
+		// make the call
+		if err := c.Call(cx, req, response, client.WithSelectOption(so)); err != nil {
+			writeError(w, r, err)
+			return
+		}
+
+		// marshall response
+		rsp, _ = response.Marshal()
+	default:
+		http.Error(w, "Unsupported Content-Type", 400)
+		return
+	}
+
+	// write the response
+	writeResponse(w, r, rsp)
+}
+
+func (rh *rpcHandler) String() string {
+	return "rpc"
+}
+
+func hasCodec(ct string, codecs []string) bool {
+	for _, codec := range codecs {
+		if ct == codec {
+			return true
+		}
+	}
+	return false
+}
+
+// requestPayload takes a *http.Request.
+// If the request is a GET the query string parameters are extracted and marshaled to JSON and the raw bytes are returned.
+// If the request method is a POST the request body is read and returned
+func requestPayload(r *http.Request) ([]byte, error) {
+	// we have to decode json-rpc and proto-rpc because we suck
+	// well actually because there's no proxy codec right now
+	switch r.Header.Get("Content-Type") {
+	case "application/json-rpc":
+		msg := codec.Message{
+			Type:   codec.Request,
+			Header: make(map[string]string),
+		}
+		c := jsonrpc.NewCodec(&buffer{r.Body})
+		if err := c.ReadHeader(&msg, codec.Request); err != nil {
+			return nil, err
+		}
+		var raw json.RawMessage
+		if err := c.ReadBody(&raw); err != nil {
+			return nil, err
+		}
+		return ([]byte)(raw), nil
+	case "application/proto-rpc", "application/octet-stream":
+		msg := codec.Message{
+			Type:   codec.Request,
+			Header: make(map[string]string),
+		}
+		c := protorpc.NewCodec(&buffer{r.Body})
+		if err := c.ReadHeader(&msg, codec.Request); err != nil {
+			return nil, err
+		}
+		var raw proto.Message
+		if err := c.ReadBody(&raw); err != nil {
+			return nil, err
+		}
+		b, _ := raw.Marshal()
+		return b, nil
+	}
+
+	// otherwise as per usual
+
+	switch r.Method {
+	case "GET":
+		if len(r.URL.RawQuery) > 0 {
+			return qson.ToJSON(r.URL.RawQuery)
+		}
+	case "PATCH", "POST":
+		return ioutil.ReadAll(r.Body)
+	}
+
+	return []byte{}, nil
+}
+
+func writeError(w http.ResponseWriter, r *http.Request, err error) {
+	ce := errors.Parse(err.Error())
+
+	switch ce.Code {
+	case 0:
+		// assuming it's totally screwed
+		ce.Code = 500
+		ce.Id = "go.micro.api"
+		ce.Status = http.StatusText(500)
+		ce.Detail = "error during request: " + ce.Detail
+		w.WriteHeader(500)
+	default:
+		w.WriteHeader(int(ce.Code))
+	}
+
+	// response content type
+	w.Header().Set("Content-Type", "application/json")
+
+	// Set trailers
+	if strings.Contains(r.Header.Get("Content-Type"), "application/grpc") {
+		w.Header().Set("Trailer", "grpc-status")
+		w.Header().Set("Trailer", "grpc-message")
+		w.Header().Set("grpc-status", "13")
+		w.Header().Set("grpc-message", ce.Detail)
+	}
+
+	w.Write([]byte(ce.Error()))
+}
+
+func writeResponse(w http.ResponseWriter, r *http.Request, rsp []byte) {
+	w.Header().Set("Content-Type", r.Header.Get("Content-Type"))
+	w.Header().Set("Content-Length", strconv.Itoa(len(rsp)))
+
+	// Set trailers
+	if strings.Contains(r.Header.Get("Content-Type"), "application/grpc") {
+		w.Header().Set("Trailer", "grpc-status")
+		w.Header().Set("Trailer", "grpc-message")
+		w.Header().Set("grpc-status", "0")
+		w.Header().Set("grpc-message", "")
+	}
+
+	// write response
+	w.Write(rsp)
+}
+
+func NewHandler(opts ...handler.Option) handler.Handler {
+	options := handler.NewOptions(opts...)
+	return &rpcHandler{
+		opts: options,
+	}
+}
+
+func WithService(s *api.Service, opts ...handler.Option) handler.Handler {
+	options := handler.NewOptions(opts...)
+	return &rpcHandler{
+		opts: options,
+		s:    s,
+	}
+}

api/handler/rpc/rpc_test.go

@@ -0,0 +1,95 @@
+package rpc
+
+import (
+	"bytes"
+	"encoding/json"
+	"net/http"
+	"testing"
+
+	"github.com/golang/protobuf/proto"
+	"github.com/micro/go-micro/api/proto"
+)
+
+func TestRequestPayloadFromRequest(t *testing.T) {
+
+	// our test event so that we can validate serialising / deserializing of true protos works
+	protoEvent := go_api.Event{
+		Name: "Test",
+	}
+
+	protoBytes, err := proto.Marshal(&protoEvent)
+	if err != nil {
+		t.Fatal("Failed to marshal proto", err)
+	}
+
+	jsonBytes, err := json.Marshal(protoEvent)
+	if err != nil {
+		t.Fatal("Failed to marshal proto to JSON ", err)
+	}
+
+	t.Run("extracting a proto from a POST request", func(t *testing.T) {
+		r, err := http.NewRequest("POST", "http://localhost/my/path", bytes.NewReader(protoBytes))
+		if err != nil {
+			t.Fatalf("Failed to created http.Request: %v", err)
+		}
+
+		extByte, err := requestPayload(r)
+		if err != nil {
+			t.Fatalf("Failed to extract payload from request: %v", err)
+		}
+		if string(extByte) != string(protoBytes) {
+			t.Fatalf("Expected %v and %v to match", string(extByte), string(protoBytes))
+		}
+	})
+
+	t.Run("extracting JSON from a POST request", func(t *testing.T) {
+		r, err := http.NewRequest("POST", "http://localhost/my/path", bytes.NewReader(jsonBytes))
+		if err != nil {
+			t.Fatalf("Failed to created http.Request: %v", err)
+		}
+
+		extByte, err := requestPayload(r)
+		if err != nil {
+			t.Fatalf("Failed to extract payload from request: %v", err)
+		}
+		if string(extByte) != string(jsonBytes) {
+			t.Fatalf("Expected %v and %v to match", string(extByte), string(jsonBytes))
+		}
+	})
+
+	t.Run("extracting params from a GET request", func(t *testing.T) {
+
+		r, err := http.NewRequest("GET", "http://localhost/my/path", nil)
+		if err != nil {
+			t.Fatalf("Failed to created http.Request: %v", err)
+		}
+
+		q := r.URL.Query()
+		q.Add("name", "Test")
+		r.URL.RawQuery = q.Encode()
+
+		extByte, err := requestPayload(r)
+		if err != nil {
+			t.Fatalf("Failed to extract payload from request: %v", err)
+		}
+		if string(extByte) != string(jsonBytes) {
+			t.Fatalf("Expected %v and %v to match", string(extByte), string(jsonBytes))
+		}
+	})
+
+	t.Run("GET request with no params", func(t *testing.T) {
+
+		r, err := http.NewRequest("GET", "http://localhost/my/path", nil)
+		if err != nil {
+			t.Fatalf("Failed to created http.Request: %v", err)
+		}
+
+		extByte, err := requestPayload(r)
+		if err != nil {
+			t.Fatalf("Failed to extract payload from request: %v", err)
+		}
+		if string(extByte) != "" {
+			t.Fatalf("Expected %v and %v to match", string(extByte), "")
+		}
+	})
+}

api/handler/udp/udp.go

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

api/handler/unix/unix.go

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

api/handler/web/web.go

@@ -0,0 +1,177 @@
+// Package web contains the web handler including websocket support
+package web
+
+import (
+	"errors"
+	"fmt"
+	"io"
+	"net"
+	"net/http"
+	"net/http/httputil"
+	"net/url"
+	"strings"
+
+	"github.com/micro/go-micro/api"
+	"github.com/micro/go-micro/api/handler"
+	"github.com/micro/go-micro/selector"
+)
+
+const (
+	Handler = "web"
+)
+
+type webHandler struct {
+	opts handler.Options
+	s    *api.Service
+}
+
+func (wh *webHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
+	service, err := wh.getService(r)
+	if err != nil {
+		w.WriteHeader(500)
+		return
+	}
+
+	if len(service) == 0 {
+		w.WriteHeader(404)
+		return
+	}
+
+	rp, err := url.Parse(service)
+	if err != nil {
+		w.WriteHeader(500)
+		return
+	}
+
+	if isWebSocket(r) {
+		wh.serveWebSocket(rp.Host, w, r)
+		return
+	}
+
+	httputil.NewSingleHostReverseProxy(rp).ServeHTTP(w, r)
+}
+
+// getService returns the service for this request from the selector
+func (wh *webHandler) getService(r *http.Request) (string, error) {
+	var service *api.Service
+
+	if wh.s != nil {
+		// we were given the service
+		service = wh.s
+	} else if wh.opts.Router != nil {
+		// try get service from router
+		s, err := wh.opts.Router.Route(r)
+		if err != nil {
+			return "", err
+		}
+		service = s
+	} else {
+		// we have no way of routing the request
+		return "", errors.New("no route found")
+	}
+
+	// create a random selector
+	next := selector.Random(service.Services)
+
+	// get the next node
+	s, err := next()
+	if err != nil {
+		return "", nil
+	}
+
+	return fmt.Sprintf("http://%s:%d", s.Address, s.Port), nil
+}
+
+// serveWebSocket used to serve a web socket proxied connection
+func (wh *webHandler) serveWebSocket(host string, w http.ResponseWriter, r *http.Request) {
+	req := new(http.Request)
+	*req = *r
+
+	if len(host) == 0 {
+		http.Error(w, "invalid host", 500)
+		return
+	}
+
+	// set x-forward-for
+	if clientIP, _, err := net.SplitHostPort(r.RemoteAddr); err == nil {
+		if ips, ok := req.Header["X-Forwarded-For"]; ok {
+			clientIP = strings.Join(ips, ", ") + ", " + clientIP
+		}
+		req.Header.Set("X-Forwarded-For", clientIP)
+	}
+
+	// connect to the backend host
+	conn, err := net.Dial("tcp", host)
+	if err != nil {
+		http.Error(w, err.Error(), 500)
+		return
+	}
+
+	// hijack the connection
+	hj, ok := w.(http.Hijacker)
+	if !ok {
+		http.Error(w, "failed to connect", 500)
+		return
+	}
+
+	nc, _, err := hj.Hijack()
+	if err != nil {
+		return
+	}
+
+	defer nc.Close()
+	defer conn.Close()
+
+	if err = req.Write(conn); err != nil {
+		return
+	}
+
+	errCh := make(chan error, 2)
+
+	cp := func(dst io.Writer, src io.Reader) {
+		_, err := io.Copy(dst, src)
+		errCh <- err
+	}
+
+	go cp(conn, nc)
+	go cp(nc, conn)
+
+	<-errCh
+}
+
+func isWebSocket(r *http.Request) bool {
+	contains := func(key, val string) bool {
+		vv := strings.Split(r.Header.Get(key), ",")
+		for _, v := range vv {
+			if val == strings.ToLower(strings.TrimSpace(v)) {
+				return true
+			}
+		}
+		return false
+	}
+
+	if contains("Connection", "upgrade") && contains("Upgrade", "websocket") {
+		return true
+	}
+
+	return false
+}
+
+func (wh *webHandler) String() string {
+	return "web"
+}
+
+func NewHandler(opts ...handler.Option) handler.Handler {
+	return &webHandler{
+		opts: handler.NewOptions(opts...),
+	}
+}
+
+func WithService(s *api.Service, opts ...handler.Option) handler.Handler {
+	options := handler.NewOptions(opts...)
+
+	return &webHandler{
+		opts: options,
+		s:    s,
+	}
+}

api/internal/proto/message.pb.go

@@ -0,0 +1,28 @@
+package proto
+
+type Message struct {
+	data []byte
+}
+
+func (m *Message) ProtoMessage() {}
+
+func (m *Message) Reset() {
+	*m = Message{}
+}
+
+func (m *Message) String() string {
+	return string(m.data)
+}
+
+func (m *Message) Marshal() ([]byte, error) {
+	return m.data, nil
+}
+
+func (m *Message) Unmarshal(data []byte) error {
+	m.data = data
+	return nil
+}
+
+func NewMessage(data []byte) *Message {
+	return &Message{data}
+}

api/proto/api.micro.go

@@ -0,0 +1,31 @@
+// Code generated by protoc-gen-micro. DO NOT EDIT.
+// source: github.com/micro/go-micro/api/proto/api.proto
+
+/*
+Package go_api is a generated protocol buffer package.
+
+It is generated from these files:
+	github.com/micro/go-micro/api/proto/api.proto
+
+It has these top-level messages:
+	Pair
+	Request
+	Response
+	Event
+*/
+package go_api
+
+import proto "github.com/golang/protobuf/proto"
+import fmt "fmt"
+import math "math"
+
+// 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

api/proto/api.pb.go

@@ -0,0 +1,332 @@
+// Code generated by protoc-gen-go. DO NOT EDIT.
+// source: github.com/micro/go-micro/api/proto/api.proto
+
+package go_api
+
+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
+
+type Pair struct {
+	Key                  string   `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"`
+	Values               []string `protobuf:"bytes,2,rep,name=values,proto3" json:"values,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *Pair) Reset()         { *m = Pair{} }
+func (m *Pair) String() string { return proto.CompactTextString(m) }
+func (*Pair) ProtoMessage()    {}
+func (*Pair) Descriptor() ([]byte, []int) {
+	return fileDescriptor_api_17a7876430d97ebd, []int{0}
+}
+func (m *Pair) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_Pair.Unmarshal(m, b)
+}
+func (m *Pair) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_Pair.Marshal(b, m, deterministic)
+}
+func (dst *Pair) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_Pair.Merge(dst, src)
+}
+func (m *Pair) XXX_Size() int {
+	return xxx_messageInfo_Pair.Size(m)
+}
+func (m *Pair) XXX_DiscardUnknown() {
+	xxx_messageInfo_Pair.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_Pair proto.InternalMessageInfo
+
+func (m *Pair) GetKey() string {
+	if m != nil {
+		return m.Key
+	}
+	return ""
+}
+
+func (m *Pair) GetValues() []string {
+	if m != nil {
+		return m.Values
+	}
+	return nil
+}
+
+// A HTTP request as RPC
+// Forward by the api handler
+type Request struct {
+	Method               string           `protobuf:"bytes,1,opt,name=method,proto3" json:"method,omitempty"`
+	Path                 string           `protobuf:"bytes,2,opt,name=path,proto3" json:"path,omitempty"`
+	Header               map[string]*Pair `protobuf:"bytes,3,rep,name=header,proto3" json:"header,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
+	Get                  map[string]*Pair `protobuf:"bytes,4,rep,name=get,proto3" json:"get,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
+	Post                 map[string]*Pair `protobuf:"bytes,5,rep,name=post,proto3" json:"post,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
+	Body                 string           `protobuf:"bytes,6,opt,name=body,proto3" json:"body,omitempty"`
+	Url                  string           `protobuf:"bytes,7,opt,name=url,proto3" json:"url,omitempty"`
+	XXX_NoUnkeyedLiteral struct{}         `json:"-"`
+	XXX_unrecognized     []byte           `json:"-"`
+	XXX_sizecache        int32            `json:"-"`
+}
+
+func (m *Request) Reset()         { *m = Request{} }
+func (m *Request) String() string { return proto.CompactTextString(m) }
+func (*Request) ProtoMessage()    {}
+func (*Request) Descriptor() ([]byte, []int) {
+	return fileDescriptor_api_17a7876430d97ebd, []int{1}
+}
+func (m *Request) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_Request.Unmarshal(m, b)
+}
+func (m *Request) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_Request.Marshal(b, m, deterministic)
+}
+func (dst *Request) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_Request.Merge(dst, src)
+}
+func (m *Request) XXX_Size() int {
+	return xxx_messageInfo_Request.Size(m)
+}
+func (m *Request) XXX_DiscardUnknown() {
+	xxx_messageInfo_Request.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_Request proto.InternalMessageInfo
+
+func (m *Request) GetMethod() string {
+	if m != nil {
+		return m.Method
+	}
+	return ""
+}
+
+func (m *Request) GetPath() string {
+	if m != nil {
+		return m.Path
+	}
+	return ""
+}
+
+func (m *Request) GetHeader() map[string]*Pair {
+	if m != nil {
+		return m.Header
+	}
+	return nil
+}
+
+func (m *Request) GetGet() map[string]*Pair {
+	if m != nil {
+		return m.Get
+	}
+	return nil
+}
+
+func (m *Request) GetPost() map[string]*Pair {
+	if m != nil {
+		return m.Post
+	}
+	return nil
+}
+
+func (m *Request) GetBody() string {
+	if m != nil {
+		return m.Body
+	}
+	return ""
+}
+
+func (m *Request) GetUrl() string {
+	if m != nil {
+		return m.Url
+	}
+	return ""
+}
+
+// A HTTP response as RPC
+// Expected response for the api handler
+type Response struct {
+	StatusCode           int32            `protobuf:"varint,1,opt,name=statusCode,proto3" json:"statusCode,omitempty"`
+	Header               map[string]*Pair `protobuf:"bytes,2,rep,name=header,proto3" json:"header,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
+	Body                 string           `protobuf:"bytes,3,opt,name=body,proto3" json:"body,omitempty"`
+	XXX_NoUnkeyedLiteral struct{}         `json:"-"`
+	XXX_unrecognized     []byte           `json:"-"`
+	XXX_sizecache        int32            `json:"-"`
+}
+
+func (m *Response) Reset()         { *m = Response{} }
+func (m *Response) String() string { return proto.CompactTextString(m) }
+func (*Response) ProtoMessage()    {}
+func (*Response) Descriptor() ([]byte, []int) {
+	return fileDescriptor_api_17a7876430d97ebd, []int{2}
+}
+func (m *Response) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_Response.Unmarshal(m, b)
+}
+func (m *Response) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_Response.Marshal(b, m, deterministic)
+}
+func (dst *Response) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_Response.Merge(dst, src)
+}
+func (m *Response) XXX_Size() int {
+	return xxx_messageInfo_Response.Size(m)
+}
+func (m *Response) XXX_DiscardUnknown() {
+	xxx_messageInfo_Response.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_Response proto.InternalMessageInfo
+
+func (m *Response) GetStatusCode() int32 {
+	if m != nil {
+		return m.StatusCode
+	}
+	return 0
+}
+
+func (m *Response) GetHeader() map[string]*Pair {
+	if m != nil {
+		return m.Header
+	}
+	return nil
+}
+
+func (m *Response) GetBody() string {
+	if m != nil {
+		return m.Body
+	}
+	return ""
+}
+
+// A HTTP event as RPC
+// Forwarded by the event handler
+type Event struct {
+	// e.g login
+	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
+	// uuid
+	Id string `protobuf:"bytes,2,opt,name=id,proto3" json:"id,omitempty"`
+	// unix timestamp of event
+	Timestamp int64 `protobuf:"varint,3,opt,name=timestamp,proto3" json:"timestamp,omitempty"`
+	// event headers
+	Header map[string]*Pair `protobuf:"bytes,4,rep,name=header,proto3" json:"header,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
+	// the event data
+	Data                 string   `protobuf:"bytes,5,opt,name=data,proto3" json:"data,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *Event) Reset()         { *m = Event{} }
+func (m *Event) String() string { return proto.CompactTextString(m) }
+func (*Event) ProtoMessage()    {}
+func (*Event) Descriptor() ([]byte, []int) {
+	return fileDescriptor_api_17a7876430d97ebd, []int{3}
+}
+func (m *Event) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_Event.Unmarshal(m, b)
+}
+func (m *Event) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_Event.Marshal(b, m, deterministic)
+}
+func (dst *Event) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_Event.Merge(dst, src)
+}
+func (m *Event) XXX_Size() int {
+	return xxx_messageInfo_Event.Size(m)
+}
+func (m *Event) XXX_DiscardUnknown() {
+	xxx_messageInfo_Event.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_Event proto.InternalMessageInfo
+
+func (m *Event) GetName() string {
+	if m != nil {
+		return m.Name
+	}
+	return ""
+}
+
+func (m *Event) GetId() string {
+	if m != nil {
+		return m.Id
+	}
+	return ""
+}
+
+func (m *Event) GetTimestamp() int64 {
+	if m != nil {
+		return m.Timestamp
+	}
+	return 0
+}
+
+func (m *Event) GetHeader() map[string]*Pair {
+	if m != nil {
+		return m.Header
+	}
+	return nil
+}
+
+func (m *Event) GetData() string {
+	if m != nil {
+		return m.Data
+	}
+	return ""
+}
+
+func init() {
+	proto.RegisterType((*Pair)(nil), "go.api.Pair")
+	proto.RegisterType((*Request)(nil), "go.api.Request")
+	proto.RegisterMapType((map[string]*Pair)(nil), "go.api.Request.GetEntry")
+	proto.RegisterMapType((map[string]*Pair)(nil), "go.api.Request.HeaderEntry")
+	proto.RegisterMapType((map[string]*Pair)(nil), "go.api.Request.PostEntry")
+	proto.RegisterType((*Response)(nil), "go.api.Response")
+	proto.RegisterMapType((map[string]*Pair)(nil), "go.api.Response.HeaderEntry")
+	proto.RegisterType((*Event)(nil), "go.api.Event")
+	proto.RegisterMapType((map[string]*Pair)(nil), "go.api.Event.HeaderEntry")
+}
+
+func init() {
+	proto.RegisterFile("github.com/micro/go-micro/api/proto/api.proto", fileDescriptor_api_17a7876430d97ebd)
+}
+
+var fileDescriptor_api_17a7876430d97ebd = []byte{
+	// 410 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x53, 0xc1, 0x6e, 0xd4, 0x30,
+	0x10, 0x55, 0xe2, 0x24, 0x6d, 0x66, 0x11, 0x42, 0x3e, 0x20, 0x53, 0x2a, 0xb4, 0xca, 0x85, 0x15,
+	0x52, 0x13, 0x68, 0x39, 0x20, 0xae, 0xb0, 0x2a, 0xc7, 0xca, 0x7f, 0xe0, 0x6d, 0xac, 0xc4, 0x62,
+	0x13, 0x9b, 0xd8, 0xa9, 0xb4, 0x1f, 0xc7, 0x81, 0xcf, 0xe0, 0x6f, 0x90, 0x27, 0xde, 0xdd, 0xb2,
+	0x5a, 0x2e, 0x74, 0x6f, 0x2f, 0xf6, 0x9b, 0x37, 0x6f, 0xde, 0x38, 0xf0, 0xb6, 0x51, 0xae, 0x1d,
+	0x57, 0xe5, 0xbd, 0xee, 0xaa, 0x4e, 0xdd, 0x0f, 0xba, 0x6a, 0xf4, 0x95, 0x30, 0xaa, 0x32, 0x83,
+	0x76, 0xba, 0x12, 0x46, 0x95, 0x88, 0x68, 0xd6, 0xe8, 0x52, 0x18, 0x55, 0xbc, 0x87, 0xe4, 0x4e,
+	0xa8, 0x81, 0xbe, 0x00, 0xf2, 0x5d, 0x6e, 0x58, 0x34, 0x8f, 0x16, 0x39, 0xf7, 0x90, 0xbe, 0x84,
+	0xec, 0x41, 0xac, 0x47, 0x69, 0x59, 0x3c, 0x27, 0x8b, 0x9c, 0x87, 0xaf, 0xe2, 0x17, 0x81, 0x33,
+	0x2e, 0x7f, 0x8c, 0xd2, 0x3a, 0xcf, 0xe9, 0xa4, 0x6b, 0x75, 0x1d, 0x0a, 0xc3, 0x17, 0xa5, 0x90,
+	0x18, 0xe1, 0x5a, 0x16, 0xe3, 0x29, 0x62, 0x7a, 0x03, 0x59, 0x2b, 0x45, 0x2d, 0x07, 0x46, 0xe6,
+	0x64, 0x31, 0xbb, 0x7e, 0x5d, 0x4e, 0x16, 0xca, 0x20, 0x56, 0x7e, 0xc3, 0xdb, 0x65, 0xef, 0x86,
+	0x0d, 0x0f, 0x54, 0xfa, 0x0e, 0x48, 0x23, 0x1d, 0x4b, 0xb0, 0x82, 0x1d, 0x56, 0xdc, 0x4a, 0x37,
+	0xd1, 0x3d, 0x89, 0x5e, 0x41, 0x62, 0xb4, 0x75, 0x2c, 0x45, 0xf2, 0xab, 0x43, 0xf2, 0x9d, 0xb6,
+	0x81, 0x8d, 0x34, 0xef, 0x71, 0xa5, 0xeb, 0x0d, 0xcb, 0x26, 0x8f, 0x1e, 0xfb, 0x14, 0xc6, 0x61,
+	0xcd, 0xce, 0xa6, 0x14, 0xc6, 0x61, 0x7d, 0x71, 0x0b, 0xb3, 0x47, 0xbe, 0x8e, 0xc4, 0x54, 0x40,
+	0x8a, 0xc1, 0xe0, 0xac, 0xb3, 0xeb, 0x67, 0xdb, 0xb6, 0x3e, 0x55, 0x3e, 0x5d, 0x7d, 0x8e, 0x3f,
+	0x45, 0x17, 0x5f, 0xe1, 0x7c, 0x6b, 0xf7, 0x09, 0x2a, 0x4b, 0xc8, 0x77, 0x73, 0xfc, 0xbf, 0x4c,
+	0xf1, 0x33, 0x82, 0x73, 0x2e, 0xad, 0xd1, 0xbd, 0x95, 0xf4, 0x0d, 0x80, 0x75, 0xc2, 0x8d, 0xf6,
+	0x8b, 0xae, 0x25, 0xaa, 0xa5, 0xfc, 0xd1, 0x09, 0xfd, 0xb8, 0x5b, 0x5c, 0x8c, 0xc9, 0x5e, 0xee,
+	0x93, 0x9d, 0x14, 0x8e, 0x6e, 0x6e, 0x1b, 0x2f, 0xd9, 0xc7, 0x7b, 0xb2, 0x30, 0x8b, 0xdf, 0x11,
+	0xa4, 0xcb, 0x07, 0xd9, 0xe3, 0x16, 0x7b, 0xd1, 0xc9, 0x20, 0x82, 0x98, 0x3e, 0x87, 0x58, 0xd5,
+	0xe1, 0xed, 0xc5, 0xaa, 0xa6, 0x97, 0x90, 0x3b, 0xd5, 0x49, 0xeb, 0x44, 0x67, 0xd0, 0x0f, 0xe1,
+	0xfb, 0x03, 0xfa, 0x61, 0x37, 0x5e, 0xf2, 0xf7, 0xc3, 0xc1, 0x06, 0xff, 0x9a, 0xad, 0x16, 0x4e,
+	0xb0, 0x74, 0x6a, 0xea, 0xf1, 0xc9, 0x66, 0x5b, 0x65, 0xf8, 0x83, 0xde, 0xfc, 0x09, 0x00, 0x00,
+	0xff, 0xff, 0x7a, 0xb4, 0xd4, 0x8f, 0xcb, 0x03, 0x00, 0x00,
+}

api/proto/api.proto

@@ -0,0 +1,43 @@
+syntax = "proto3";
+
+package go.api;
+
+message Pair {
+	string key = 1;
+	repeated string values = 2;
+}
+
+// A HTTP request as RPC
+// Forward by the api handler
+message Request {
+        string method = 1;
+        string path = 2;
+        map<string, Pair> header = 3;
+        map<string, Pair> get = 4;
+        map<string, Pair> post = 5;
+        string body = 6;  // raw request body; if not application/x-www-form-urlencoded
+	string url = 7;
+}
+
+// A HTTP response as RPC
+// Expected response for the api handler
+message Response {
+        int32 statusCode = 1;
+        map<string, Pair> header = 2;
+        string body = 3;
+}
+
+// A HTTP event as RPC
+// Forwarded by the event handler
+message Event {
+	// e.g login
+	string name = 1;
+	// uuid
+	string id = 2;
+	// unix timestamp of event
+	int64 timestamp = 3;
+	// event headers
+        map<string, Pair> header = 4;
+	// the event data
+	string data = 5;
+}

api/resolver/grpc/grpc.go

@@ -0,0 +1,38 @@
+// Package grpc resolves a grpc service like /greeter.Say/Hello to greeter service
+package grpc
+
+import (
+	"errors"
+	"net/http"
+	"strings"
+
+	"github.com/micro/go-micro/api/resolver"
+)
+
+type Resolver struct{}
+
+func (r *Resolver) Resolve(req *http.Request) (*resolver.Endpoint, error) {
+	// /foo.Bar/Service
+	if req.URL.Path == "/" {
+		return nil, errors.New("unknown name")
+	}
+	// [foo.Bar, Service]
+	parts := strings.Split(req.URL.Path[1:], "/")
+	// [foo, Bar]
+	name := strings.Split(parts[0], ".")
+	// foo
+	return &resolver.Endpoint{
+		Name:   strings.Join(name[:len(name)-1], "."),
+		Host:   req.Host,
+		Method: req.Method,
+		Path:   req.URL.Path,
+	}, nil
+}
+
+func (r *Resolver) String() string {
+	return "grpc"
+}
+
+func NewResolver(opts ...resolver.Option) resolver.Resolver {
+	return &Resolver{}
+}

api/resolver/host/host.go

@@ -0,0 +1,27 @@
+// Package host resolves using http host
+package host
+
+import (
+	"net/http"
+
+	"github.com/micro/go-micro/api/resolver"
+)
+
+type Resolver struct{}
+
+func (r *Resolver) Resolve(req *http.Request) (*resolver.Endpoint, error) {
+	return &resolver.Endpoint{
+		Name:   req.Host,
+		Host:   req.Host,
+		Method: req.Method,
+		Path:   req.URL.Path,
+	}, nil
+}
+
+func (r *Resolver) String() string {
+	return "host"
+}
+
+func NewResolver(opts ...resolver.Option) resolver.Resolver {
+	return &Resolver{}
+}

api/resolver/micro/micro.go

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

api/resolver/micro/route.go

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

api/resolver/micro/route_test.go

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

api/resolver/options.go

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

api/resolver/path/path.go

@@ -0,0 +1,33 @@
+// Package path resolves using http path
+package path
+
+import (
+	"errors"
+	"net/http"
+	"strings"
+
+	"github.com/micro/go-micro/api/resolver"
+)
+
+type Resolver struct{}
+
+func (r *Resolver) Resolve(req *http.Request) (*resolver.Endpoint, error) {
+	if req.URL.Path == "/" {
+		return nil, errors.New("unknown name")
+	}
+	parts := strings.Split(req.URL.Path[1:], "/")
+	return &resolver.Endpoint{
+		Name:   parts[0],
+		Host:   req.Host,
+		Method: req.Method,
+		Path:   req.URL.Path,
+	}, nil
+}
+
+func (r *Resolver) String() string {
+	return "path"
+}
+
+func NewResolver(opts ...resolver.Option) resolver.Resolver {
+	return &Resolver{}
+}

api/resolver/resolver.go

@@ -0,0 +1,31 @@
+// Package resolver resolves a http request to an endpoint
+package resolver
+
+import (
+	"net/http"
+)
+
+// Resolver resolves requests to endpoints
+type Resolver interface {
+	Resolve(r *http.Request) (*Endpoint, error)
+	String() string
+}
+
+// Endpoint is the endpoint for a http request
+type Endpoint struct {
+	// e.g greeter
+	Name string
+	// HTTP Host e.g example.com
+	Host string
+	// HTTP Methods e.g GET, POST
+	Method string
+	// HTTP Path e.g /greeter.
+	Path string
+}
+
+type Options struct {
+	Handler   string
+	Namespace string
+}
+
+type Option func(o *Options)

api/resolver/vpath/vpath.go

@@ -0,0 +1,59 @@
+// Package vpath resolves using http path and recognised versioned urls
+package vpath
+
+import (
+	"errors"
+	"net/http"
+	"regexp"
+	"strings"
+
+	"github.com/micro/go-micro/api/resolver"
+)
+
+type Resolver struct{}
+
+var (
+	re = regexp.MustCompile("^v[0-9]+$")
+)
+
+func (r *Resolver) Resolve(req *http.Request) (*resolver.Endpoint, error) {
+	if req.URL.Path == "/" {
+		return nil, errors.New("unknown name")
+	}
+
+	parts := strings.Split(req.URL.Path[1:], "/")
+
+	if len(parts) == 1 {
+		return &resolver.Endpoint{
+			Name:   parts[0],
+			Host:   req.Host,
+			Method: req.Method,
+			Path:   req.URL.Path,
+		}, nil
+	}
+
+	// /v1/foo
+	if re.MatchString(parts[0]) {
+		return &resolver.Endpoint{
+			Name:   parts[1],
+			Host:   req.Host,
+			Method: req.Method,
+			Path:   req.URL.Path,
+		}, nil
+	}
+
+	return &resolver.Endpoint{
+		Name:   parts[0],
+		Host:   req.Host,
+		Method: req.Method,
+		Path:   req.URL.Path,
+	}, nil
+}
+
+func (r *Resolver) String() string {
+	return "path"
+}
+
+func NewResolver(opts ...resolver.Option) resolver.Resolver {
+	return &Resolver{}
+}

api/router/options.go

@@ -0,0 +1,61 @@
+package router
+
+import (
+	"github.com/micro/go-micro/api/resolver"
+	"github.com/micro/go-micro/api/resolver/micro"
+	"github.com/micro/go-micro/cmd"
+	"github.com/micro/go-micro/registry"
+)
+
+type Options struct {
+	Namespace string
+	Handler   string
+	Registry  registry.Registry
+	Resolver  resolver.Resolver
+}
+
+type Option func(o *Options)
+
+func NewOptions(opts ...Option) Options {
+	options := Options{
+		Handler:  "meta",
+		Registry: *cmd.DefaultOptions().Registry,
+	}
+
+	for _, o := range opts {
+		o(&options)
+	}
+
+	if options.Resolver == nil {
+		options.Resolver = micro.NewResolver(
+			resolver.WithHandler(options.Handler),
+			resolver.WithNamespace(options.Namespace),
+		)
+	}
+
+	return options
+}
+
+func WithHandler(h string) Option {
+	return func(o *Options) {
+		o.Handler = h
+	}
+}
+
+func WithNamespace(ns string) Option {
+	return func(o *Options) {
+		o.Namespace = ns
+	}
+}
+
+func WithRegistry(r registry.Registry) Option {
+	return func(o *Options) {
+		o.Registry = r
+	}
+}
+
+func WithResolver(r resolver.Resolver) Option {
+	return func(o *Options) {
+		o.Resolver = r
+	}
+}

api/router/registry/registry.go

@@ -0,0 +1,393 @@
+// Package registry provides a dynamic api service router
+package registry
+
+import (
+	"errors"
+	"fmt"
+	"log"
+	"net/http"
+	"regexp"
+	"strings"
+	"sync"
+	"time"
+
+	"github.com/micro/go-micro/api"
+	"github.com/micro/go-micro/api/router"
+	"github.com/micro/go-micro/registry"
+	"github.com/micro/go-micro/registry/cache"
+)
+
+// router is the default router
+type registryRouter struct {
+	exit chan bool
+	opts router.Options
+
+	// registry cache
+	rc cache.Cache
+
+	sync.RWMutex
+	eps map[string]*api.Service
+}
+
+func setNamespace(ns, name string) string {
+	ns = strings.TrimSpace(ns)
+	name = strings.TrimSpace(name)
+
+	// no namespace
+	if len(ns) == 0 {
+		return name
+	}
+
+	switch {
+	// has - suffix
+	case strings.HasSuffix(ns, "-"):
+		return strings.Replace(ns+name, ".", "-", -1)
+	// has . suffix
+	case strings.HasSuffix(ns, "."):
+		return ns + name
+	}
+
+	// default join .
+	return strings.Join([]string{ns, name}, ".")
+}
+
+func (r *registryRouter) isClosed() bool {
+	select {
+	case <-r.exit:
+		return true
+	default:
+		return false
+	}
+}
+
+// refresh list of api services
+func (r *registryRouter) refresh() {
+	var attempts int
+
+	for {
+		services, err := r.opts.Registry.ListServices()
+		if err != nil {
+			attempts++
+			log.Println("Error listing endpoints", err)
+			time.Sleep(time.Duration(attempts) * time.Second)
+			continue
+		}
+
+		attempts = 0
+
+		// for each service, get service and store endpoints
+		for _, s := range services {
+			// only get services for this namespace
+			if !strings.HasPrefix(s.Name, r.opts.Namespace) {
+				continue
+			}
+			service, err := r.rc.GetService(s.Name)
+			if err != nil {
+				continue
+			}
+			r.store(service)
+		}
+
+		// refresh list in 10 minutes... cruft
+		select {
+		case <-time.After(time.Minute * 10):
+		case <-r.exit:
+			return
+		}
+	}
+}
+
+// process watch event
+func (r *registryRouter) process(res *registry.Result) {
+	// skip these things
+	if res == nil || res.Service == nil || !strings.HasPrefix(res.Service.Name, r.opts.Namespace) {
+		return
+	}
+
+	// get entry from cache
+	service, err := r.rc.GetService(res.Service.Name)
+	if err != nil {
+		return
+	}
+
+	// update our local endpoints
+	r.store(service)
+}
+
+// store local endpoint cache
+func (r *registryRouter) store(services []*registry.Service) {
+	// endpoints
+	eps := map[string]*api.Service{}
+
+	// services
+	names := map[string]bool{}
+
+	// create a new endpoint mapping
+	for _, service := range services {
+		// set names we need later
+		names[service.Name] = true
+
+		// map per endpoint
+		for _, endpoint := range service.Endpoints {
+			// create a key service:endpoint_name
+			key := fmt.Sprintf("%s:%s", service.Name, endpoint.Name)
+			// decode endpoint
+			end := api.Decode(endpoint.Metadata)
+
+			// if we got nothing skip
+			if err := api.Validate(end); err != nil {
+				continue
+			}
+
+			// try get endpoint
+			ep, ok := eps[key]
+			if !ok {
+				ep = &api.Service{Name: service.Name}
+			}
+
+			// overwrite the endpoint
+			ep.Endpoint = end
+			// append services
+			ep.Services = append(ep.Services, service)
+			// store it
+			eps[key] = ep
+		}
+	}
+
+	r.Lock()
+	defer r.Unlock()
+
+	// delete any existing eps for services we know
+	for key, service := range r.eps {
+		// skip what we don't care about
+		if !names[service.Name] {
+			continue
+		}
+
+		// ok we know this thing
+		// delete delete delete
+		delete(r.eps, key)
+	}
+
+	// now set the eps we have
+	for name, endpoint := range eps {
+		r.eps[name] = endpoint
+	}
+}
+
+// watch for endpoint changes
+func (r *registryRouter) watch() {
+	var attempts int
+
+	for {
+		if r.isClosed() {
+			return
+		}
+
+		// watch for changes
+		w, err := r.opts.Registry.Watch()
+		if err != nil {
+			attempts++
+			log.Println("Error watching endpoints", err)
+			time.Sleep(time.Duration(attempts) * time.Second)
+			continue
+		}
+
+		ch := make(chan bool)
+
+		go func() {
+			select {
+			case <-ch:
+				w.Stop()
+			case <-r.exit:
+				w.Stop()
+			}
+		}()
+
+		// reset if we get here
+		attempts = 0
+
+		for {
+			// process next event
+			res, err := w.Next()
+			if err != nil {
+				log.Println("Error getting next endpoint", err)
+				close(ch)
+				break
+			}
+			r.process(res)
+		}
+	}
+}
+
+func (r *registryRouter) Options() router.Options {
+	return r.opts
+}
+
+func (r *registryRouter) Close() error {
+	select {
+	case <-r.exit:
+		return nil
+	default:
+		close(r.exit)
+		r.rc.Stop()
+	}
+	return nil
+}
+
+func (r *registryRouter) Endpoint(req *http.Request) (*api.Service, error) {
+	if r.isClosed() {
+		return nil, errors.New("router closed")
+	}
+
+	r.RLock()
+	defer r.RUnlock()
+
+	// use the first match
+	// TODO: weighted matching
+	for _, e := range r.eps {
+		ep := e.Endpoint
+
+		// match
+		var pathMatch, hostMatch, methodMatch bool
+
+		// 1. try method GET, POST, PUT, etc
+		// 2. try host example.com, foobar.com, etc
+		// 3. try path /foo/bar, /bar/baz, etc
+
+		// 1. try match method
+		for _, m := range ep.Method {
+			if req.Method == m {
+				methodMatch = true
+				break
+			}
+		}
+
+		// no match on method pass
+		if len(ep.Method) > 0 && !methodMatch {
+			continue
+		}
+
+		// 2. try match host
+		for _, h := range ep.Host {
+			if req.Host == h {
+				hostMatch = true
+				break
+			}
+		}
+
+		// no match on host pass
+		if len(ep.Host) > 0 && !hostMatch {
+			continue
+		}
+
+		// 3. try match paths
+		for _, p := range ep.Path {
+			re, err := regexp.CompilePOSIX(p)
+			if err == nil && re.MatchString(req.URL.Path) {
+				pathMatch = true
+				break
+			}
+		}
+
+		// no match pass
+		if len(ep.Path) > 0 && !pathMatch {
+			continue
+		}
+
+		// TODO: Percentage traffic
+
+		// we got here, so its a match
+		return e, nil
+	}
+
+	// no match
+	return nil, errors.New("not found")
+}
+
+func (r *registryRouter) Route(req *http.Request) (*api.Service, error) {
+	if r.isClosed() {
+		return nil, errors.New("router closed")
+	}
+
+	// try get an endpoint
+	ep, err := r.Endpoint(req)
+	if err == nil {
+		return ep, nil
+	}
+
+	// error not nil
+	// ignore that shit
+	// TODO: don't ignore that shit
+
+	// get the service name
+	rp, err := r.opts.Resolver.Resolve(req)
+	if err != nil {
+		return nil, err
+	}
+
+	// service name
+	name := setNamespace(r.opts.Namespace, rp.Name)
+
+	// get service
+	services, err := r.rc.GetService(name)
+	if err != nil {
+		return nil, err
+	}
+
+	// only use endpoint matching when the meta handler is set aka api.Default
+	switch r.opts.Handler {
+	// rpc handlers
+	case "meta", "api", "rpc":
+		handler := r.opts.Handler
+
+		// set default handler to api
+		if r.opts.Handler == "meta" {
+			handler = "rpc"
+		}
+
+		// construct api service
+		return &api.Service{
+			Name: name,
+			Endpoint: &api.Endpoint{
+				Name:    rp.Method,
+				Handler: handler,
+			},
+			Services: services,
+		}, nil
+	// http handler
+	case "http", "proxy", "web":
+		// construct api service
+		return &api.Service{
+			Name: name,
+			Endpoint: &api.Endpoint{
+				Name:    req.URL.String(),
+				Handler: r.opts.Handler,
+				Host:    []string{req.Host},
+				Method:  []string{req.Method},
+				Path:    []string{req.URL.Path},
+			},
+			Services: services,
+		}, nil
+	}
+
+	return nil, errors.New("unknown handler")
+}
+
+func newRouter(opts ...router.Option) *registryRouter {
+	options := router.NewOptions(opts...)
+	r := &registryRouter{
+		exit: make(chan bool),
+		opts: options,
+		rc:   cache.New(options.Registry),
+		eps:  make(map[string]*api.Service),
+	}
+	go r.watch()
+	go r.refresh()
+	return r
+}
+
+// NewRouter returns the default router
+func NewRouter(opts ...router.Option) router.Router {
+	return newRouter(opts...)
+}

api/router/registry/registry_test.go

@@ -0,0 +1,181 @@
+package registry
+
+import (
+	"fmt"
+	"net/http"
+	"net/url"
+	"testing"
+
+	"github.com/micro/go-micro/api"
+)
+
+func TestSetNamespace(t *testing.T) {
+	testCases := []struct {
+		namespace string
+		name      string
+		expected  string
+	}{
+		// default dotted path
+		{
+			"go.micro.api",
+			"foo",
+			"go.micro.api.foo",
+		},
+		// dotted end
+		{
+			"go.micro.api.",
+			"foo",
+			"go.micro.api.foo",
+		},
+		// dashed end
+		{
+			"go-micro-api-",
+			"foo",
+			"go-micro-api-foo",
+		},
+		// no namespace
+		{
+			"",
+			"foo",
+			"foo",
+		},
+		{
+			"go-micro-api-",
+			"v2.foo",
+			"go-micro-api-v2-foo",
+		},
+	}
+
+	for _, test := range testCases {
+		name := setNamespace(test.namespace, test.name)
+		if name != test.expected {
+			t.Fatalf("expected name %s got %s", test.expected, name)
+		}
+	}
+}
+
+func TestRouter(t *testing.T) {
+	r := newRouter()
+
+	compare := func(expect, got []string) bool {
+		// no data to compare, return true
+		if len(expect) == 0 && len(got) == 0 {
+			return true
+		}
+		// no data expected but got some return false
+		if len(expect) == 0 && len(got) > 0 {
+			return false
+		}
+
+		// compare expected with what we got
+		for _, e := range expect {
+			var seen bool
+			for _, g := range got {
+				if e == g {
+					seen = true
+					break
+				}
+			}
+			if !seen {
+				return false
+			}
+		}
+
+		// we're done, return true
+		return true
+	}
+
+	testData := []struct {
+		e *api.Endpoint
+		r *http.Request
+		m bool
+	}{
+		{
+			e: &api.Endpoint{
+				Name:   "Foo.Bar",
+				Host:   []string{"example.com"},
+				Method: []string{"GET"},
+				Path:   []string{"/foo"},
+			},
+			r: &http.Request{
+				Host:   "example.com",
+				Method: "GET",
+				URL: &url.URL{
+					Path: "/foo",
+				},
+			},
+			m: true,
+		},
+		{
+			e: &api.Endpoint{
+				Name:   "Bar.Baz",
+				Host:   []string{"example.com", "foo.com"},
+				Method: []string{"GET", "POST"},
+				Path:   []string{"/foo/bar"},
+			},
+			r: &http.Request{
+				Host:   "foo.com",
+				Method: "POST",
+				URL: &url.URL{
+					Path: "/foo/bar",
+				},
+			},
+			m: true,
+		},
+		{
+			e: &api.Endpoint{
+				Name:   "Test.Cruft",
+				Host:   []string{"example.com", "foo.com"},
+				Method: []string{"GET", "POST"},
+				Path:   []string{"/xyz"},
+			},
+			r: &http.Request{
+				Host:   "fail.com",
+				Method: "DELETE",
+				URL: &url.URL{
+					Path: "/test/fail",
+				},
+			},
+			m: false,
+		},
+	}
+
+	for _, d := range testData {
+		key := fmt.Sprintf("%s:%s", "test.service", d.e.Name)
+		r.eps[key] = &api.Service{
+			Endpoint: d.e,
+		}
+	}
+
+	for _, d := range testData {
+		e, err := r.Endpoint(d.r)
+		if d.m && err != nil {
+			t.Fatalf("expected match, got %v", err)
+		}
+		if !d.m && err == nil {
+			t.Fatal("expected error got match")
+		}
+		// skip testing the non match
+		if !d.m {
+			continue
+		}
+
+		ep := e.Endpoint
+
+		// test the match
+		if d.e.Name != ep.Name {
+			t.Fatalf("expected %v got %v", d.e.Name, ep.Name)
+		}
+		if ok := compare(d.e.Method, ep.Method); !ok {
+			t.Fatalf("expected %v got %v", d.e.Method, ep.Method)
+		}
+		if ok := compare(d.e.Path, ep.Path); !ok {
+			t.Fatalf("expected %v got %v", d.e.Path, ep.Path)
+		}
+		if ok := compare(d.e.Host, ep.Host); !ok {
+			t.Fatalf("expected %v got %v", d.e.Host, ep.Host)
+		}
+
+	}
+
+}

api/router/router.go

@@ -0,0 +1,20 @@
+// Package router provides api service routing
+package router
+
+import (
+	"net/http"
+
+	"github.com/micro/go-micro/api"
+)
+
+// Router is used to determine an endpoint for a request
+type Router interface {
+	// Returns options
+	Options() Options
+	// Stop the router
+	Close() error
+	// Endpoint returns an api.Service endpoint or an error if it does not exist
+	Endpoint(r *http.Request) (*api.Service, error)
+	// Route returns an api.Service route
+	Route(r *http.Request) (*api.Service, error)
+}

api/server/http/http.go

@@ -0,0 +1,98 @@
+// Package http provides a http server with features; acme, cors, etc
+package http
+
+import (
+	"crypto/tls"
+	"net"
+	"net/http"
+	"os"
+	"sync"
+
+	"github.com/gorilla/handlers"
+	"github.com/micro/go-micro/api/server"
+	"github.com/micro/go-micro/util/log"
+	"golang.org/x/crypto/acme/autocert"
+)
+
+type httpServer struct {
+	mux  *http.ServeMux
+	opts server.Options
+
+	mtx     sync.RWMutex
+	address string
+	exit    chan chan error
+}
+
+func NewServer(address string) server.Server {
+	return &httpServer{
+		opts:    server.Options{},
+		mux:     http.NewServeMux(),
+		address: address,
+		exit:    make(chan chan error),
+	}
+}
+
+func (s *httpServer) Address() string {
+	s.mtx.RLock()
+	defer s.mtx.RUnlock()
+	return s.address
+}
+
+func (s *httpServer) Init(opts ...server.Option) error {
+	for _, o := range opts {
+		o(&s.opts)
+	}
+	return nil
+}
+
+func (s *httpServer) Handle(path string, handler http.Handler) {
+	s.mux.Handle(path, handlers.CombinedLoggingHandler(os.Stdout, handler))
+}
+
+func (s *httpServer) Start() error {
+	var l net.Listener
+	var err error
+
+	if s.opts.EnableACME {
+		// should we check the address to make sure its using :443?
+		l = autocert.NewListener(s.opts.ACMEHosts...)
+	} else if s.opts.EnableTLS && s.opts.TLSConfig != nil {
+		l, err = tls.Listen("tcp", s.address, s.opts.TLSConfig)
+	} else {
+		// otherwise plain listen
+		l, err = net.Listen("tcp", s.address)
+	}
+	if err != nil {
+		return err
+	}
+
+	log.Logf("HTTP API Listening on %s", l.Addr().String())
+
+	s.mtx.Lock()
+	s.address = l.Addr().String()
+	s.mtx.Unlock()
+
+	go func() {
+		if err := http.Serve(l, s.mux); err != nil {
+			// temporary fix
+			//log.Fatal(err)
+		}
+	}()
+
+	go func() {
+		ch := <-s.exit
+		ch <- l.Close()
+	}()
+
+	return nil
+}
+
+func (s *httpServer) Stop() error {
+	ch := make(chan error)
+	s.exit <- ch
+	return <-ch
+}
+
+func (s *httpServer) String() string {
+	return "http"
+}

api/server/http/http_test.go

@@ -0,0 +1,41 @@
+package http
+
+import (
+	"fmt"
+	"io/ioutil"
+	"net/http"
+	"testing"
+)
+
+func TestHTTPServer(t *testing.T) {
+	testResponse := "hello world"
+
+	s := NewServer("localhost:0")
+
+	s.Handle("/", http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		fmt.Fprint(w, testResponse)
+	}))
+
+	if err := s.Start(); err != nil {
+		t.Fatal(err)
+	}
+
+	rsp, err := http.Get(fmt.Sprintf("http://%s/", s.Address()))
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer rsp.Body.Close()
+
+	b, err := ioutil.ReadAll(rsp.Body)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	if string(b) != testResponse {
+		t.Fatalf("Unexpected response, got %s, expected %s", string(b), testResponse)
+	}
+
+	if err := s.Stop(); err != nil {
+		t.Fatal(err)
+	}
+}

api/server/options.go

@@ -0,0 +1,38 @@
+package server
+
+import (
+	"crypto/tls"
+)
+
+type Option func(o *Options)
+
+type Options struct {
+	EnableACME bool
+	EnableTLS  bool
+	ACMEHosts  []string
+	TLSConfig  *tls.Config
+}
+
+func ACMEHosts(hosts ...string) Option {
+	return func(o *Options) {
+		o.ACMEHosts = hosts
+	}
+}
+
+func EnableACME(b bool) Option {
+	return func(o *Options) {
+		o.EnableACME = b
+	}
+}
+
+func EnableTLS(b bool) Option {
+	return func(o *Options) {
+		o.EnableTLS = b
+	}
+}
+
+func TLSConfig(t *tls.Config) Option {
+	return func(o *Options) {
+		o.TLSConfig = t
+	}
+}

api/server/server.go

@@ -0,0 +1,15 @@
+// Package server provides an API gateway server which handles inbound requests
+package server
+
+import (
+	"net/http"
+)
+
+// Server serves api requests
+type Server interface {
+	Address() string
+	Init(opts ...Option) error
+	Handle(path string, handler http.Handler)
+	Start() error
+	Stop() error
+}

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

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

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

broker/http_broker.go

@@ -19,14 +19,14 @@ import (
 	"time"
 
 	"github.com/google/uuid"
-	"github.com/micro/go-log"
-	"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/micro/go-micro/registry/cache"
+	maddr "github.com/micro/go-micro/util/addr"
+	mnet "github.com/micro/go-micro/util/net"
+	mls "github.com/micro/go-micro/util/tls"
+	"golang.org/x/net/http2"
 )
 
 // HTTP Broker is a point to point async broker
@@ -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(),
 	}
 
@@ -124,6 +136,7 @@ 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
@@ -166,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()
@@ -340,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()
 
@@ -357,8 +412,8 @@ func (h *httpBroker) Connect() error {
 	if !ok {
 		reg = registry.DefaultRegistry
 	}
-	// set rcache
-	h.r = rcache.New(reg)
+	// set cache
+	h.r = cache.New(reg)
 
 	// set running
 	h.running = true
@@ -377,8 +432,8 @@ func (h *httpBroker) Disconnect() error {
 	h.Lock()
 	defer h.Unlock()
 
-	// stop rcache
-	rc, ok := h.r.(rcache.Cache)
+	// stop cache
+	rc, ok := h.r.(cache.Cache)
 	if ok {
 		rc.Stop()
 	}
@@ -422,13 +477,20 @@ func (h *httpBroker) Init(opts ...Option) error {
 		reg = registry.DefaultRegistry
 	}
 
-	// get rcache
-	if rc, ok := h.r.(rcache.Cache); ok {
+	// get cache
+	if rc, ok := h.r.(cache.Cache); ok {
 		rc.Stop()
 	}
 
 	// set registry
-	h.r = rcache.New(reg)
+	h.r = cache.New(reg)
+
+	// reconfigure tls config
+	if c := h.opts.TLSConfig; c != nil {
+		h.c = &http.Client{
+			Transport: newTransport(c),
+		}
+	}
 
 	return nil
 }
@@ -438,14 +500,7 @@ func (h *httpBroker) Options() Options {
 }
 
 func (h *httpBroker) Publish(topic string, msg *Message, opts ...PublishOption) error {
-	h.RLock()
-	s, err := h.r.GetService("topic:" + topic)
-	if err != nil {
-		h.RUnlock()
-		return err
-	}
-	h.RUnlock()
-
+	// create the message first
 	m := &Message{
 		Header: make(map[string]string),
 		Body:   msg.Body,
@@ -457,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
@@ -475,39 +544,76 @@ 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 {
-			io.Copy(ioutil.Discard, r.Body)
-			r.Body.Close()
+		if err != nil {
+			return err
 		}
+
+		// discard response body
+		io.Copy(ioutil.Discard, r.Body)
+		r.Body.Close()
+		return nil
 	}
 
-	for _, service := range s {
-		// only process if we have nodes
-		if len(service.Nodes) == 0 {
-			continue
-		}
-
-		switch service.Version {
-		// broadcast version means broadcast to all nodes
-		case broadcastVersion:
-			for _, node := range service.Nodes {
-				// publish async
-				go pub(node, b)
+	srv := func(s []*registry.Service, b []byte) {
+		for _, service := range s {
+			// only process if we have nodes
+			if len(service.Nodes) == 0 {
+				continue
 			}
-		default:
-			// select node to publish to
-			node := service.Nodes[rand.Int()%len(service.Nodes)]
 
-			// publish async
-			go pub(node, b)
+			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
+					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 to one node
+				if err := pub(node, topic, b); err != nil {
+					// if failed save it
+					h.saveMessage(topic, b)
+				}
+			}
 		}
 	}
 
+	// do the rest async
+	go func() {
+		// get a third of the backlog
+		messages := h.getMessage(topic, 8)
+		delay := (len(messages) > 1)
+
+		// publish all the messages
+		for _, msg := range messages {
+			// serialize here
+			srv(s, msg)
+
+			// sending a backlog of messages
+			if delay {
+				time.Sleep(time.Millisecond * 100)
+			}
+		}
+	}()
+
 	return nil
 }
 
 func (h *httpBroker) Subscribe(topic string, handler Handler, opts ...SubscribeOption) (Subscriber, error) {
-	options := newSubscribeOptions(opts...)
+	options := NewSubscribeOptions(opts...)
 
 	// parse address for host, port
 	parts := strings.Split(h.Address(), ":")

broker/http_broker_test.go

@@ -5,13 +5,26 @@ import (
 	"testing"
 	"time"
 
+	glog "github.com/go-log/log"
 	"github.com/google/uuid"
-	"github.com/micro/go-micro/registry/mock"
+	"github.com/micro/go-micro/registry/memory"
+	"github.com/micro/go-micro/util/log"
 )
 
+func newTestRegistry() *memory.Registry {
+	r := memory.NewRegistry()
+	m := r.(*memory.Registry)
+	m.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.New().String()
 
@@ -69,8 +82,11 @@ 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.New().String()
 
@@ -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 {

broker/memory/memory.go

@@ -1,4 +1,5 @@
-package mock
+// Package memory provides a memory broker
+package memory
 
 import (
 	"errors"
@@ -8,20 +9,20 @@ import (
 	"github.com/micro/go-micro/broker"
 )
 
-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,7 +111,7 @@ func (m *mockBroker) Subscribe(topic string, handler broker.Handler, opts ...bro
 		o(&options)
 	}
 
-	sub := &mockSubscriber{
+	sub := &memorySubscriber{
 		exit:    make(chan bool, 1),
 		id:      uuid.New().String(),
 		topic:   topic,
@@ -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 {
-	return "mock"
+func (m *memoryBroker) String() string {
+	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),
 	}
 }

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 {

broker/nats/context.go

@@ -0,0 +1,37 @@
+package nats
+
+import (
+	"context"
+
+	"github.com/micro/go-micro/broker"
+)
+
+// setSubscribeOption returns a function to setup a context with given value
+func setSubscribeOption(k, v interface{}) broker.SubscribeOption {
+	return func(o *broker.SubscribeOptions) {
+		if o.Context == nil {
+			o.Context = context.Background()
+		}
+		o.Context = context.WithValue(o.Context, k, v)
+	}
+}
+
+// setBrokerOption returns a function to setup a context with given value
+func setBrokerOption(k, v interface{}) broker.Option {
+	return func(o *broker.Options) {
+		if o.Context == nil {
+			o.Context = context.Background()
+		}
+		o.Context = context.WithValue(o.Context, k, v)
+	}
+}
+
+// setPublishOption returns a function to setup a context with given value
+func setPublishOption(k, v interface{}) broker.PublishOption {
+	return func(o *broker.PublishOptions) {
+		if o.Context == nil {
+			o.Context = context.Background()
+		}
+		o.Context = context.WithValue(o.Context, k, v)
+	}
+}

broker/nats/nats.go

@@ -0,0 +1,245 @@
+// Package nats provides a NATS broker
+package nats
+
+import (
+	"context"
+	"errors"
+	"strings"
+	"sync"
+
+	"github.com/micro/go-micro/broker"
+	"github.com/micro/go-micro/codec/json"
+	nats "github.com/nats-io/nats.go"
+)
+
+type natsBroker struct {
+	sync.RWMutex
+	addrs []string
+	conn  *nats.Conn
+	opts  broker.Options
+	nopts nats.Options
+	drain bool
+}
+
+type subscriber struct {
+	s     *nats.Subscription
+	opts  broker.SubscribeOptions
+	drain bool
+}
+
+type publication struct {
+	t string
+	m *broker.Message
+}
+
+func (p *publication) Topic() string {
+	return p.t
+}
+
+func (p *publication) Message() *broker.Message {
+	return p.m
+}
+
+func (p *publication) Ack() error {
+	// nats does not support acking
+	return nil
+}
+
+func (s *subscriber) Options() broker.SubscribeOptions {
+	return s.opts
+}
+
+func (s *subscriber) Topic() string {
+	return s.s.Subject
+}
+
+func (s *subscriber) Unsubscribe() error {
+	if s.drain {
+		return s.s.Drain()
+	}
+	return s.s.Unsubscribe()
+}
+
+func (n *natsBroker) Address() string {
+	if n.conn != nil && n.conn.IsConnected() {
+		return n.conn.ConnectedUrl()
+	}
+	if len(n.addrs) > 0 {
+		return n.addrs[0]
+	}
+
+	return ""
+}
+
+func setAddrs(addrs []string) []string {
+	var cAddrs []string
+	for _, addr := range addrs {
+		if len(addr) == 0 {
+			continue
+		}
+		if !strings.HasPrefix(addr, "nats://") {
+			addr = "nats://" + addr
+		}
+		cAddrs = append(cAddrs, addr)
+	}
+	if len(cAddrs) == 0 {
+		cAddrs = []string{nats.DefaultURL}
+	}
+	return cAddrs
+}
+
+func (n *natsBroker) Connect() error {
+	n.Lock()
+	defer n.Unlock()
+
+	status := nats.CLOSED
+	if n.conn != nil {
+		status = n.conn.Status()
+	}
+
+	switch status {
+	case nats.CONNECTED, nats.RECONNECTING, nats.CONNECTING:
+		return nil
+	default: // DISCONNECTED or CLOSED or DRAINING
+		opts := n.nopts
+		opts.Servers = n.addrs
+		opts.Secure = n.opts.Secure
+		opts.TLSConfig = n.opts.TLSConfig
+
+		// secure might not be set
+		if n.opts.TLSConfig != nil {
+			opts.Secure = true
+		}
+
+		c, err := opts.Connect()
+		if err != nil {
+			return err
+		}
+		n.conn = c
+		return nil
+	}
+}
+
+func (n *natsBroker) Disconnect() error {
+	n.RLock()
+	if n.drain {
+		n.conn.Drain()
+	} else {
+		n.conn.Close()
+	}
+	n.RUnlock()
+	return nil
+}
+
+func (n *natsBroker) Init(opts ...broker.Option) error {
+	for _, o := range opts {
+		o(&n.opts)
+	}
+	n.addrs = setAddrs(n.opts.Addrs)
+	return nil
+}
+
+func (n *natsBroker) Options() broker.Options {
+	return n.opts
+}
+
+func (n *natsBroker) Publish(topic string, msg *broker.Message, opts ...broker.PublishOption) error {
+	b, err := n.opts.Codec.Marshal(msg)
+	if err != nil {
+		return err
+	}
+	n.RLock()
+	defer n.RUnlock()
+	return n.conn.Publish(topic, b)
+}
+
+func (n *natsBroker) Subscribe(topic string, handler broker.Handler, opts ...broker.SubscribeOption) (broker.Subscriber, error) {
+	if n.conn == nil {
+		return nil, errors.New("not connected")
+	}
+
+	opt := broker.SubscribeOptions{
+		AutoAck: true,
+		Context: context.Background(),
+	}
+
+	for _, o := range opts {
+		o(&opt)
+	}
+
+	var drain bool
+	if _, ok := opt.Context.Value(drainSubscriptionKey{}).(bool); ok {
+		drain = true
+	}
+
+	fn := func(msg *nats.Msg) {
+		var m broker.Message
+		if err := n.opts.Codec.Unmarshal(msg.Data, &m); err != nil {
+			return
+		}
+		handler(&publication{m: &m, t: msg.Subject})
+	}
+
+	var sub *nats.Subscription
+	var err error
+
+	n.RLock()
+	if len(opt.Queue) > 0 {
+		sub, err = n.conn.QueueSubscribe(topic, opt.Queue, fn)
+	} else {
+		sub, err = n.conn.Subscribe(topic, fn)
+	}
+	n.RUnlock()
+	if err != nil {
+		return nil, err
+	}
+	return &subscriber{s: sub, opts: opt, drain: drain}, nil
+}
+
+func (n *natsBroker) String() string {
+	return "nats"
+}
+
+func NewBroker(opts ...broker.Option) broker.Broker {
+	options := broker.Options{
+		// Default codec
+		Codec:   json.Marshaler{},
+		Context: context.Background(),
+	}
+
+	for _, o := range opts {
+		o(&options)
+	}
+
+	natsOpts := nats.GetDefaultOptions()
+	if n, ok := options.Context.Value(optionsKey{}).(nats.Options); ok {
+		natsOpts = n
+	}
+
+	var drain bool
+	if _, ok := options.Context.Value(drainSubscriptionKey{}).(bool); ok {
+		drain = true
+	}
+
+	// broker.Options have higher priority than nats.Options
+	// only if Addrs, Secure or TLSConfig were not set through a broker.Option
+	// we read them from nats.Option
+	if len(options.Addrs) == 0 {
+		options.Addrs = natsOpts.Servers
+	}
+
+	if !options.Secure {
+		options.Secure = natsOpts.Secure
+	}
+
+	if options.TLSConfig == nil {
+		options.TLSConfig = natsOpts.TLSConfig
+	}
+
+	return &natsBroker{
+		opts:  options,
+		nopts: natsOpts,
+		addrs: setAddrs(options.Addrs),
+		drain: drain,
+	}
+}

broker/nats/nats_test.go

@@ -0,0 +1,99 @@
+package nats
+
+import (
+	"fmt"
+	"testing"
+
+	"github.com/micro/go-micro/broker"
+	nats "github.com/nats-io/nats.go"
+)
+
+var addrTestCases = []struct {
+	name        string
+	description string
+	addrs       map[string]string // expected address : set address
+}{
+	{
+		"brokerOpts",
+		"set broker addresses through a broker.Option in constructor",
+		map[string]string{
+			"nats://192.168.10.1:5222": "192.168.10.1:5222",
+			"nats://10.20.10.0:4222":   "10.20.10.0:4222"},
+	},
+	{
+		"brokerInit",
+		"set broker addresses through a broker.Option in broker.Init()",
+		map[string]string{
+			"nats://192.168.10.1:5222": "192.168.10.1:5222",
+			"nats://10.20.10.0:4222":   "10.20.10.0:4222"},
+	},
+	{
+		"natsOpts",
+		"set broker addresses through the nats.Option in constructor",
+		map[string]string{
+			"nats://192.168.10.1:5222": "192.168.10.1:5222",
+			"nats://10.20.10.0:4222":   "10.20.10.0:4222"},
+	},
+	{
+		"default",
+		"check if default Address is set correctly",
+		map[string]string{
+			"nats://localhost:4222": "",
+		},
+	},
+}
+
+// TestInitAddrs tests issue #100. Ensures that if the addrs is set by an option in init it will be used.
+func TestInitAddrs(t *testing.T) {
+
+	for _, tc := range addrTestCases {
+		t.Run(fmt.Sprintf("%s: %s", tc.name, tc.description), func(t *testing.T) {
+
+			var br broker.Broker
+			var addrs []string
+
+			for _, addr := range tc.addrs {
+				addrs = append(addrs, addr)
+			}
+
+			switch tc.name {
+			case "brokerOpts":
+				// we know that there are just two addrs in the dict
+				br = NewBroker(broker.Addrs(addrs[0], addrs[1]))
+				br.Init()
+			case "brokerInit":
+				br = NewBroker()
+				// we know that there are just two addrs in the dict
+				br.Init(broker.Addrs(addrs[0], addrs[1]))
+			case "natsOpts":
+				nopts := nats.GetDefaultOptions()
+				nopts.Servers = addrs
+				br = NewBroker(Options(nopts))
+				br.Init()
+			case "default":
+				br = NewBroker()
+				br.Init()
+			}
+
+			natsBroker, ok := br.(*natsBroker)
+			if !ok {
+				t.Fatal("Expected broker to be of types *natsBroker")
+			}
+			// check if the same amount of addrs we set has actually been set, default
+			// have only 1 address nats://127.0.0.1:4222 (current nats code) or
+			// nats://localhost:4222 (older code version)
+			if len(natsBroker.addrs) != len(tc.addrs) && tc.name != "default" {
+				t.Errorf("Expected Addr count = %d, Actual Addr count = %d",
+					len(natsBroker.addrs), len(tc.addrs))
+			}
+
+			for _, addr := range natsBroker.addrs {
+				_, ok := tc.addrs[addr]
+				if !ok {
+					t.Errorf("Expected '%s' has not been set", addr)
+				}
+			}
+		})
+
+	}
+}

broker/nats/options.go

@@ -0,0 +1,25 @@
+package nats
+
+import (
+	"github.com/micro/go-micro/broker"
+	nats "github.com/nats-io/nats.go"
+)
+
+type optionsKey struct{}
+type drainConnectionKey struct{}
+type drainSubscriptionKey struct{}
+
+// Options accepts nats.Options
+func Options(opts nats.Options) broker.Option {
+	return setBrokerOption(optionsKey{}, opts)
+}
+
+// DrainConnection will drain subscription on close
+func DrainConnection() broker.Option {
+	return setBrokerOption(drainConnectionKey{}, true)
+}
+
+// DrainSubscription will drain pending messages when unsubscribe
+func DrainSubscription() broker.SubscribeOption {
+	return setSubscribeOption(drainSubscriptionKey{}, true)
+}

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
@@ -44,13 +44,11 @@ type PublishOption func(*PublishOptions)
 
 type SubscribeOption func(*SubscribeOptions)
 
-type contextKeyT string
-
 var (
-	registryKey = contextKeyT("github.com/micro/go-micro/registry")
+	registryKey = "github.com/micro/go-micro/registry"
 )
 
-func newSubscribeOptions(opts ...SubscribeOption) SubscribeOptions {
+func NewSubscribeOptions(opts ...SubscribeOption) SubscribeOptions {
 	opt := SubscribeOptions{
 		AutoAck: true,
 	}
@@ -71,7 +69,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 +109,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
+	}
+}

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 {
-	return DefaultClient.NewRequest(service, method, request, reqOpts...)
+func NewRequest(service, endpoint string, request interface{}, reqOpts ...RequestOption) Request {
+	return DefaultClient.NewRequest(service, endpoint, request, reqOpts...)
 }
 
 // Creates a streaming connection with a service and returns responses on the

client/grpc/README.md

@@ -0,0 +1,25 @@
+# GRPC Client
+
+The grpc client is a [micro.Client](https://godoc.org/github.com/micro/go-micro/client#Client) compatible client.
+
+## Overview
+
+The client makes use of the [google.golang.org/grpc](google.golang.org/grpc) framework for the underlying communication mechanism.
+
+## Usage
+
+Specify the client to your micro service
+
+```go
+import (
+	"github.com/micro/go-micro"
+	"github.com/micro/go-plugins/client/grpc"
+)
+
+func main() {
+	service := micro.NewService(
+		micro.Name("greeter"),
+		micro.Client(grpc.NewClient()),
+	)
+}
+```

client/grpc/buffer.go

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

client/grpc/codec.go

@@ -0,0 +1,98 @@
+package grpc
+
+import (
+	"fmt"
+
+	"github.com/golang/protobuf/proto"
+	"github.com/json-iterator/go"
+	"github.com/micro/go-micro/codec"
+	"github.com/micro/go-micro/codec/jsonrpc"
+	"github.com/micro/go-micro/codec/protorpc"
+	"google.golang.org/grpc/encoding"
+)
+
+type jsonCodec struct{}
+type protoCodec struct{}
+type bytesCodec struct{}
+type wrapCodec struct{ encoding.Codec }
+
+var (
+	defaultGRPCCodecs = map[string]encoding.Codec{
+		"application/json":         jsonCodec{},
+		"application/proto":        protoCodec{},
+		"application/protobuf":     protoCodec{},
+		"application/octet-stream": protoCodec{},
+		"application/grpc+json":    jsonCodec{},
+		"application/grpc+proto":   protoCodec{},
+		"application/grpc+bytes":   bytesCodec{},
+	}
+
+	defaultRPCCodecs = map[string]codec.NewCodec{
+		"application/json":         jsonrpc.NewCodec,
+		"application/json-rpc":     jsonrpc.NewCodec,
+		"application/protobuf":     protorpc.NewCodec,
+		"application/proto-rpc":    protorpc.NewCodec,
+		"application/octet-stream": protorpc.NewCodec,
+	}
+
+	json = jsoniter.ConfigCompatibleWithStandardLibrary
+)
+
+// UseNumber fix unmarshal Number(8234567890123456789) to interface(8.234567890123457e+18)
+func UseNumber() {
+	json = jsoniter.Config{
+		UseNumber:              true,
+		EscapeHTML:             true,
+		SortMapKeys:            true,
+		ValidateJsonRawMessage: true,
+	}.Froze()
+}
+
+func (w wrapCodec) String() string {
+	return w.Codec.Name()
+}
+
+func (protoCodec) Marshal(v interface{}) ([]byte, error) {
+	return proto.Marshal(v.(proto.Message))
+}
+
+func (protoCodec) Unmarshal(data []byte, v interface{}) error {
+	return proto.Unmarshal(data, v.(proto.Message))
+}
+
+func (protoCodec) Name() string {
+	return "proto"
+}
+
+func (bytesCodec) Marshal(v interface{}) ([]byte, error) {
+	b, ok := v.(*[]byte)
+	if !ok {
+		return nil, fmt.Errorf("failed to marshal: %v is not type of *[]byte", v)
+	}
+	return *b, nil
+}
+
+func (bytesCodec) Unmarshal(data []byte, v interface{}) error {
+	b, ok := v.(*[]byte)
+	if !ok {
+		return fmt.Errorf("failed to unmarshal: %v is not type of *[]byte", v)
+	}
+	*b = data
+	return nil
+}
+
+func (bytesCodec) Name() string {
+	return "bytes"
+}
+
+func (jsonCodec) Marshal(v interface{}) ([]byte, error) {
+	return json.Marshal(v)
+}
+
+func (jsonCodec) Unmarshal(data []byte, v interface{}) error {
+	return json.Unmarshal(data, v)
+}
+
+func (jsonCodec) Name() string {
+	return "json"
+}

client/grpc/error.go

@@ -0,0 +1,30 @@
+package grpc
+
+import (
+	"github.com/micro/go-micro/errors"
+	"google.golang.org/grpc/status"
+)
+
+func microError(err error) error {
+	// no error
+	switch err {
+	case nil:
+		return nil
+	}
+
+	// micro error
+	if v, ok := err.(*errors.Error); ok {
+		return v
+	}
+
+	// grpc error
+	if s, ok := status.FromError(err); ok {
+		if e := errors.Parse(s.Message()); e.Code > 0 {
+			return e // actually a micro error
+		}
+		return errors.InternalServerError("go.micro.client", s.Message())
+	}
+
+	// do nothing
+	return err
+}

client/grpc/grpc.go

@@ -0,0 +1,538 @@
+// Package grpc provides a gRPC client
+package grpc
+
+import (
+	"bytes"
+	"context"
+	"crypto/tls"
+	"fmt"
+	"sync"
+	"time"
+
+	"github.com/micro/go-micro/broker"
+	"github.com/micro/go-micro/client"
+	"github.com/micro/go-micro/codec"
+	"github.com/micro/go-micro/errors"
+	"github.com/micro/go-micro/metadata"
+	"github.com/micro/go-micro/registry"
+	"github.com/micro/go-micro/selector"
+	"github.com/micro/go-micro/transport"
+
+	"google.golang.org/grpc"
+	"google.golang.org/grpc/credentials"
+	"google.golang.org/grpc/encoding"
+	gmetadata "google.golang.org/grpc/metadata"
+)
+
+type grpcClient struct {
+	once sync.Once
+	opts client.Options
+	pool *pool
+}
+
+func init() {
+	encoding.RegisterCodec(jsonCodec{})
+	encoding.RegisterCodec(bytesCodec{})
+}
+
+// secure returns the dial option for whether its a secure or insecure connection
+func (g *grpcClient) secure() grpc.DialOption {
+	if g.opts.Context != nil {
+		if v := g.opts.Context.Value(tlsAuth{}); v != nil {
+			tls := v.(*tls.Config)
+			creds := credentials.NewTLS(tls)
+			return grpc.WithTransportCredentials(creds)
+		}
+	}
+	return grpc.WithInsecure()
+}
+
+func (g *grpcClient) next(request client.Request, opts client.CallOptions) (selector.Next, error) {
+	// return remote address
+	if len(opts.Address) > 0 {
+		return func() (*registry.Node, error) {
+			return &registry.Node{
+				Address: opts.Address,
+			}, nil
+		}, nil
+	}
+
+	// get next nodes from the selector
+	next, err := g.opts.Selector.Select(request.Service(), opts.SelectOptions...)
+	if err != nil && err == selector.ErrNotFound {
+		return nil, errors.NotFound("go.micro.client", err.Error())
+	} else if err != nil {
+		return nil, errors.InternalServerError("go.micro.client", err.Error())
+	}
+
+	return next, nil
+}
+
+func (g *grpcClient) call(ctx context.Context, node *registry.Node, req client.Request, rsp interface{}, opts client.CallOptions) error {
+	address := node.Address
+	if node.Port > 0 {
+		address = fmt.Sprintf("%s:%d", address, node.Port)
+	}
+
+	header := make(map[string]string)
+	if md, ok := metadata.FromContext(ctx); ok {
+		for k, v := range md {
+			header[k] = v
+		}
+	}
+
+	// set timeout in nanoseconds
+	header["timeout"] = fmt.Sprintf("%d", opts.RequestTimeout)
+	// set the content type for the request
+	header["x-content-type"] = req.ContentType()
+
+	md := gmetadata.New(header)
+	ctx = gmetadata.NewOutgoingContext(ctx, md)
+
+	cf, err := g.newGRPCCodec(req.ContentType())
+	if err != nil {
+		return errors.InternalServerError("go.micro.client", err.Error())
+	}
+
+	maxRecvMsgSize := g.maxRecvMsgSizeValue()
+	maxSendMsgSize := g.maxSendMsgSizeValue()
+
+	var grr error
+
+	cc, err := g.pool.getConn(address, grpc.WithDefaultCallOptions(grpc.CallCustomCodec(cf)),
+		grpc.WithTimeout(opts.DialTimeout), g.secure(),
+		grpc.WithDefaultCallOptions(
+			grpc.MaxCallRecvMsgSize(maxRecvMsgSize),
+			grpc.MaxCallSendMsgSize(maxSendMsgSize),
+		))
+	if err != nil {
+		return errors.InternalServerError("go.micro.client", fmt.Sprintf("Error sending request: %v", err))
+	}
+	defer func() {
+		// defer execution of release
+		g.pool.release(address, cc, grr)
+	}()
+
+	ch := make(chan error, 1)
+
+	go func() {
+		err := cc.Invoke(ctx, methodToGRPC(req.Endpoint(), req.Body()), req.Body(), rsp, grpc.CallContentSubtype(cf.String()))
+		ch <- microError(err)
+	}()
+
+	select {
+	case err := <-ch:
+		grr = err
+	case <-ctx.Done():
+		grr = ctx.Err()
+	}
+
+	return grr
+}
+
+func (g *grpcClient) stream(ctx context.Context, node *registry.Node, req client.Request, opts client.CallOptions) (client.Stream, error) {
+	address := node.Address
+	if node.Port > 0 {
+		address = fmt.Sprintf("%s:%d", address, node.Port)
+	}
+
+	header := make(map[string]string)
+	if md, ok := metadata.FromContext(ctx); ok {
+		for k, v := range md {
+			header[k] = v
+		}
+	}
+
+	// set timeout in nanoseconds
+	header["timeout"] = fmt.Sprintf("%d", opts.RequestTimeout)
+	// set the content type for the request
+	header["x-content-type"] = req.ContentType()
+
+	md := gmetadata.New(header)
+	ctx = gmetadata.NewOutgoingContext(ctx, md)
+
+	cf, err := g.newGRPCCodec(req.ContentType())
+	if err != nil {
+		return nil, errors.InternalServerError("go.micro.client", err.Error())
+	}
+
+	var dialCtx context.Context
+	var cancel context.CancelFunc
+	if opts.DialTimeout >= 0 {
+		dialCtx, cancel = context.WithTimeout(ctx, opts.DialTimeout)
+	} else {
+		dialCtx, cancel = context.WithCancel(ctx)
+	}
+	defer cancel()
+	cc, err := grpc.DialContext(dialCtx, address, grpc.WithDefaultCallOptions(grpc.CallCustomCodec(cf)), g.secure())
+	if err != nil {
+		return nil, errors.InternalServerError("go.micro.client", fmt.Sprintf("Error sending request: %v", err))
+	}
+
+	desc := &grpc.StreamDesc{
+		StreamName:    req.Service() + req.Endpoint(),
+		ClientStreams: true,
+		ServerStreams: true,
+	}
+
+	st, err := cc.NewStream(ctx, desc, methodToGRPC(req.Endpoint(), req.Body()), grpc.CallContentSubtype(cf.String()))
+	if err != nil {
+		return nil, errors.InternalServerError("go.micro.client", fmt.Sprintf("Error creating stream: %v", err))
+	}
+
+	return &grpcStream{
+		context: ctx,
+		request: req,
+		stream:  st,
+		conn:    cc,
+	}, nil
+}
+
+func (g *grpcClient) maxRecvMsgSizeValue() int {
+	if g.opts.Context == nil {
+		return DefaultMaxRecvMsgSize
+	}
+	v := g.opts.Context.Value(maxRecvMsgSizeKey{})
+	if v == nil {
+		return DefaultMaxRecvMsgSize
+	}
+	return v.(int)
+}
+
+func (g *grpcClient) maxSendMsgSizeValue() int {
+	if g.opts.Context == nil {
+		return DefaultMaxSendMsgSize
+	}
+	v := g.opts.Context.Value(maxSendMsgSizeKey{})
+	if v == nil {
+		return DefaultMaxSendMsgSize
+	}
+	return v.(int)
+}
+
+func (g *grpcClient) newGRPCCodec(contentType string) (grpc.Codec, error) {
+	codecs := make(map[string]encoding.Codec)
+	if g.opts.Context != nil {
+		if v := g.opts.Context.Value(codecsKey{}); v != nil {
+			codecs = v.(map[string]encoding.Codec)
+		}
+	}
+	if c, ok := codecs[contentType]; ok {
+		return wrapCodec{c}, nil
+	}
+	if c, ok := defaultGRPCCodecs[contentType]; ok {
+		return wrapCodec{c}, nil
+	}
+	return nil, fmt.Errorf("Unsupported Content-Type: %s", contentType)
+}
+
+func (g *grpcClient) newCodec(contentType string) (codec.NewCodec, error) {
+	if c, ok := g.opts.Codecs[contentType]; ok {
+		return c, nil
+	}
+	if cf, ok := defaultRPCCodecs[contentType]; ok {
+		return cf, nil
+	}
+	return nil, fmt.Errorf("Unsupported Content-Type: %s", contentType)
+}
+
+func (g *grpcClient) Init(opts ...client.Option) error {
+	size := g.opts.PoolSize
+	ttl := g.opts.PoolTTL
+
+	for _, o := range opts {
+		o(&g.opts)
+	}
+
+	// update pool configuration if the options changed
+	if size != g.opts.PoolSize || ttl != g.opts.PoolTTL {
+		g.pool.Lock()
+		g.pool.size = g.opts.PoolSize
+		g.pool.ttl = int64(g.opts.PoolTTL.Seconds())
+		g.pool.Unlock()
+	}
+
+	return nil
+}
+
+func (g *grpcClient) Options() client.Options {
+	return g.opts
+}
+
+func (g *grpcClient) NewMessage(topic string, msg interface{}, opts ...client.MessageOption) client.Message {
+	return newGRPCPublication(topic, msg, "application/octet-stream")
+}
+
+func (g *grpcClient) NewRequest(service, method string, req interface{}, reqOpts ...client.RequestOption) client.Request {
+	return newGRPCRequest(service, method, req, g.opts.ContentType, reqOpts...)
+}
+
+func (g *grpcClient) Call(ctx context.Context, req client.Request, rsp interface{}, opts ...client.CallOption) error {
+	// make a copy of call opts
+	callOpts := g.opts.CallOptions
+	for _, opt := range opts {
+		opt(&callOpts)
+	}
+
+	next, err := g.next(req, callOpts)
+	if err != nil {
+		return err
+	}
+
+	// check if we already have a deadline
+	d, ok := ctx.Deadline()
+	if !ok {
+		// no deadline so we create a new one
+		ctx, _ = context.WithTimeout(ctx, callOpts.RequestTimeout)
+	} else {
+		// got a deadline so no need to setup context
+		// but we need to set the timeout we pass along
+		opt := client.WithRequestTimeout(time.Until(d))
+		opt(&callOpts)
+	}
+
+	// should we noop right here?
+	select {
+	case <-ctx.Done():
+		return errors.New("go.micro.client", fmt.Sprintf("%v", ctx.Err()), 408)
+	default:
+	}
+
+	// make copy of call method
+	gcall := g.call
+
+	// wrap the call in reverse
+	for i := len(callOpts.CallWrappers); i > 0; i-- {
+		gcall = callOpts.CallWrappers[i-1](gcall)
+	}
+
+	// return errors.New("go.micro.client", "request timeout", 408)
+	call := func(i int) error {
+		// call backoff first. Someone may want an initial start delay
+		t, err := callOpts.Backoff(ctx, req, i)
+		if err != nil {
+			return errors.InternalServerError("go.micro.client", err.Error())
+		}
+
+		// only sleep if greater than 0
+		if t.Seconds() > 0 {
+			time.Sleep(t)
+		}
+
+		// select next node
+		node, err := next()
+		if err != nil && err == selector.ErrNotFound {
+			return errors.NotFound("go.micro.client", err.Error())
+		} else if err != nil {
+			return errors.InternalServerError("go.micro.client", err.Error())
+		}
+
+		// make the call
+		err = gcall(ctx, node, req, rsp, callOpts)
+		g.opts.Selector.Mark(req.Service(), node, err)
+		return err
+	}
+
+	ch := make(chan error, callOpts.Retries+1)
+	var gerr error
+
+	for i := 0; i <= callOpts.Retries; i++ {
+		go func() {
+			ch <- call(i)
+		}()
+
+		select {
+		case <-ctx.Done():
+			return errors.New("go.micro.client", fmt.Sprintf("%v", ctx.Err()), 408)
+		case err := <-ch:
+			// if the call succeeded lets bail early
+			if err == nil {
+				return nil
+			}
+
+			retry, rerr := callOpts.Retry(ctx, req, i, err)
+			if rerr != nil {
+				return rerr
+			}
+
+			if !retry {
+				return err
+			}
+
+			gerr = err
+		}
+	}
+
+	return gerr
+}
+
+func (g *grpcClient) Stream(ctx context.Context, req client.Request, opts ...client.CallOption) (client.Stream, error) {
+	// make a copy of call opts
+	callOpts := g.opts.CallOptions
+	for _, opt := range opts {
+		opt(&callOpts)
+	}
+
+	next, err := g.next(req, callOpts)
+	if err != nil {
+		return nil, err
+	}
+
+	// #200 - streams shouldn't have a request timeout set on the context
+
+	// should we noop right here?
+	select {
+	case <-ctx.Done():
+		return nil, errors.New("go.micro.client", fmt.Sprintf("%v", ctx.Err()), 408)
+	default:
+	}
+
+	call := func(i int) (client.Stream, error) {
+		// call backoff first. Someone may want an initial start delay
+		t, err := callOpts.Backoff(ctx, req, i)
+		if err != nil {
+			return nil, errors.InternalServerError("go.micro.client", err.Error())
+		}
+
+		// only sleep if greater than 0
+		if t.Seconds() > 0 {
+			time.Sleep(t)
+		}
+
+		node, err := next()
+		if err != nil && err == selector.ErrNotFound {
+			return nil, errors.NotFound("go.micro.client", err.Error())
+		} else if err != nil {
+			return nil, errors.InternalServerError("go.micro.client", err.Error())
+		}
+
+		stream, err := g.stream(ctx, node, req, callOpts)
+		g.opts.Selector.Mark(req.Service(), node, err)
+		return stream, err
+	}
+
+	type response struct {
+		stream client.Stream
+		err    error
+	}
+
+	ch := make(chan response, callOpts.Retries+1)
+	var grr error
+
+	for i := 0; i <= callOpts.Retries; i++ {
+		go func() {
+			s, err := call(i)
+			ch <- response{s, err}
+		}()
+
+		select {
+		case <-ctx.Done():
+			return nil, errors.New("go.micro.client", fmt.Sprintf("%v", ctx.Err()), 408)
+		case rsp := <-ch:
+			// if the call succeeded lets bail early
+			if rsp.err == nil {
+				return rsp.stream, nil
+			}
+
+			retry, rerr := callOpts.Retry(ctx, req, i, err)
+			if rerr != nil {
+				return nil, rerr
+			}
+
+			if !retry {
+				return nil, rsp.err
+			}
+
+			grr = rsp.err
+		}
+	}
+
+	return nil, grr
+}
+
+func (g *grpcClient) Publish(ctx context.Context, p client.Message, opts ...client.PublishOption) error {
+	md, ok := metadata.FromContext(ctx)
+	if !ok {
+		md = make(map[string]string)
+	}
+	md["Content-Type"] = p.ContentType()
+
+	cf, err := g.newCodec(p.ContentType())
+	if err != nil {
+		return errors.InternalServerError("go.micro.client", err.Error())
+	}
+
+	b := &buffer{bytes.NewBuffer(nil)}
+	if err := cf(b).Write(&codec.Message{Type: codec.Publication}, p.Payload()); err != nil {
+		return errors.InternalServerError("go.micro.client", err.Error())
+	}
+
+	g.once.Do(func() {
+		g.opts.Broker.Connect()
+	})
+
+	return g.opts.Broker.Publish(p.Topic(), &broker.Message{
+		Header: md,
+		Body:   b.Bytes(),
+	})
+}
+
+func (g *grpcClient) String() string {
+	return "grpc"
+}
+
+func newClient(opts ...client.Option) client.Client {
+	options := client.Options{
+		Codecs: make(map[string]codec.NewCodec),
+		CallOptions: client.CallOptions{
+			Backoff:        client.DefaultBackoff,
+			Retry:          client.DefaultRetry,
+			Retries:        client.DefaultRetries,
+			RequestTimeout: client.DefaultRequestTimeout,
+			DialTimeout:    transport.DefaultDialTimeout,
+		},
+		PoolSize: client.DefaultPoolSize,
+		PoolTTL:  client.DefaultPoolTTL,
+	}
+
+	for _, o := range opts {
+		o(&options)
+	}
+
+	if len(options.ContentType) == 0 {
+		options.ContentType = "application/grpc+proto"
+	}
+
+	if options.Broker == nil {
+		options.Broker = broker.DefaultBroker
+	}
+
+	if options.Registry == nil {
+		options.Registry = registry.DefaultRegistry
+	}
+
+	if options.Selector == nil {
+		options.Selector = selector.NewSelector(
+			selector.Registry(options.Registry),
+		)
+	}
+
+	rc := &grpcClient{
+		once: sync.Once{},
+		opts: options,
+		pool: newPool(options.PoolSize, options.PoolTTL),
+	}
+
+	c := client.Client(rc)
+
+	// wrap in reverse
+	for i := len(options.Wrappers); i > 0; i-- {
+		c = options.Wrappers[i-1](c)
+	}
+
+	return c
+}
+
+func NewClient(opts ...client.Option) client.Client {
+	return newClient(opts...)
+}

client/grpc/grpc_pool.go

@@ -0,0 +1,83 @@
+package grpc
+
+import (
+	"sync"
+	"time"
+
+	"google.golang.org/grpc"
+)
+
+type pool struct {
+	size int
+	ttl  int64
+
+	sync.Mutex
+	conns map[string][]*poolConn
+}
+
+type poolConn struct {
+	*grpc.ClientConn
+	created int64
+}
+
+func newPool(size int, ttl time.Duration) *pool {
+	return &pool{
+		size:  size,
+		ttl:   int64(ttl.Seconds()),
+		conns: make(map[string][]*poolConn),
+	}
+}
+
+func (p *pool) getConn(addr string, opts ...grpc.DialOption) (*poolConn, error) {
+	p.Lock()
+	conns := p.conns[addr]
+	now := time.Now().Unix()
+
+	// while we have conns check age and then return one
+	// otherwise we'll create a new conn
+	for len(conns) > 0 {
+		conn := conns[len(conns)-1]
+		conns = conns[:len(conns)-1]
+		p.conns[addr] = conns
+
+		// if conn is old kill it and move on
+		if d := now - conn.created; d > p.ttl {
+			conn.ClientConn.Close()
+			continue
+		}
+
+		// we got a good conn, lets unlock and return it
+		p.Unlock()
+
+		return conn, nil
+	}
+
+	p.Unlock()
+
+	// create new conn
+	cc, err := grpc.Dial(addr, opts...)
+	if err != nil {
+		return nil, err
+	}
+
+	return &poolConn{cc, time.Now().Unix()}, nil
+}
+
+func (p *pool) release(addr string, conn *poolConn, err error) {
+	// don't store the conn if it has errored
+	if err != nil {
+		conn.ClientConn.Close()
+		return
+	}
+
+	// otherwise put it back for reuse
+	p.Lock()
+	conns := p.conns[addr]
+	if len(conns) >= p.size {
+		p.Unlock()
+		conn.ClientConn.Close()
+		return
+	}
+	p.conns[addr] = append(conns, conn)
+	p.Unlock()
+}

client/grpc/grpc_pool_test.go

@@ -0,0 +1,64 @@
+package grpc
+
+import (
+	"net"
+	"testing"
+	"time"
+
+	"context"
+	"google.golang.org/grpc"
+	pgrpc "google.golang.org/grpc"
+	pb "google.golang.org/grpc/examples/helloworld/helloworld"
+)
+
+func testPool(t *testing.T, size int, ttl time.Duration) {
+	// setup server
+	l, err := net.Listen("tcp", ":0")
+	if err != nil {
+		t.Fatalf("failed to listen: %v", err)
+	}
+	defer l.Close()
+
+	s := pgrpc.NewServer()
+	pb.RegisterGreeterServer(s, &greeterServer{})
+
+	go s.Serve(l)
+	defer s.Stop()
+
+	// zero pool
+	p := newPool(size, ttl)
+
+	for i := 0; i < 10; i++ {
+		// get a conn
+		cc, err := p.getConn(l.Addr().String(), grpc.WithInsecure())
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		rsp := pb.HelloReply{}
+
+		err = cc.Invoke(context.TODO(), "/helloworld.Greeter/SayHello", &pb.HelloRequest{Name: "John"}, &rsp)
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		if rsp.Message != "Hello John" {
+			t.Fatalf("Got unexpected response %v", rsp.Message)
+		}
+
+		// release the conn
+		p.release(l.Addr().String(), cc, nil)
+
+		p.Lock()
+		if i := len(p.conns[l.Addr().String()]); i > size {
+			p.Unlock()
+			t.Fatalf("pool size %d is greater than expected %d", i, size)
+		}
+		p.Unlock()
+	}
+}
+
+func TestGRPCPool(t *testing.T) {
+	testPool(t, 0, time.Minute)
+	testPool(t, 2, time.Minute)
+}

client/grpc/grpc_test.go

@@ -0,0 +1,91 @@
+package grpc
+
+import (
+	"context"
+	"net"
+	"strconv"
+	"strings"
+	"testing"
+
+	"github.com/micro/go-micro/client"
+	"github.com/micro/go-micro/registry"
+	"github.com/micro/go-micro/registry/memory"
+	"github.com/micro/go-micro/selector"
+	pgrpc "google.golang.org/grpc"
+	pb "google.golang.org/grpc/examples/helloworld/helloworld"
+)
+
+// server is used to implement helloworld.GreeterServer.
+type greeterServer struct{}
+
+// SayHello implements helloworld.GreeterServer
+func (g *greeterServer) SayHello(ctx context.Context, in *pb.HelloRequest) (*pb.HelloReply, error) {
+	return &pb.HelloReply{Message: "Hello " + in.Name}, nil
+}
+
+func TestGRPCClient(t *testing.T) {
+	l, err := net.Listen("tcp", ":0")
+	if err != nil {
+		t.Fatalf("failed to listen: %v", err)
+	}
+	defer l.Close()
+
+	s := pgrpc.NewServer()
+	pb.RegisterGreeterServer(s, &greeterServer{})
+
+	go s.Serve(l)
+	defer s.Stop()
+
+	parts := strings.Split(l.Addr().String(), ":")
+	port, _ := strconv.Atoi(parts[len(parts)-1])
+	addr := strings.Join(parts[:len(parts)-1], ":")
+
+	// create mock registry
+	r := memory.NewRegistry()
+
+	// register service
+	r.Register(&registry.Service{
+		Name:    "test",
+		Version: "test",
+		Nodes: []*registry.Node{
+			&registry.Node{
+				Id:      "test-1",
+				Address: addr,
+				Port:    port,
+			},
+		},
+	})
+
+	// create selector
+	se := selector.NewSelector(
+		selector.Registry(r),
+	)
+
+	// create client
+	c := NewClient(
+		client.Registry(r),
+		client.Selector(se),
+	)
+
+	testMethods := []string{
+		"/helloworld.Greeter/SayHello",
+		"Greeter.SayHello",
+	}
+
+	for _, method := range testMethods {
+		req := c.NewRequest("test", method, &pb.HelloRequest{
+			Name: "John",
+		})
+
+		rsp := pb.HelloReply{}
+
+		err = c.Call(context.TODO(), req, &rsp)
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		if rsp.Message != "Hello John" {
+			t.Fatalf("Got unexpected response %v", rsp.Message)
+		}
+	}
+}

client/grpc/message.go

@@ -0,0 +1,40 @@
+package grpc
+
+import (
+	"github.com/micro/go-micro/client"
+)
+
+type grpcPublication struct {
+	topic       string
+	contentType string
+	payload     interface{}
+}
+
+func newGRPCPublication(topic string, payload interface{}, contentType string, opts ...client.MessageOption) client.Message {
+	var options client.MessageOptions
+	for _, o := range opts {
+		o(&options)
+	}
+
+	if len(options.ContentType) > 0 {
+		contentType = options.ContentType
+	}
+
+	return &grpcPublication{
+		payload:     payload,
+		topic:       topic,
+		contentType: contentType,
+	}
+}
+
+func (g *grpcPublication) ContentType() string {
+	return g.contentType
+}
+
+func (g *grpcPublication) Topic() string {
+	return g.topic
+}
+
+func (g *grpcPublication) Payload() interface{} {
+	return g.payload
+}

client/grpc/options.go

@@ -0,0 +1,74 @@
+// Package grpc provides a gRPC options
+package grpc
+
+import (
+	"context"
+	"crypto/tls"
+
+	"github.com/micro/go-micro/client"
+	"google.golang.org/grpc/encoding"
+)
+
+var (
+	// DefaultMaxRecvMsgSize maximum message that client can receive
+	// (4 MB).
+	DefaultMaxRecvMsgSize = 1024 * 1024 * 4
+
+	// DefaultMaxSendMsgSize maximum message that client can send
+	// (4 MB).
+	DefaultMaxSendMsgSize = 1024 * 1024 * 4
+)
+
+type codecsKey struct{}
+type tlsAuth struct{}
+type maxRecvMsgSizeKey struct{}
+type maxSendMsgSizeKey struct{}
+
+// gRPC Codec to be used to encode/decode requests for a given content type
+func Codec(contentType string, c encoding.Codec) client.Option {
+	return func(o *client.Options) {
+		codecs := make(map[string]encoding.Codec)
+		if o.Context == nil {
+			o.Context = context.Background()
+		}
+		if v := o.Context.Value(codecsKey{}); v != nil {
+			codecs = v.(map[string]encoding.Codec)
+		}
+		codecs[contentType] = c
+		o.Context = context.WithValue(o.Context, codecsKey{}, codecs)
+	}
+}
+
+// AuthTLS should be used to setup a secure authentication using TLS
+func AuthTLS(t *tls.Config) client.Option {
+	return func(o *client.Options) {
+		if o.Context == nil {
+			o.Context = context.Background()
+		}
+		o.Context = context.WithValue(o.Context, tlsAuth{}, t)
+	}
+}
+
+//
+// MaxRecvMsgSize set the maximum size of message that client can receive.
+//
+func MaxRecvMsgSize(s int) client.Option {
+	return func(o *client.Options) {
+		if o.Context == nil {
+			o.Context = context.Background()
+		}
+		o.Context = context.WithValue(o.Context, maxRecvMsgSizeKey{}, s)
+	}
+}
+
+//
+// MaxSendMsgSize set the maximum size of message that client can send.
+//
+func MaxSendMsgSize(s int) client.Option {
+	return func(o *client.Options) {
+		if o.Context == nil {
+			o.Context = context.Background()
+		}
+		o.Context = context.WithValue(o.Context, maxSendMsgSizeKey{}, s)
+	}
+}

client/grpc/request.go

@@ -0,0 +1,92 @@
+package grpc
+
+import (
+	"fmt"
+	"reflect"
+	"strings"
+
+	"github.com/micro/go-micro/client"
+	"github.com/micro/go-micro/codec"
+)
+
+type grpcRequest struct {
+	service     string
+	method      string
+	contentType string
+	request     interface{}
+	opts        client.RequestOptions
+}
+
+func methodToGRPC(method string, request interface{}) string {
+	// no method or already grpc method
+	if len(method) == 0 || method[0] == '/' {
+		return method
+	}
+	// can't operate on nil request
+	t := reflect.TypeOf(request)
+	if t == nil {
+		return method
+	}
+	// dereference
+	if t.Kind() == reflect.Ptr {
+		t = t.Elem()
+	}
+	// get package name
+	pParts := strings.Split(t.PkgPath(), "/")
+	pkg := pParts[len(pParts)-1]
+	// assume method is Foo.Bar
+	mParts := strings.Split(method, ".")
+	if len(mParts) != 2 {
+		return method
+	}
+	// return /pkg.Foo/Bar
+	return fmt.Sprintf("/%s.%s/%s", pkg, mParts[0], mParts[1])
+}
+
+func newGRPCRequest(service, method string, request interface{}, contentType string, reqOpts ...client.RequestOption) client.Request {
+	var opts client.RequestOptions
+	for _, o := range reqOpts {
+		o(&opts)
+	}
+
+	// set the content-type specified
+	if len(opts.ContentType) > 0 {
+		contentType = opts.ContentType
+	}
+
+	return &grpcRequest{
+		service:     service,
+		method:      method,
+		request:     request,
+		contentType: contentType,
+		opts:        opts,
+	}
+}
+
+func (g *grpcRequest) ContentType() string {
+	return g.contentType
+}
+
+func (g *grpcRequest) Service() string {
+	return g.service
+}
+
+func (g *grpcRequest) Method() string {
+	return g.method
+}
+
+func (g *grpcRequest) Endpoint() string {
+	return g.method
+}
+
+func (g *grpcRequest) Codec() codec.Writer {
+	return nil
+}
+
+func (g *grpcRequest) Body() interface{} {
+	return g.request
+}
+
+func (g *grpcRequest) Stream() bool {
+	return g.opts.Stream
+}

client/grpc/request_test.go

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

client/grpc/stream.go

@@ -0,0 +1,77 @@
+package grpc
+
+import (
+	"context"
+	"io"
+	"sync"
+
+	"github.com/micro/go-micro/client"
+	"google.golang.org/grpc"
+)
+
+// Implements the streamer interface
+type grpcStream struct {
+	sync.RWMutex
+	err     error
+	conn    *grpc.ClientConn
+	request client.Request
+	stream  grpc.ClientStream
+	context context.Context
+}
+
+func (g *grpcStream) Context() context.Context {
+	return g.context
+}
+
+func (g *grpcStream) Request() client.Request {
+	return g.request
+}
+
+func (g *grpcStream) Response() client.Response {
+	return nil
+}
+
+func (g *grpcStream) Send(msg interface{}) error {
+	if err := g.stream.SendMsg(msg); err != nil {
+		g.setError(err)
+		return err
+	}
+	return nil
+}
+
+func (g *grpcStream) Recv(msg interface{}) (err error) {
+	defer g.setError(err)
+	if err = g.stream.RecvMsg(msg); err != nil {
+		if err == io.EOF {
+			// #202 - inconsistent gRPC stream behavior
+			// the only way to tell if the stream is done is when we get a EOF on the Recv
+			// here we should close the underlying gRPC ClientConn
+			closeErr := g.conn.Close()
+			if closeErr != nil {
+				err = closeErr
+			}
+		}
+	}
+	return
+}
+
+func (g *grpcStream) Error() error {
+	g.RLock()
+	defer g.RUnlock()
+	return g.err
+}
+
+func (g *grpcStream) setError(e error) {
+	g.Lock()
+	g.err = e
+	g.Unlock()
+}
+
+// Close the gRPC send stream
+// #202 - inconsistent gRPC stream behavior
+// The underlying gRPC stream should not be closed here since the
+// stream should still be able to receive after this function call
+// TODO: should the conn be closed in another way?
+func (g *grpcStream) Close() error {
+	return g.stream.CloseSend()
+}

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 {
-	return m.Client.NewRequest(service, method, req, reqOpts...)
+func (m *MockClient) NewRequest(service, endpoint string, req interface{}, reqOpts ...client.RequestOption) client.Request {
+	return m.Client.NewRequest(service, endpoint, req, reqOpts...)
 }
 
 func (m *MockClient) Call(ctx context.Context, req client.Request, rsp interface{}, opts ...client.CallOption) error {
@@ -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) {

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"}},
-		{Method: "Foo.Struct", Response: &TestResponse{Param: "aparam"}},
-		{Method: "Foo.Fail", Error: errors.InternalServerError("go.mock", "failed")},
-		{Method: "Foo.Func", Response: func() string { return "string" }},
-		{Method: "Foo.FuncStruct", Response: func() *TestResponse { return &TestResponse{Param: "aparam"} }},
+		{Endpoint: "Foo.Bar", Response: map[string]interface{}{"foo": "bar"}},
+		{Endpoint: "Foo.Struct", Response: &TestResponse{Param: "aparam"}},
+		{Endpoint: "Foo.Fail", Error: errors.InternalServerError("go.mock", "failed")},
+		{Endpoint: "Foo.Func", Response: func() string { return "string" }},
+		{Endpoint: "Foo.FuncStruct", Response: func() *TestResponse { return &TestResponse{Param: "aparam"} }},
+		{Endpoint: "Foo.FuncWithReqBody", Response: func(req interface{}) string {
+			if req.(map[string]string)["foo"] == "bar" {
+				return "string"
+			}
+			return "wrong"
+		}},
 	}
 
 	c := NewClient(Response("go.mock", response))
 
 	for _, r := range response {
-		req := c.NewRequest("go.mock", r.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)
+		}
 	}
 
 }

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

client/rpc_client.go

@@ -4,11 +4,14 @@ import (
 	"bytes"
 	"context"
 	"fmt"
+	"net"
+	"os"
+	"strconv"
 	"sync"
+	"sync/atomic"
 	"time"
 
-	"sync/atomic"
-
+	"github.com/google/uuid"
 	"github.com/micro/go-micro/broker"
 	"github.com/micro/go-micro/codec"
 	"github.com/micro/go-micro/errors"
@@ -49,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),
 	}
@@ -74,9 +82,16 @@ 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())
-	if err != nil {
-		return errors.InternalServerError("go.micro.client", err.Error())
+	// 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
@@ -91,13 +106,20 @@ func (r *rpcClient) call(ctx context.Context, address string, req Request, resp
 
 	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,
-		closed:  make(chan bool),
-		codec:   newRpcPlusCodec(msg, c, cf),
-		seq:     seq,
+		context:  ctx,
+		request:  req,
+		response: rsp,
+		codec:    codec,
+		closed:   make(chan bool),
+		id:       fmt.Sprintf("%v", seq),
 	}
 	defer stream.Close()
 
@@ -111,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
 		}
@@ -132,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),
 	}
@@ -155,9 +182,16 @@ 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())
-	if err != nil {
-		return nil, errors.InternalServerError("go.micro.client", err.Error())
+	// 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{
@@ -173,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,
-		closed:  make(chan bool),
-		codec:   newRpcPlusCodec(msg, c, cf),
+		context:  ctx,
+		request:  req,
+		response: rsp,
+		closed:   make(chan bool),
+		codec:    codec,
 	}
 
 	ch := make(chan error, 1)
 
 	go func() {
-		ch <- stream.Send(req.Request())
+		ch <- stream.Send(req.Body())
 	}()
 
 	var grr error
@@ -192,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 {
@@ -227,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
@@ -274,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:
 	}
 
@@ -307,19 +376,13 @@ 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++ {
@@ -329,7 +392,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 +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:
 	}
 
@@ -390,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
-		if node.Port > 0 {
-			address = fmt.Sprintf("%s:%d", address, node.Port)
-		}
-
-		stream, err := r.stream(ctx, address, request, callOpts)
+		stream, err := r.stream(ctx, node, request, callOpts)
 		r.opts.Selector.Mark(request.Service(), node, err)
 		return stream, err
 	}
@@ -405,18 +463,18 @@ 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++ {
-		go func() {
+		go func(i int) {
 			s, err := call(i)
 			ch <- response{s, err}
-		}()
+		}(i)
 
 		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 {
@@ -440,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())
@@ -452,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(),
 	})

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"
-	address := "10.1.10.1:8080"
+	endpoint := "Test.Endpoint"
+	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 {
-				return fmt.Errorf("expected service: %s got %s", method, req.Method())
+			if req.Endpoint() != endpoint {
+				return fmt.Errorf("expected service: %s got %s", endpoint, req.Endpoint())
 			}
 
-			if addr != address {
-				return fmt.Errorf("expected address: %s got %s", address, addr)
+			if node.Address != address {
+				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"
-	address := "10.1.10.1:8080"
+	endpoint := "Test.Endpoint"
+	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"
-	host := "10.1.10.1"
+	endpoint := "Test.Endpoint"
+	address := "10.1.10.1"
 	port := 8080
-	address := "10.1.10.1:8080"
 
 	wrap := func(cf CallFunc) CallFunc {
-		return func(ctx context.Context, 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 {
-				return fmt.Errorf("expected service: %s got %s", method, req.Method())
+			if req.Endpoint() != endpoint {
+				return fmt.Errorf("expected service: %s got %s", endpoint, req.Endpoint())
 			}
 
-			if addr != address {
-				return fmt.Errorf("expected address: %s got %s", address, addr)
+			if node.Address != address {
+				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)
 	}

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,
-		Target: req.Service,
-		Method: req.ServiceMethod,
-		Type:   codec.Request,
-		Header: map[string]string{},
+
+	// create header
+	if m.Header == nil {
+		m.Header = map[string]string{}
 	}
-	if err := c.codec.Write(m, body); err != nil {
-		return errors.InternalServerError("go.micro.client.codec", err.Error())
+
+	// copy original header
+	for k, v := range c.req.Header {
+		m.Header[k] = v
 	}
-	c.req.Body = c.buf.wbuf.Bytes()
-	for k, v := range m.Header {
-		c.req.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 err := c.client.Send(c.req); err != 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())
+		}
+		// set body
+		m.Body = c.buf.wbuf.Bytes()
+	}
+
+	// create new transport message
+	msg := transport.Message{
+		Header: m.Header,
+		Body:   m.Body,
+	}
+	// send the request
+	if err := c.client.Send(&msg); err != nil {
 		return errors.InternalServerError("go.micro.client.transport", err.Error())
 	}
 	return nil
 }
 
-func (c *rpcPlusCodec) ReadResponseHeader(r *response) error {
-	var m transport.Message
-	if err := c.client.Recv(&m); err != nil {
+func (c *rpcCodec) ReadHeader(m *codec.Message, r codec.MessageType) error {
+	var tm transport.Message
+
+	// 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)
-	var me codec.Message
-	err := c.codec.ReadHeader(&me, codec.Response)
-	r.ServiceMethod = me.Method
-	r.Seq = me.Id
-	r.Error = me.Error
+	c.buf.rbuf.Write(tm.Body)
+
+	// set headers from transport
+	m.Header = tm.Header
+
+	// 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"
+}

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

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,
-		request:     request,
+		method:      endpoint,
+		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{} {
-	return r.request
+func (r *rpcRequest) Endpoint() string {
+	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 {

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" {
-		t.Fatalf("expected 'method' got %s", r.Method())
+	if r.Endpoint() != "endpoint" {
+		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())
 	}
 }

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

client/rpc_stream.go

@@ -4,17 +4,20 @@ import (
 	"context"
 	"io"
 	"sync"
+
+	"github.com/micro/go-micro/codec"
 )
 
 // Implements the streamer interface
 type rpcStream struct {
 	sync.RWMutex
-	seq     uint64
-	closed  chan bool
-	err     error
-	request Request
-	codec   clientCodec
-	context context.Context
+	id       string
+	closed   chan bool
+	err      error
+	request  Request
+	response Response
+	codec    codec.Codec
+	context  context.Context
 }
 
 func (r *rpcStream) isClosed() bool {
@@ -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 := request{
-		Service:       r.request.Service(),
-		Seq:           seq,
-		ServiceMethod: r.request.Method(),
+	req := codec.Message{
+		Id:       r.id,
+		Target:   r.request.Service(),
+		Method:   r.request.Method(),
+		Endpoint: r.request.Endpoint(),
+		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
-	if err := r.codec.ReadResponseHeader(&resp); err != nil {
+	var resp codec.Message
+
+	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
 		}
 	}

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

cmd/cmd.go

@@ -12,23 +12,31 @@ import (
 	"github.com/micro/cli"
 	"github.com/micro/go-micro/client"
 	"github.com/micro/go-micro/server"
+	"github.com/micro/go-micro/util/log"
 
 	// brokers
 	"github.com/micro/go-micro/broker"
 	"github.com/micro/go-micro/broker/http"
+	"github.com/micro/go-micro/broker/memory"
+	"github.com/micro/go-micro/broker/nats"
 
 	// 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"
+	tgrpc "github.com/micro/go-micro/transport/grpc"
 	thttp "github.com/micro/go-micro/transport/http"
+	tmem "github.com/micro/go-micro/transport/memory"
 )
 
 type Cmd interface {
@@ -65,6 +73,7 @@ var (
 		cli.IntFlag{
 			Name:   "client_retries",
 			EnvVar: "MICRO_CLIENT_RETRIES",
+			Value:  client.DefaultRetries,
 			Usage:  "Sets the client retries. Default: 1",
 		},
 		cli.IntFlag{
@@ -147,7 +156,6 @@ var (
 			Name:   "selector",
 			EnvVar: "MICRO_SELECTOR",
 			Usage:  "Selector used to pick nodes for querying",
-			Value:  "cache",
 		},
 		cli.StringFlag{
 			Name:   "transport",
@@ -162,7 +170,9 @@ var (
 	}
 
 	DefaultBrokers = map[string]func(...broker.Option) broker.Broker{
-		"http": http.NewBroker,
+		"http":   http.NewBroker,
+		"memory": memory.NewBroker,
+		"nats":   nats.NewBroker,
 	}
 
 	DefaultClients = map[string]func(...client.Option) client.Client{
@@ -171,12 +181,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,15 +198,17 @@ var (
 	}
 
 	DefaultTransports = map[string]func(...transport.Option) transport.Transport{
-		"http": thttp.NewTransport,
+		"memory": tmem.NewTransport,
+		"http":   thttp.NewTransport,
+		"grpc":   tgrpc.NewTransport,
 	}
 
 	// used for default selection as the fall back
 	defaultClient    = "rpc"
 	defaultServer    = "rpc"
 	defaultBroker    = "http"
-	defaultRegistry  = "consul"
-	defaultSelector  = "cache"
+	defaultRegistry  = "mdns"
+	defaultSelector  = "registry"
 	defaultTransport = "http"
 )
 
@@ -299,10 +315,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 +368,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 +409,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 +441,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