Bring in the list APIs implemented by Bala <bala@minio.io>

vendor/github.com/gorilla/rpc/v2/LICENSE

@@ -0,0 +1,27 @@
+Copyright (c) 2012 Rodrigo Moraes. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are
+met:
+
+	 * Redistributions of source code must retain the above copyright
+notice, this list of conditions and the following disclaimer.
+	 * Redistributions in binary form must reproduce the above
+copyright notice, this list of conditions and the following disclaimer
+in the documentation and/or other materials provided with the
+distribution.
+	 * Neither the name of Google Inc. nor the names of its
+contributors may be used to endorse or promote products derived from
+this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

vendor/github.com/gorilla/rpc/v2/README.md

@@ -0,0 +1,6 @@
+rpc
+===
+
+gorilla/rpc is a foundation for RPC over HTTP services, providing access to the exported methods of an object through HTTP requests.
+
+Read the full documentation here: http://www.gorillatoolkit.org/pkg/rpc

vendor/github.com/gorilla/rpc/v2/compression_selector.go

@@ -0,0 +1,90 @@
+// Copyright 2009 The Go Authors. All rights reserved.
+// Copyright 2012 The Gorilla Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package rpc
+
+import (
+	"compress/flate"
+	"compress/gzip"
+	"io"
+	"net/http"
+	"strings"
+	"unicode"
+)
+
+// gzipWriter writes and closes the gzip writer.
+type gzipWriter struct {
+	w *gzip.Writer
+}
+
+func (gw *gzipWriter) Write(p []byte) (n int, err error) {
+	defer gw.w.Close()
+	return gw.w.Write(p)
+}
+
+// gzipEncoder implements the gzip compressed http encoder.
+type gzipEncoder struct {
+}
+
+func (enc *gzipEncoder) Encode(w http.ResponseWriter) io.Writer {
+	w.Header().Set("Content-Encoding", "gzip")
+	return &gzipWriter{gzip.NewWriter(w)}
+}
+
+// flateWriter writes and closes the flate writer.
+type flateWriter struct {
+	w *flate.Writer
+}
+
+func (fw *flateWriter) Write(p []byte) (n int, err error) {
+	defer fw.w.Close()
+	return fw.w.Write(p)
+}
+
+// flateEncoder implements the flate compressed http encoder.
+type flateEncoder struct {
+}
+
+func (enc *flateEncoder) Encode(w http.ResponseWriter) io.Writer {
+	fw, err := flate.NewWriter(w, flate.DefaultCompression)
+	if err != nil {
+		return w
+	}
+	w.Header().Set("Content-Encoding", "deflate")
+	return &flateWriter{fw}
+}
+
+// CompressionSelector generates the compressed http encoder.
+type CompressionSelector struct {
+}
+
+// acceptedEnc returns the first compression type in "Accept-Encoding" header
+// field of the request.
+func acceptedEnc(req *http.Request) string {
+	encHeader := req.Header.Get("Accept-Encoding")
+	if encHeader == "" {
+		return ""
+	}
+	encTypes := strings.FieldsFunc(encHeader, func(r rune) bool {
+		return unicode.IsSpace(r) || r == ','
+	})
+	for _, enc := range encTypes {
+		if enc == "gzip" || enc == "deflate" {
+			return enc
+		}
+	}
+	return ""
+}
+
+// Select method selects the correct compression encoder based on http HEADER.
+func (_ *CompressionSelector) Select(r *http.Request) Encoder {
+	switch acceptedEnc(r) {
+	case "gzip":
+		return &gzipEncoder{}
+	case "flate":
+		return &flateEncoder{}
+	}
+	return DefaultEncoder
+}

vendor/github.com/gorilla/rpc/v2/doc.go

