Popularity
4.0
Stable
Activity
4.0
Declining
115
6
10

Programming language: Go
Latest version: v2.1

jsonrpc alternatives and similar packages

Based on the "Distributed Systems" category

Do you think we are missing an alternative of jsonrpc or a related project?

Add another 'Distributed Systems' Package

README

jsonrpc

Travis branch codecov Go Report Card codebeat badge Maintainability GoDoc GitHub license

About

  • Simple, Poetic, Pithy.
  • No reflect package.
    • But reflect package is used only when invoke the debug handler.
  • Support GAE/Go Standard Environment.
  • Compliance with JSON-RPC 2.0.

Note: If you use Go 1.6, see v1.0.

Install

$ go get -u github.com/osamingo/jsonrpc

Usage

package main

import (
    "context"
    "log"
    "net/http"

    "github.com/intel-go/fastjson"
    "github.com/osamingo/jsonrpc"
)

type (
    EchoHandler struct{}
    EchoParams  struct {
        Name string `json:"name"`
    }
    EchoResult struct {
        Message string `json:"message"`
    }

    PositionalHandler struct{}
    PositionalParams  []int
    PositionalResult  struct {
        Message []int `json:"message"`
    }
)

func (h EchoHandler) ServeJSONRPC(c context.Context, params *fastjson.RawMessage) (interface{}, *jsonrpc.Error) {

    var p EchoParams
    if err := jsonrpc.Unmarshal(params, &p); err != nil {
        return nil, err
    }

    return EchoResult{
        Message: "Hello, " + p.Name,
    }, nil
}

func (h PositionalHandler) ServeJSONRPC(c context.Context, params *fastjson.RawMessage) (interface{}, *Error) {

    var p PositionalParams
    if err := jsonrpc.Unmarshal(params, &p); err != nil {
        return nil, err
    }

    return PositionalResult{
        Message: p,
    }, nil
}

func main() {

    mr := jsonrpc.NewMethodRepository()

    if err := mr.RegisterMethod("Main.Echo", EchoHandler{}, EchoParams{}, EchoResult{}); err != nil {
        log.Fatalln(err)
    }

    if err := mr.RegisterMethod("Main.Positional", PositionalHandler{}, PositionalParams{}, PositionalResult{}); err != nil {
        log.Fatalln(err)
    }

    http.Handle("/jrpc", mr)
    http.HandleFunc("/jrpc/debug", mr.ServeDebug)

    if err := http.ListenAndServe(":8080", http.DefaultServeMux); err != nil {
        log.Fatalln(err)
    }
}

Advanced

package main

import (
    "log"
    "net/http"

    "github.com/osamingo/jsonrpc"
)

type (
    HandleParamsResulter interface {
        jsonrpc.Handler
        Name() string
        Params() interface{}
        Result() interface{}
    }
    Servicer interface {
        MethodName(HandleParamsResulter) string
        Handlers() []HandleParamsResulter
    }
    UserService struct {
        SignUpHandler HandleParamsResulter
        SignInHandler HandleParamsResulter
    }
)

func (us *UserService) MethodName(h HandleParamsResulter) string {
    return "UserService." + h.Name()
}

func (us *UserService) Handlers() []HandleParamsResulter {
    return []HandleParamsResulter{us.SignUpHandler, us.SignInHandler}
}

func NewUserService() *UserService {
    return &UserService{
    // Initialize handlers
    }
}

func main() {

    mr := jsonrpc.NewMethodRepository()

    for _, s := range []Servicer{NewUserService()} {
        for _, h := range s.Handlers() {
            mr.RegisterMethod(s.MethodName(h), h, h.Params(), h.Result())
        }
    }

    http.Handle("/jrpc", mr)
    http.HandleFunc("/jrpc/debug", mr.ServeDebug)

    if err := http.ListenAndServe(":8080", http.DefaultServeMux); err != nil {
        log.Fatalln(err)
    }
}

Result

Invoke the Echo method

POST /jrpc HTTP/1.1
Accept: application/json, */*
Accept-Encoding: gzip, deflate
Connection: keep-alive
Content-Length: 82
Content-Type: application/json
Host: localhost:8080
User-Agent: HTTPie/0.9.6

{
  "jsonrpc": "2.0",
  "method": "Main.Echo",
  "params": {
    "name": "John Doe"
  },
  "id": "243a718a-2ebb-4e32-8cc8-210c39e8a14b"
}

HTTP/1.1 200 OK
Content-Length: 68
Content-Type: application/json
Date: Mon, 28 Nov 2016 13:48:13 GMT

{
  "jsonrpc": "2.0",
  "result": {
    "message": "Hello, John Doe"
  },
  "id": "243a718a-2ebb-4e32-8cc8-210c39e8a14b"
}

Invoke the Positional method

POST /jrpc HTTP/1.1
Accept: */*
Content-Length: 133
Content-Type: application/json
Host: localhost:8080
User-Agent: curl/7.61.1

{
  "jsonrpc": "2.0",
  "method": "Main.Positional",
  "params": [3,1,1,3,5,3],
  "id": "243a718a-2ebb-4e32-8cc8-210c39e8a14b"
}

HTTP/1.1 200 OK
Content-Length: 97
Content-Type: application/json
Date: Mon, 05 Nov 2018 11:23:35 GMT

{
  "jsonrpc": "2.0",
  "result": {
    "message": [3,1,1,3,5,3]
  },
  "id": "243a718a-2ebb-4e32-8cc8-210c39e8a14b"
}

Access to debug handler

GET /jrpc/debug HTTP/1.1
Accept: */*
Accept-Encoding: gzip, deflate
Connection: keep-alive
Host: localhost:8080
User-Agent: HTTPie/0.9.6

HTTP/1.1 200 OK
Content-Length: 408
Content-Type: application/json
Date: Mon, 28 Nov 2016 13:56:24 GMT

[
  {
    "handler": "EchoHandler",
    "name": "Main.Echo",
    "params": {
      "$ref": "#/definitions/EchoParams",
      "$schema": "http://json-schema.org/draft-04/schema#",
      "definitions": {
        "EchoParams": {
          "additionalProperties": false,
          "properties": {
            "name": {
              "type": "string"
            }
          },
          "required": [
            "name"
          ],
          "type": "object"
        }
      }
    },
    "result": {
      "$ref": "#/definitions/EchoResult",
      "$schema": "http://json-schema.org/draft-04/schema#",
      "definitions": {
        "EchoResult": {
          "additionalProperties": false,
          "properties": {
            "message": {
              "type": "string"
            }
          },
          "required": [
            "message"
          ],
          "type": "object"
        }
      }
    }
  }
]

License

Released under the MIT License.


*Note that all licence references and agreements mentioned in the jsonrpc README section above are relevant to that project's source code only.