Feat: add query params

tcp/client.go

@@ -5,41 +5,68 @@ import (
 	"net"
 )
 
-func Do(addr, route string, method Method, body []byte) ([]byte, error) {
+func Do(
+	addr, route string,
+	method Method,
+	params map[string]string,
+	body []byte,
+) (*Response, error) {
 	conn, err := net.Dial("tcp", addr)
 	if err != nil {
-		return []byte{}, err
+		return nil, err
 	}
 	defer conn.Close()
-	header := RequestHeader{
+	reqHeader := RequestHeader{
 		Method: method,
 		Route:  route,
+		Params: params,
 	}
 
-	rawHeader, err := json.Marshal(header)
+	rawHeader, err := json.Marshal(reqHeader)
 	if err != nil {
-		return []byte{}, err
+		return nil, err
 	}
 	if err := sendFrame(conn, rawHeader); err != nil {
-		return []byte{}, err
+		return nil, err
 	}
 
 	if err := sendFrame(conn, body); err != nil {
-		return []byte{}, err
+		return nil, err
 	}
 
-	b, err := readFrame(conn)
+	rawHeader, err = readFrame(conn)
 	if err != nil {
-		return []byte{}, err
+		return nil, err
 	}
 
-	return b, nil
+	var resHeader ResponseHeader
+	if err := json.Unmarshal(rawHeader, &resHeader); err != nil {
+		return nil, err
+	}
+
+	body, err = readFrame(conn)
+	if err != nil {
+		return nil, err
+	}
+
+	return &Response{
+		StatusCode: resHeader.StatusCode,
+		Body:       body,
+		RemoteAddr: conn.RemoteAddr().String(),
+	}, nil
 }
 
-func Get(addr, route string) ([]byte, error) {
-	return Do(addr, route, MethodGET, []byte{})
+func Get(
+	addr, route string,
+	params map[string]string,
+) (*Response, error) {
+	return Do(addr, route, MethodGET, params, nil)
 }
 
-func Post(addr, route string, b []byte) ([]byte, error) {
-	return Do(addr, route, MethodPOST, b)
+func Post(
+	addr, route string,
+	params map[string]string,
+	b []byte,
+) (*Response, error) {
+	return Do(addr, route, MethodPOST, params, b)
 }

tcp/request.go

@@ -17,13 +17,15 @@ const (
 )
 
 type RequestHeader struct {
-	Method Method `json:"method"`
-	Route  string `json:"route"`
+	Method Method            `json:"method"`
+	Route  string            `json:"route"`
+	Params map[string]string `json:"params"`
 }
 
 type Request struct {
 	Method Method
 	Route  string
+	Params map[string]string
 
 	RemoteAddr string
 
@@ -34,6 +36,7 @@ func (self *Request) Header() ([]byte, error) {
 	b, err := json.Marshal(RequestHeader{
 		Method: self.Method,
 		Route:  self.Route,
+		Params: self.Params,
 	})
 	if err != nil {
 		return []byte{}, err
@@ -45,6 +48,7 @@ func NewRequest(conn net.Conn, header RequestHeader, body []byte) *Request {
 	return &Request{
 		Method: header.Method,
 		Route:  header.Route,
+		Params: header.Params,
 
 		RemoteAddr: conn.RemoteAddr().String(),
 

tcp/router.go

@@ -22,8 +22,9 @@ func NewRouter() *Router {
 	}
 }
 
-func (self *Router) Use(middleware Middleware) {
+func (self *Router) Use(middleware Middleware) *Router {
 	self.middlewares = append(self.middlewares, middleware)
+	return self
 }
 
 func (self *Router) Register(method Method, route string, handler Handler) {
@@ -38,6 +39,26 @@ func (self *Router) Register(method Method, route string, handler Handler) {
 	self.routes[method][route] = handler
 }
 
+func (self *Router) GET(route string, handler Handler) {
+	self.Register(MethodGET, route, handler)
+}
+
+func (self *Router) POST(route string, handler Handler) {
+	self.Register(MethodPOST, route, handler)
+}
+
+func (self *Router) PUT(route string, handler Handler) {
+	self.Register(MethodPUT, route, handler)
+}
+
+func (self *Router) DELETE(route string, handler Handler) {
+	self.Register(MethodDELETE, route, handler)
+}
+
+func (self *Router) SOCKET(route string, handler Handler) {
+	self.Register(MethodSOCKET, route, handler)
+}
+
 func (self *Router) run(conn net.Conn, req *Request) {
 	handler, ok := self.routes[req.Method][req.Route]
 	if !ok {

tcp/utils.go

@@ -4,6 +4,8 @@ import (
 	"encoding/binary"
 	"io"
 	"net"
+
+	"go.uber.org/zap"
 )
 
 const (
@@ -19,6 +21,11 @@ func readFrame(conn net.Conn) ([]byte, error) {
 
 	messageLength := binary.BigEndian.Uint32(lengthBytes)
 
+	if messageLength > 65536 {
+		zap.L().Warn("message length exceed",
+			zap.Uint32("length", messageLength))
+	}
+
 	payload := make([]byte, messageLength)
 	_, err = io.ReadFull(conn, payload)
 	if err != nil {