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

Compare commits

base: ziggi:v1.3.3
Branches Tags
ziggi:master
ziggi:v1.3.4 ziggi:v1.3.3 ziggi:v1.3.2 ziggi:v1.3.1 ziggi:v1.3.0 ziggi:v1.2.2 ziggi:v1.2.1 ziggi:v1.2.0 ziggi:v1.1.3 ziggi:v1.1.4 ziggi:v1.1.2 ziggi:v1.1.1 ziggi:v1.1.0 ziggi:v1.0.6 ziggi:v1.0.1 ziggi:v1.0.2 ziggi:v1.0.3 ziggi:v1.0.4 ziggi:v1.0.5
...
compare: ziggi:master
Branches Tags
ziggi:master
ziggi:v1.3.4 ziggi:v1.3.3 ziggi:v1.3.2 ziggi:v1.3.1 ziggi:v1.3.0 ziggi:v1.2.2 ziggi:v1.2.1 ziggi:v1.2.0 ziggi:v1.1.3 ziggi:v1.1.4 ziggi:v1.1.2 ziggi:v1.1.1 ziggi:v1.1.0 ziggi:v1.0.6 ziggi:v1.0.1 ziggi:v1.0.2 ziggi:v1.0.3 ziggi:v1.0.4 ziggi:v1.0.5

1 Commits
v1.3.3 ... master

Author SHA1 Message Date
Oleg Borodin
498abc18b4 delete timestamp from logger 2023-05-18 13:44:39 +02:00
2 changed files with 251 additions and 270 deletions
Expand all files Collapse all files

494
exec_test.go
View File

