dsrpc, Data RPC

DSRPC is easy and simple RPC framework over TCP socket.

Purpose

A very easy and open RPC framework with data streaming.

You can

• Use own post and pre-execution middleware
• Hash-based authentication in middleware
• Test remote function without network

Socket encryption is not used at this time since framefork is oriented to transfer large amounts of data.

Style of the framework is similar of GIN framework.

Exec method example

Server

package main

import (
    "log"
    "github.com/kindsoldier/dsrpc"
    "netsrv/api"
)

func main() {
    err := server()
    if err != nil {
        log.Println(err)
    }
}

func server() error {
    var err error

    serv := dsrpc.NewService()

    cont := NewController()
    serv.Handler(api.HelloMethod, cont.HelloHandler)

    serv.PreMiddleware(dsrpc.LogRequest)
    serv.PostMiddleware(dsrpc.LogResponse)
    serv.PostMiddleware(dsrpc.LogAccess)

    err = serv.Listen(":8081")
    if err != nil {
        return err
    }
    return err
}


type Controller struct {
}

func NewController() *Controller {
    return &Controller{}
}

func (cont *Controller) HelloHandler(context *dsrpc.Context) error {
    var err error
    params := api.NewHelloParams()
    err = context.BindParams(params)
    if err != nil {
        return err
    }

    log.Println("hello message:", params.Message)

    result := api.NewHelloResult()
    result.Message = "hello!"

    err = context.SendResult(result, 0)
    if err != nil {
        return err
    }

    return err
}

Client

package main

import (
    "fmt"
    "github.com/kindsoldier/dsrpc"
    "netsrv/api"
)

func main() {

    err := exec()
    if err != nil {
        fmt.Println("exec err:", err)
    }
}

func exec() error {
    var err error

    params := api.NewHelloParams()
    params.Message = "hello, server!"

    result := api.NewHelloResult()

    err = dsrpc.Exec("127.0.0.1:8081", api.HelloMethod, params, result, nil)
    if err != nil {
        return err
    }

    fmt.Println("result:", result.Message)
    return err
}

Common api

package api

const HelloMethod string = "hello"

type HelloParams struct {
    Message string      `json:"message"`
}

func NewHelloParams() *HelloParams {
    return &HelloParams{}
}

type HelloResult struct {
    Message string      `json:"message"`
}

func NewHelloResult() *HelloResult {
    return &HelloResult{}
}

Authentication and authorization

Client side

func clientHello() error {
    var err error

    params := NewHelloParams()
    params.Message = "hello server!"
    result := NewHelloResult()

    auth := dsrpc.CreateAuth([]byte("login"), []byte("password"))

    err = dsrpc.Exec("127.0.0.1:8081", HelloMethod, params, result, auth)
    if err != nil {
        log.Println("method err:", err)
        return err
    }

    //...
}

Server side

func authMiddleware(context *dsrpc.Context) error {
    var err error
    reqIdent := context.AuthIdent()
    reqSalt := context.AuthSalt()
    reqHash := context.AuthHash()

    if reqIdent != "login" {
        err = errors.New("auth ident or pass mismatch")
        context.SendError(err)
        return err
    }

    ident := reqIdent
    pass := []byte("password")

    ok := dsrpc.CheckHash(ident, pass, reqSalt, reqHash)
    log.Println("auth is ok:", ok)
    if !ok {
        err = errors.New("auth ident or pass mismatch")
        context.SendError(err)
        return err
    }
    return err
}

func sampleServ(quiet bool) error {
    var err error

    if quiet {
        dsrpc.SetAccessWriter(io.Discard)
        dsrpc.SetMessageWriter(io.Discard)
    }
    serv := NewService()

    serv.PreMiddleware(authMiddleware)
    serv.PreMiddleware(dsrpc.LogRequest)

    serv.Handler(HelloMethod, helloHandler)
    serv.Handler(SaveMethod, saveHandler)
    serv.Handler(LoadMethod, loadHandler)

    serv.PostMiddleware(dsrpc.LogResponse)
    serv.PostMiddleware(dsrpc.LogAccess)

    err = serv.Listen(":8081")
    if err != nil {
        return err
    }
    return err
}

Put method

Client side sample

    var binSize int64 = 16
    rand.Seed(time.Now().UnixNano())
    binBytes := make([]byte, binSize)
    rand.Read(binBytes)

    reader := bytes.NewReader(binBytes)

    err = dsrpc.Put("127.0.0.1:8081", SaveMethod, reader, binSize, params, result, auth)

Server side

func saveHandler(context *dsrpc.Context) error {
    var err error
    params := NewSaveParams()

    err = context.BindParams(params)
    if err != nil {
        return err
    }

    bufferBytes := make([]byte, 0, 1024)
    binWriter := bytes.NewBuffer(bufferBytes)

    err = context.ReadBin(binWriter)
    if err != nil {
        context.SendError(err)
        return err
    }

    result := NewSaveResult()
    result.Message = "saved successfully!"

    err = context.SendResult(result, 0)
    if err != nil {
        return err
    }
    return err
}

Get method

Client side

    params := NewLoadParams()
    params.Message = "load data!"
    result := NewHelloResult()
    auth := CreateAuth([]byte("qwert"), []byte("12345"))

    binBytes := make([]byte, 0)
    writer := bytes.NewBuffer(binBytes)

    err = dsrpc.Get("127.0.0.1:8081", LoadMethod, writer, params, result, auth)
    if err != nil {
        return err
    }

    //...

Server side

func getHandler(context *dsrpc.Context) error {
    var err error
    params := NewSaveParams()

    err = context.BindParams(params)
    if err != nil {
        return err
    }

    var binSize int64 = 1024

    rand.Seed(time.Now().UnixNano())
    binBytes := make([]byte, binSize)
    rand.Read(binBytes)

    binReader := bytes.NewReader(binBytes)

    result := NewSaveResult()
    result.Message = "load successfully!"

    err = context.SendResult(result, binSize)
    if err != nil {
        return err
    }
    binWriter := context.BinWriter()
    _, err = dsrpc.CopyBytes(binReader, binWriter, binSize)
    if err != nil {
        return err
    }

    return err
}