README
¶
jrpc - rpc with json 
jrpc library provides client and server for RPC-like communication over HTTP with json encoded messages. The protocol is a somewhat simplified version of json-rpc with a single POST call sending Request json (method name and the list of parameters) moreover, receiving json Response with result data and an error string.
Usage
Plugin (server)
// Server wraps jrpc.Server and adds synced map to store data
type Puglin struct {
*jrpc.Server
}
// create plugin (jrpc server)
plugin := jrpcServer{
Server: &jrpc.Server{
API: "/command", // base url for rpc calls
AuthUser: "user", // basic auth user name
AuthPasswd: "password", // basic auth password
AppName: "jrpc-example", // plugin name for headers
Logger: logger,
},
}
plugin.Add("mycommand", func(id uint64, params json.RawMessage) Response {
return jrpc.EncodeResponse(id, "hello, it works", nil)
})
Application (client)
// Client makes jrpc.Client and invoke remote call
rpcClient := jrpc.Client{
API: "http://127.0.0.1:8080/command",
Client: http.Client{},
AuthUser: "user",
AuthPasswd: "password",
}
resp, err := rpcClient.Call("mycommand")
var message string
if err = json.Unmarshal(*resp.Result, &message); err != nil {
panic(err)
}
for functional examples for both plugin and application see _example
Technical details
jrpc.Serverruns on user-defined port as a regular http server- Server accepts a single POST request on user-defined url with Request sent as json payload
request details and an example:
```go
type Request struct {
Method string `json:"method"`
Params interface{} `json:"params,omitempty"`
ID uint64 `json:"id"`
}
```
example:
```json
{
"method":"test",
"params":[123,"abc"],
"id":1
}
```
response details:
// Response encloses result and error received from remote server
type Response struct {
Result *json.RawMessage `json:"result,omitempty"`
Error string `json:"error,omitempty"`
ID uint64 `json:"id"`
}
Status
The code was extracted from remark42 and still under development. Until v1.x released the API & protocol may change.
Documentation
¶
Overview ¶
Package jrpc implements client and server for RPC-like communication over HTTP with json encoded messages. The protocol is somewhat simplified version of json-rpc with a single POST call sending Request json (method name and the list of parameters) and receiving back json Response with "result" json and error string
Index ¶
Constants ¶
This section is empty.
Variables ¶
var NoOpLogger = LoggerFunc(func(format string, args ...interface{}) {})
NoOpLogger logger does nothing
Functions ¶
This section is empty.
Types ¶
type Client ¶
type Client struct {
API string // URL to jrpc server with entrypoint, i.e. http://127.0.0.1:8080/command
Client http.Client // http client injected by user
AuthUser string // basic auth user name, should match Server.AuthUser, optional
AuthPasswd string // basic auth password, should match Server.AuthPasswd, optional
// contains filtered or unexported fields
}
Client implements remote engine and delegates all calls to remote http server if AuthUser and AuthPasswd defined will be used for basic auth in each call to server
func (*Client) Call ¶
Call remote server with given method and arguments. Empty args will be ignored, single arg will be marshaled as-us and multiple args marshaled as []interface{}. Returns Response and error. Note: Response has it's own Error field, but that onw controlled by server. Returned error represent client-level errors, like failed http call, failed marshaling and so on.
type L ¶
type L interface {
Logf(format string, args ...interface{})
}
L defined logger interface used for an optional rest logging
type LoggerFunc ¶
type LoggerFunc func(format string, args ...interface{})
LoggerFunc type is an adapter to allow the use of ordinary functions as Logger.
func (LoggerFunc) Logf ¶
func (f LoggerFunc) Logf(format string, args ...interface{})
Logf calls f(id)
type Request ¶
type Request struct {
Method string `json:"method"` // method (function) name
Params interface{} `json:"params,omitempty"` // function arguments
ID uint64 `json:"id"` // unique call id
}
Request encloses method name and all params
type Response ¶
type Response struct {
Result *json.RawMessage `json:"result,omitempty"` // response json
Error string `json:"error,omitempty"` // optional remote (server side / plugin side) error
ID uint64 `json:"id"` // unique call id, echoed Request.ID to allow calls tracing
}
Response encloses result and error received from remote server
func EncodeResponse ¶
EncodeResponse convert anything (type interface{}) and incoming error (if any) to Response
type Server ¶
type Server struct {
API string // url path, i.e. "/command" or "/rpc" etc.
AuthUser string // basic auth user name, should match Client.AuthUser, optional
AuthPasswd string // basic auth password, should match Client.AuthPasswd, optional
Version string // server version, injected from main and used for informational headers only
AppName string // plugin name, injected from main and used for informational headers only
Logger L // logger, if nil will default to NoOpLogger
// contains filtered or unexported fields
}
Server is json-rpc server with an optional basic auth
func (*Server) Group ¶
func (s *Server) Group(prefix string, m HandlersGroup)
Group of handlers with common prefix, match on group.method
Source Files