ziggi/dsrpc
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

go fmt

Browse Source
This commit is contained in:
Oleg Borodin
2023-02-11 07:52:40 +02:00
parent 5366bd7ff7
commit 59d850da3c
18 changed files with 1183 additions and 1208 deletions
Download Patch File Download Diff File Expand all files Collapse all files
client.go
+252 -256
View File
@@ -5,332 +5,328 @@
package dsrpc package dsrpc
import ( import (
"errors" "errors"
"fmt" "fmt"
"io" "io"
"net" "net"
"sync" "sync"
encoder "github.com/vmihailenco/msgpack/v5" encoder "github.com/vmihailenco/msgpack/v5"
) )
func Put(address string, method string, reader io.Reader, size int64, param, result any, auth *Auth) error { func Put(address string, method string, reader io.Reader, size int64, param, result any, auth *Auth) error {
var err error var err error
addr, err := net.ResolveTCPAddr("tcp", address) addr, err := net.ResolveTCPAddr("tcp", address)
if err != nil { if err != nil {
err = fmt.Errorf("unable to resolve adddress: %s", err) err = fmt.Errorf("unable to resolve adddress: %s", err)
return Err(err) return Err(err)
} }
conn, err := net.DialTCP("tcp", nil, addr) conn, err := net.DialTCP("tcp", nil, addr)
if err != nil { if err != nil {
return Err(err) return Err(err)
} }
defer conn.Close() defer conn.Close()
//err = conn.SetKeepAlive(true) //err = conn.SetKeepAlive(true)
//if err != nil { //if err != nil {
// err = fmt.Errorf("unable to set keepalive: %s", err) // err = fmt.Errorf("unable to set keepalive: %s", err)
// return Err(err) // return Err(err)
//} //}
//err = conn.SetKeepAlivePeriod(10 * time.Second) //err = conn.SetKeepAlivePeriod(10 * time.Second)
//if err != nil { //if err != nil {
// err = fmt.Errorf("unable to set keepalive period: %s", err) // err = fmt.Errorf("unable to set keepalive period: %s", err)
// return Err(err) // return Err(err)
//} //}
return ConnPut(conn, method, reader, size, param, result, auth) return ConnPut(conn, method, reader, size, param, result, auth)
} }
func ConnPut(conn net.Conn, method string, reader io.Reader, size int64, param, result any, auth *Auth) error { func ConnPut(conn net.Conn, method string, reader io.Reader, size int64, param, result any, auth *Auth) error {
var err error var err error
context := CreateContext(conn) context := CreateContext(conn)
context.reqRPC.Method = method context.reqRPC.Method = method
context.reqRPC.Params = param context.reqRPC.Params = param
context.reqRPC.Auth = auth context.reqRPC.Auth = auth
context.resRPC.Result = result context.resRPC.Result = result
context.binReader = reader context.binReader = reader
context.binWriter = conn context.binWriter = conn
context.reqHeader.binSize = size context.reqHeader.binSize = size
if context.reqRPC.Params == nil { if context.reqRPC.Params == nil {
context.reqRPC.Params = NewEmpty() context.reqRPC.Params = NewEmpty()
} }
err = context.CreateRequest() err = context.CreateRequest()
if err != nil { if err != nil {
return Err(err) return Err(err)
} }
err = context.WriteRequest() err = context.WriteRequest()
if err != nil { if err != nil {
return Err(err) return Err(err)
} }
var wg sync.WaitGroup var wg sync.WaitGroup
errChan := make(chan error, 1) errChan := make(chan error, 1)
wg.Add(1) wg.Add(1)
go context.ReadResponseAsync(&wg, errChan) go context.ReadResponseAsync(&wg, errChan)
wg.Add(1) wg.Add(1)
go context.UploadBinAsync(&wg) go context.UploadBinAsync(&wg)
wg.Wait() wg.Wait()
err = <- errChan err = <-errChan
if err != nil { if err != nil {
return Err(err) return Err(err)
} }
err = context.BindResponse() err = context.BindResponse()
if err != nil { if err != nil {
return Err(err) return Err(err)
} }
return Err(err) return Err(err)
} }
func Get(address string, method string, writer io.Writer, param, result any, auth *Auth) error { func Get(address string, method string, writer io.Writer, param, result any, auth *Auth) error {
var err error var err error
addr, err := net.ResolveTCPAddr("tcp", address) addr, err := net.ResolveTCPAddr("tcp", address)
if err != nil { if err != nil {
err = fmt.Errorf("unable to resolve adddress: %s", err) err = fmt.Errorf("unable to resolve adddress: %s", err)
return Err(err) return Err(err)
} }
conn, err := net.DialTCP("tcp", nil, addr) conn, err := net.DialTCP("tcp", nil, addr)
if err != nil { if err != nil {
return Err(err) return Err(err)
} }
defer conn.Close() defer conn.Close()
//err = conn.SetKeepAlive(true) //err = conn.SetKeepAlive(true)
//if err != nil { //if err != nil {
// err = fmt.Errorf("unable to set keepalive: %s", err) // err = fmt.Errorf("unable to set keepalive: %s", err)
// return Err(err) // return Err(err)
//} //}
//err = conn.SetKeepAlivePeriod(10 * time.Second) //err = conn.SetKeepAlivePeriod(10 * time.Second)
//if err != nil { //if err != nil {
// err = fmt.Errorf("unable to set keepalive period: %s", err) // err = fmt.Errorf("unable to set keepalive period: %s", err)
// return Err(err) // return Err(err)
//} //}
return ConnGet(conn, method, writer, param, result, auth) return ConnGet(conn, method, writer, param, result, auth)
} }
func ConnGet(conn net.Conn, method string, writer io.Writer, param, result any, auth *Auth) error { func ConnGet(conn net.Conn, method string, writer io.Writer, param, result any, auth *Auth) error {
var err error var err error
context := CreateContext(conn) context := CreateContext(conn)
context.reqRPC.Method = method context.reqRPC.Method = method
context.reqRPC.Params = param context.reqRPC.Params = param
context.reqRPC.Auth = auth context.reqRPC.Auth = auth
context.resRPC.Result = result context.resRPC.Result = result
context.binReader = conn context.binReader = conn
context.binWriter = writer context.binWriter = writer
if context.reqRPC.Params == nil { if context.reqRPC.Params == nil {
context.reqRPC.Params = NewEmpty() context.reqRPC.Params = NewEmpty()
} }
err = context.CreateRequest() err = context.CreateRequest()
if err != nil { if err != nil {
return Err(err) return Err(err)
} }
err = context.WriteRequest() err = context.WriteRequest()
if err != nil { if err != nil {
return Err(err) return Err(err)
} }
err = context.ReadResponse() err = context.ReadResponse()
if err != nil { if err != nil {
return Err(err) return Err(err)
} }
err = context.DownloadBin() err = context.DownloadBin()
if err != nil { if err != nil {
return Err(err) return Err(err)
} }
err = context.BindResponse() err = context.BindResponse()
if err != nil { if err != nil {
return Err(err) return Err(err)
} }
return Err(err) return Err(err)
} }
func Exec(address, method string, param any, result any, auth *Auth) error { func Exec(address, method string, param any, result any, auth *Auth) error {
var err error var err error
addr, err := net.ResolveTCPAddr("tcp", address) addr, err := net.ResolveTCPAddr("tcp", address)
if err != nil { if err != nil {
err = fmt.Errorf("unable to resolve adddress: %s", err) err = fmt.Errorf("unable to resolve adddress: %s", err)
return Err(err) return Err(err)
} }
conn, err := net.DialTCP("tcp", nil, addr) conn, err := net.DialTCP("tcp", nil, addr)
if err != nil { if err != nil {
return Err(err) return Err(err)
} }
defer conn.Close() defer conn.Close()
//err = conn.SetKeepAlive(true) //err = conn.SetKeepAlive(true)
//if err != nil { //if err != nil {
// err = fmt.Errorf("unable to set keepalive: %s", err) // err = fmt.Errorf("unable to set keepalive: %s", err)
// return Err(err) // return Err(err)
//} //}
//err = conn.SetKeepAlivePeriod(10 * time.Second) //err = conn.SetKeepAlivePeriod(10 * time.Second)
//if err != nil { //if err != nil {
// err = fmt.Errorf("unable to set keepalive period: %s", err) // err = fmt.Errorf("unable to set keepalive period: %s", err)
// return Err(err) // return Err(err)
//} //}
err = ConnExec(conn, method, param, result, auth) err = ConnExec(conn, method, param, result, auth)
if err != nil { if err != nil {
return Err(err) return Err(err)
} }
return Err(err) return Err(err)
} }
func ConnExec(conn net.Conn, method string, param any, result any, auth *Auth) error { func ConnExec(conn net.Conn, method string, param any, result any, auth *Auth) error {
var err error var err error
context := CreateContext(conn) context := CreateContext(conn)
context.reqRPC.Method = method context.reqRPC.Method = method
context.reqRPC.Params = param context.reqRPC.Params = param
context.reqRPC.Auth = auth context.reqRPC.Auth = auth
context.resRPC.Result = result context.resRPC.Result = result
if context.reqRPC.Params == nil { if context.reqRPC.Params == nil {
context.reqRPC.Params = NewEmpty() context.reqRPC.Params = NewEmpty()
} }
err = context.CreateRequest() err = context.CreateRequest()
if err != nil { if err != nil {
return Err(err) return Err(err)
} }
err = context.WriteRequest() err = context.WriteRequest()
if err != nil { if err != nil {
return Err(err) return Err(err)
} }
err = context.ReadResponse() err = context.ReadResponse()
if err != nil { if err != nil {
return Err(err) return Err(err)
} }
err = context.BindResponse() err = context.BindResponse()
if err != nil { if err != nil {
return Err(err) return Err(err)
} }
return Err(err) return Err(err)
} }
func (context *Context) CreateRequest() error { func (context *Context) CreateRequest() error {
var err error var err error
context.reqPacket.rcpPayload, err = context.reqRPC.Pack() context.reqPacket.rcpPayload, err = context.reqRPC.Pack()
if err != nil { if err != nil {
return Err(err) return Err(err)
} }
rpcSize := int64(len(context.reqPacket.rcpPayload)) rpcSize := int64(len(context.reqPacket.rcpPayload))
context.reqHeader.rpcSize = rpcSize context.reqHeader.rpcSize = rpcSize
context.reqPacket.header, err = context.reqHeader.Pack() context.reqPacket.header, err = context.reqHeader.Pack()
if err != nil { if err != nil {
return Err(err) return Err(err)
} }
return Err(err) return Err(err)
} }
func (context *Context) WriteRequest() error { func (context *Context) WriteRequest() error {
var err error var err error
_, err = context.sockWriter.Write(context.reqPacket.header) _, err = context.sockWriter.Write(context.reqPacket.header)
if err != nil { if err != nil {
return Err(err) return Err(err)
} }
_, err = context.sockWriter.Write(context.reqPacket.rcpPayload) _, err = context.sockWriter.Write(context.reqPacket.rcpPayload)
if err != nil { if err != nil {
return Err(err) return Err(err)
} }
return Err(err) return Err(err)
} }
func (context *Context) UploadBin() error { func (context *Context) UploadBin() error {
var err error var err error
_, err = CopyBytes(context.binReader, context.binWriter, context.reqHeader.binSize) _, err = CopyBytes(context.binReader, context.binWriter, context.reqHeader.binSize)
return Err(err) return Err(err)
} }
func (context *Context) ReadResponse() error { func (context *Context) ReadResponse() error {
var err error var err error
context.resPacket.header, err = ReadBytes(context.sockReader, headerSize) context.resPacket.header, err = ReadBytes(context.sockReader, headerSize)
if err != nil { if err != nil {
return Err(err) return Err(err)
} }
context.resHeader, err = UnpackHeader(context.resPacket.header) context.resHeader, err = UnpackHeader(context.resPacket.header)
if err != nil { if err != nil {
return Err(err) return Err(err)
} }
rpcSize := context.resHeader.rpcSize rpcSize := context.resHeader.rpcSize
context.resPacket.rcpPayload, err = ReadBytes(context.sockReader, rpcSize) context.resPacket.rcpPayload, err = ReadBytes(context.sockReader, rpcSize)
if err != nil { if err != nil {
return Err(err) return Err(err)
} }
return Err(err) return Err(err)
} }
func (context *Context) UploadBinAsync(wg *sync.WaitGroup) { func (context *Context) UploadBinAsync(wg *sync.WaitGroup) {
exitFunc := func() { exitFunc := func() {
wg.Done() wg.Done()
} }
defer exitFunc() defer exitFunc()
_, _ = CopyBytes(context.binReader, context.binWriter, context.reqHeader.binSize) _, _ = CopyBytes(context.binReader, context.binWriter, context.reqHeader.binSize)
return return
} }
func (context *Context) ReadResponseAsync(wg *sync.WaitGroup, errChan chan error) { func (context *Context) ReadResponseAsync(wg *sync.WaitGroup, errChan chan error) {
var err error var err error
exitFunc := func() { exitFunc := func() {
errChan <- err errChan <- err
wg.Done() wg.Done()
} }
defer exitFunc() defer exitFunc()
context.resPacket.header, err = ReadBytes(context.sockReader, headerSize) context.resPacket.header, err = ReadBytes(context.sockReader, headerSize)
if err != nil { if err != nil {
err = Err(err) err = Err(err)
return return
} }
context.resHeader, err = UnpackHeader(context.resPacket.header) context.resHeader, err = UnpackHeader(context.resPacket.header)
if err != nil { if err != nil {
err = Err(err) err = Err(err)
return return
} }
rpcSize := context.resHeader.rpcSize rpcSize := context.resHeader.rpcSize
context.resPacket.rcpPayload, err = ReadBytes(context.sockReader, rpcSize) context.resPacket.rcpPayload, err = ReadBytes(context.sockReader, rpcSize)
if err != nil { if err != nil {
err = Err(err) err = Err(err)
return return
} }
return return
} }
func (context *Context) DownloadBin() error { func (context *Context) DownloadBin() error {
var err error var err error
_, err = CopyBytes(context.binReader, context.binWriter, context.resHeader.binSize) _, err = CopyBytes(context.binReader, context.binWriter, context.resHeader.binSize)
return Err(err) return Err(err)
} }
func (context *Context) BindResponse() error { func (context *Context) BindResponse() error {
var err error var err error
err = encoder.Unmarshal(context.resPacket.rcpPayload, context.resRPC) err = encoder.Unmarshal(context.resPacket.rcpPayload, context.resRPC)
if err != nil { if err != nil {
return Err(err) return Err(err)
} }
if len(context.resRPC.Error) > 0 { if len(context.resRPC.Error) > 0 {
err = errors.New(context.resRPC.Error) err = errors.New(context.resRPC.Error)
return Err(err) return Err(err)
} }
return Err(err) return Err(err)
} }
context.go
+81 -85
View File
@@ -5,152 +5,148 @@
package dsrpc package dsrpc
import ( import (
"io" "io"
"net" "net"
"time" "time"
) )
type Context struct { type Context struct {
start time.Time start time.Time
remoteHost string remoteHost string
sockReader io.Reader sockReader io.Reader
sockWriter io.Writer sockWriter io.Writer
reqHeader *Header reqHeader *Header
reqRPC *Request reqRPC *Request
reqPacket *Packet reqPacket *Packet
resPacket *Packet resPacket *Packet
resHeader *Header resHeader *Header
resRPC *Response resRPC *Response
binReader io.Reader binReader io.Reader
binWriter io.Writer binWriter io.Writer
} }
func NewContext() *Context { func NewContext() *Context {
context := &Context{} context := &Context{}
context.start = time.Now() context.start = time.Now()
return context return context
} }
func CreateContext(conn net.Conn) *Context { func CreateContext(conn net.Conn) *Context {
context := &Context{} context := &Context{}
context.start = time.Now() context.start = time.Now()
context.sockReader = conn context.sockReader = conn
context.sockWriter = conn context.sockWriter = conn
context.reqPacket = NewPacket() context.reqPacket = NewPacket()
context.resPacket = NewPacket() context.resPacket = NewPacket()
context.reqHeader = NewHeader() context.reqHeader = NewHeader()
context.reqRPC = NewRequest() context.reqRPC = NewRequest()
context.resHeader = NewHeader() context.resHeader = NewHeader()
context.resRPC = NewResponse() context.resRPC = NewResponse()
context.resRPC = NewResponse() context.resRPC = NewResponse()
return context return context
} }
func (context *Context) Request() *Request { func (context *Context) Request() *Request {
return context.reqRPC return context.reqRPC
} }
func (context *Context) RemoteHost() string { func (context *Context) RemoteHost() string {
return context.remoteHost return context.remoteHost
} }
func (context *Context) Start() time.Time { func (context *Context) Start() time.Time {
return context.start return context.start
} }
func (context *Context) Method() string { func (context *Context) Method() string {
var method string var method string
if context.reqRPC != nil { if context.reqRPC != nil {
method = context.reqRPC.Method method = context.reqRPC.Method
} }
return method return method
} }
func (context *Context) ReqRpcSize() int64 { func (context *Context) ReqRpcSize() int64 {
var size int64 var size int64
if context.reqHeader != nil { if context.reqHeader != nil {
size = context.reqHeader.rpcSize size = context.reqHeader.rpcSize
} }
return size return size
} }
func (context *Context) ReqBinSize() int64 { func (context *Context) ReqBinSize() int64 {
var size int64 var size int64
if context.reqHeader != nil { if context.reqHeader != nil {
size = context.reqHeader.binSize size = context.reqHeader.binSize
} }
return size return size
} }
func (context *Context) ResBinSize() int64 { func (context *Context) ResBinSize() int64 {
var size int64 var size int64
if context.resHeader != nil { if context.resHeader != nil {
size = context.resHeader.binSize size = context.resHeader.binSize
} }
return size return size
} }
func (context *Context) ResRpcSize() int64 { func (context *Context) ResRpcSize() int64 {
var size int64 var size int64
if context.resHeader != nil { if context.resHeader != nil {
size = context.resHeader.rpcSize size = context.resHeader.rpcSize
} }
return size return size
} }
func (context *Context) ReqSize() int64 { func (context *Context) ReqSize() int64 {
var size int64 var size int64
if context.reqHeader != nil { if context.reqHeader != nil {
size += context.reqHeader.binSize size += context.reqHeader.binSize
size += context.reqHeader.rpcSize size += context.reqHeader.rpcSize
} }
return size return size
} }
func (context *Context) ResSize() int64 { func (context *Context) ResSize() int64 {
var size int64 var size int64
if context.resHeader != nil { if context.resHeader != nil {
size += context.resHeader.binSize size += context.resHeader.binSize
size += context.resHeader.rpcSize size += context.resHeader.rpcSize
} }
return size return size
} }
func (context *Context) SetAuthIdent(ident []byte) {
context.reqRPC.Auth.Ident = ident
func (context *Context) SetAuthIdent(ident []byte) {
context.reqRPC.Auth.Ident = ident
} }
func (context *Context) SetAuthSalt(salt []byte) { func (context *Context) SetAuthSalt(salt []byte) {
context.reqRPC.Auth.Salt = salt context.reqRPC.Auth.Salt = salt
} }
func (context *Context) SetAuthHash(hash []byte) { func (context *Context) SetAuthHash(hash []byte) {
context.reqRPC.Auth.Hash = hash context.reqRPC.Auth.Hash = hash
} }
func (context *Context) AuthIdent() []byte { func (context *Context) AuthIdent() []byte {
return context.reqRPC.Auth.Ident return context.reqRPC.Auth.Ident
} }
func (context *Context) AuthSalt() []byte { func (context *Context) AuthSalt() []byte {
return context.reqRPC.Auth.Salt return context.reqRPC.Auth.Salt
} }
func (context *Context) AuthHash() []byte { func (context *Context) AuthHash() []byte {
return context.reqRPC.Auth.Hash return context.reqRPC.Auth.Hash
} }
func (context *Context) Auth() *Auth { func (context *Context) Auth() *Auth {
return context.reqRPC.Auth return context.reqRPC.Auth
} }
empty.go
+2 -2
View File
@@ -6,8 +6,8 @@
package dsrpc package dsrpc
type Empty struct {} type Empty struct{}
func NewEmpty() *Empty { func NewEmpty() *Empty {
return &Empty{} return &Empty{}
} }
error.go
+23 -24
View File
@@ -5,39 +5,38 @@
package dsrpc package dsrpc
import ( import (
"fmt" "fmt"
"runtime" "io"
"io" "runtime"
) )
var develMode bool = false var develMode bool = false
var debugMode bool = false var debugMode bool = false
func SetDevelMode(mode bool) { func SetDevelMode(mode bool) {
develMode = mode develMode = mode
} }
func SetDebugMode(mode bool) { func SetDebugMode(mode bool) {
debugMode = mode debugMode = mode
} }
func Err(err error) error { func Err(err error) error {
switch err { switch err {
case io.EOF: case io.EOF:
return err return err
} }
if err != nil { if err != nil {
switch { switch {
case develMode == true: case develMode == true:
pc, filename, line, _ := runtime.Caller(1) pc, filename, line, _ := runtime.Caller(1)
funcName := runtime.FuncForPC(pc).Name() funcName := runtime.FuncForPC(pc).Name()
err = fmt.Errorf(" %s:%d:%s:%s", filename, line, funcName, err.Error()) err = fmt.Errorf(" %s:%d:%s:%s", filename, line, funcName, err.Error())
case debugMode == true: case debugMode == true:
pc, _, line, _ := runtime.Caller(1) pc, _, line, _ := runtime.Caller(1)
funcName := runtime.FuncForPC(pc).Name() funcName := runtime.FuncForPC(pc).Name()
err = fmt.Errorf(" %s:%d:%s ", funcName, line, err.Error()) err = fmt.Errorf(" %s:%d:%s ", funcName, line, err.Error())
default: default:
} }
} }
return err return err
} }
exec_test.go
+230 -239
View File
@@ -5,370 +5,361 @@
package dsrpc package dsrpc
import ( import (
"bytes" "bytes"
"encoding/json" "encoding/json"
"errors" "errors"
"io" "io"
"math/rand" "math/rand"
"testing" "testing"
"time" "time"
"github.com/stretchr/testify/require" "github.com/stretchr/testify/require"
) )
func TestLocalExec(t *testing.T) { func TestLocalExec(t *testing.T) {
var err error var err error
params := NewHelloParams() params := NewHelloParams()
params.Message = "hello server!" params.Message = "hello server!"
result := NewHelloResult() result := NewHelloResult()
auth := CreateAuth([]byte("qwert"), []byte("12345")) auth := CreateAuth([]byte("qwert"), []byte("12345"))
err = LocalExec(HelloMethod, params, result, auth, helloHandler) err = LocalExec(HelloMethod, params, result, auth, helloHandler)
require.NoError(t, err) require.NoError(t, err)
resultJSON, _ := json.Marshal(result) resultJSON, _ := json.Marshal(result)
logDebug("method result:", string(resultJSON)) logDebug("method result:", string(resultJSON))
} }
func TestLocalSave(t *testing.T) { func TestLocalSave(t *testing.T) {
var err error var err error
params := NewSaveParams() params := NewSaveParams()
params.Message = "save data!" params.Message = "save data!"
result := NewHelloResult() result := NewHelloResult()
auth := CreateAuth([]byte("qwert"), []byte("12345")) auth := CreateAuth([]byte("qwert"), []byte("12345"))
var binSize int64 = 16 var binSize int64 = 16
rand.Seed(time.Now().UnixNano()) rand.Seed(time.Now().UnixNano())
binBytes := make([]byte, binSize) binBytes := make([]byte, binSize)
rand.Read(binBytes) rand.Read(binBytes)
reader := bytes.NewReader(binBytes) reader := bytes.NewReader(binBytes)
err = LocalPut(SaveMethod, reader, binSize, params, result, auth, saveHandler) err = LocalPut(SaveMethod, reader, binSize, params, result, auth, saveHandler)
require.NoError(t, err) require.NoError(t, err)
resultJSON, _ := json.Marshal(result) resultJSON, _ := json.Marshal(result)
logDebug("method result:", string(resultJSON)) logDebug("method result:", string(resultJSON))
} }
func TestLocalLoad(t *testing.T) { func TestLocalLoad(t *testing.T) {
var err error var err error
params := NewLoadParams() params := NewLoadParams()
params.Message = "load data!" params.Message = "load data!"
result := NewHelloResult() result := NewHelloResult()
auth := CreateAuth([]byte("qwert"), []byte("12345")) auth := CreateAuth([]byte("qwert"), []byte("12345"))
binBytes := make([]byte, 0) binBytes := make([]byte, 0)
writer := bytes.NewBuffer(binBytes) writer := bytes.NewBuffer(binBytes)
err = LocalGet(LoadMethod, writer, params, result, auth, loadHandler) err = LocalGet(LoadMethod, writer, params, result, auth, loadHandler)
require.NoError(t, err) require.NoError(t, err)
resultJSON, _ := json.Marshal(result) resultJSON, _ := json.Marshal(result)
logDebug("method result:", string(resultJSON)) logDebug("method result:", string(resultJSON))
logDebug("bin size:", len(writer.Bytes())) logDebug("bin size:", len(writer.Bytes()))
} }
func TestNetExec(t *testing.T) { func TestNetExec(t *testing.T) {
go testServ(false) go testServ(false)
time.Sleep(10 * time.Millisecond) time.Sleep(10 * time.Millisecond)
err := clientHello() err := clientHello()
require.NoError(t, err) require.NoError(t, err)
} }
func TestNetSave(t *testing.T) { func TestNetSave(t *testing.T) {
go testServ(false) go testServ(false)
time.Sleep(10 * time.Millisecond) time.Sleep(10 * time.Millisecond)
err := clientSave() err := clientSave()
require.NoError(t, err) require.NoError(t, err)
} }
func TestNetLoad(t *testing.T) { func TestNetLoad(t *testing.T) {
go testServ(false) go testServ(false)
time.Sleep(10 * time.Millisecond) time.Sleep(10 * time.Millisecond)
err := clientLoad() err := clientLoad()
require.NoError(t, err) require.NoError(t, err)
} }
func BenchmarkNetPut(b *testing.B) { func BenchmarkNetPut(b *testing.B) {
go testServ(true) go testServ(true)
time.Sleep(10 * time.Millisecond) time.Sleep(10 * time.Millisecond)
clientSave() clientSave()
pBench := func(pb *testing.PB) { pBench := func(pb *testing.PB) {
for pb.Next() { for pb.Next() {
clientSave() clientSave()
} }
} }
b.SetParallelism(10) b.SetParallelism(10)
b.RunParallel(pBench) b.RunParallel(pBench)
} }
func clientHello() error { func clientHello() error {
var err error var err error
params := NewHelloParams() params := NewHelloParams()
params.Message = "hello server!" params.Message = "hello server!"
result := NewHelloResult() result := NewHelloResult()
auth := CreateAuth([]byte("qwert"), []byte("12345")) auth := CreateAuth([]byte("qwert"), []byte("12345"))
var binSize int64 = 16 var binSize int64 = 16
rand.Seed(time.Now().UnixNano()) rand.Seed(time.Now().UnixNano())
binBytes := make([]byte, binSize) binBytes := make([]byte, binSize)
rand.Read(binBytes) rand.Read(binBytes)
err = Exec("127.0.0.1:8081", HelloMethod, params, result, auth) err = Exec("127.0.0.1:8081", HelloMethod, params, result, auth)
if err != nil { if err != nil {
logError("method err:", err) logError("method err:", err)
return err return err
} }
resultJSON, _ := json.Marshal(result) resultJSON, _ := json.Marshal(result)
logDebug("method result:", string(resultJSON)) logDebug("method result:", string(resultJSON))
return err return err
} }
func clientSave() error { func clientSave() error {
var err error var err error
params := NewSaveParams() params := NewSaveParams()
params.Message = "save data!" params.Message = "save data!"
result := NewHelloResult() result := NewHelloResult()
auth := CreateAuth([]byte("qwert"), []byte("12345")) auth := CreateAuth([]byte("qwert"), []byte("12345"))
var binSize int64 = 16 var binSize int64 = 16
rand.Seed(time.Now().UnixNano()) rand.Seed(time.Now().UnixNano())
binBytes := make([]byte, binSize) binBytes := make([]byte, binSize)
rand.Read(binBytes) rand.Read(binBytes)
reader := bytes.NewReader(binBytes) reader := bytes.NewReader(binBytes)
err = Put("127.0.0.1:8081", SaveMethod, reader, binSize, params, result, auth) err = Put("127.0.0.1:8081", SaveMethod, reader, binSize, params, result, auth)
if err != nil { if err != nil {
logError("method err:", err) logError("method err:", err)
return err return err
} }
resultJSON, _ := json.Marshal(result) resultJSON, _ := json.Marshal(result)
logDebug("method result:", string(resultJSON)) logDebug("method result:", string(resultJSON))
return err return err
} }
func clientLoad() error { func clientLoad() error {
var err error var err error
params := NewLoadParams() params := NewLoadParams()
params.Message = "load data!" params.Message = "load data!"
result := NewHelloResult() result := NewHelloResult()
auth := CreateAuth([]byte("qwert"), []byte("12345")) auth := CreateAuth([]byte("qwert"), []byte("12345"))
binBytes := make([]byte, 0)
writer := bytes.NewBuffer(binBytes)
binBytes := make([]byte, 0) err = Get("127.0.0.1:8081", LoadMethod, writer, params, result, auth)
writer := bytes.NewBuffer(binBytes) if err != nil {
logError("method err:", err)
err = Get("127.0.0.1:8081", LoadMethod, writer, params, result, auth) return err
if err != nil { }
logError("method err:", err) resultJSON, _ := json.Marshal(result)
return err logDebug("method result:", string(resultJSON))
} logDebug("bin size:", len(writer.Bytes()))
resultJSON, _ := json.Marshal(result) return err
logDebug("method result:", string(resultJSON))
logDebug("bin size:", len(writer.Bytes()))
return err
} }
var testServRun bool = false var testServRun bool = false
func testServ(quiet bool) error { func testServ(quiet bool) error {
var err error var err error
if testServRun { if testServRun {
return err return err
} }
testServRun = true testServRun = true
if quiet { if quiet {
SetAccessWriter(io.Discard) SetAccessWriter(io.Discard)
SetMessageWriter(io.Discard) SetMessageWriter(io.Discard)
} }
serv := NewService() serv := NewService()
serv.Handler(HelloMethod, helloHandler) serv.Handler(HelloMethod, helloHandler)
serv.Handler(SaveMethod, saveHandler) serv.Handler(SaveMethod, saveHandler)
serv.Handler(LoadMethod, loadHandler) serv.Handler(LoadMethod, loadHandler)
serv.PreMiddleware(LogRequest) serv.PreMiddleware(LogRequest)
serv.PreMiddleware(auth) serv.PreMiddleware(auth)
serv.PostMiddleware(LogResponse) serv.PostMiddleware(LogResponse)
serv.PostMiddleware(LogAccess) serv.PostMiddleware(LogAccess)
err = serv.Listen(":8081") err = serv.Listen(":8081")
if err != nil { if err != nil {
return err return err
} }
return err return err
} }
func auth(context *Context) error { func auth(context *Context) error {
var err error var err error
reqIdent := context.AuthIdent() reqIdent := context.AuthIdent()
reqSalt := context.AuthSalt() reqSalt := context.AuthSalt()
reqHash := context.AuthHash() reqHash := context.AuthHash()
ident := reqIdent ident := reqIdent
pass := []byte("12345") pass := []byte("12345")
auth := context.Auth() auth := context.Auth()
logDebug("auth ", string(auth.JSON())) logDebug("auth ", string(auth.JSON()))
ok := CheckHash(ident, pass, reqSalt, reqHash) ok := CheckHash(ident, pass, reqSalt, reqHash)
logDebug("auth ok:", ok) logDebug("auth ok:", ok)
if !ok { if !ok {
err = errors.New("auth ident or pass missmatch") err = errors.New("auth ident or pass missmatch")
context.SendError(err) context.SendError(err)
return err return err
} }
return err return err
} }
func helloHandler(context *Context) error { func helloHandler(context *Context) error {
var err error var err error
params := NewHelloParams() params := NewHelloParams()
err = context.BindParams(params) err = context.BindParams(params)
if err != nil { if err != nil {
return err return err
} }
err = context.ReadBin(io.Discard) err = context.ReadBin(io.Discard)
if err != nil { if err != nil {
context.SendError(err) context.SendError(err)
return err return err
} }
result := NewHelloResult() result := NewHelloResult()
result.Message = "hello, client!" result.Message = "hello, client!"
err = context.SendResult(result, 0) err = context.SendResult(result, 0)
if err != nil { if err != nil {
return err return err
} }
return err return err
} }
func saveHandler(context *Context) error { func saveHandler(context *Context) error {
var err error var err error
params := NewSaveParams() params := NewSaveParams()
err = context.BindParams(params) err = context.BindParams(params)
if err != nil { if err != nil {
return err return err
} }
bufferBytes := make([]byte, 0, 1024) bufferBytes := make([]byte, 0, 1024)
binWriter := bytes.NewBuffer(bufferBytes) binWriter := bytes.NewBuffer(bufferBytes)
err = context.ReadBin(binWriter) err = context.ReadBin(binWriter)
if err != nil { if err != nil {
context.SendError(err) context.SendError(err)
return err return err
} }
result := NewSaveResult() result := NewSaveResult()
result.Message = "saved successfully!" result.Message = "saved successfully!"
err = context.SendResult(result, 0) err = context.SendResult(result, 0)
if err != nil { if err != nil {
return err return err
} }
return err return err
} }
func loadHandler(context *Context) error { func loadHandler(context *Context) error {
var err error var err error
params := NewSaveParams() params := NewSaveParams()
err = context.BindParams(params) err = context.BindParams(params)
if err != nil { if err != nil {
return err return err
} }
err = context.ReadBin(io.Discard) err = context.ReadBin(io.Discard)
if err != nil { if err != nil {
context.SendError(err) context.SendError(err)
return err return err
} }
var binSize int64 = 1024 var binSize int64 = 1024
rand.Seed(time.Now().UnixNano()) rand.Seed(time.Now().UnixNano())
binBytes := make([]byte, binSize) binBytes := make([]byte, binSize)
rand.Read(binBytes) rand.Read(binBytes)
binReader := bytes.NewReader(binBytes) binReader := bytes.NewReader(binBytes)
result := NewSaveResult() result := NewSaveResult()
result.Message = "load successfully!" result.Message = "load successfully!"
err = context.SendResult(result, binSize) err = context.SendResult(result, binSize)
if err != nil { if err != nil {
return err return err
} }
binWriter := context.BinWriter() binWriter := context.BinWriter()
_, err = CopyBytes(binReader, binWriter, binSize) _, err = CopyBytes(binReader, binWriter, binSize)
if err != nil { if err != nil {
return err return err
} }
return err return err
} }
const HelloMethod string = "hello" const HelloMethod string = "hello"
type HelloParams struct { type HelloParams struct {
Message string `json:"message" msgpack:"message"` Message string `json:"message" msgpack:"message"`
} }
func NewHelloParams() *HelloParams { func NewHelloParams() *HelloParams {
return &HelloParams{} return &HelloParams{}
} }
type HelloResult struct { type HelloResult struct {
Message string `json:"message" msgpack:"message"` Message string `json:"message" msgpack:"message"`
} }
func NewHelloResult() *HelloResult { func NewHelloResult() *HelloResult {
return &HelloResult{} return &HelloResult{}
} }
const SaveMethod string = "save" const SaveMethod string = "save"
type SaveParams HelloParams type SaveParams HelloParams
type SaveResult HelloResult type SaveResult HelloResult
func NewSaveParams() *SaveParams { func NewSaveParams() *SaveParams {
return &SaveParams{} return &SaveParams{}
} }
func NewSaveResult() *SaveResult { func NewSaveResult() *SaveResult {
return &SaveResult{} return &SaveResult{}
} }
const LoadMethod string = "load" const LoadMethod string = "load"
type LoadParams HelloParams type LoadParams HelloParams
type LoadResult HelloResult type LoadResult HelloResult
func NewLoadParams() *LoadParams { func NewLoadParams() *LoadParams {
return &LoadParams{} return &LoadParams{}
} }
func NewLoadResult() *LoadResult { func NewLoadResult() *LoadResult {
return &LoadResult{} return &LoadResult{}
} }
faddr.go
+8 -8
View File
@@ -5,21 +5,21 @@
package dsrpc package dsrpc
type FAddr struct { type FAddr struct {
network string network string
address string address string
} }
func NewFAddr() *FAddr { func NewFAddr() *FAddr {
var addr FAddr var addr FAddr
addr.network = "tcp" addr.network = "tcp"
addr.address = "127.0.0.1:5000" addr.address = "127.0.0.1:5000"
return &addr return &addr
} }
func (addr *FAddr) Network() string { func (addr *FAddr) Network() string {
return addr.network return addr.network
} }
func (addr *FAddr) String() string { func (addr *FAddr) String() string {
return addr.address return addr.address
} }
faddr_test.go
+35 -35
View File
@@ -7,51 +7,51 @@
package dsrpc package dsrpc
import ( import (
"net" "github.com/stretchr/testify/require"
"testing" "net"
"github.com/stretchr/testify/require" "testing"
) )
func TestFConn0(t *testing.T) { func TestFConn0(t *testing.T) {
var cConn, sConn net.Conn var cConn, sConn net.Conn
sConn, cConn = NewFConn() sConn, cConn = NewFConn()
cData := []byte("qwerty") cData := []byte("qwerty")
count := 10 count := 10
for i := 0; i < count; i++ { for i := 0; i < count; i++ {
wc, err := cConn.Write(cData) wc, err := cConn.Write(cData)
if err != nil { if err != nil {
t.Error(err) t.Error(err)
} }
require.Equal(t, wc, len(cData)) require.Equal(t, wc, len(cData))
sData := make([]byte, len(cData)) sData := make([]byte, len(cData))
rc, err := sConn.Read(sData) rc, err := sConn.Read(sData)
require.NoError(t, err) require.NoError(t, err)
require.Equal(t, rc, len(cData)) require.Equal(t, rc, len(cData))
require.Equal(t, cData, sData) require.Equal(t, cData, sData)
} }
} }
func TestFConn1(t *testing.T) { func TestFConn1(t *testing.T) {
var cConn, sConn net.Conn var cConn, sConn net.Conn
cConn, sConn = NewFConn() cConn, sConn = NewFConn()
cData := []byte("qwerty") cData := []byte("qwerty")
count := 10 count := 10
for i := 0; i < count; i++ { for i := 0; i < count; i++ {
wc, err := cConn.Write(cData) wc, err := cConn.Write(cData)
if err != nil { if err != nil {
t.Error(err) t.Error(err)
} }
require.Equal(t, wc, len(cData)) require.Equal(t, wc, len(cData))
sData := make([]byte, len(cData)) sData := make([]byte, len(cData))
rc, err := sConn.Read(sData) rc, err := sConn.Read(sData)
require.NoError(t, err) require.NoError(t, err)
require.Equal(t, rc, len(cData)) require.Equal(t, rc, len(cData))
require.Equal(t, cData, sData) require.Equal(t, cData, sData)
} }
} }
fconn.go
+29 -29
View File
@@ -7,62 +7,62 @@
package dsrpc package dsrpc
import ( import (
"bytes" "bytes"
"io" "io"
"net" "net"
"time" "time"
) )
type FConn struct { type FConn struct {
reader io.Reader reader io.Reader
writer io.Writer writer io.Writer
} }
func NewFConn() (*FConn, *FConn){ func NewFConn() (*FConn, *FConn) {
c2sBuffer := bytes.NewBuffer(make([]byte, 0)) c2sBuffer := bytes.NewBuffer(make([]byte, 0))
s2cBuffer := bytes.NewBuffer(make([]byte, 0)) s2cBuffer := bytes.NewBuffer(make([]byte, 0))
var client FConn var client FConn
client.writer = c2sBuffer client.writer = c2sBuffer
client.reader = s2cBuffer client.reader = s2cBuffer
var server FConn var server FConn
server.writer = s2cBuffer server.writer = s2cBuffer
server.reader = c2sBuffer server.reader = c2sBuffer
return &client, &server return &client, &server
} }
func (conn FConn) SetDeadline(t time.Time) error { func (conn FConn) SetDeadline(t time.Time) error {
var err error var err error
return err return err
} }
func (conn FConn) SetReadDeadline(t time.Time) error { func (conn FConn) SetReadDeadline(t time.Time) error {
var err error var err error
return err return err
} }
func (conn FConn) SetWriteDeadline(t time.Time) error { func (conn FConn) SetWriteDeadline(t time.Time) error {
var err error var err error
return err return err
} }
func (conn FConn) LocalAddr() net.Addr { func (conn FConn) LocalAddr() net.Addr {
return NewFAddr() return NewFAddr()
} }
func (conn FConn) RemoteAddr() net.Addr { func (conn FConn) RemoteAddr() net.Addr {
return NewFAddr() return NewFAddr()
} }
func (conn FConn) Write(data []byte) (int, error) { func (conn FConn) Write(data []byte) (int, error) {
return conn.writer.Write(data) return conn.writer.Write(data)
} }
func (conn FConn) Read(data []byte) (int, error) { func (conn FConn) Read(data []byte) (int, error) {
return conn.reader.Read(data) return conn.reader.Read(data)
} }
func (conn FConn) Close() error { func (conn FConn) Close() error {
var err error var err error
return err return err
} }
header.go
+54 -56
View File
@@ -7,92 +7,90 @@
package dsrpc package dsrpc
import ( import (
"errors" "bytes"
"encoding/binary" "encoding/binary"
"encoding/json" "encoding/json"
"bytes" "errors"
) )
const headerSize int64 = 16 * 2 const headerSize int64 = 16 * 2
const sizeOfInt64 int = 8 const sizeOfInt64 int = 8
const magicCodeA int64 = 0xEE00ABBA const magicCodeA int64 = 0xEE00ABBA
const magicCodeB int64 = 0xEE44ABBA const magicCodeB int64 = 0xEE44ABBA
type Header struct { type Header struct {
magicCodeA int64 `json:"magicCodeA"` magicCodeA int64 `json:"magicCodeA"`
rpcSize int64 `json:"rpcSize"` rpcSize int64 `json:"rpcSize"`
binSize int64 `json:"binSize"` binSize int64 `json:"binSize"`
magicCodeB int64 `json:"magicCodeB"` magicCodeB int64 `json:"magicCodeB"`
} }
func NewHeader() *Header { func NewHeader() *Header {
return &Header{ return &Header{
magicCodeA: magicCodeA, magicCodeA: magicCodeA,
magicCodeB: magicCodeB, magicCodeB: magicCodeB,
} }
} }
func (hdr *Header) JSON() []byte { func (hdr *Header) JSON() []byte {
jBytes, _ := json.Marshal(hdr) jBytes, _ := json.Marshal(hdr)
return jBytes return jBytes
} }
func (hdr *Header) Pack() ([]byte, error) { func (hdr *Header) Pack() ([]byte, error) {
var err error var err error
headerBytes := make([]byte, 0, headerSize) headerBytes := make([]byte, 0, headerSize)
headerBuffer := bytes.NewBuffer(headerBytes) headerBuffer := bytes.NewBuffer(headerBytes)
magicCodeABytes := encoderI64(hdr.magicCodeA) magicCodeABytes := encoderI64(hdr.magicCodeA)
headerBuffer.Write(magicCodeABytes) headerBuffer.Write(magicCodeABytes)
rpcSizeBytes := encoderI64(hdr.rpcSize) rpcSizeBytes := encoderI64(hdr.rpcSize)
headerBuffer.Write(rpcSizeBytes) headerBuffer.Write(rpcSizeBytes)
binSizeBytes := encoderI64(hdr.binSize) binSizeBytes := encoderI64(hdr.binSize)
headerBuffer.Write(binSizeBytes) headerBuffer.Write(binSizeBytes)
magicCodeBBytes := encoderI64(hdr.magicCodeB) magicCodeBBytes := encoderI64(hdr.magicCodeB)
headerBuffer.Write(magicCodeBBytes) headerBuffer.Write(magicCodeBBytes)
return headerBuffer.Bytes(), Err(err) return headerBuffer.Bytes(), Err(err)
} }
func UnpackHeader(headerBytes []byte) (*Header, error) { func UnpackHeader(headerBytes []byte) (*Header, error) {
var err error var err error
header := NewHeader() header := NewHeader()
headerReader := bytes.NewReader(headerBytes) headerReader := bytes.NewReader(headerBytes)
magicCodeABytes := make([]byte, sizeOfInt64) magicCodeABytes := make([]byte, sizeOfInt64)
headerReader.Read(magicCodeABytes) headerReader.Read(magicCodeABytes)
header.magicCodeA = decoderI64(magicCodeABytes) header.magicCodeA = decoderI64(magicCodeABytes)
rpcSizeBytes := make([]byte, sizeOfInt64) rpcSizeBytes := make([]byte, sizeOfInt64)
headerReader.Read(rpcSizeBytes) headerReader.Read(rpcSizeBytes)
header.rpcSize = decoderI64(rpcSizeBytes) header.rpcSize = decoderI64(rpcSizeBytes)
binSizeBytes := make([]byte, sizeOfInt64) binSizeBytes := make([]byte, sizeOfInt64)
headerReader.Read(binSizeBytes) headerReader.Read(binSizeBytes)
header.binSize = decoderI64(binSizeBytes) header.binSize = decoderI64(binSizeBytes)
magicCodeBBytes := make([]byte, sizeOfInt64) magicCodeBBytes := make([]byte, sizeOfInt64)
headerReader.Read(magicCodeBBytes) headerReader.Read(magicCodeBBytes)
header.magicCodeB = decoderI64(magicCodeBBytes) header.magicCodeB = decoderI64(magicCodeBBytes)
if header.magicCodeA != magicCodeA || header.magicCodeB != magicCodeB { if header.magicCodeA != magicCodeA || header.magicCodeB != magicCodeB {
err = errors.New("wrong protocol magic code") err = errors.New("wrong protocol magic code")
return header, Err(err) return header, Err(err)
} }
return header, Err(err) return header, Err(err)
} }
func encoderI64(i int64) []byte { func encoderI64(i int64) []byte {
buffer := make([]byte, sizeOfInt64) buffer := make([]byte, sizeOfInt64)
binary.BigEndian.PutUint64(buffer, uint64(i)) binary.BigEndian.PutUint64(buffer, uint64(i))
return buffer return buffer
} }
func decoderI64(b []byte) int64 { func decoderI64(b []byte) int64 {
return int64(binary.BigEndian.Uint64(b)) return int64(binary.BigEndian.Uint64(b))
} }
logger.go
+14 -14
View File
@@ -7,39 +7,39 @@
package dsrpc package dsrpc
import ( import (
"fmt" "fmt"
"io" "io"
"os" "os"
"time" "time"
) )
var messageWriter io.Writer = os.Stdout var messageWriter io.Writer = os.Stdout
var accessWriter io.Writer = os.Stdout var accessWriter io.Writer = os.Stdout
func logDebug(messages ...any) { func logDebug(messages ...any) {
stamp := time.Now().Format(time.RFC3339) stamp := time.Now().Format(time.RFC3339)
fmt.Fprintln(messageWriter, stamp, "debug", messages) fmt.Fprintln(messageWriter, stamp, "debug", messages)
} }
func logInfo(messages ...any) { func logInfo(messages ...any) {
stamp := time.Now().Format(time.RFC3339) stamp := time.Now().Format(time.RFC3339)
fmt.Fprintln(messageWriter, stamp, "info", messages) fmt.Fprintln(messageWriter, stamp, "info", messages)
} }
func logError(messages ...any) { func logError(messages ...any) {
stamp := time.Now().Format(time.RFC3339) stamp := time.Now().Format(time.RFC3339)
fmt.Fprintln(messageWriter, stamp, "error", messages) fmt.Fprintln(messageWriter, stamp, "error", messages)
} }
func logAccess(messages ...any) { func logAccess(messages ...any) {
stamp := time.Now().Format(time.RFC3339) stamp := time.Now().Format(time.RFC3339)
fmt.Fprintln(accessWriter, stamp, "access", messages) fmt.Fprintln(accessWriter, stamp, "access", messages)
} }
func SetAccessWriter(writer io.Writer) { func SetAccessWriter(writer io.Writer) {
accessWriter = writer accessWriter = writer
} }
func SetMessageWriter(writer io.Writer) { func SetMessageWriter(writer io.Writer) {
messageWriter = writer messageWriter = writer
} }
midware.go
+12 -12
View File
@@ -5,25 +5,25 @@
package dsrpc package dsrpc
import ( import (
"time" "time"
) )
func LogRequest(context *Context) error { func LogRequest(context *Context) error {
var err error var err error
logDebug("request:", string(context.reqRPC.JSON())) logDebug("request:", string(context.reqRPC.JSON()))
return Err(err) return Err(err)
} }
func LogResponse(context *Context) error { func LogResponse(context *Context) error {
var err error var err error
logDebug("response:", string(context.resRPC.JSON())) logDebug("response:", string(context.resRPC.JSON()))
return Err(err) return Err(err)
} }
func LogAccess(context *Context) error { func LogAccess(context *Context) error {
var err error var err error
execTime := time.Now().Sub(context.start) execTime := time.Now().Sub(context.start)
login := string(context.AuthIdent()) login := string(context.AuthIdent())
logAccess(context.remoteHost, login, context.reqRPC.Method, execTime) logAccess(context.remoteHost, login, context.reqRPC.Method, execTime)
return Err(err) return Err(err)
} }
packet.go
+6 -6
View File
@@ -5,19 +5,19 @@
package dsrpc package dsrpc
import ( import (
"encoding/json" "encoding/json"
) )
type Packet struct { type Packet struct {
header []byte header []byte
rcpPayload []byte rcpPayload []byte
} }
func NewPacket() *Packet { func NewPacket() *Packet {
return &Packet{} return &Packet{}
} }
func (pkt *Packet) JSON() []byte { func (pkt *Packet) JSON() []byte {
jBytes, _ := json.Marshal(pkt) jBytes, _ := json.Marshal(pkt)
return jBytes return jBytes
} }
request.go
+12 -12
View File
@@ -7,28 +7,28 @@
package dsrpc package dsrpc
import ( import (
"encoding/json" "encoding/json"
encoder "github.com/vmihailenco/msgpack/v5" encoder "github.com/vmihailenco/msgpack/v5"
) )
type Request struct { type Request struct {
Method string `json:"method" msgpack:"method"` Method string `json:"method" msgpack:"method"`
Params any `json:"params,omitempty" msgpack:"params"` Params any `json:"params,omitempty" msgpack:"params"`
Auth *Auth `json:"auth,omitempty" msgpack:"auth"` Auth *Auth `json:"auth,omitempty" msgpack:"auth"`
} }
func NewRequest() *Request { func NewRequest() *Request {
req := &Request{} req := &Request{}
req.Auth = &Auth{} req.Auth = &Auth{}
return req return req
} }
func (req *Request) Pack() ([]byte, error) { func (req *Request) Pack() ([]byte, error) {
rBytes, err := encoder.Marshal(req) rBytes, err := encoder.Marshal(req)
return rBytes, Err(err) return rBytes, Err(err)
} }
func (req *Request) JSON() []byte { func (req *Request) JSON() []byte {
jBytes, _ := json.Marshal(req) jBytes, _ := json.Marshal(req)
return jBytes return jBytes
} }
response.go
+9 -10
View File
@@ -5,26 +5,25 @@
package dsrpc package dsrpc
import ( import (
"encoding/json" "encoding/json"
encoder "github.com/vmihailenco/msgpack/v5" encoder "github.com/vmihailenco/msgpack/v5"
) )
type Response struct { type Response struct {
Error string `json:"error" msgpack:"error"` Error string `json:"error" msgpack:"error"`
Result any `json:"result" msgpack:"result"` Result any `json:"result" msgpack:"result"`
} }
func NewResponse() *Response { func NewResponse() *Response {
return &Response{} return &Response{}
} }
func (resp *Response) JSON() []byte { func (resp *Response) JSON() []byte {
jBytes, _ := json.Marshal(resp) jBytes, _ := json.Marshal(resp)
return jBytes return jBytes
} }
func (resp *Response) Pack() ([]byte, error) { func (resp *Response) Pack() ([]byte, error) {
rBytes, err := encoder.Marshal(resp) rBytes, err := encoder.Marshal(resp)
return rBytes, Err(err) return rBytes, Err(err)
} }
server.go
+218 -220
View File
@@ -5,305 +5,303 @@
package dsrpc package dsrpc
import ( import (
"context" "context"
"errors" "errors"
"fmt" "fmt"
"io" "io"
"net" "net"
"sync" "sync"
"time" "time"
encoder "github.com/vmihailenco/msgpack/v5" encoder "github.com/vmihailenco/msgpack/v5"
) )
type HandlerFunc = func(*Context) error type HandlerFunc = func(*Context) error
type Service struct { type Service struct {
handlers map[string]HandlerFunc handlers map[string]HandlerFunc
ctx context.Context ctx context.Context
cancel context.CancelFunc cancel context.CancelFunc
wg *sync.WaitGroup wg *sync.WaitGroup
preMw []HandlerFunc preMw []HandlerFunc
postMw []HandlerFunc postMw []HandlerFunc
keepalive bool keepalive bool
kaTime time.Duration kaTime time.Duration
kaMtx sync.Mutex kaMtx sync.Mutex
} }
func NewService() *Service { func NewService() *Service {
rdrpc := &Service{} rdrpc := &Service{}
rdrpc.handlers = make(map[string]HandlerFunc) rdrpc.handlers = make(map[string]HandlerFunc)
ctx, cancel := context.WithCancel(context.Background()) ctx, cancel := context.WithCancel(context.Background())
rdrpc.ctx = ctx rdrpc.ctx = ctx
rdrpc.cancel = cancel rdrpc.cancel = cancel
var wg sync.WaitGroup var wg sync.WaitGroup
rdrpc.wg = &wg rdrpc.wg = &wg
rdrpc.preMw = make([]HandlerFunc, 0) rdrpc.preMw = make([]HandlerFunc, 0)
rdrpc.postMw = make([]HandlerFunc, 0) rdrpc.postMw = make([]HandlerFunc, 0)
return rdrpc return rdrpc
} }
func (svc *Service) PreMiddleware(mw HandlerFunc) { func (svc *Service) PreMiddleware(mw HandlerFunc) {
svc.preMw = append(svc.preMw, mw) svc.preMw = append(svc.preMw, mw)
} }
func (svc *Service) PostMiddleware(mw HandlerFunc) { func (svc *Service) PostMiddleware(mw HandlerFunc) {
svc.postMw = append(svc.postMw, mw) svc.postMw = append(svc.postMw, mw)
} }
func (svc *Service) Handler(method string, handler HandlerFunc) { func (svc *Service) Handler(method string, handler HandlerFunc) {
svc.handlers[method] = handler svc.handlers[method] = handler
} }
func (svc *Service) SetKeepAlive(flag bool) { func (svc *Service) SetKeepAlive(flag bool) {
svc.kaMtx.Lock() svc.kaMtx.Lock()
defer svc.kaMtx.Unlock() defer svc.kaMtx.Unlock()
svc.keepalive = true svc.keepalive = true
} }
func (svc *Service) SetKeepAlivePeriod(interval time.Duration) { func (svc *Service) SetKeepAlivePeriod(interval time.Duration) {
svc.kaMtx.Lock() svc.kaMtx.Lock()
defer svc.kaMtx.Unlock() defer svc.kaMtx.Unlock()
svc.kaTime = interval svc.kaTime = interval
} }
func (svc *Service) Listen(address string) error { func (svc *Service) Listen(address string) error {
var err error var err error
logInfo("server listen:", address) logInfo("server listen:", address)
addr, err := net.ResolveTCPAddr("tcp", address) addr, err := net.ResolveTCPAddr("tcp", address)
if err != nil { if err != nil {
err = fmt.Errorf("unable to resolve adddress: %s", err) err = fmt.Errorf("unable to resolve adddress: %s", err)
return err return err
} }
listener, err := net.ListenTCP("tcp", addr) listener, err := net.ListenTCP("tcp", addr)
if err != nil { if err != nil {
err = fmt.Errorf("unable to start listener: %s", err) err = fmt.Errorf("unable to start listener: %s", err)
return err return err
} }
for { for {
conn, err := listener.AcceptTCP() conn, err := listener.AcceptTCP()
if err != nil { if err != nil {
logError("conn accept err:", err) logError("conn accept err:", err)
} }
select { select {
case <-svc.ctx.Done(): case <-svc.ctx.Done():
return err return err
default: default:
} }
svc.wg.Add(1) svc.wg.Add(1)
go svc.handleConn(conn, svc.wg) go svc.handleConn(conn, svc.wg)
} }
return err return err
} }
func notFound(context *Context) error { func notFound(context *Context) error {
execErr := errors.New("method not found") execErr := errors.New("method not found")
err := context.SendError(execErr) err := context.SendError(execErr)
return err return err
} }
func (svc *Service) Stop() error { func (svc *Service) Stop() error {
var err error var err error
// Disable new connection // Disable new connection
logInfo("cancel rpc accept loop") logInfo("cancel rpc accept loop")
svc.cancel() svc.cancel()
// Wait handlers // Wait handlers
logInfo("wait rpc handlers") logInfo("wait rpc handlers")
svc.wg.Wait() svc.wg.Wait()
return err return err
} }
func (svc *Service) handleConn(conn *net.TCPConn, wg *sync.WaitGroup) { func (svc *Service) handleConn(conn *net.TCPConn, wg *sync.WaitGroup) {
var err error var err error
if svc.keepalive { if svc.keepalive {
err = conn.SetKeepAlive(true) err = conn.SetKeepAlive(true)
if err != nil { if err != nil {
err = fmt.Errorf("unable to set keepalive: %s", err) err = fmt.Errorf("unable to set keepalive: %s", err)
return return
} }
if svc.kaTime > 0 { if svc.kaTime > 0 {
err = conn.SetKeepAlivePeriod(svc.kaTime) err = conn.SetKeepAlivePeriod(svc.kaTime)
if err != nil { if err != nil {
err = fmt.Errorf("unable to set keepalive period: %s", err) err = fmt.Errorf("unable to set keepalive period: %s", err)
return return
} }
} }
} }
context := CreateContext(conn) context := CreateContext(conn)
remoteAddr := conn.RemoteAddr().String() remoteAddr := conn.RemoteAddr().String()
remoteHost, _, _ := net.SplitHostPort(remoteAddr) remoteHost, _, _ := net.SplitHostPort(remoteAddr)
context.remoteHost = remoteHost context.remoteHost = remoteHost
context.binReader = conn context.binReader = conn
context.binWriter = io.Discard context.binWriter = io.Discard
exitFunc := func() { exitFunc := func() {
conn.Close() conn.Close()
wg.Done() wg.Done()
if err != nil { if err != nil {
logError("conn handler err:", err) logError("conn handler err:", err)
} }
} }
defer exitFunc() defer exitFunc()
recovFunc := func () { recovFunc := func() {
panicMsg := recover() panicMsg := recover()
if panicMsg != nil { if panicMsg != nil {
logError("handler panic message:", panicMsg) logError("handler panic message:", panicMsg)
} }
} }
defer recovFunc() defer recovFunc()
err = context.ReadRequest() err = context.ReadRequest()
if err != nil { if err != nil {
err = Err(err) err = Err(err)
return return
} }
err = context.BindMethod() err = context.BindMethod()
if err != nil { if err != nil {
err = Err(err) err = Err(err)
return return
} }
for _, mw := range svc.preMw { for _, mw := range svc.preMw {
err = mw(context) err = mw(context)
if err != nil { if err != nil {
err = Err(err) err = Err(err)
return return
} }
} }
err = svc.Route(context) err = svc.Route(context)
if err != nil { if err != nil {
err = Err(err) err = Err(err)
return return
} }
for _, mw := range svc.postMw { for _, mw := range svc.postMw {
err = mw(context) err = mw(context)
if err != nil { if err != nil {
err = Err(err) err = Err(err)
return return
} }
} }
return return
} }
func (svc *Service) Route(context *Context) error { func (svc *Service) Route(context *Context) error {
handler, ok := svc.handlers[context.reqRPC.Method] handler, ok := svc.handlers[context.reqRPC.Method]
if ok { if ok {
return Err(handler(context)) return Err(handler(context))
} }
return Err(notFound(context)) return Err(notFound(context))
} }
func (context *Context) ReadRequest() error { func (context *Context) ReadRequest() error {
var err error var err error
context.reqPacket.header, err = ReadBytes(context.sockReader, headerSize) context.reqPacket.header, err = ReadBytes(context.sockReader, headerSize)
if err != nil { if err != nil {
return Err(err) return Err(err)
} }
context.reqHeader, err = UnpackHeader(context.reqPacket.header) context.reqHeader, err = UnpackHeader(context.reqPacket.header)
if err != nil { if err != nil {
return Err(err) return Err(err)
} }
rpcSize := context.reqHeader.rpcSize rpcSize := context.reqHeader.rpcSize
context.reqPacket.rcpPayload, err = ReadBytes(context.sockReader, rpcSize) context.reqPacket.rcpPayload, err = ReadBytes(context.sockReader, rpcSize)
if err != nil { if err != nil {
return Err(err) return Err(err)
} }
return Err(err) return Err(err)
} }
func (context *Context) BinWriter() io.Writer { func (context *Context) BinWriter() io.Writer {
return context.sockWriter return context.sockWriter
} }
func (context *Context) BinReader() io.Reader { func (context *Context) BinReader() io.Reader {
return context.sockReader return context.sockReader
} }
func (context *Context) BinSize() int64 { func (context *Context) BinSize() int64 {
return context.reqHeader.binSize return context.reqHeader.binSize
} }
func (context *Context) ReadBin(writer io.Writer) error { func (context *Context) ReadBin(writer io.Writer) error {
var err error var err error
_, err = CopyBytes(context.sockReader, writer, context.reqHeader.binSize) _, err = CopyBytes(context.sockReader, writer, context.reqHeader.binSize)
return Err(err) return Err(err)
} }
func (context *Context) BindMethod() error { func (context *Context) BindMethod() error {
var err error var err error
err = encoder.Unmarshal(context.reqPacket.rcpPayload, context.reqRPC) err = encoder.Unmarshal(context.reqPacket.rcpPayload, context.reqRPC)
return Err(err) return Err(err)
} }
func (context *Context) BindParams(params any) error { func (context *Context) BindParams(params any) error {
var err error var err error
context.reqRPC.Params = params context.reqRPC.Params = params
err = encoder.Unmarshal(context.reqPacket.rcpPayload, context.reqRPC) err = encoder.Unmarshal(context.reqPacket.rcpPayload, context.reqRPC)
if err != nil { if err != nil {
return Err(err) return Err(err)
} }
return Err(err) return Err(err)
} }
func (context *Context) SendResult(result any, binSize int64) error { func (context *Context) SendResult(result any, binSize int64) error {
var err error var err error
context.resRPC.Result = result context.resRPC.Result = result
context.resPacket.rcpPayload, err = context.resRPC.Pack() context.resPacket.rcpPayload, err = context.resRPC.Pack()
if err != nil { if err != nil {
return Err(err) return Err(err)
} }
context.resHeader.rpcSize = int64(len(context.resPacket.rcpPayload)) context.resHeader.rpcSize = int64(len(context.resPacket.rcpPayload))
context.resHeader.binSize = binSize context.resHeader.binSize = binSize
context.resPacket.header, err = context.resHeader.Pack() context.resPacket.header, err = context.resHeader.Pack()
if err != nil { if err != nil {
return Err(err) return Err(err)
} }
_, err = context.sockWriter.Write(context.resPacket.header) _, err = context.sockWriter.Write(context.resPacket.header)
if err != nil { if err != nil {
return Err(err) return Err(err)
} }
_, err = context.sockWriter.Write(context.resPacket.rcpPayload) _, err = context.sockWriter.Write(context.resPacket.rcpPayload)
if err != nil { if err != nil {
return Err(err) return Err(err)
} }
return Err(err) return Err(err)
} }
func (context *Context) SendError(execErr error) error { func (context *Context) SendError(execErr error) error {
var err error var err error
context.resRPC.Error = execErr.Error() context.resRPC.Error = execErr.Error()
context.resRPC.Result = NewEmpty() context.resRPC.Result = NewEmpty()
context.resPacket.rcpPayload, err = context.resRPC.Pack() context.resPacket.rcpPayload, err = context.resRPC.Pack()
if err != nil { if err != nil {
return Err(err) return Err(err)
} }
context.resHeader.rpcSize = int64(len(context.resPacket.rcpPayload)) context.resHeader.rpcSize = int64(len(context.resPacket.rcpPayload))
context.resPacket.header, err = context.resHeader.Pack() context.resPacket.header, err = context.resHeader.Pack()
if err != nil { if err != nil {
return Err(err) return Err(err)
} }
_, err = context.sockWriter.Write(context.resPacket.header) _, err = context.sockWriter.Write(context.resPacket.header)
if err != nil { if err != nil {
return Err(err) return Err(err)
} }
_, err = context.sockWriter.Write(context.resPacket.rcpPayload) _, err = context.sockWriter.Write(context.resPacket.rcpPayload)
if err != nil { if err != nil {
return Err(err) return Err(err)
} }
return Err(err) return Err(err)
} }
tools.go
+42 -42
View File
@@ -5,53 +5,53 @@
package dsrpc package dsrpc
import ( import (
"errors" "errors"
"io" "fmt"
"fmt" "io"
) )
func ReadBytes(reader io.Reader, size int64) ([]byte, error) { func ReadBytes(reader io.Reader, size int64) ([]byte, error) {
buffer := make([]byte, size) buffer := make([]byte, size)
read, err := io.ReadFull(reader, buffer) read, err := io.ReadFull(reader, buffer)
return buffer[0:read], Err(err) return buffer[0:read], Err(err)
} }
func CopyBytes(reader io.Reader, writer io.Writer, dataSize int64) (int64, error) { func CopyBytes(reader io.Reader, writer io.Writer, dataSize int64) (int64, error) {
var err error var err error
var bSize int64 = 1024 * 16 var bSize int64 = 1024 * 16
var total int64 = 0 var total int64 = 0
var remains int64 = dataSize var remains int64 = dataSize
buffer := make([]byte, bSize) buffer := make([]byte, bSize)
for { for {
if reader == nil { if reader == nil {
return total, errors.New("reader is nil") return total, errors.New("reader is nil")
} }
if writer == nil { if writer == nil {
return total, errors.New("writer is nil") return total, errors.New("writer is nil")
} }
if remains == 0 { if remains == 0 {
return total, err return total, err
} }
if remains < bSize { if remains < bSize {
bSize = remains bSize = remains
} }
received, err := reader.Read(buffer[0:bSize]) received, err := reader.Read(buffer[0:bSize])
if err != nil { if err != nil {
err = fmt.Errorf("read error: %v", err) err = fmt.Errorf("read error: %v", err)
return total, Err(err) return total, Err(err)
} }
recorded, err := writer.Write(buffer[0:received]) recorded, err := writer.Write(buffer[0:received])
if err != nil { if err != nil {
err = fmt.Errorf("write error: %v", err) err = fmt.Errorf("write error: %v", err)
return total, Err(err) return total, Err(err)
} }
if recorded != received { if recorded != received {
err = errors.New("size mismatch") err = errors.New("size mismatch")
return total, Err(err) return total, Err(err)
} }
total += int64(recorded) total += int64(recorded)
remains -= int64(recorded) remains -= int64(recorded)
} }
return total, Err(err) return total, Err(err)
} }
validate.go
+124 -126
View File
@@ -4,161 +4,159 @@
package dsrpc package dsrpc
import ( import (
"io" "io"
"net" "net"
) )
func LocalExec(method string, param any, result any, auth *Auth, handler HandlerFunc) error { func LocalExec(method string, param any, result any, auth *Auth, handler HandlerFunc) error {
var err error var err error
cliConn, srvConn := NewFConn() cliConn, srvConn := NewFConn()
context := CreateContext(cliConn) context := CreateContext(cliConn)
context.reqRPC.Method = method context.reqRPC.Method = method
context.reqRPC.Params = param context.reqRPC.Params = param
context.reqRPC.Auth = auth context.reqRPC.Auth = auth
context.resRPC.Result = result context.resRPC.Result = result
if context.reqRPC.Params == nil { if context.reqRPC.Params == nil {
context.reqRPC.Params = NewEmpty() context.reqRPC.Params = NewEmpty()
} }
err = context.CreateRequest() err = context.CreateRequest()
if err != nil { if err != nil {
return err return err
} }
err = context.WriteRequest() err = context.WriteRequest()
if err != nil { if err != nil {
return err return err
} }
err = LocalService(srvConn, handler) err = LocalService(srvConn, handler)
if err != nil { if err != nil {
return err return err
} }
err = context.ReadResponse() err = context.ReadResponse()
if err != nil { if err != nil {
return err return err
} }
err = context.BindResponse() err = context.BindResponse()
if err != nil { if err != nil {
return err return err
} }
return err return err
} }
func LocalPut(method string, reader io.Reader, size int64, param, result any, auth *Auth, handler HandlerFunc) error { func LocalPut(method string, reader io.Reader, size int64, param, result any, auth *Auth, handler HandlerFunc) error {
var err error var err error
cliConn, srvConn := NewFConn() cliConn, srvConn := NewFConn()
context := CreateContext(cliConn) context := CreateContext(cliConn)
context.reqRPC.Method = method context.reqRPC.Method = method
context.reqRPC.Params = param context.reqRPC.Params = param
context.reqRPC.Auth = auth context.reqRPC.Auth = auth
context.resRPC.Result = result context.resRPC.Result = result
context.binReader = reader context.binReader = reader
context.binWriter = cliConn context.binWriter = cliConn
context.reqHeader.binSize = size context.reqHeader.binSize = size
if context.reqRPC.Params == nil { if context.reqRPC.Params == nil {
context.reqRPC.Params = NewEmpty() context.reqRPC.Params = NewEmpty()
} }
err = context.CreateRequest() err = context.CreateRequest()
if err != nil { if err != nil {
return err return err
} }
err = context.WriteRequest() err = context.WriteRequest()
if err != nil { if err != nil {
return err return err
} }
err = context.UploadBin() err = context.UploadBin()
if err != nil { if err != nil {
return err return err
} }
err = LocalService(srvConn, handler) err = LocalService(srvConn, handler)
if err != nil { if err != nil {
return err return err
} }
err = context.ReadResponse() err = context.ReadResponse()
if err != nil { if err != nil {
return err return err
} }
err = context.BindResponse() err = context.BindResponse()
if err != nil { if err != nil {
return err return err
} }
return err return err
} }
func LocalGet(method string, writer io.Writer, param, result any, auth *Auth, handler HandlerFunc) error { func LocalGet(method string, writer io.Writer, param, result any, auth *Auth, handler HandlerFunc) error {
var err error var err error
cliConn, srvConn := NewFConn() cliConn, srvConn := NewFConn()
context := CreateContext(cliConn) context := CreateContext(cliConn)
context.reqRPC.Method = method context.reqRPC.Method = method
context.reqRPC.Params = param context.reqRPC.Params = param
context.reqRPC.Auth = auth context.reqRPC.Auth = auth
context.resRPC.Result = result context.resRPC.Result = result
context.binReader = cliConn context.binReader = cliConn
context.binWriter = writer context.binWriter = writer
if context.reqRPC.Params == nil { if context.reqRPC.Params == nil {
context.reqRPC.Params = NewEmpty() context.reqRPC.Params = NewEmpty()
} }
err = context.CreateRequest() err = context.CreateRequest()
if err != nil { if err != nil {
return err return err
} }
err = context.WriteRequest() err = context.WriteRequest()
if err != nil { if err != nil {
return err return err
} }
err = LocalService(srvConn, handler) err = LocalService(srvConn, handler)
if err != nil { if err != nil {
return err return err
} }
err = context.ReadResponse() err = context.ReadResponse()
if err != nil { if err != nil {
return err return err
} }
err = context.DownloadBin() err = context.DownloadBin()
if err != nil { if err != nil {
return err return err
} }
err = context.BindResponse() err = context.BindResponse()
if err != nil { if err != nil {
return err return err
} }
return err return err
} }
func LocalService(conn net.Conn, handler HandlerFunc) error { func LocalService(conn net.Conn, handler HandlerFunc) error {
var err error var err error
context := CreateContext(conn) context := CreateContext(conn)
remoteAddr := conn.RemoteAddr().String() remoteAddr := conn.RemoteAddr().String()
remoteHost, _, _ := net.SplitHostPort(remoteAddr) remoteHost, _, _ := net.SplitHostPort(remoteAddr)
context.remoteHost = remoteHost context.remoteHost = remoteHost
context.binReader = conn context.binReader = conn
context.binWriter = io.Discard context.binWriter = io.Discard
err = context.ReadRequest() err = context.ReadRequest()
if err != nil { if err != nil {
return err return err
} }
err = context.BindMethod() err = context.BindMethod()
if err != nil { if err != nil {
return err return err
} }
return handler(context) return handler(context)
} }
xauth.go
+32 -32
View File
@@ -5,60 +5,60 @@
package dsrpc package dsrpc
import ( import (
"encoding/json" "bytes"
"bytes" "crypto/sha256"
"math/rand" "encoding/json"
"time" "math/rand"
"crypto/sha256" "time"
) )
func init() { func init() {
rand.Seed(time.Now().UnixNano()) rand.Seed(time.Now().UnixNano())
} }
type Auth struct { type Auth struct {
Ident []byte `msgpack:"ident" json:"ident"` Ident []byte `msgpack:"ident" json:"ident"`
Salt []byte `msgpack:"salt" json:"salt"` Salt []byte `msgpack:"salt" json:"salt"`
Hash []byte `msgpack:"hash" json:"hash"` Hash []byte `msgpack:"hash" json:"hash"`
} }
func NewAuth() *Auth { func NewAuth() *Auth {
return &Auth{} return &Auth{}
} }
func (this *Auth) JSON() []byte { func (this *Auth) JSON() []byte {
jBytes, _ := json.Marshal(this) jBytes, _ := json.Marshal(this)
return jBytes return jBytes
} }
func CreateAuth(ident, pass []byte) *Auth { func CreateAuth(ident, pass []byte) *Auth {
salt := CreateSalt() salt := CreateSalt()
hash := CreateHash(ident, pass, salt) hash := CreateHash(ident, pass, salt)
auth := &Auth{} auth := &Auth{}
auth.Ident = ident auth.Ident = ident
auth.Salt = salt auth.Salt = salt
auth.Hash = hash auth.Hash = hash
return auth return auth
} }
func CreateSalt() []byte { func CreateSalt() []byte {
const saltSize = 16 const saltSize = 16
randBytes := make([]byte, saltSize) randBytes := make([]byte, saltSize)
rand.Read(randBytes) rand.Read(randBytes)
return randBytes return randBytes
} }
func CreateHash(ident, pass, salt []byte) []byte { func CreateHash(ident, pass, salt []byte) []byte {
vec := make([]byte, 0, len(ident) + len(salt) + len(pass)) vec := make([]byte, 0, len(ident)+len(salt)+len(pass))
vec = append(vec, ident...) vec = append(vec, ident...)
vec = append(vec, salt...) vec = append(vec, salt...)
vec = append(vec, pass...) vec = append(vec, pass...)
hasher := sha256.New() hasher := sha256.New()
hash := hasher.Sum(vec) hash := hasher.Sum(vec)
return hash return hash
} }
func CheckHash(ident, pass, reqSalt, reqHash []byte) bool { func CheckHash(ident, pass, reqSalt, reqHash []byte) bool {
localHash := CreateHash(ident, pass, reqSalt) localHash := CreateHash(ident, pass, reqSalt)
return bytes.Equal(reqHash, localHash) return bytes.Equal(reqHash, localHash)
} }