@@ -0,0 +1,81 @@
+// Copyright 2009 The Go Authors. All rights reserved.
+// Copyright 2012 The Gorilla Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+/*
+Package gorilla/rpc is a foundation for RPC over HTTP services, providing
+access to the exported methods of an object through HTTP requests.
+
+This package derives from the standard net/rpc package but uses a single HTTP
+request per call instead of persistent connections. Other differences
+compared to net/rpc:
+
+	- Multiple codecs can be registered in the same server.
+	- A codec is chosen based on the "Content-Type" header from the request.
+	- Service methods also receive http.Request as parameter.
+	- This package can be used on Google App Engine.
+
+Let's setup a server and register a codec and service:
+
+	import (
+		"http"
+		"github.com/gorilla/rpc/v2"
+		"github.com/gorilla/rpc/v2/json"
+	)
+
+	func init() {
+		s := rpc.NewServer()
+		s.RegisterCodec(json.NewCodec(), "application/json")
+		s.RegisterService(new(HelloService), "")
+		http.Handle("/rpc", s)
+	}
+
+This server handles requests to the "/rpc" path using a JSON codec.
+A codec is tied to a content type. In the example above, the JSON codec is
+registered to serve requests with "application/json" as the value for the
+"Content-Type" header. If the header includes a charset definition, it is
+ignored; only the media-type part is taken into account.
+
+A service can be registered using a name. If the name is empty, like in the
+example above, it will be inferred from the service type.
+
+That's all about the server setup. Now let's define a simple service:
+
+	type HelloArgs struct {
+		Who string
+	}
+
+	type HelloReply struct {
+		Message string
+	}
+
+	type HelloService struct {}
+
+	func (h *HelloService) Say(r *http.Request, args *HelloArgs, reply *HelloReply) error {
+		reply.Message = "Hello, " + args.Who + "!"
+		return nil
+	}
+
+The example above defines a service with a method "HelloService.Say" and
+the arguments and reply related to that method.
+
+The service must be exported (begin with an upper case letter) or local
+(defined in the package registering the service).
+
+When a service is registered, the server inspects the service methods
+and make available the ones that follow these rules:
+
+	- The method name is exported.
+	- The method has three arguments: *http.Request, *args, *reply.
+	- All three arguments are pointers.
+	- The second and third arguments are exported or local.
+	- The method has return type error.
+
+All other methods are ignored.
+
+Gorilla has packages with common RPC codecs. Check out their documentation:
+
+	JSON: http://gorilla-web.appspot.com/pkg/rpc/json
+*/
+package rpc

vendor/github.com/gorilla/rpc/v2/encoder_selector.go

@@ -0,0 +1,43 @@
+// Copyright 2009 The Go Authors. All rights reserved.
+// Copyright 2012 The Gorilla Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package rpc
+
+import (
+	"io"
+	"net/http"
+)
+
+// Encoder interface contains the encoder for http response.
+// Eg. gzip, flate compressions.
+type Encoder interface {
+	Encode(w http.ResponseWriter) io.Writer
+}
+
+type encoder struct {
+}
+
+func (_ *encoder) Encode(w http.ResponseWriter) io.Writer {
+	return w
+}
+
+var DefaultEncoder = &encoder{}
+
+// EncoderSelector interface provides a way to select encoder using the http
+// request. Typically people can use this to check HEADER of the request and
+// figure out client capabilities.
+// Eg. "Accept-Encoding" tells about supported compressions.
+type EncoderSelector interface {
+	Select(r *http.Request) Encoder
+}
+
+type encoderSelector struct {
+}
+
+func (_ *encoderSelector) Select(_ *http.Request) Encoder {
+	return DefaultEncoder
+}
+
+var DefaultEncoderSelector = &encoderSelector{}

vendor/github.com/gorilla/rpc/v2/json/client.go

