jsonrpc

type Ctx interface {
	// Req 返回当前请求的Request
	Req() *http.Request
	// Header 获取头部参数
	Header(string) string
	// Bind 获取当前请求的URL参数
	Bind(interface{}) error
	// Success 成功返回
	Success(interface{}) error
	// Error 错误返回
	Error(int, string, interface{}) error
	Logger() Logger
}

type HTTPError struct {
	Code int
	// contains filtered or unexported fields
}

type Logger interface {
	SetBase(base map[string]string)
	Debug(msg string, fields ...interface{})
	Info(msg string, fields ...interface{})
	Warn(msg string, fields ...interface{})
	Error(msg string, fields ...interface{})
}

type RPCClient interface {
	// Call 用于发送JSON-RPC请求到服务端.
	//
	// 规则说明, 参数只能是数组或map,不能是基础数据类型.
	// 所以有几个简单的规则要注意:
	//
	// 1. 无参数: Call("getinfo")
	//
	// 2. 单个基础数据参数: 参数值被封装在数组里面. 例如. Call("getByID", 1423)
	//
	// 3. 单个数组或map参数: 例如. Call("storePerson", &Person{Name: "Alex"})
	//
	// 4. 多个参数: 封装成数组. 例如. Call("setDetails", "Alex, 35, "Germany", true)
	//
	// 示例:
	//   Call("getinfo") -> {"method": "getinfo"}
	//   Call("getPersonId", 123) -> {"method": "getPersonId", "params": [123]}
	//   Call("setName", "Alex") -> {"method": "setName", "params": ["Alex"]}
	//   Call("setMale", true) -> {"method": "setMale", "params": [true]}
	//   Call("setNumbers", []int{1, 2, 3}) -> {"method": "setNumbers", "params": [1, 2, 3]}
	//   Call("setNumbers", 1, 2, 3) -> {"method": "setNumbers", "params": [1, 2, 3]}
	//   Call("savePerson", &Person{Name: "Alex", Age: 35}) -> {"method": "savePerson", "params": {"name": "Alex", "age": 35}}
	//   Call("setPersonDetails", "Alex", 35, "Germany") -> {"method": "setPersonDetails", "params": ["Alex", 35, "Germany"}}
	//
	Call(method string, params ...interface{}) (*RPCResponse, error)

	// CallRaw 和Call类似，但是没有处理requests.Params字段.
	// RPCRequest对象按提供的数据原样发送.
	// 查看: NewRequest, RPCRequest, Params()
	//
	// 建议优先考虑Call和CallFor
	CallRaw(request *RPCRequest) (*RPCResponse, error)

	// method和params: 和 Call() 方法的一样
	//
	// 如果请求不成功 (网络或http错误)或rpc响应返回一个错误,
	// error将得到一个错误类型的值. 如果它是JSON-RPC错误类型，那它可以通过*RPCError解析.
	//
	CallFor(out interface{}, method string, params ...interface{}) error

	// CallBatch 在一个请求中调用多个方法.
	//
	// 最直观的使用方式如下:
	// CallBatch(RPCRequests{
	//   NewRequest("myMethod1", 1, 2, 3),
	//   NewRequest("myMethod2", "Test"),
	// })
	//
	// 可以自己创建[]*RPCRequest数组，但不建议这样做，且应该注意以下几点:
	// - field Params is sent as provided, so Params: 2 forms an invalid json (correct would be Params: []int{2})
	// - you can use the helper function Params(1, 2, 3) to use the same format as in Call()
	// - `JSONRPC`字段值会被覆盖为"2.0"
	// - `ID`字段会被覆盖为一个映射到数组下标的值 (例如. requests[5].ID == 5)
	//
	// - 返回的RPCResponses是[]*RPCResponse
	// - 注意RPCResponses的值是无序的, 这样就可能发生: responses[i] != responses[i].ID
	// - RPCPersponses有一些有用的函数, 例如: responses.HasError()， 如果其中某一个请求响应是RPCError则返回true
	CallBatch(requests RPCRequests) (RPCResponses, error)

	// CallBatchRaw  在一个请求中调用多个RPCRequests.
	// It sends the RPCRequests parameter is it passed (no magic, no id autoincrement).
	//
	// 建议优先考虑CallBatch.
	//
	// CallBatchRaw(RPCRequests{
	//   &RPCRequest{
	//     ID: 123,            // 在CallBatchRaw里面，该值不会变
	//     JSONRPC: "wrong",   // 在CallBatchRaw里面，该值不会变
	//     Method: "myMethod1",
	//     Params: []int{1},   // 没有处理, 所以必须确保是array或map
	//   },
	//   &RPCRequest{
	//     ID: 612,
	//     JSONRPC: "2.0",
	//     Method: "myMethod2",
	//     Params: Params("Alex", 35, true), // Params()方法可以处理参数
	//   },
	// })
	//
	// - 返回的RPCResponses是[]*RPCResponse
	// - 注意RPCResponses的值是无序的
	// - 必须将id映射到您提供的id
	// - RPCPersponses有一些有用的函数, 例如: responses.HasError()， 如果其中某一个请求响应是RPCError则返回true
	CallBatchRaw(requests RPCRequests) (RPCResponses, error)
}

type RPCClientOpts struct {
	HTTPClient    *http.Client
	CustomHeaders map[string]string
}

type RPCError struct {
	Code    int         `json:"code"`
	Message string      `json:"message"`
	Data    interface{} `json:"data,omitempty"`
}

type RPCRequest struct {
	Method  string      `json:"method"`
	Params  interface{} `json:"params,omitempty"`
	ID      int         `json:"id"`
	JSONRPC string      `json:"jsonrpc"`
}

type RPCRequests []*RPCRequest

type RPCResponse struct {
	JSONRPC string      `json:"jsonrpc"`
	Result  interface{} `json:"result,omitempty"`
	Error   *RPCError   `json:"error,omitempty"`
	ID      interface{} `json:"id"`
}

type RPCResponses []*RPCResponse

type ServeMux struct {
	// contains filtered or unexported fields
}