Move router and proxy into network package

proxy/http/http.go

@@ -1,149 +0,0 @@
-// Package http provides a micro rpc to http proxy
-package http
-
-import (
-	"bytes"
-	"context"
-	"io"
-	"io/ioutil"
-	"net/http"
-	"net/url"
-	"path"
-
-	"github.com/micro/go-micro/config/options"
-	"github.com/micro/go-micro/errors"
-	"github.com/micro/go-micro/proxy"
-	"github.com/micro/go-micro/server"
-)
-
-// Proxy will proxy rpc requests as http POST requests. It is a server.Proxy
-type Proxy struct {
-	options.Options
-
-	// The http backend to call
-	Endpoint string
-
-	// first request
-	first bool
-}
-
-func getMethod(hdr map[string]string) string {
-	switch hdr["Micro-Method"] {
-	case "GET", "HEAD", "POST", "PUT", "DELETE", "CONNECT", "OPTIONS", "TRACE", "PATCH":
-		return hdr["Micro-Method"]
-	default:
-		return "POST"
-	}
-}
-
-func getEndpoint(hdr map[string]string) string {
-	ep := hdr["Micro-Endpoint"]
-	if len(ep) > 0 && ep[0] == '/' {
-		return ep
-	}
-	return ""
-}
-
-// ServeRequest honours the server.Router interface
-func (p *Proxy) ServeRequest(ctx context.Context, req server.Request, rsp server.Response) error {
-	if p.Endpoint == "" {
-		p.Endpoint = proxy.DefaultEndpoint
-	}
-
-	for {
-		// get data
-		body, err := req.Read()
-		if err == io.EOF {
-			return nil
-		}
-		if err != nil {
-			return err
-		}
-
-		// get the header
-		hdr := req.Header()
-
-		// get method
-		method := getMethod(hdr)
-
-		// get endpoint
-		endpoint := getEndpoint(hdr)
-
-		// set the endpoint
-		if len(endpoint) == 0 {
-			endpoint = p.Endpoint
-		} else {
-			// add endpoint to backend
-			u, err := url.Parse(p.Endpoint)
-			if err != nil {
-				return errors.InternalServerError(req.Service(), err.Error())
-			}
-			u.Path = path.Join(u.Path, endpoint)
-			endpoint = u.String()
-		}
-
-		// send to backend
-		hreq, err := http.NewRequest(method, endpoint, bytes.NewReader(body))
-		if err != nil {
-			return errors.InternalServerError(req.Service(), err.Error())
-		}
-
-		// set the headers
-		for k, v := range hdr {
-			hreq.Header.Set(k, v)
-		}
-
-		// make the call
-		hrsp, err := http.DefaultClient.Do(hreq)
-		if err != nil {
-			return errors.InternalServerError(req.Service(), err.Error())
-		}
-
-		// read body
-		b, err := ioutil.ReadAll(hrsp.Body)
-		hrsp.Body.Close()
-		if err != nil {
-			return errors.InternalServerError(req.Service(), err.Error())
-		}
-
-		// set response headers
-		hdr = map[string]string{}
-		for k, _ := range hrsp.Header {
-			hdr[k] = hrsp.Header.Get(k)
-		}
-		// write the header
-		rsp.WriteHeader(hdr)
-		// write the body
-		err = rsp.Write(b)
-		if err == io.EOF {
-			return nil
-		}
-		if err != nil {
-			return errors.InternalServerError(req.Service(), err.Error())
-		}
-	}
-
-	return nil
-}
-
-// NewSingleHostProxy returns a router which sends requests to a single http backend
-func NewSingleHostProxy(url string) proxy.Proxy {
-	return &Proxy{
-		Endpoint: url,
-	}
-}
-
-// NewProxy returns a new proxy which will route using a http client
-func NewProxy(opts ...options.Option) proxy.Proxy {
-	p := new(Proxy)
-	p.Options = options.NewOptions(opts...)
-	p.Options.Init(options.WithString("http"))
-
-	// get endpoint
-	ep, ok := p.Options.Values().Get("proxy.endpoint")
-	if ok {
-		p.Endpoint = ep.(string)
-	}
-
-	return p
-}

proxy/http/http_test.go

@@ -1,93 +0,0 @@
-package http
-
-import (
-	"context"
-	"fmt"
-	"net"
-	"net/http"
-	"sync"
-	"testing"
-
-	"github.com/micro/go-micro"
-	"github.com/micro/go-micro/client"
-	"github.com/micro/go-micro/registry/memory"
-	"github.com/micro/go-micro/server"
-)
-
-type testHandler struct{}
-
-func (t *testHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
-	w.Write([]byte(`{"hello": "world"}`))
-}
-
-func TestHTTPProxy(t *testing.T) {
-	c, err := net.Listen("tcp", "localhost:0")
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer c.Close()
-	addr := c.Addr().String()
-
-	url := fmt.Sprintf("http://%s", addr)
-
-	testCases := []struct {
-		// http endpoint to call e.g /foo/bar
-		httpEp string
-		// rpc endpoint called e.g Foo.Bar
-		rpcEp string
-		// should be an error
-		err bool
-	}{
-		{"/", "Foo.Bar", false},
-		{"/", "Foo.Baz", false},
-		{"/helloworld", "Hello.World", true},
-	}
-
-	// handler
-	http.Handle("/", new(testHandler))
-
-	// new proxy
-	p := NewSingleHostProxy(url)
-
-	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
-
-	var wg sync.WaitGroup
-	wg.Add(1)
-
-	// new micro service
-	service := micro.NewService(
-		micro.Context(ctx),
-		micro.Name("foobar"),
-		micro.Registry(memory.NewRegistry()),
-		micro.AfterStart(func() error {
-			wg.Done()
-			return nil
-		}),
-	)
-
-	// set router
-	service.Server().Init(
-		server.WithRouter(p),
-	)
-
-	// run service
-	// server
-	go http.Serve(c, nil)
-	go service.Run()
-
-	// wait till service is started
-	wg.Wait()
-
-	for _, test := range testCases {
-		req := service.Client().NewRequest("foobar", test.rpcEp, map[string]string{"foo": "bar"}, client.WithContentType("application/json"))
-		var rsp map[string]string
-		err := service.Client().Call(ctx, req, &rsp)
-		if err != nil && test.err == false {
-			t.Fatal(err)
-		}
-		if v := rsp["hello"]; v != "world" {
-			t.Fatalf("Expected hello world got %s from %s", v, test.rpcEp)
-		}
-	}
-}