@@ -0,0 +1,61 @@
+// Copyright 2009 The Go Authors. All rights reserved.
+// Copyright 2012-2013 The Gorilla Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package json
+
+import (
+	"encoding/json"
+	"fmt"
+	"io"
+	"math/rand"
+)
+
+// ----------------------------------------------------------------------------
+// Request and Response
+// ----------------------------------------------------------------------------
+
+// clientRequest represents a JSON-RPC request sent by a client.
+type clientRequest struct {
+	// A String containing the name of the method to be invoked.
+	Method string `json:"method"`
+	// Object to pass as request parameter to the method.
+	Params [1]interface{} `json:"params"`
+	// The request id. This can be of any type. It is used to match the
+	// response with the request that it is replying to.
+	Id uint64 `json:"id"`
+}
+
+// clientResponse represents a JSON-RPC response returned to a client.
+type clientResponse struct {
+	Result *json.RawMessage `json:"result"`
+	Error  interface{}      `json:"error"`
+	Id     uint64           `json:"id"`
+}
+
+// EncodeClientRequest encodes parameters for a JSON-RPC client request.
+func EncodeClientRequest(method string, args interface{}) ([]byte, error) {
+	c := &clientRequest{
+		Method: method,
+		Params: [1]interface{}{args},
+		Id:     uint64(rand.Int63()),
+	}
+	return json.Marshal(c)
+}
+
+// DecodeClientResponse decodes the response body of a client request into
+// the interface reply.
+func DecodeClientResponse(r io.Reader, reply interface{}) error {
+	var c clientResponse
+	if err := json.NewDecoder(r).Decode(&c); err != nil {
+		return err
+	}
+	if c.Error != nil {
+		return &Error{Data: c.Error}
+	}
+	if c.Result == nil {
+		return fmt.Errorf("Unexpected null result")
+	}
+	return json.Unmarshal(*c.Result, reply)
+}

vendor/github.com/gorilla/rpc/v2/json/doc.go

@@ -0,0 +1,58 @@
+// Copyright 2009 The Go Authors. All rights reserved.
+// Copyright 2012 The Gorilla Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+/*
+Package gorilla/rpc/json provides a codec for JSON-RPC over HTTP services.
+
+To register the codec in a RPC server:
+
+	import (
+		"http"
+		"github.com/gorilla/rpc/v2"
+		"github.com/gorilla/rpc/v2/json"
+	)
+
+	func init() {
+		s := rpc.NewServer()
+		s.RegisterCodec(json.NewCodec(), "application/json")
+		// [...]
+		http.Handle("/rpc", s)
+	}
+
+A codec is tied to a content type. In the example above, the server will use
+the JSON codec for requests with "application/json" as the value for the
+"Content-Type" header.
+
+This package follows the JSON-RPC 1.0 specification:
+
+	http://json-rpc.org/wiki/specification
+
+Request format is:
+
+	method:
+		The name of the method to be invoked, as a string in dotted notation
+		as in "Service.Method".
+	params:
+		An array with a single object to pass as argument to the method.
+	id:
+		The request id, a uint. It is used to match the response with the
+		request that it is replying to.
+
+Response format is:
+
+	result:
+		The Object that was returned by the invoked method,
+		or null in case there was an error invoking the method.
+	error:
+		An Error object if there was an error invoking the method,
+		or null if there was no error.
+	id:
+		The same id as the request it is responding to.
+
+Check the gorilla/rpc documentation for more details:
+
+	http://gorilla-web.appspot.com/pkg/rpc
+*/
+package json

vendor/github.com/gorilla/rpc/v2/json/json_test.go

