Popularity
5.0
Growing
Activity
3.4
Declining
156
5
16

Programming language: Go
License: MIT License
Latest version: v2.3.1

jsonrpc alternatives and similar packages

Based on the "Distributed Systems" category.
Alternatively, view jsonrpc alternatives based on common mentions on social networks and blogs.

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

Add another 'Distributed Systems' Package

README

jsonrpc

GitHub Actions 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.