Further consolidate the libraries

2019-06-03 18:44:43 +01:00
parent fe060b2d0b
commit b42b6fa0fc
110 changed files with 11934 additions and 83 deletions
--- a/api/handler/api/api.go
+++ b/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,
+	}
+}
--- a/api/handler/api/util.go
+++ b/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)
+	}
+}
--- a/api/handler/api/util_test.go
+++ b/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])
+				}
+			}
+		}
+	}
+}
--- a/api/handler/broker/broker.go
+++ b/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...),
+	}
+}
--- a/api/handler/cloudevents/cloudevents.go
+++ b/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...),
+	}
+}
--- a/api/handler/cloudevents/event.go
+++ b/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
+}
--- a/api/handler/event/event.go
+++ b/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...),
+	}
+}
--- a/api/handler/file/file.go
+++ b/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"
+}
--- a/api/handler/handler.go
+++ b/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
+}
--- a/api/handler/http/http.go
+++ b/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,
+	}
+}
--- a/api/handler/http/http_test.go
+++ b/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)
+	}
+}
--- a/api/handler/options.go
+++ b/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
+	}
+}
--- a/api/handler/registry/registry.go
+++ b/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,
+	}
+}
--- a/api/handler/rpc/rpc.go
+++ b/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,
+	}
+}
--- a/api/handler/rpc/rpc_test.go
+++ b/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), "")
+		}
+	})
+}
--- a/api/handler/udp/udp.go
+++ b/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"
+}
--- a/api/handler/unix/unix.go
+++ b/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"
+}
--- a/api/handler/web/web.go
+++ b/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,
+	}
+}