@@ -0,0 +1,132 @@
+// Copyright 2009 The Go Authors. All rights reserved.
+// Copyright 2012 The Gorilla Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package json
+
+import (
+	"bytes"
+	"encoding/json"
+	"errors"
+	"net/http"
+	"net/http/httptest"
+	"reflect"
+	"testing"
+
+	"github.com/gorilla/rpc/v2"
+)
+
+var (
+	ErrResponseError     = errors.New("response error")
+	ErrResponseJsonError = &Error{Data: map[string]interface{}{
+		"stackstrace": map[string]interface{}{"0": "foo()"},
+		"error":       "a message",
+	}}
+)
+
+type Service1Request struct {
+	A int
+	B int
+}
+
+type Service1Response struct {
+	Result int
+}
+
+type Service1 struct {
+}
+
+func (t *Service1) Multiply(r *http.Request, req *Service1Request, res *Service1Response) error {
+	res.Result = req.A * req.B
+	return nil
+}
+
+func (t *Service1) ResponseError(r *http.Request, req *Service1Request, res *Service1Response) error {
+	return ErrResponseError
+}
+
+func (t *Service1) ResponseJsonError(r *http.Request, req *Service1Request, res *Service1Response) error {
+	return ErrResponseJsonError
+}
+
+func execute(t *testing.T, s *rpc.Server, method string, req, res interface{}) error {
+	if !s.HasMethod(method) {
+		t.Fatal("Expected to be registered:", method)
+	}
+
+	buf, _ := EncodeClientRequest(method, req)
+	body := bytes.NewBuffer(buf)
+	r, _ := http.NewRequest("POST", "http://localhost:8080/", body)
+	r.Header.Set("Content-Type", "application/json")
+
+	w := httptest.NewRecorder()
+	s.ServeHTTP(w, r)
+
+	return DecodeClientResponse(w.Body, res)
+}
+
+func executeRaw(t *testing.T, s *rpc.Server, req json.RawMessage) (int, *bytes.Buffer) {
+	r, _ := http.NewRequest("POST", "http://localhost:8080/", bytes.NewBuffer(req))
+	r.Header.Set("Content-Type", "application/json")
+
+	w := httptest.NewRecorder()
+	s.ServeHTTP(w, r)
+
+	return w.Code, w.Body
+}
+
+func field(name string, blob json.RawMessage) (v interface{}, ok bool) {
+	var obj map[string]interface{}
+	if err := json.Unmarshal(blob, &obj); err != nil {
+		return nil, false
+	}
+	v, ok = obj[name]
+	return
+}
+
+func TestService(t *testing.T) {
+	s := rpc.NewServer()
+	s.RegisterCodec(NewCodec(), "application/json")
+	s.RegisterService(new(Service1), "")
+
+	var res Service1Response
+	if err := execute(t, s, "Service1.Multiply", &Service1Request{4, 2}, &res); err != nil {
+		t.Error("Expected err to be nil, but got", err)
+	}
+	if res.Result != 8 {
+		t.Error("Expected res.Result to be 8, but got", res.Result)
+	}
+	if err := execute(t, s, "Service1.ResponseError", &Service1Request{4, 2}, &res); err == nil {
+		t.Errorf("Expected to get %q, but got nil", ErrResponseError)
+	} else if err.Error() != ErrResponseError.Error() {
+		t.Errorf("Expected to get %q, but got %q", ErrResponseError, err)
+	}
+	if code, res := executeRaw(t, s, json.RawMessage(`{"method":"Service1.Multiply","params":null,"id":5}`)); code != 400 {
+		t.Error("Expected response code to be 400, but got", code)
+	} else if v, ok := field("result", res.Bytes()); !ok || v != nil {
+		t.Errorf("Expected ok to be true and v to be nil, but got %v and %v", ok, v)
+	}
+	if err := execute(t, s, "Service1.ResponseJsonError", &Service1Request{4, 2}, &res); err == nil {
+		t.Errorf("Expected to get %q, but got nil", ErrResponseError)
+	} else if jsonErr, ok := err.(*Error); !ok {
+		t.Error("Expected err to be of a *json.Error type")
+	} else if !reflect.DeepEqual(jsonErr.Data, ErrResponseJsonError.Data) {
+		t.Errorf("Expected jsonErr to be %q, but got %q", ErrResponseJsonError, jsonErr)
+	}
+}
+
+func TestClientNullResult(t *testing.T) {
+	data := `{"jsonrpc": "2.0", "id": 8674665223082153551, "result": null}`
+	reader := bytes.NewReader([]byte(data))
+
+	var reply interface{}
+
+	err := DecodeClientResponse(reader, &reply)
+	if err == nil {
+		t.Fatal(err)
+	}
+	if err.Error() != "Unexpected null result" {
+		t.Fatalf("Unexpected error: %s", err)
+	}
+}

vendor/github.com/gorilla/rpc/v2/json/server.go