@@ -5,26 +5,26 @@
package dsrpc package dsrpc
import ( import (
"bytes" "bytes"
"context" "context"
"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"
) )
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"`
} }
type HelloResult struct { type HelloResult struct {
Message string `json:"message" msgpack:"message"` Message string `json:"message" msgpack:"message"`
} }
const SaveMethod string = "save" const SaveMethod string = "save"
@@ -38,342 +38,342 @@ type LoadParams HelloParams
type LoadResult HelloResult type LoadResult HelloResult
func TestLocalExec(t *testing.T) { func TestLocalExec(t *testing.T) {
var err error var err error
params := HelloParams{} params := HelloParams{}
params.Message = "hello server!" params.Message = "hello server!"
result := HelloResult{} result := HelloResult{}
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 := SaveParams{} params := SaveParams{}
params.Message = "save data!" params.Message = "save data!"
result := SaveResult{} result := SaveResult{}
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)
timeout := time.Duration(5 * time.Second) timeout := time.Duration(5 * time.Second)
ctx, cancel := context.WithTimeout(context.Background(), timeout) ctx, cancel := context.WithTimeout(context.Background(), timeout)
defer cancel() defer cancel()
err = LocalPut(ctx, SaveMethod, reader, binSize, &params, &result, auth, saveHandler) err = LocalPut(ctx, 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 := LoadParams{} params := LoadParams{}
params.Message = "load data!" params.Message = "load data!"
result := LoadResult{} result := LoadResult{}
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)
timeout := time.Duration(5 * time.Second) timeout := time.Duration(5 * time.Second)
ctx, cancel := context.WithTimeout(context.Background(), timeout) ctx, cancel := context.WithTimeout(context.Background(), timeout)
defer cancel() defer cancel()
err = LocalGet(ctx, LoadMethod, writer, &params, &result, auth, loadHandler) err = LocalGet(ctx, 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(100 * time.Millisecond) time.Sleep(100 * 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(100 * time.Millisecond) time.Sleep(100 * 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(100 * time.Millisecond) time.Sleep(100 * 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(1000 * time.Millisecond) time.Sleep(1000 * time.Millisecond)
clientSave() clientSave()
pBench := func(pb *testing.PB) { pBench := func(pb *testing.PB) {
for pb.Next() { for pb.Next() {
clientSave() clientSave()
} }
} }
b.SetParallelism(2000) b.SetParallelism(2000)
b.RunParallel(pBench) b.RunParallel(pBench)
} }
func clientHello() error { func clientHello() error {
var err error var err error
params := HelloParams{} params := HelloParams{}
params.Message = "hello server!" params.Message = "hello server!"
result := HelloResult{} result := HelloResult{}
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)
timeout := time.Duration(5 * time.Second) timeout := time.Duration(5 * time.Second)
ctx, cancel := context.WithTimeout(context.Background(), timeout) ctx, cancel := context.WithTimeout(context.Background(), timeout)
defer cancel() defer cancel()
err = Exec(ctx, "127.0.0.1:18081", HelloMethod, &params, &result, auth) err = Exec(ctx, "127.0.0.1:18081", 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 := SaveParams{} params := SaveParams{}
params.Message = "save data!" params.Message = "save data!"
result := SaveResult{} result := SaveResult{}
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)
timeout := time.Duration(5 * time.Second) timeout := time.Duration(5 * time.Second)
ctx, cancel := context.WithTimeout(context.Background(), timeout) ctx, cancel := context.WithTimeout(context.Background(), timeout)
defer cancel() defer cancel()
err = Put(ctx, "127.0.0.1:18081", SaveMethod, reader, binSize, &params, &result, auth) err = Put(ctx, "127.0.0.1:18081", 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 := LoadParams{} params := LoadParams{}
params.Message = "load data!" params.Message = "load data!"
result := LoadResult{} result := LoadResult{}
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)
timeout := time.Duration(5 * time.Second) timeout := time.Duration(5 * time.Second)
ctx, cancel := context.WithTimeout(context.Background(), timeout) ctx, cancel := context.WithTimeout(context.Background(), timeout)
defer cancel() defer cancel()
err = Get(ctx, "127.0.0.1:18081", LoadMethod, writer, &params, &result, auth) err = Get(ctx, "127.0.0.1:18081", LoadMethod, writer, &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))
logDebug("bin size:", len(writer.Bytes())) logDebug("bin size:", len(writer.Bytes()))
return err 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.Handle(HelloMethod, helloHandler) serv.Handle(HelloMethod, helloHandler)
serv.Handle(SaveMethod, saveHandler) serv.Handle(SaveMethod, saveHandler)
serv.Handle(LoadMethod, loadHandler) serv.Handle(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(":18081") err = serv.Listen(":18081")
if err != nil { if err != nil {
return err return err
} }
return err return err
} }
func auth(content *Content) error { func auth(content *Content) error {
var err error var err error
reqIdent := content.AuthIdent() reqIdent := content.AuthIdent()
reqSalt := content.AuthSalt() reqSalt := content.AuthSalt()
reqHash := content.AuthHash() reqHash := content.AuthHash()
ident := reqIdent ident := reqIdent
pass := []byte("12345") pass := []byte("12345")
auth := content.Auth() auth := content.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")
content.SendError(err) content.SendError(err)
return err return err
} }
return err return err
} }
func helloHandler(content *Content) error { func helloHandler(content *Content) error {
var err error var err error
params := HelloParams{} params := HelloParams{}
err = content.BindParams(&params) err = content.BindParams(&params)
if err != nil { if err != nil {
return err return err
} }
timeout := time.Duration(5 * time.Second) timeout := time.Duration(5 * time.Second)
ctx, cancel := context.WithTimeout(context.Background(), timeout) ctx, cancel := context.WithTimeout(context.Background(), timeout)
defer cancel() defer cancel()
err = content.ReadBin(ctx, io.Discard) err = content.ReadBin(ctx, io.Discard)
if err != nil { if err != nil {
content.SendError(err) content.SendError(err)
return err return err
} }
result := HelloResult{} result := HelloResult{}
result.Message = "hello, client!" result.Message = "hello, client!"
err = content.SendResult(result, 0) err = content.SendResult(result, 0)
if err != nil { if err != nil {
return err return err
} }
return err return err
} }
func saveHandler(content *Content) error { func saveHandler(content *Content) error {
var err error var err error
params := SaveParams{} params := SaveParams{}
err = content.BindParams(&params) err = content.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)
timeout := time.Duration(5 * time.Second) timeout := time.Duration(5 * time.Second)
ctx, cancel := context.WithTimeout(context.Background(), timeout) ctx, cancel := context.WithTimeout(context.Background(), timeout)
defer cancel() defer cancel()
err = content.ReadBin(ctx, binWriter) err = content.ReadBin(ctx, binWriter)
if err != nil { if err != nil {
content.SendError(err) content.SendError(err)
return err return err
} }
result := SaveResult{} result := SaveResult{}
result.Message = "saved successfully!" result.Message = "saved successfully!"
err = content.SendResult(result, 0) err = content.SendResult(result, 0)
if err != nil { if err != nil {
return err return err
} }
return err return err
} }
func loadHandler(content *Content) error { func loadHandler(content *Content) error {
var err error var err error
params := SaveParams{} params := SaveParams{}
err = content.BindParams(&params) err = content.BindParams(&params)
if err != nil { if err != nil {
return err return err
} }
timeout := time.Duration(5 * time.Second) timeout := time.Duration(5 * time.Second)
ctx, cancel := context.WithTimeout(context.Background(), timeout) ctx, cancel := context.WithTimeout(context.Background(), timeout)
defer cancel() defer cancel()
err = content.ReadBin(ctx, io.Discard) err = content.ReadBin(ctx, io.Discard)
if err != nil { if err != nil {
content.SendError(err) content.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 := SaveResult{} result := SaveResult{}
result.Message = "load successfully!" result.Message = "load successfully!"
err = content.SendResult(result, binSize) err = content.SendResult(result, binSize)
if err != nil { if err != nil {
return err return err
} }
binWriter := content.BinWriter() binWriter := content.BinWriter()
_, err = CopyBytes(ctx, binReader, binWriter, binSize) _, err = CopyBytes(ctx, binReader, binWriter, binSize)
if err != nil { if err != nil {
return err return err
} }
return err return err
} }

27
logger.go
View File

@@ -10,41 +10,27 @@ import (
"fmt" "fmt"
"io" "io"
"os" "os"
"time"
) )
var ( var (
messageWriter io.Writer = os.Stdout messageWriter io.Writer = os.Stdout
accessWriter io.Writer = os.Stdout accessWriter io.Writer = os.Stdout
logTimestamp bool = false
) )
func getLogStamp() string {
var stamp string
if logTimestamp {
stamp = time.Now().Format(time.RFC3339)
}
return stamp
}
func logDebug(messages ...any) { func logDebug(messages ...any) {
stamp := getLogStamp() fmt.Fprintln(messageWriter, "debug:", messages)
fmt.Fprintln(messageWriter, stamp, "debug", messages)
} }
func logInfo(messages ...any) { func logInfo(messages ...any) {
stamp := getLogStamp() fmt.Fprintln(messageWriter, "info:", messages)
fmt.Fprintln(messageWriter, stamp, "info", messages)
} }
func logError(messages ...any) { func logError(messages ...any) {
stamp := getLogStamp() fmt.Fprintln(messageWriter, "error:", messages)
fmt.Fprintln(messageWriter, stamp, "error", messages)
} }
func logAccess(messages ...any) { func logAccess(messages ...any) {
stamp := getLogStamp() fmt.Fprintln(accessWriter, "access:", messages)
fmt.Fprintln(accessWriter, stamp, "access", messages)
} }
func SetAccessWriter(writer io.Writer) { func SetAccessWriter(writer io.Writer) {
@@ -54,8 +40,3 @@ func SetAccessWriter(writer io.Writer) {
func SetMessageWriter(writer io.Writer) { func SetMessageWriter(writer io.Writer) {
messageWriter = writer messageWriter = writer
} }
func EnableLogTimestamp(enable bool) {
logTimestamp = enable
}