fixed mistakes

README.md

@@ -44,7 +44,7 @@ func server() error {
     serv := dsrpc.NewService()
 
     cont := NewController()
-    serv.Handler(api.HelloMethod, cont.HelloHandler)
+    serv.Handle(api.HelloMethod, cont.HelloHandler)
 
     serv.PreMiddleware(dsrpc.LogRequest)
     serv.PostMiddleware(dsrpc.LogResponse)
@@ -220,9 +220,9 @@ func sampleServ(quiet bool) error {
     serv.PreMiddleware(authMiddleware)
     serv.PreMiddleware(dsrpc.LogRequest)
 
-    serv.Handler(HelloMethod, helloHandler)
+    serv.Handle(HelloMethod, helloHandler)
-    serv.Handler(SaveMethod, saveHandler)
+    serv.Handle(SaveMethod, saveHandler)
-    serv.Handler(LoadMethod, loadHandler)
+    serv.Handle(LoadMethod, loadHandler)
 
     serv.PostMiddleware(dsrpc.LogResponse)
     serv.PostMiddleware(dsrpc.LogAccess)

example/srv/netsrv.go

@@ -26,7 +26,7 @@ func server() error {
     serv := dsrpc.NewService()
 
     cont := NewController()
-    serv.Handler(api.HelloMethod, cont.HelloHandler)
+    serv.Handle(api.HelloMethod, cont.HelloHandler)
 
     serv.PreMiddleware(dsrpc.LogRequest)
     serv.PostMiddleware(dsrpc.LogResponse)

exec_test.go

@@ -229,9 +229,9 @@ func testServ(quiet bool) error {
 		SetMessageWriter(io.Discard)
 	}
 	serv := NewService()
-	serv.Handler(HelloMethod, helloHandler)
+	serv.Handle(HelloMethod, helloHandler)
-	serv.Handler(SaveMethod, saveHandler)
+	serv.Handle(SaveMethod, saveHandler)
-	serv.Handler(LoadMethod, loadHandler)
+	serv.Handle(LoadMethod, loadHandler)
 
 	serv.PreMiddleware(LogRequest)
 	serv.PreMiddleware(auth)

server.go

@@ -5,335 +5,344 @@
 package dsrpc
 
 import (
-	"context"
+        "context"
-	"crypto/tls"
+        "crypto/tls"
-	"errors"
+        "errors"
-	"fmt"
+        "fmt"
-	"io"
+        "io"
-	"net"
+        "net"
-	"sync"
+        "sync"
-	"time"
+        "time"
 
-	encoder "encoding/json"
+        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) 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.handleTCPConn(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
+        var err error
-	logInfo("server listen:", address)
+        logInfo("server listen:", address)
 
-	listener, err := tls.Listen("tcp", address, tlsConfig)
+        svc.listener, err = tls.Listen("tcp", address, tlsConfig)
-	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.Accept()
+                conn, err := svc.listener.Accept()
-		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
+                        logInfo("accept loop done")
-		default:
+                        return err
-		}
+                default:
-		svc.wg.Add(1)
+                }
-		go svc.handleConn(conn, svc.wg)
+                svc.wg.Add(1)
-	}
+                go svc.handleConn(conn, svc.wg)
-	return err
+        }
+        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) handleTCPConn(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
-			}
+                        }
-		}
+                }
-	}
+        }
-	svc.handleConn(conn, wg)
+        svc.handleConn(conn, wg)
 }
 
 func (svc *Service) handleConn(conn net.Conn, wg *sync.WaitGroup) {
-	var err error
+        var err error
 
-	content := CreateContent(conn)
+        content := CreateContent(conn)
 
-	remoteAddr := conn.RemoteAddr().String()
+        remoteAddr := conn.RemoteAddr().String()
-	remoteHost, _, _ := net.SplitHostPort(remoteAddr)
+        remoteHost, _, _ := net.SplitHostPort(remoteAddr)
-	content.remoteHost = remoteHost
+        content.remoteHost = remoteHost
 
-	content.binReader = conn
+        content.binReader = conn
-	content.binWriter = io.Discard
+        content.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 = content.ReadRequest()
+        err = content.ReadRequest()
-	if err != nil {
+        if err != nil {
-		err = err
+                err = err
-		return
+                return
-	}
+        }
 
-	err = content.BindMethod()
+        err = content.BindMethod()
-	if err != nil {
+        if err != nil {
-		err = err
+                err = err
-		return
+                return
-	}
+        }
-	for _, mw := range svc.preMw {
+        for _, mw := range svc.preMw {
-		err = mw(content)
+                err = mw(content)
-		if err != nil {
+                if err != nil {
-			err = err
+                        err = err
-			return
+                        return
-		}
+                }
-	}
+        }
-	err = svc.Route(content)
+        err = svc.Route(content)
-	if err != nil {
+        if err != nil {
-		err = err
+                err = err
-		return
+                return
-	}
+        }
-	for _, mw := range svc.postMw {
+        for _, mw := range svc.postMw {
-		err = mw(content)
+                err = mw(content)
-		if err != nil {
+                if err != nil {
-			err = err
+                        err = err
-			return
+                        return
-		}
+                }
-	}
+        }
-	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
 }