@@ -0,0 +1,155 @@
+// Copyright 2009 The Go Authors. All rights reserved.
+// Copyright 2012 The Gorilla Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package json
+
+import (
+	"encoding/json"
+	"errors"
+	"fmt"
+	"net/http"
+
+	"github.com/gorilla/rpc/v2"
+)
+
+var null = json.RawMessage([]byte("null"))
+
+// An Error is a wrapper for a JSON interface value. It can be used by either
+// a service's handler func to write more complex JSON data to an error field
+// of a server's response, or by a client to read it.
+type Error struct {
+	Data interface{}
+}
+
+func (e *Error) Error() string {
+	return fmt.Sprintf("%v", e.Data)
+}
+
+// ----------------------------------------------------------------------------
+// Request and Response
+// ----------------------------------------------------------------------------
+
+// serverRequest represents a JSON-RPC request received by the server.
+type serverRequest struct {
+	// A String containing the name of the method to be invoked.
+	Method string `json:"method"`
+	// An Array of objects to pass as arguments to the method.
+	Params *json.RawMessage `json:"params"`
+	// The request id. This can be of any type. It is used to match the
+	// response with the request that it is replying to.
+	Id *json.RawMessage `json:"id"`
+}
+
+// serverResponse represents a JSON-RPC response returned by the server.
+type serverResponse struct {
+	// The Object that was returned by the invoked method. This must be null
+	// in case there was an error invoking the method.
+	Result interface{} `json:"result"`
+	// An Error object if there was an error invoking the method. It must be
+	// null if there was no error.
+	Error interface{} `json:"error"`
+	// This must be the same id as the request it is responding to.
+	Id *json.RawMessage `json:"id"`
+}
+
+// ----------------------------------------------------------------------------
+// Codec
+// ----------------------------------------------------------------------------
+
+// NewCodec returns a new JSON Codec.
+func NewCodec() *Codec {
+	return &Codec{}
+}
+
+// Codec creates a CodecRequest to process each request.
+type Codec struct {
+}
+
+// NewRequest returns a CodecRequest.
+func (c *Codec) NewRequest(r *http.Request) rpc.CodecRequest {
+	return newCodecRequest(r)
+}
+
+// ----------------------------------------------------------------------------
+// CodecRequest
+// ----------------------------------------------------------------------------
+
+// newCodecRequest returns a new CodecRequest.
+func newCodecRequest(r *http.Request) rpc.CodecRequest {
+	// Decode the request body and check if RPC method is valid.
+	req := new(serverRequest)
+	err := json.NewDecoder(r.Body).Decode(req)
+	r.Body.Close()
+	return &CodecRequest{request: req, err: err}
+}
+
+// CodecRequest decodes and encodes a single request.
+type CodecRequest struct {
+	request *serverRequest
+	err     error
+}
+
+// Method returns the RPC method for the current request.
+//
+// The method uses a dotted notation as in "Service.Method".
+func (c *CodecRequest) Method() (string, error) {
+	if c.err == nil {
+		return c.request.Method, nil
+	}
+	return "", c.err
+}
+
+// ReadRequest fills the request object for the RPC method.
+func (c *CodecRequest) ReadRequest(args interface{}) error {
+	if c.err == nil {
+		if c.request.Params != nil {
+			// JSON params is array value. RPC params is struct.
+			// Unmarshal into array containing the request struct.
+			params := [1]interface{}{args}
+			c.err = json.Unmarshal(*c.request.Params, &params)
+		} else {
+			c.err = errors.New("rpc: method request ill-formed: missing params field")
+		}
+	}
+	return c.err
+}
+
+// WriteResponse encodes the response and writes it to the ResponseWriter.
+func (c *CodecRequest) WriteResponse(w http.ResponseWriter, reply interface{}) {
+	if c.request.Id != nil {
+		// Id is null for notifications and they don't have a response.
+		res := &serverResponse{
+			Result: reply,
+			Error:  &null,
+			Id:     c.request.Id,
+		}
+		c.writeServerResponse(w, 200, res)
+	}
+}
+
+func (c *CodecRequest) WriteError(w http.ResponseWriter, _ int, err error) {
+	res := &serverResponse{
+		Result: &null,
+		Id:     c.request.Id,
+	}
+	if jsonErr, ok := err.(*Error); ok {
+		res.Error = jsonErr.Data
+	} else {
+		res.Error = err.Error()
+	}
+	c.writeServerResponse(w, 400, res)
+}
+
+func (c *CodecRequest) writeServerResponse(w http.ResponseWriter, status int, res *serverResponse) {
+	b, err := json.Marshal(res)
+	if err == nil {
+		w.WriteHeader(status)
+		w.Header().Set("Content-Type", "application/json; charset=utf-8")
+		w.Write(b)
+	} else {
+		// Not sure in which case will this happen. But seems harmless.
+		rpc.WriteError(w, 400, err.Error())
+	}
+}

