added listener close()

client.go

@@ -6,13 +6,14 @@ package dsrpc
 
 import (
 	"context"
+	"crypto/tls"
 	"errors"
 	"fmt"
 	"io"
 	"net"
 	"sync"
 
-	encoder "github.com/vmihailenco/msgpack/v5"
+	encoder "encoding/json"
 )
 
 func Put(ctx context.Context, address string, method string, reader io.Reader, binSize int64, param, result any, auth *Auth) error {
@@ -32,6 +33,18 @@ func Put(ctx context.Context, address string, method string, reader io.Reader, b
 	return ConnPut(ctx, conn, method, reader, binSize, param, result, auth)
 }
 
+func PutTLS(ctx context.Context, tlsConfig *tls.Config, address string, method string, reader io.Reader, binSize int64, param, result any, auth *Auth) error {
+	var err error
+
+	conn, err := tls.Dial("tcp", address, tlsConfig)
+	if err != nil {
+		return err
+	}
+	defer conn.Close()
+
+	return ConnPut(ctx, conn, method, reader, binSize, param, result, auth)
+}
+
 func ConnPut(ctx context.Context, conn net.Conn, method string, reader io.Reader, binSize int64, param, result any, auth *Auth) error {
 	var err error
 	content := CreateContent(conn)
@@ -99,6 +112,18 @@ func Get(ctx context.Context, address string, method string, writer io.Writer, p
 	return ConnGet(ctx, conn, method, writer, param, result, auth)
 }
 
+func GetTLS(ctx context.Context, tlsConfig *tls.Config, address string, method string, writer io.Writer, param, result any, auth *Auth) error {
+	var err error
+
+	conn, err := tls.Dial("tcp", address, tlsConfig)
+	if err != nil {
+		return err
+	}
+	defer conn.Close()
+
+	return ConnGet(ctx, conn, method, writer, param, result, auth)
+}
+
 func ConnGet(ctx context.Context, conn net.Conn, method string, writer io.Writer, param, result any, auth *Auth) error {
 	var err error
 
@@ -161,6 +186,22 @@ func Exec(ctx context.Context, address, method string, param any, result any, au
 	return err
 }
 
+func ExecTLS(ctx context.Context, tlsConfig *tls.Config, address, method string, param any, result any, auth *Auth) error {
+	var err error
+
+	conn, err := tls.Dial("tcp", address, tlsConfig)
+	if err != nil {
+		return err
+	}
+	defer conn.Close()
+
+	err = ConnExec(ctx, conn, method, param, result, auth)
+	if err != nil {
+		return err
+	}
+	return err
+}
+
 func ConnExec(ctx context.Context, conn net.Conn, method string, param any, result any, auth *Auth) error {
 	var err error
 

example/cli/netcli.go

@@ -7,33 +7,40 @@
 package main
 
 import (
-    "fmt"
+	"context"
-    "github.com/kindsoldier/dsrpc"
+	"fmt"
-    "netsrv/api"
+	"time"
+
+	"github.com/kindsoldier/dsrpc"
+
+	"netsrv/api"
 )
 
 func main() {
 
-    err := exec()
+	err := exec()
-    if err != nil {
+	if err != nil {
-        fmt.Println("exec err:", err)
+		fmt.Println("exec err:", err)
-    }
+	}
 }
 
 func exec() error {
-    var err error
+	var err error
 
-    params := api.HelloParams{
+	params := api.HelloParams{
-        Message: "hello, server!",
+		Message: "hello, server!",
-    }
+	}
 
-    result := api.HelloResult{}
+	result := api.HelloResult{}
 
-    err = dsrpc.Exec("127.0.0.1:8081", api.HelloMethod, &params, &result, nil)
+	ctx, cancel := context.WithTimeout(context.Background(), time.Duration(5*time.Second))
-    if err != nil {
+	defer cancel()
-        return err
-    }
 
-    fmt.Println("result:", result.Message)
+	err = dsrpc.Exec(ctx, "127.0.0.1:8081", api.HelloMethod, &params, &result, nil)
-    return err
+	if err != nil {
+		return err
+	}
+
+	fmt.Println("result:", result.Message)
+	return err
 }

example/go.mod

@@ -2,9 +2,4 @@ module netsrv
 
 go 1.19
 
-require github.com/kindsoldier/dsrpc v1.1.4
+require github.com/kindsoldier/dsrpc v1.2.1
-
-require (
-	github.com/vmihailenco/msgpack/v5 v5.3.5 // indirect
-	github.com/vmihailenco/tagparser/v2 v2.0.0 // indirect
-)

example/go.sum

@@ -1,18 +1,6 @@
-github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
-github.com/kindsoldier/dsrpc v1.1.2 h1:bFTIGpRSMq5OK1a3dHQxLPMxf6R+Ik15slkqNN0QrNE=
+github.com/kindsoldier/dsrpc v1.2.1 h1:sw1a3MAD83Do1Fu+Dh+AHArrwVMgZ/KTLUWWTkQ6vj8=
-github.com/kindsoldier/dsrpc v1.1.2/go.mod h1:KG8x2ZPid/hPJdhkUHtt1mDulWPVhj9fh/1XL3Z2xT8=
+github.com/kindsoldier/dsrpc v1.2.1/go.mod h1:zYb5yYfE/18BYK+iCUNcpkZ4uArwUNNhwYkUK8xDHQk=
-github.com/kindsoldier/dsrpc v1.1.4 h1:F6e1K5C7C92jKGOrH4lF/XraLe5E2glsQTeVP9avYBE=
-github.com/kindsoldier/dsrpc v1.1.4/go.mod h1:KG8x2ZPid/hPJdhkUHtt1mDulWPVhj9fh/1XL3Z2xT8=
 github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
-github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
-github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
-github.com/stretchr/testify v1.6.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
 github.com/stretchr/testify v1.8.2 h1:+h33VjcLVPDHtOdpUCuF+7gSuG3yGIftsP1YvFihtJ8=
-github.com/vmihailenco/msgpack/v5 v5.3.5 h1:5gO0H1iULLWGhs2H5tbAHIZTV8/cYafcFOr9znI5mJU=
-github.com/vmihailenco/msgpack/v5 v5.3.5/go.mod h1:7xyJ9e+0+9SaZT0Wt1RGleJXzli6Q/V5KbhBonMG9jc=
-github.com/vmihailenco/tagparser/v2 v2.0.0 h1:y09buUbR+b5aycVFQs/g70pqKVZNBmxwAhO7/IwNM9g=
-github.com/vmihailenco/tagparser/v2 v2.0.0/go.mod h1:Wri+At7QHww0WTrCBeu4J6bNtoV6mEfg5OIWRZA9qds=
-gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
-gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
 gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=

go.mod

@@ -2,14 +2,10 @@ module github.com/kindsoldier/dsrpc
 
 go 1.19
 
-require (
+require github.com/stretchr/testify v1.8.2
-	github.com/stretchr/testify v1.8.2
-	github.com/vmihailenco/msgpack/v5 v5.3.5
-)
 
 require (
 	github.com/davecgh/go-spew v1.1.1 // indirect
 	github.com/pmezard/go-difflib v1.0.0 // indirect
-	github.com/vmihailenco/tagparser/v2 v2.0.0 // indirect
 	gopkg.in/yaml.v3 v3.0.1 // indirect
 )

go.sum

@@ -6,15 +6,10 @@ github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZN
 github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
 github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw=
 github.com/stretchr/objx v0.5.0/go.mod h1:Yh+to48EsGEfYuaHDzXPcE3xhTkx73EhmCGUpEOglKo=
-github.com/stretchr/testify v1.6.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
 github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
 github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU=
 github.com/stretchr/testify v1.8.2 h1:+h33VjcLVPDHtOdpUCuF+7gSuG3yGIftsP1YvFihtJ8=
 github.com/stretchr/testify v1.8.2/go.mod h1:w2LPCIKwWwSfY2zedu0+kehJoqGctiVI29o6fzry7u4=
-github.com/vmihailenco/msgpack/v5 v5.3.5 h1:5gO0H1iULLWGhs2H5tbAHIZTV8/cYafcFOr9znI5mJU=
-github.com/vmihailenco/msgpack/v5 v5.3.5/go.mod h1:7xyJ9e+0+9SaZT0Wt1RGleJXzli6Q/V5KbhBonMG9jc=
-github.com/vmihailenco/tagparser/v2 v2.0.0 h1:y09buUbR+b5aycVFQs/g70pqKVZNBmxwAhO7/IwNM9g=
-github.com/vmihailenco/tagparser/v2 v2.0.0/go.mod h1:Wri+At7QHww0WTrCBeu4J6bNtoV6mEfg5OIWRZA9qds=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=

request.go

@@ -9,7 +9,7 @@ package dsrpc
 import (
 	"encoding/json"
 
-	encoder "github.com/vmihailenco/msgpack/v5"
+	encoder "encoding/json"
 )
 
 type EmptyParams struct{}

response.go

@@ -7,7 +7,7 @@ package dsrpc
 import (
 	"encoding/json"
 
-	encoder "github.com/vmihailenco/msgpack/v5"
+	encoder "encoding/json"
 )
 
 type EmptyResult struct{}

server.go

@@ -5,303 +5,344 @@
 package dsrpc
 
 import (
-	"context"
+        "context"
-	"errors"
+        "crypto/tls"
-	"fmt"
+        "errors"
-	"io"
+        "fmt"
-	"net"
+        "io"
-	"sync"
+        "net"
-	"time"
+        "sync"
+        "time"
 
-	encoder "github.com/vmihailenco/msgpack/v5"
+        encoder "encoding/json"
 )
 
 type HandlerFunc = func(*Content) error
 
 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
+        listener    net.Listener
+        tcpListener *net.TCPListener
 }
 
 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) {
-	svc.preMw = append(svc.preMw, mw)
+        svc.preMw = append(svc.preMw, mw)
 }
 
 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) Handle(method string, handler HandlerFunc) {
-	svc.handlers[method] = handler
+        svc.handlers[method] = handler
 }
 
 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) {
-	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 {
-	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)
+        svc.tcpListener, 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 := svc.tcpListener.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.handleTCPConn(conn, svc.wg)
-	}
+        }
-	return err
+        return err
+}
+
+func (svc *Service) ListenTLS(address string, tlsConfig *tls.Config) error {
+        var err error
+        logInfo("server listen:", address)
+
+        svc.listener, err = tls.Listen("tcp", address, tlsConfig)
+        if err != nil {
+                err = fmt.Errorf("unable to start listener: %s", err)
+                return err
+        }
+
+        for {
+                conn, err := svc.listener.Accept()
+                if err != nil {
+                        logError("conn accept err:", err)
+                }
+                select {
+                case <-svc.ctx.Done():
+                        logMessage("accept loop done")
+                        return err
+                default:
+                }
+                svc.wg.Add(1)
+                go svc.handleConn(conn, svc.wg)
+        }
+        return err
 }
 
 func notFound(content *Content) error {
-	execErr := errors.New("method not found")
+        execErr := errors.New("method not found")
-	err := content.SendError(execErr)
+        err := content.SendError(execErr)
-	return err
+        return err
 }
 
 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()
