Switch from glide to govendor
This commit is contained in:
Manfred Touron
2
vendor/github.com/go-kit/kit/transport/doc.go
generated
vendored
2
vendor/github.com/go-kit/kit/transport/doc.go
generated
vendored
@@ -1,2 +0,0 @@
|
||||
// Package transport contains bindings to concrete transports.
|
||||
package transport
|
||||
149
vendor/github.com/go-kit/kit/transport/http/client_test.go
generated
vendored
149
vendor/github.com/go-kit/kit/transport/http/client_test.go
generated
vendored
@@ -1,149 +0,0 @@
|
||||
package http_test
|
||||
|
||||
import (
|
||||
"io"
|
||||
"net/http"
|
||||
"net/http/httptest"
|
||||
"net/url"
|
||||
"testing"
|
||||
"time"
|
||||
|
||||
"golang.org/x/net/context"
|
||||
|
||||
httptransport "github.com/go-kit/kit/transport/http"
|
||||
)
|
||||
|
||||
type TestResponse struct {
|
||||
Body io.ReadCloser
|
||||
String string
|
||||
}
|
||||
|
||||
func TestHTTPClient(t *testing.T) {
|
||||
var (
|
||||
testbody = "testbody"
|
||||
encode = func(context.Context, *http.Request, interface{}) error { return nil }
|
||||
decode = func(_ context.Context, r *http.Response) (interface{}, error) {
|
||||
buffer := make([]byte, len(testbody))
|
||||
r.Body.Read(buffer)
|
||||
return TestResponse{r.Body, string(buffer)}, nil
|
||||
}
|
||||
headers = make(chan string, 1)
|
||||
headerKey = "X-Foo"
|
||||
headerVal = "abcde"
|
||||
afterHeaderKey = "X-The-Dude"
|
||||
afterHeaderVal = "Abides"
|
||||
afterVal = ""
|
||||
afterFunc = func(ctx context.Context, r *http.Response) context.Context {
|
||||
afterVal = r.Header.Get(afterHeaderKey)
|
||||
return ctx
|
||||
}
|
||||
)
|
||||
|
||||
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
||||
headers <- r.Header.Get(headerKey)
|
||||
w.Header().Set(afterHeaderKey, afterHeaderVal)
|
||||
w.WriteHeader(http.StatusOK)
|
||||
w.Write([]byte(testbody))
|
||||
}))
|
||||
|
||||
client := httptransport.NewClient(
|
||||
"GET",
|
||||
mustParse(server.URL),
|
||||
encode,
|
||||
decode,
|
||||
httptransport.ClientBefore(httptransport.SetRequestHeader(headerKey, headerVal)),
|
||||
httptransport.ClientAfter(afterFunc),
|
||||
)
|
||||
|
||||
res, err := client.Endpoint()(context.Background(), struct{}{})
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
|
||||
var have string
|
||||
select {
|
||||
case have = <-headers:
|
||||
case <-time.After(time.Millisecond):
|
||||
t.Fatalf("timeout waiting for %s", headerKey)
|
||||
}
|
||||
// Check that Request Header was successfully received
|
||||
if want := headerVal; want != have {
|
||||
t.Errorf("want %q, have %q", want, have)
|
||||
}
|
||||
|
||||
// Check that Response header set from server was received in SetClientAfter
|
||||
if want, have := afterVal, afterHeaderVal; want != have {
|
||||
t.Errorf("want %q, have %q", want, have)
|
||||
}
|
||||
|
||||
// Check that the response was successfully decoded
|
||||
response, ok := res.(TestResponse)
|
||||
if !ok {
|
||||
t.Fatal("response should be TestResponse")
|
||||
}
|
||||
if want, have := testbody, response.String; want != have {
|
||||
t.Errorf("want %q, have %q", want, have)
|
||||
}
|
||||
|
||||
// Check that response body was closed
|
||||
b := make([]byte, 1)
|
||||
_, err = response.Body.Read(b)
|
||||
if err == nil {
|
||||
t.Fatal("wanted error, got none")
|
||||
}
|
||||
if doNotWant, have := io.EOF, err; doNotWant == have {
|
||||
t.Errorf("do not want %q, have %q", doNotWant, have)
|
||||
}
|
||||
}
|
||||
|
||||
func TestHTTPClientBufferedStream(t *testing.T) {
|
||||
var (
|
||||
testbody = "testbody"
|
||||
encode = func(context.Context, *http.Request, interface{}) error { return nil }
|
||||
decode = func(_ context.Context, r *http.Response) (interface{}, error) {
|
||||
return TestResponse{r.Body, ""}, nil
|
||||
}
|
||||
)
|
||||
|
||||
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
||||
w.WriteHeader(http.StatusOK)
|
||||
w.Write([]byte(testbody))
|
||||
}))
|
||||
|
||||
client := httptransport.NewClient(
|
||||
"GET",
|
||||
mustParse(server.URL),
|
||||
encode,
|
||||
decode,
|
||||
httptransport.BufferedStream(true),
|
||||
)
|
||||
|
||||
res, err := client.Endpoint()(context.Background(), struct{}{})
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
|
||||
// Check that the response was successfully decoded
|
||||
response, ok := res.(TestResponse)
|
||||
if !ok {
|
||||
t.Fatal("response should be TestResponse")
|
||||
}
|
||||
|
||||
// Check that response body was NOT closed
|
||||
b := make([]byte, len(testbody))
|
||||
_, err = response.Body.Read(b)
|
||||
if want, have := io.EOF, err; have != want {
|
||||
t.Fatalf("want %q, have %q", want, have)
|
||||
}
|
||||
if want, have := testbody, string(b); want != have {
|
||||
t.Errorf("want %q, have %q", want, have)
|
||||
}
|
||||
}
|
||||
|
||||
func mustParse(s string) *url.URL {
|
||||
u, err := url.Parse(s)
|
||||
if err != nil {
|
||||
panic(err)
|
||||
}
|
||||
return u
|
||||
}
|
||||
56
vendor/github.com/go-kit/kit/transport/http/err_test.go
generated
vendored
56
vendor/github.com/go-kit/kit/transport/http/err_test.go
generated
vendored
@@ -1,56 +0,0 @@
|
||||
package http_test
|
||||
|
||||
import (
|
||||
"errors"
|
||||
"fmt"
|
||||
"net/http"
|
||||
"net/url"
|
||||
"testing"
|
||||
|
||||
"golang.org/x/net/context"
|
||||
|
||||
httptransport "github.com/go-kit/kit/transport/http"
|
||||
)
|
||||
|
||||
func TestClientEndpointEncodeError(t *testing.T) {
|
||||
var (
|
||||
sampleErr = errors.New("Oh no, an error")
|
||||
enc = func(context.Context, *http.Request, interface{}) error { return sampleErr }
|
||||
dec = func(context.Context, *http.Response) (interface{}, error) { return nil, nil }
|
||||
)
|
||||
|
||||
u := &url.URL{
|
||||
Scheme: "https",
|
||||
Host: "localhost",
|
||||
Path: "/does/not/matter",
|
||||
}
|
||||
|
||||
c := httptransport.NewClient(
|
||||
"GET",
|
||||
u,
|
||||
enc,
|
||||
dec,
|
||||
)
|
||||
|
||||
_, err := c.Endpoint()(context.Background(), nil)
|
||||
if err == nil {
|
||||
t.Fatal("err == nil")
|
||||
}
|
||||
|
||||
e, ok := err.(httptransport.Error)
|
||||
if !ok {
|
||||
t.Fatal("err is not of type github.com/go-kit/kit/transport/http.Error")
|
||||
}
|
||||
|
||||
if want, have := sampleErr, e.Err; want != have {
|
||||
t.Fatalf("want %v, have %v", want, have)
|
||||
}
|
||||
}
|
||||
|
||||
func ExampleErrorOutput() {
|
||||
sampleErr := errors.New("oh no, an error")
|
||||
err := httptransport.Error{Domain: httptransport.DomainDo, Err: sampleErr}
|
||||
fmt.Println(err)
|
||||
// Output:
|
||||
// Do: oh no, an error
|
||||
}
|
||||
31
vendor/github.com/go-kit/kit/transport/http/request_response_funcs_test.go
generated
vendored
31
vendor/github.com/go-kit/kit/transport/http/request_response_funcs_test.go
generated
vendored
@@ -1,31 +0,0 @@
|
||||
package http_test
|
||||
|
||||
import (
|
||||
"net/http/httptest"
|
||||
"testing"
|
||||
|
||||
"golang.org/x/net/context"
|
||||
|
||||
httptransport "github.com/go-kit/kit/transport/http"
|
||||
)
|
||||
|
||||
func TestSetHeader(t *testing.T) {
|
||||
const (
|
||||
key = "X-Foo"
|
||||
val = "12345"
|
||||
)
|
||||
r := httptest.NewRecorder()
|
||||
httptransport.SetResponseHeader(key, val)(context.Background(), r)
|
||||
if want, have := val, r.Header().Get(key); want != have {
|
||||
t.Errorf("want %q, have %q", want, have)
|
||||
}
|
||||
}
|
||||
|
||||
func TestSetContentType(t *testing.T) {
|
||||
const contentType = "application/json"
|
||||
r := httptest.NewRecorder()
|
||||
httptransport.SetContentType(contentType)(context.Background(), r)
|
||||
if want, have := contentType, r.Header().Get("Content-Type"); want != have {
|
||||
t.Errorf("want %q, have %q", want, have)
|
||||
}
|
||||
}
|
||||
120
vendor/github.com/go-kit/kit/transport/http/server_test.go
generated
vendored
120
vendor/github.com/go-kit/kit/transport/http/server_test.go
generated
vendored
@@ -1,120 +0,0 @@
|
||||
package http_test
|
||||
|
||||
import (
|
||||
"errors"
|
||||
"io/ioutil"
|
||||
"net/http"
|
||||
"net/http/httptest"
|
||||
"testing"
|
||||
|
||||
"golang.org/x/net/context"
|
||||
|
||||
httptransport "github.com/go-kit/kit/transport/http"
|
||||
)
|
||||
|
||||
func TestServerBadDecode(t *testing.T) {
|
||||
handler := httptransport.NewServer(
|
||||
context.Background(),
|
||||
func(context.Context, interface{}) (interface{}, error) { return struct{}{}, nil },
|
||||
func(context.Context, *http.Request) (interface{}, error) { return struct{}{}, errors.New("dang") },
|
||||
func(context.Context, http.ResponseWriter, interface{}) error { return nil },
|
||||
)
|
||||
server := httptest.NewServer(handler)
|
||||
defer server.Close()
|
||||
resp, _ := http.Get(server.URL)
|
||||
if want, have := http.StatusBadRequest, resp.StatusCode; want != have {
|
||||
t.Errorf("want %d, have %d", want, have)
|
||||
}
|
||||
}
|
||||
|
||||
func TestServerBadEndpoint(t *testing.T) {
|
||||
handler := httptransport.NewServer(
|
||||
context.Background(),
|
||||
func(context.Context, interface{}) (interface{}, error) { return struct{}{}, errors.New("dang") },
|
||||
func(context.Context, *http.Request) (interface{}, error) { return struct{}{}, nil },
|
||||
func(context.Context, http.ResponseWriter, interface{}) error { return nil },
|
||||
)
|
||||
server := httptest.NewServer(handler)
|
||||
defer server.Close()
|
||||
resp, _ := http.Get(server.URL)
|
||||
if want, have := http.StatusServiceUnavailable, resp.StatusCode; want != have {
|
||||
t.Errorf("want %d, have %d", want, have)
|
||||
}
|
||||
}
|
||||
|
||||
func TestServerBadEncode(t *testing.T) {
|
||||
handler := httptransport.NewServer(
|
||||
context.Background(),
|
||||
func(context.Context, interface{}) (interface{}, error) { return struct{}{}, nil },
|
||||
func(context.Context, *http.Request) (interface{}, error) { return struct{}{}, nil },
|
||||
func(context.Context, http.ResponseWriter, interface{}) error { return errors.New("dang") },
|
||||
)
|
||||
server := httptest.NewServer(handler)
|
||||
defer server.Close()
|
||||
resp, _ := http.Get(server.URL)
|
||||
if want, have := http.StatusInternalServerError, resp.StatusCode; want != have {
|
||||
t.Errorf("want %d, have %d", want, have)
|
||||
}
|
||||
}
|
||||
|
||||
func TestServerErrorEncoder(t *testing.T) {
|
||||
errTeapot := errors.New("teapot")
|
||||
code := func(err error) int {
|
||||
if e, ok := err.(httptransport.Error); ok && e.Err == errTeapot {
|
||||
return http.StatusTeapot
|
||||
}
|
||||
return http.StatusInternalServerError
|
||||
}
|
||||
handler := httptransport.NewServer(
|
||||
context.Background(),
|
||||
func(context.Context, interface{}) (interface{}, error) { return struct{}{}, errTeapot },
|
||||
func(context.Context, *http.Request) (interface{}, error) { return struct{}{}, nil },
|
||||
func(context.Context, http.ResponseWriter, interface{}) error { return nil },
|
||||
httptransport.ServerErrorEncoder(func(_ context.Context, err error, w http.ResponseWriter) { w.WriteHeader(code(err)) }),
|
||||
)
|
||||
server := httptest.NewServer(handler)
|
||||
defer server.Close()
|
||||
resp, _ := http.Get(server.URL)
|
||||
if want, have := http.StatusTeapot, resp.StatusCode; want != have {
|
||||
t.Errorf("want %d, have %d", want, have)
|
||||
}
|
||||
}
|
||||
|
||||
func TestServerHappyPath(t *testing.T) {
|
||||
_, step, response := testServer(t)
|
||||
step()
|
||||
resp := <-response
|
||||
defer resp.Body.Close()
|
||||
buf, _ := ioutil.ReadAll(resp.Body)
|
||||
if want, have := http.StatusOK, resp.StatusCode; want != have {
|
||||
t.Errorf("want %d, have %d (%s)", want, have, buf)
|
||||
}
|
||||
}
|
||||
|
||||
func testServer(t *testing.T) (cancel, step func(), resp <-chan *http.Response) {
|
||||
var (
|
||||
ctx, cancelfn = context.WithCancel(context.Background())
|
||||
stepch = make(chan bool)
|
||||
endpoint = func(context.Context, interface{}) (interface{}, error) { <-stepch; return struct{}{}, nil }
|
||||
response = make(chan *http.Response)
|
||||
handler = httptransport.NewServer(
|
||||
ctx,
|
||||
endpoint,
|
||||
func(context.Context, *http.Request) (interface{}, error) { return struct{}{}, nil },
|
||||
func(context.Context, http.ResponseWriter, interface{}) error { return nil },
|
||||
httptransport.ServerBefore(func(ctx context.Context, r *http.Request) context.Context { return ctx }),
|
||||
httptransport.ServerAfter(func(ctx context.Context, w http.ResponseWriter) context.Context { return ctx }),
|
||||
)
|
||||
)
|
||||
go func() {
|
||||
server := httptest.NewServer(handler)
|
||||
defer server.Close()
|
||||
resp, err := http.Get(server.URL)
|
||||
if err != nil {
|
||||
t.Error(err)
|
||||
return
|
||||
}
|
||||
response <- resp
|
||||
}()
|
||||
return cancelfn, func() { stepch <- true }, response
|
||||
}
|
||||
4
vendor/github.com/go-kit/kit/transport/httprp/doc.go
generated
vendored
4
vendor/github.com/go-kit/kit/transport/httprp/doc.go
generated
vendored
@@ -1,4 +0,0 @@
|
||||
// Package httprp provides an HTTP reverse-proxy transport. HTTP handlers that
|
||||
// need to proxy requests to another HTTP service can do so with this package by
|
||||
// specifying the URL to forward the request to.
|
||||
package httprp
|
||||
61
vendor/github.com/go-kit/kit/transport/httprp/server.go
generated
vendored
61
vendor/github.com/go-kit/kit/transport/httprp/server.go
generated
vendored
@@ -1,61 +0,0 @@
|
||||
package httprp
|
||||
|
||||
import (
|
||||
"net/http"
|
||||
"net/http/httputil"
|
||||
"net/url"
|
||||
|
||||
"golang.org/x/net/context"
|
||||
)
|
||||
|
||||
// RequestFunc may take information from an HTTP request and put it into a
|
||||
// request context. BeforeFuncs are executed prior to invoking the
|
||||
// endpoint.
|
||||
type RequestFunc func(context.Context, *http.Request) context.Context
|
||||
|
||||
// Server is a proxying request handler.
|
||||
type Server struct {
|
||||
ctx context.Context
|
||||
proxy http.Handler
|
||||
before []RequestFunc
|
||||
errorEncoder func(w http.ResponseWriter, err error)
|
||||
}
|
||||
|
||||
// NewServer constructs a new server that implements http.Server and will proxy
|
||||
// requests to the given base URL using its scheme, host, and base path.
|
||||
// If the target's path is "/base" and the incoming request was for "/dir",
|
||||
// the target request will be for /base/dir.
|
||||
func NewServer(
|
||||
ctx context.Context,
|
||||
baseURL *url.URL,
|
||||
options ...ServerOption,
|
||||
) *Server {
|
||||
s := &Server{
|
||||
ctx: ctx,
|
||||
proxy: httputil.NewSingleHostReverseProxy(baseURL),
|
||||
}
|
||||
for _, option := range options {
|
||||
option(s)
|
||||
}
|
||||
return s
|
||||
}
|
||||
|
||||
// ServerOption sets an optional parameter for servers.
|
||||
type ServerOption func(*Server)
|
||||
|
||||
// ServerBefore functions are executed on the HTTP request object before the
|
||||
// request is decoded.
|
||||
func ServerBefore(before ...RequestFunc) ServerOption {
|
||||
return func(s *Server) { s.before = before }
|
||||
}
|
||||
|
||||
// ServeHTTP implements http.Handler.
|
||||
func (s Server) ServeHTTP(w http.ResponseWriter, r *http.Request) {
|
||||
ctx := s.ctx
|
||||
|
||||
for _, f := range s.before {
|
||||
ctx = f(ctx, r)
|
||||
}
|
||||
|
||||
s.proxy.ServeHTTP(w, r)
|
||||
}
|
||||
122
vendor/github.com/go-kit/kit/transport/httprp/server_test.go
generated
vendored
122
vendor/github.com/go-kit/kit/transport/httprp/server_test.go
generated
vendored
@@ -1,122 +0,0 @@
|
||||
package httprp_test
|
||||
|
||||
import (
|
||||
"io/ioutil"
|
||||
"net/http"
|
||||
"net/http/httptest"
|
||||
"net/url"
|
||||
"testing"
|
||||
|
||||
"golang.org/x/net/context"
|
||||
|
||||
httptransport "github.com/go-kit/kit/transport/httprp"
|
||||
)
|
||||
|
||||
func TestServerHappyPathSingleServer(t *testing.T) {
|
||||
originServer := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
||||
w.WriteHeader(http.StatusOK)
|
||||
w.Write([]byte("hey"))
|
||||
}))
|
||||
defer originServer.Close()
|
||||
originURL, _ := url.Parse(originServer.URL)
|
||||
|
||||
handler := httptransport.NewServer(
|
||||
context.Background(),
|
||||
originURL,
|
||||
)
|
||||
proxyServer := httptest.NewServer(handler)
|
||||
defer proxyServer.Close()
|
||||
|
||||
resp, _ := http.Get(proxyServer.URL)
|
||||
if want, have := http.StatusOK, resp.StatusCode; want != have {
|
||||
t.Errorf("want %d, have %d", want, have)
|
||||
}
|
||||
|
||||
responseBody, _ := ioutil.ReadAll(resp.Body)
|
||||
if want, have := "hey", string(responseBody); want != have {
|
||||
t.Errorf("want %q, have %q", want, have)
|
||||
}
|
||||
}
|
||||
|
||||
func TestServerHappyPathSingleServerWithServerOptions(t *testing.T) {
|
||||
const (
|
||||
headerKey = "X-TEST-HEADER"
|
||||
headerVal = "go-kit-proxy"
|
||||
)
|
||||
|
||||
originServer := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
||||
if want, have := headerVal, r.Header.Get(headerKey); want != have {
|
||||
t.Errorf("want %q, have %q", want, have)
|
||||
}
|
||||
|
||||
w.WriteHeader(http.StatusOK)
|
||||
w.Write([]byte("hey"))
|
||||
}))
|
||||
defer originServer.Close()
|
||||
originURL, _ := url.Parse(originServer.URL)
|
||||
|
||||
handler := httptransport.NewServer(
|
||||
context.Background(),
|
||||
originURL,
|
||||
httptransport.ServerBefore(func(ctx context.Context, r *http.Request) context.Context {
|
||||
r.Header.Add(headerKey, headerVal)
|
||||
return ctx
|
||||
}),
|
||||
)
|
||||
proxyServer := httptest.NewServer(handler)
|
||||
defer proxyServer.Close()
|
||||
|
||||
resp, _ := http.Get(proxyServer.URL)
|
||||
if want, have := http.StatusOK, resp.StatusCode; want != have {
|
||||
t.Errorf("want %d, have %d", want, have)
|
||||
}
|
||||
|
||||
responseBody, _ := ioutil.ReadAll(resp.Body)
|
||||
if want, have := "hey", string(responseBody); want != have {
|
||||
t.Errorf("want %q, have %q", want, have)
|
||||
}
|
||||
}
|
||||
|
||||
func TestServerOriginServerNotFoundResponse(t *testing.T) {
|
||||
originServer := httptest.NewServer(http.NotFoundHandler())
|
||||
defer originServer.Close()
|
||||
originURL, _ := url.Parse(originServer.URL)
|
||||
|
||||
handler := httptransport.NewServer(
|
||||
context.Background(),
|
||||
originURL,
|
||||
)
|
||||
proxyServer := httptest.NewServer(handler)
|
||||
defer proxyServer.Close()
|
||||
|
||||
resp, _ := http.Get(proxyServer.URL)
|
||||
if want, have := http.StatusNotFound, resp.StatusCode; want != have {
|
||||
t.Errorf("want %d, have %d", want, have)
|
||||
}
|
||||
}
|
||||
|
||||
func TestServerOriginServerUnreachable(t *testing.T) {
|
||||
// create a server, then promptly shut it down
|
||||
originServer := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
||||
w.WriteHeader(http.StatusOK)
|
||||
}))
|
||||
originURL, _ := url.Parse(originServer.URL)
|
||||
originServer.Close()
|
||||
|
||||
handler := httptransport.NewServer(
|
||||
context.Background(),
|
||||
originURL,
|
||||
)
|
||||
proxyServer := httptest.NewServer(handler)
|
||||
defer proxyServer.Close()
|
||||
|
||||
resp, _ := http.Get(proxyServer.URL)
|
||||
switch resp.StatusCode {
|
||||
case http.StatusBadGateway: // go1.7 and beyond
|
||||
break
|
||||
case http.StatusInternalServerError: // to go1.7
|
||||
break
|
||||
default:
|
||||
t.Errorf("want %d or %d, have %d", http.StatusBadGateway, http.StatusInternalServerError, resp.StatusCode)
|
||||
}
|
||||
}
|
||||
14
vendor/github.com/go-kit/kit/transport/netrpc/README.md
generated
vendored
14
vendor/github.com/go-kit/kit/transport/netrpc/README.md
generated
vendored
@@ -1,14 +0,0 @@
|
||||
# net/rpc
|
||||
|
||||
[net/rpc](https://golang.org/pkg/net/rpc) is an RPC transport that's part of the Go standard library.
|
||||
It's a simple and fast transport that's appropriate when all of your services are written in Go.
|
||||
|
||||
Using net/rpc with Go kit is very simple.
|
||||
Just write a simple binding from your service definition to the net/rpc definition.
|
||||
See [netrpc_binding.go](https://github.com/go-kit/kit/blob/ec8b02591ee873433565a1ae9d317353412d1d27/examples/addsvc/netrpc_binding.go) for an example.
|
||||
|
||||
That's it!
|
||||
The net/rpc binding can be registered to a name, and bound to an HTTP handler, the same as any other net/rpc endpoint.
|
||||
And within your service, you can use standard Go kit components and idioms.
|
||||
See [addsvc](https://github.com/go-kit/kit/tree/master/examples/addsvc) for a complete working example with net/rpc support.
|
||||
And remember: Go kit services can support multiple transports simultaneously.
|
||||
32
vendor/github.com/go-kit/kit/transport/thrift/README.md
generated
vendored
32
vendor/github.com/go-kit/kit/transport/thrift/README.md
generated
vendored
@@ -1,32 +0,0 @@
|
||||
# Thrift
|
||||
|
||||
[Thrift](https://thrift.apache.org/) is a large IDL and transport package from Apache, popularized by Facebook.
|
||||
Thrift is well-supported in Go kit, for organizations that already have significant Thrift investment.
|
||||
And using Thrift with Go kit is very simple.
|
||||
|
||||
First, define your service in the Thrift IDL.
|
||||
The [Thrift IDL documentation](https://thrift.apache.org/docs/idl) provides more details.
|
||||
See [add.thrift](https://github.com/go-kit/kit/blob/ec8b02591ee873433565a1ae9d317353412d1d27/examples/addsvc/_thrift/add.thrift) for an example.
|
||||
Make sure the Thrift definition matches your service's Go kit (interface) definition.
|
||||
|
||||
Next, [download Thrift](https://thrift.apache.org/download) and [install the compiler](https://thrift.apache.org/docs/install/).
|
||||
On a Mac, you may be able to `brew install thrift`.
|
||||
|
||||
Then, compile your service definition, from .thrift to .go.
|
||||
You'll probably want to specify the package_prefix option to the --gen go flag.
|
||||
See [THRIFT-3021](https://issues.apache.org/jira/browse/THRIFT-3021) for more details.
|
||||
|
||||
```
|
||||
thrift -r --gen go:package_prefix=github.com/my-org/my-repo/thrift/gen-go/ add.thrift
|
||||
```
|
||||
|
||||
Finally, write a tiny binding from your service definition to the Thrift definition.
|
||||
It's a straightforward conversion from one domain to the other.
|
||||
See [thrift_binding.go](https://github.com/go-kit/kit/blob/ec8b02591ee873433565a1ae9d317353412d1d27/examples/addsvc/thrift_binding.go) for an example.
|
||||
|
||||
That's it!
|
||||
The Thrift binding can be bound to a listener and serve normal Thrift requests.
|
||||
And within your service, you can use standard Go kit components and idioms.
|
||||
Unfortunately, setting up a Thrift listener is rather laborious and nonidiomatic in Go.
|
||||
Fortunately, [addsvc](https://github.com/go-kit/kit/tree/master/examples/addsvc) is a complete working example with Thrift support.
|
||||
And remember: Go kit services can support multiple transports simultaneously.
|
||||
Reference in New Issue
Block a user