vendor/github.com/gorilla/rpc/v2/map.go

@@ -0,0 +1,164 @@
+// Copyright 2009 The Go Authors. All rights reserved.
+// Copyright 2012 The Gorilla Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package rpc
+
+import (
+	"fmt"
+	"net/http"
+	"reflect"
+	"strings"
+	"sync"
+	"unicode"
+	"unicode/utf8"
+)
+
+var (
+	// Precompute the reflect.Type of error and http.Request
+	typeOfError   = reflect.TypeOf((*error)(nil)).Elem()
+	typeOfRequest = reflect.TypeOf((*http.Request)(nil)).Elem()
+)
+
+// ----------------------------------------------------------------------------
+// service
+// ----------------------------------------------------------------------------
+
+type service struct {
+	name     string                    // name of service
+	rcvr     reflect.Value             // receiver of methods for the service
+	rcvrType reflect.Type              // type of the receiver
+	methods  map[string]*serviceMethod // registered methods
+}
+
+type serviceMethod struct {
+	method    reflect.Method // receiver method
+	argsType  reflect.Type   // type of the request argument
+	replyType reflect.Type   // type of the response argument
+}
+
+// ----------------------------------------------------------------------------
+// serviceMap
+// ----------------------------------------------------------------------------
+
+// serviceMap is a registry for services.
+type serviceMap struct {
+	mutex    sync.Mutex
+	services map[string]*service
+}
+
+// register adds a new service using reflection to extract its methods.
+func (m *serviceMap) register(rcvr interface{}, name string) error {
+	// Setup service.
+	s := &service{
+		name:     name,
+		rcvr:     reflect.ValueOf(rcvr),
+		rcvrType: reflect.TypeOf(rcvr),
+		methods:  make(map[string]*serviceMethod),
+	}
+	if name == "" {
+		s.name = reflect.Indirect(s.rcvr).Type().Name()
+		if !isExported(s.name) {
+			return fmt.Errorf("rpc: type %q is not exported", s.name)
+		}
+	}
+	if s.name == "" {
+		return fmt.Errorf("rpc: no service name for type %q",
+			s.rcvrType.String())
+	}
+	// Setup methods.
+	for i := 0; i < s.rcvrType.NumMethod(); i++ {
+		method := s.rcvrType.Method(i)
+		mtype := method.Type
+		// Method must be exported.
+		if method.PkgPath != "" {
+			continue
+		}
+		// Method needs four ins: receiver, *http.Request, *args, *reply.
+		if mtype.NumIn() != 4 {
+			continue
+		}
+		// First argument must be a pointer and must be http.Request.
+		reqType := mtype.In(1)
+		if reqType.Kind() != reflect.Ptr || reqType.Elem() != typeOfRequest {
+			continue
+		}
+		// Second argument must be a pointer and must be exported.
+		args := mtype.In(2)
+		if args.Kind() != reflect.Ptr || !isExportedOrBuiltin(args) {
+			continue
+		}
+		// Third argument must be a pointer and must be exported.
+		reply := mtype.In(3)
+		if reply.Kind() != reflect.Ptr || !isExportedOrBuiltin(reply) {
+			continue
+		}
+		// Method needs one out: error.
+		if mtype.NumOut() != 1 {
+			continue
+		}
+		if returnType := mtype.Out(0); returnType != typeOfError {
+			continue
+		}
+		s.methods[method.Name] = &serviceMethod{
+			method:    method,
+			argsType:  args.Elem(),
+			replyType: reply.Elem(),
+		}
+	}
+	if len(s.methods) == 0 {
+		return fmt.Errorf("rpc: %q has no exported methods of suitable type",
+			s.name)
+	}
+	// Add to the map.
+	m.mutex.Lock()
+	defer m.mutex.Unlock()
+	if m.services == nil {
+		m.services = make(map[string]*service)
+	} else if _, ok := m.services[s.name]; ok {
+		return fmt.Errorf("rpc: service already defined: %q", s.name)
+	}
+	m.services[s.name] = s
+	return nil
+}
+
+// get returns a registered service given a method name.
+//
+// The method name uses a dotted notation as in "Service.Method".
+func (m *serviceMap) get(method string) (*service, *serviceMethod, error) {
+	parts := strings.Split(method, ".")
+	if len(parts) != 2 {
+		err := fmt.Errorf("rpc: service/method request ill-formed: %q", method)
+		return nil, nil, err
+	}
+	m.mutex.Lock()
+	service := m.services[parts[0]]
+	m.mutex.Unlock()
+	if service == nil {
+		err := fmt.Errorf("rpc: can't find service %q", method)
+		return nil, nil, err
+	}
+	serviceMethod := service.methods[parts[1]]
+	if serviceMethod == nil {
+		err := fmt.Errorf("rpc: can't find method %q", method)
+		return nil, nil, err
+	}
+	return service, serviceMethod, nil
+}
+
+// isExported returns true of a string is an exported (upper case) name.
+func isExported(name string) bool {
+	rune, _ := utf8.DecodeRuneInString(name)
+	return unicode.IsUpper(rune)
+}
+
+// isExportedOrBuiltin returns true if a type is exported or a builtin.
+func isExportedOrBuiltin(t reflect.Type) bool {
+	for t.Kind() == reflect.Ptr {
+		t = t.Elem()
+	}
+	// PkgPath will be non-empty even for an exported type,
+	// so we need to check the type name as well.
+	return isExported(t.Name()) || t.PkgPath() == ""
+}