+        if svc.listener != nil {
-	// Wait handlers
+                svc.listener.Close()
-	logInfo("wait rpc handlers")
+        }
-	svc.wg.Wait()
+        if svc.tcpListener != nil {
-	return err
+                svc.tcpListener.Close()
+        }
+        svc.cancel()
+        // Wait handlers
+        logInfo("wait rpc handlers")
+        svc.wg.Wait()
+        return err
 }
 
-func (svc *Service) handleConn(conn *net.TCPConn, wg *sync.WaitGroup) {
+func (svc *Service) handleTCPConn(conn *net.TCPConn, wg *sync.WaitGroup) {
-	var err error
+        var err error
+        if svc.keepalive {
+                err = conn.SetKeepAlive(true)
+                if err != nil {
+                        err = fmt.Errorf("unable to set keepalive: %s", err)
+                        return
+                }
+                if svc.kaTime > 0 {
+                        err = conn.SetKeepAlivePeriod(svc.kaTime)
+                        if err != nil {
+                                err = fmt.Errorf("unable to set keepalive period: %s", err)
+                                return
+                        }
+                }
+        }
+        svc.handleConn(conn, wg)
+}
 
-	if svc.keepalive {
+func (svc *Service) handleConn(conn net.Conn, wg *sync.WaitGroup) {
-		err = conn.SetKeepAlive(true)
+        var err error
-		if err != nil {
-			err = fmt.Errorf("unable to set keepalive: %s", err)
-			return
-		}
-		if svc.kaTime > 0 {
-			err = conn.SetKeepAlivePeriod(svc.kaTime)
-			if err != nil {
-				err = fmt.Errorf("unable to set keepalive period: %s", err)
-				return
-			}
-		}
-	}
-	content := CreateContent(conn)
 
-	remoteAddr := conn.RemoteAddr().String()
+        content := CreateContent(conn)
-	remoteHost, _, _ := net.SplitHostPort(remoteAddr)
-	content.remoteHost = remoteHost
 
-	content.binReader = conn
+        remoteAddr := conn.RemoteAddr().String()
-	content.binWriter = io.Discard
+        remoteHost, _, _ := net.SplitHostPort(remoteAddr)
+        content.remoteHost = remoteHost
 
-	exitFunc := func() {
+        content.binReader = conn
-		conn.Close()
+        content.binWriter = io.Discard
-		wg.Done()
-		if err != nil {
-			logError("conn handler err:", err)
-		}
-	}
-	defer exitFunc()
 
-	recovFunc := func() {
+        exitFunc := func() {
-		panicMsg := recover()
+                conn.Close()
-		if panicMsg != nil {
+                wg.Done()
-			logError("handler panic message:", panicMsg)
+                if err != nil {
-		}
+                        logError("conn handler err:", err)
-	}
+                }
-	defer recovFunc()
+        }
+        defer exitFunc()
 
-	err = content.ReadRequest()
+        recovFunc := func() {
-	if err != nil {
+                panicMsg := recover()
-		err = err
+                if panicMsg != nil {
-		return
+                        logError("handler panic message:", panicMsg)
-	}
+                }
+        }
+        defer recovFunc()
 
-	err = content.BindMethod()
+        err = content.ReadRequest()
-	if err != nil {
+        if err != nil {
-		err = err
+                err = err
-		return
+                return
-	}
+        }
-	for _, mw := range svc.preMw {
+
-		err = mw(content)
+        err = content.BindMethod()
-		if err != nil {
+        if err != nil {
-			err = err
+                err = err
-			return
+                return
-		}
+        }
-	}
+        for _, mw := range svc.preMw {
-	err = svc.Route(content)
+                err = mw(content)
-	if err != nil {
+                if err != nil {
-		err = err
+                        err = err
-		return
+                        return
-	}
+                }
-	for _, mw := range svc.postMw {
+        }
-		err = mw(content)
+        err = svc.Route(content)
-		if err != nil {
+        if err != nil {
-			err = err
+                err = err
-			return
+                return
-		}
+        }
-	}
+        for _, mw := range svc.postMw {
-	return
+                err = mw(content)
+                if err != nil {
+                        err = err
+                        return
+                }
+        }
+        return
 }
 
 func (svc *Service) Route(content *Content) error {
-	handler, ok := svc.handlers[content.reqBlock.Method]
+        handler, ok := svc.handlers[content.reqBlock.Method]
-	if ok {
+        if ok {
-		return handler(content)
+                return handler(content)
-	}
+        }
-	return notFound(content)
+        return notFound(content)
 }
 
 func (content *Content) ReadRequest() error {
-	var err error
+        var err error
 
-	content.reqPacket.header, err = ReadBytes(content.sockReader, headerSize)
+        content.reqPacket.header, err = ReadBytes(content.sockReader, headerSize)
-	if err != nil {
+        if err != nil {
-		return err
+                return err
-	}
+        }
-	content.reqHeader, err = UnpackHeader(content.reqPacket.header)
+        content.reqHeader, err = UnpackHeader(content.reqPacket.header)
-	if err != nil {
+        if err != nil {
-		return err
+                return err
-	}
+        }
 
-	rpcSize := content.reqHeader.rpcSize
+        rpcSize := content.reqHeader.rpcSize
-	content.reqPacket.rcpPayload, err = ReadBytes(content.sockReader, rpcSize)
+        content.reqPacket.rcpPayload, err = ReadBytes(content.sockReader, rpcSize)
-	if err != nil {
+        if err != nil {
-		return err
+                return err
-	}
+        }
-	return err
+        return err
 }
 
 func (content *Content) BinWriter() io.Writer {
-	return content.sockWriter
+        return content.sockWriter
 }
 
 func (content *Content) BinReader() io.Reader {
-	return content.sockReader
+        return content.sockReader
 }
 
 func (content *Content) BinSize() int64 {
-	return content.reqHeader.binSize
+        return content.reqHeader.binSize
 }
 
 func (content *Content) ReadBin(ctx context.Context, writer io.Writer) error {
-	var err error
+        var err error
-	_, err = CopyBytes(ctx, content.sockReader, writer, content.reqHeader.binSize)
+        _, err = CopyBytes(ctx, content.sockReader, writer, content.reqHeader.binSize)
-	return err
+        return err
 }
 
 func (content *Content) BindMethod() error {
-	var err error
+        var err error
-	err = encoder.Unmarshal(content.reqPacket.rcpPayload, content.reqBlock)
+        err = encoder.Unmarshal(content.reqPacket.rcpPayload, content.reqBlock)
-	return err
+        return err
 }
 
 func (content *Content) BindParams(params any) error {
-	var err error
+        var err error
-	content.reqBlock.Params = params
+        content.reqBlock.Params = params
-	err = encoder.Unmarshal(content.reqPacket.rcpPayload, content.reqBlock)
+        err = encoder.Unmarshal(content.reqPacket.rcpPayload, content.reqBlock)
-	if err != nil {
+        if err != nil {
-		return err
+                return err
-	}
+        }
-	return err
+        return err
 }
 
 func (content *Content) SendResult(result any, binSize int64) error {
-	var err error
+        var err error
-	content.resBlock.Result = result
+        content.resBlock.Result = result
 
-	content.resPacket.rcpPayload, err = content.resBlock.Pack()
+        content.resPacket.rcpPayload, err = content.resBlock.Pack()
-	if err != nil {
+        if err != nil {
-		return err
+                return err
-	}
+        }
-	content.resHeader.rpcSize = int64(len(content.resPacket.rcpPayload))
+        content.resHeader.rpcSize = int64(len(content.resPacket.rcpPayload))
-	content.resHeader.binSize = binSize
+        content.resHeader.binSize = binSize
 
-	content.resPacket.header, err = content.resHeader.Pack()
+        content.resPacket.header, err = content.resHeader.Pack()
-	if err != nil {
+        if err != nil {
-		return err
+                return err
-	}
+        }
-	_, err = content.sockWriter.Write(content.resPacket.header)
+        _, err = content.sockWriter.Write(content.resPacket.header)
-	if err != nil {
+        if err != nil {
-		return err
+                return err
-	}
+        }
-	_, err = content.sockWriter.Write(content.resPacket.rcpPayload)
+        _, err = content.sockWriter.Write(content.resPacket.rcpPayload)
-	if err != nil {
+        if err != nil {
-		return err
+                return err
-	}
+        }
-	return err
+        return err
 }
 
 func (content *Content) SendError(execErr error) error {
-	var err error
+        var err error
 
-	content.resBlock.Error = execErr.Error()
+        content.resBlock.Error = execErr.Error()
-	content.resBlock.Result = NewEmptyResult()
+        content.resBlock.Result = NewEmptyResult()
 
-	content.resPacket.rcpPayload, err = content.resBlock.Pack()
+        content.resPacket.rcpPayload, err = content.resBlock.Pack()
-	if err != nil {
+        if err != nil {
-		return err
+                return err
-	}
+        }
-	content.resHeader.rpcSize = int64(len(content.resPacket.rcpPayload))
+        content.resHeader.rpcSize = int64(len(content.resPacket.rcpPayload))
-	content.resPacket.header, err = content.resHeader.Pack()
+        content.resPacket.header, err = content.resHeader.Pack()
-	if err != nil {
+        if err != nil {
-		return err
+                return err
-	}
+        }
-	_, err = content.sockWriter.Write(content.resPacket.header)
+        _, err = content.sockWriter.Write(content.resPacket.header)
-	if err != nil {
+        if err != nil {
-		return err
+                return err
-	}
+        }
-	_, err = content.sockWriter.Write(content.resPacket.rcpPayload)
+        _, err = content.sockWriter.Write(content.resPacket.rcpPayload)
-	if err != nil {
+        if err != nil {
-		return err
+                return err
-	}
+        }
-	return err
+        return err
 }