vendor/github.com/gorilla/rpc/v2/server.go

@@ -0,0 +1,158 @@
+// Copyright 2009 The Go Authors. All rights reserved.
+// Copyright 2012 The Gorilla Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package rpc
+
+import (
+	"fmt"
+	"net/http"
+	"reflect"
+	"strings"
+)
+
+// ----------------------------------------------------------------------------
+// Codec
+// ----------------------------------------------------------------------------
+
+// Codec creates a CodecRequest to process each request.
+type Codec interface {
+	NewRequest(*http.Request) CodecRequest
+}
+
+// CodecRequest decodes a request and encodes a response using a specific
+// serialization scheme.
+type CodecRequest interface {
+	// Reads the request and returns the RPC method name.
+	Method() (string, error)
+	// Reads the request filling the RPC method args.
+	ReadRequest(interface{}) error
+	// Writes the response using the RPC method reply.
+	WriteResponse(http.ResponseWriter, interface{})
+	// Writes an error produced by the server.
+	WriteError(w http.ResponseWriter, status int, err error)
+}
+
+// ----------------------------------------------------------------------------
+// Server
+// ----------------------------------------------------------------------------
+
+// NewServer returns a new RPC server.
+func NewServer() *Server {
+	return &Server{
+		codecs:   make(map[string]Codec),
+		services: new(serviceMap),
+	}
+}
+
+// Server serves registered RPC services using registered codecs.
+type Server struct {
+	codecs   map[string]Codec
+	services *serviceMap
+}
+
+// RegisterCodec adds a new codec to the server.
+//
+// Codecs are defined to process a given serialization scheme, e.g., JSON or
+// XML. A codec is chosen based on the "Content-Type" header from the request,
+// excluding the charset definition.
+func (s *Server) RegisterCodec(codec Codec, contentType string) {
+	s.codecs[strings.ToLower(contentType)] = codec
+}
+
+// RegisterService adds a new service to the server.
+//
+// The name parameter is optional: if empty it will be inferred from
+// the receiver type name.
+//
+// Methods from the receiver will be extracted if these rules are satisfied:
+//
+//    - The receiver is exported (begins with an upper case letter) or local
+//      (defined in the package registering the service).
+//    - The method name is exported.
+//    - The method has three arguments: *http.Request, *args, *reply.
+//    - All three arguments are pointers.
+//    - The second and third arguments are exported or local.
+//    - The method has return type error.
+//
+// All other methods are ignored.
+func (s *Server) RegisterService(receiver interface{}, name string) error {
+	return s.services.register(receiver, name)
+}
+
+// HasMethod returns true if the given method is registered.
+//
+// The method uses a dotted notation as in "Service.Method".
+func (s *Server) HasMethod(method string) bool {
+	if _, _, err := s.services.get(method); err == nil {
+		return true
+	}
+	return false
+}
+
+// ServeHTTP
+func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) {
+	if r.Method != "POST" {
+		WriteError(w, 405, "rpc: POST method required, received "+r.Method)
+		return
+	}
+	contentType := r.Header.Get("Content-Type")
+	idx := strings.Index(contentType, ";")
+	if idx != -1 {
+		contentType = contentType[:idx]
+	}
+	codec := s.codecs[strings.ToLower(contentType)]
+	if codec == nil {
+		WriteError(w, 415, "rpc: unrecognized Content-Type: "+contentType)
+		return
+	}
+	// Create a new codec request.
+	codecReq := codec.NewRequest(r)
+	// Get service method to be called.
+	method, errMethod := codecReq.Method()
+	if errMethod != nil {
+		codecReq.WriteError(w, 400, errMethod)
+		return
+	}
+	serviceSpec, methodSpec, errGet := s.services.get(method)
+	if errGet != nil {
+		codecReq.WriteError(w, 400, errGet)
+		return
+	}
+	// Decode the args.
+	args := reflect.New(methodSpec.argsType)
+	if errRead := codecReq.ReadRequest(args.Interface()); errRead != nil {
+		codecReq.WriteError(w, 400, errRead)
+		return
+	}
+	// Call the service method.
+	reply := reflect.New(methodSpec.replyType)
+	errValue := methodSpec.method.Func.Call([]reflect.Value{
+		serviceSpec.rcvr,
+		reflect.ValueOf(r),
+		args,
+		reply,
+	})
+	// Cast the result to error if needed.
+	var errResult error
+	errInter := errValue[0].Interface()
+	if errInter != nil {
+		errResult = errInter.(error)
+	}
+	// Prevents Internet Explorer from MIME-sniffing a response away
+	// from the declared content-type
+	w.Header().Set("x-content-type-options", "nosniff")
+	// Encode the response.
+	if errResult == nil {
+		codecReq.WriteResponse(w, reply.Interface())
+	} else {
+		codecReq.WriteError(w, 400, errResult)
+	}
+}
+
+func WriteError(w http.ResponseWriter, status int, msg string) {
+	w.WriteHeader(status)
+	w.Header().Set("Content-Type", "text/plain; charset=utf-8")
+	fmt.Fprint(w, msg)
+}

vendor/github.com/gorilla/rpc/v2/server_test.go

@@ -0,0 +1,54 @@
+// Copyright 2009 The Go Authors. All rights reserved.
+// Copyright 2012 The Gorilla Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package rpc
+
+import (
+	"net/http"
+	"testing"
+)
+
+type Service1Request struct {
+	A int
+	B int
+}
+
+type Service1Response struct {
+	Result int
+}
+
+type Service1 struct {
+}
+
+func (t *Service1) Multiply(r *http.Request, req *Service1Request, res *Service1Response) error {
+	res.Result = req.A * req.B
+	return nil
+}
+
+type Service2 struct {
+}
+
+func TestRegisterService(t *testing.T) {
+	var err error
+	s := NewServer()
+	service1 := new(Service1)
+	service2 := new(Service2)
+
+	// Inferred name.
+	err = s.RegisterService(service1, "")
+	if err != nil || !s.HasMethod("Service1.Multiply") {
+		t.Errorf("Expected to be registered: Service1.Multiply")
+	}
+	// Provided name.
+	err = s.RegisterService(service1, "Foo")
+	if err != nil || !s.HasMethod("Foo.Multiply") {
+		t.Errorf("Expected to be registered: Foo.Multiply")
+	}
+	// No methods.
+	err = s.RegisterService(service2, "")
+	if err == nil {
+		t.Errorf("Expected error on service2")
+	}
+}