Merge pull request #19 from DarthPestilane/refactor/router-simplify

Refactor: router simplify

Author: DarthPestilane

README.md

@@ -102,22 +102,20 @@ in [examples/tcp](./examples/tcp).
 
 ## Benchmark
 
-- goversion: 1.15.15
-- goos: darwin
-- goarch: amd64
-
-| Benchmark name          | (1)    | (2)        | (3)       | (4)          | remark                        |
-| ----------------------- | ------ | ---------- | --------- | ------------ | ----------------------------- |
-| NoRoute-8               | 250000 | 4584 ns/op | 79 B/op   | 2 allocs/op  |                               |
-| NotFoundHandler-8       | 250000 | 5471 ns/op | 565 B/op  | 6 allocs/op  |                               |
-| OneHandler-8            | 250000 | 6250 ns/op | 352 B/op  | 7 allocs/op  |                               |
-| ManyHandlers-8          | 250000 | 6405 ns/op | 464 B/op  | 11 allocs/op |                               |
-| OneRouteCtxGetSet-8     | 250000 | 6940 ns/op | 697 B/op  | 11 allocs/op |                               |
-| OneRouteMessageGetSet-8 | 250000 | 5406 ns/op | 623 B/op  | 9 allocs/op  |                               |
-| OneRouteJsonCodec-8     | 250000 | 7582 ns/op | 1383 B/op | 21 allocs/op | built with `encoding/json`    |
-| OneRouteJsonCodec-8     | 250000 | 8430 ns/op | 1410 B/op | 17 allocs/op | built with `json-jsoniter/go` |
-| OneRouteProtobufCodec-8 | 250000 | 6628 ns/op | 444 B/op  | 8 allocs/op  |                               |
-| OneRouteMsgpackCodec-8  | 250000 | 7491 ns/op | 661 B/op  | 11 allocs/op |                               |
+```sh
+go test -bench=. -run=none -benchmem -benchtime=250000x
+goos: darwin
+goarch: amd64
+pkg: github.com/DarthPestilane/easytcp
+Benchmark_NoHandler-8                 	  250000	      4479 ns/op	      86 B/op	       2 allocs/op
+Benchmark_OneHandler-8                	  250000	      4377 ns/op	      85 B/op	       2 allocs/op
+Benchmark_OneHandlerCtxGetSet-8       	  250000	      4076 ns/op	     363 B/op	       4 allocs/op
+Benchmark_OneHandlerMessageGetSet-8   	  250000	      4202 ns/op	     396 B/op	       5 allocs/op
+PASS
+ok  	github.com/DarthPestilane/easytcp	4.609s
+```
+
+*since easytcp is built on the top of golang `net` library, the benchmark of networks does not make much sense.*
 
 ## Architecture
 

benchmarks_test.go

@@ -1,8 +1,6 @@
 package easytcp
 
 import (
-	"github.com/DarthPestilane/easytcp/internal/test_data/msgpack"
-	"github.com/DarthPestilane/easytcp/internal/test_data/pb"
 	"github.com/DarthPestilane/easytcp/message"
 	"net"
 	"testing"
@@ -15,7 +13,7 @@ type mutedLogger struct{}
 func (m *mutedLogger) Errorf(_ string, _ ...interface{}) {}
 func (m *mutedLogger) Tracef(_ string, _ ...interface{}) {}
 
-func Benchmark_NoRoute(b *testing.B) {
+func Benchmark_NoHandler(b *testing.B) {
 	s := NewServer(&ServerOption{
 		DoNotPrintRoutes: true,
 	})
@@ -38,73 +36,13 @@ func Benchmark_NoRoute(b *testing.B) {
 	}
 }
 
-func Benchmark_NotFoundHandler(b *testing.B) {
-	s := NewServer(&ServerOption{
-		DoNotPrintRoutes: true,
-	})
-	s.NotFoundHandler(func(ctx *Context) error {
-		return ctx.Response(0, []byte("not found"))
-	})
-	go s.Serve("127.0.0.1:0") // nolint
-	defer s.Stop()            // nolint
-
-	<-s.accepting
-
-	// client
-	client, err := net.Dial("tcp", s.Listener.Addr().String())
-	if err != nil {
-		panic(err)
-	}
-	defer client.Close() // nolint
-
-	packedMsg, _ := s.Packer.Pack(&message.Entry{ID: 1, Data: []byte("ping")})
-	beforeBench(b)
-	for i := 0; i < b.N; i++ {
-		_, _ = client.Write(packedMsg)
-	}
-}
-
 func Benchmark_OneHandler(b *testing.B) {
 	s := NewServer(&ServerOption{
 		DoNotPrintRoutes: true,
 	})
 	s.AddRoute(1, func(ctx *Context) error {
-		return ctx.Response(2, []byte("pong"))
-	})
-	go s.Serve("127.0.0.1:0") // nolint
-	defer s.Stop()            // nolint
-
-	<-s.accepting
-
-	// client
-	client, err := net.Dial("tcp", s.Listener.Addr().String())
-	if err != nil {
-		panic(err)
-	}
-	defer client.Close() // nolint
-
-	packedMsg, _ := s.Packer.Pack(&message.Entry{ID: 1, Data: []byte("ping")})
-	beforeBench(b)
-	for i := 0; i < b.N; i++ {
-		_, _ = client.Write(packedMsg)
-	}
-}
-
-func Benchmark_ManyHandlers(b *testing.B) {
-	s := NewServer(&ServerOption{
-		DoNotPrintRoutes: true,
+		return nil
 	})
-
-	var m MiddlewareFunc = func(next HandlerFunc) HandlerFunc {
-		return func(ctx *Context) error {
-			return next(ctx)
-		}
-	}
-
-	s.AddRoute(1, func(ctx *Context) error {
-		return ctx.Response(2, []byte("pong"))
-	}, m, m)
-
 	go s.Serve("127.0.0.1:0") // nolint
 	defer s.Stop()            // nolint
 
@@ -124,14 +62,14 @@ func Benchmark_ManyHandlers(b *testing.B) {
 	}
 }
 
-func Benchmark_OneRouteCtxGetSet(b *testing.B) {
+func Benchmark_OneHandlerCtxGetSet(b *testing.B) {
 	s := NewServer(&ServerOption{
 		DoNotPrintRoutes: true,
 	})
 	s.AddRoute(1, func(ctx *Context) error {
 		ctx.Set("key", "value")
-		v := ctx.MustGet("key").(string)
-		return ctx.Response(2, []byte(v))
+		_ = ctx.MustGet("key").(string)
+		return nil
 	})
 	go s.Serve("127.0.0.1:0") // nolint
 	defer s.Stop()            // nolint
@@ -152,14 +90,14 @@ func Benchmark_OneRouteCtxGetSet(b *testing.B) {
 	}
 }
 
-func Benchmark_OneRouteMessageGetSet(b *testing.B) {
+func Benchmark_OneHandlerMessageGetSet(b *testing.B) {
 	s := NewServer(&ServerOption{
 		DoNotPrintRoutes: true,
 	})
 	s.AddRoute(1, func(ctx *Context) error {
 		ctx.Message().Set("key", []byte("val"))
-		v := ctx.Message().MustGet("key").([]byte)
-		return ctx.Response(2, v)
+		_ = ctx.Message().MustGet("key").([]byte)
+		return nil
 	})
 	go s.Serve("127.0.0.1:0") // nolint
 	defer s.Stop()            // nolint
@@ -180,95 +118,6 @@ func Benchmark_OneRouteMessageGetSet(b *testing.B) {
 	}
 }
 
-func Benchmark_OneRouteJsonCodec(b *testing.B) {
-	s := NewServer(&ServerOption{
-		Codec:            &JsonCodec{},
-		DoNotPrintRoutes: true,
-	})
-	s.AddRoute(1, func(ctx *Context) error {
-		req := make(map[string]string)
-		ctx.MustBind(&req)
-		return ctx.Response(2, map[string]string{"data": "pong"})
-	})
-	go s.Serve("127.0.0.1:0") // nolint
-	defer s.Stop()            // nolint
-
-	<-s.accepting
-
-	// client
-	client, err := net.Dial("tcp", s.Listener.Addr().String())
-	if err != nil {
-		panic(err)
-	}
-	defer client.Close() // nolint
-
-	packedMsg, _ := s.Packer.Pack(&message.Entry{ID: 1, Data: []byte(`{"data": "ping"}`)})
-	beforeBench(b)
-	for i := 0; i < b.N; i++ {
-		_, _ = client.Write(packedMsg)
-	}
-}
-
-func Benchmark_OneRouteProtobufCodec(b *testing.B) {
-	s := NewServer(&ServerOption{
-		Codec:            &ProtobufCodec{},
-		DoNotPrintRoutes: true,
-	})
-	s.AddRoute(1, func(ctx *Context) error {
-		var req pb.Sample
-		ctx.MustBind(&req)
-		return ctx.Response(2, &pb.Sample{Foo: "test-resp", Bar: req.Bar + 1})
-	})
-	go s.Serve("127.0.0.1:0") // nolint
-	defer s.Stop()            // nolint
-
-	<-s.accepting
-
-	// client
-	client, err := net.Dial("tcp", s.Listener.Addr().String())
-	if err != nil {
-		panic(err)
-	}
-	defer client.Close() // nolint
-
-	data, _ := s.Codec.Encode(&pb.Sample{Foo: "test", Bar: 1})
-	packedMsg, _ := s.Packer.Pack(&message.Entry{ID: 1, Data: data})
-	beforeBench(b)
-	for i := 0; i < b.N; i++ {
-		_, _ = client.Write(packedMsg)
-	}
-}
-
-func Benchmark_OneRouteMsgpackCodec(b *testing.B) {
-	s := NewServer(&ServerOption{
-		Codec:            &MsgpackCodec{},
-		DoNotPrintRoutes: true,
-	})
-	s.AddRoute(1, func(ctx *Context) error {
-		var req msgpack.Sample
-		ctx.MustBind(&req)
-		return ctx.Response(2, &msgpack.Sample{Foo: "test-resp", Bar: req.Bar + 1})
-	})
-	go s.Serve("127.0.0.1:0") // nolint
-	defer s.Stop()            // nolint
-
-	<-s.accepting
-
-	// client
-	client, err := net.Dial("tcp", s.Listener.Addr().String())
-	if err != nil {
-		panic(err)
-	}
-	defer client.Close() // nolint
-
-	data, _ := s.Codec.Encode(&msgpack.Sample{Foo: "test", Bar: 1})
-	packedMsg, _ := s.Packer.Pack(&message.Entry{ID: 1, Data: data})
-	beforeBench(b)
-	for i := 0; i < b.N; i++ {
-		_, _ = client.Write(packedMsg)
-	}
-}
-
 func beforeBench(b *testing.B) {
 	Log = &mutedLogger{}
 	b.ReportAllocs()

examples/tcp/simple/server/main.go

@@ -27,7 +27,6 @@ func main() {
 		SocketWriteBufferSize: 1024 * 1024,
 		ReadTimeout:           time.Second * 3,
 		WriteTimeout:          time.Second * 3,
-		ReqQueueSize:          -1,
 		RespQueueSize:         -1,
 		Packer:                easytcp.NewDefaultPacker(),
 		Codec:                 nil,

router.go

@@ -8,16 +8,8 @@ import (
 	"runtime"
 )
 
-func newRouter(queueSize ...int) *Router {
-	size := 0
-	if len(queueSize) != 0 {
-		if qs := queueSize[0]; qs > 0 {
-			size = qs
-		}
-	}
+func newRouter() *Router {
 	return &Router{
-		reqQueue:          make(chan *Context, size),
-		stopped:           make(chan struct{}),
 		handlerMapper:     make(map[interface{}]HandlerFunc),
 		middlewaresMapper: make(map[interface{}][]MiddlewareFunc),
 	}
@@ -39,8 +31,6 @@ type Router struct {
 	globalMiddlewares []MiddlewareFunc
 
 	notFoundHandler HandlerFunc
-	reqQueue        chan *Context
-	stopped         chan struct{}
 }
 
 // HandlerFunc is the function type for handlers.
@@ -60,42 +50,6 @@ var nilHandler HandlerFunc = func(ctx *Context) error {
 	return nil
 }
 
-// stop stops the router.
-func (r *Router) stop() {
-	close(r.stopped)
-}
-
-// consumeRequest fetches context from reqQueue, and handle it.
-func (r *Router) consumeRequest() {
-	defer func() { Log.Tracef("router stopped") }()
-	for {
-		select {
-		case <-r.stopped:
-			close(r.reqQueue)
-			return
-		case ctx, ok := <-r.reqQueue:
-			if !ok {
-				return
-			}
-			select {
-			case <-ctx.session.closed:
-				continue
-			default:
-			}
-
-			go func() {
-				if err := r.handleRequest(ctx); err != nil {
-					Log.Errorf("router handle request err: %s", err)
-					return
-				}
-				if err := ctx.session.SendResp(ctx); err != nil {
-					Log.Errorf("router send resp err: %s", err)
-				}
-			}()
-		}
-	}
-}
-
 // handleRequest walks ctx through middlewares and handler,
 // and returns response message entry.
 func (r *Router) handleRequest(ctx *Context) error {
@@ -124,13 +78,11 @@ func (r *Router) handleRequest(ctx *Context) error {
 // 	var wrapped HandlerFunc = m1(m2(m3(handle)))
 func (r *Router) wrapHandlers(handler HandlerFunc, middles []MiddlewareFunc) (wrapped HandlerFunc) {
 	if handler == nil {
-		if r.notFoundHandler != nil {
-			handler = r.notFoundHandler
-		} else {
-			handler = nilHandler
-		}
+		handler = r.notFoundHandler
+	}
+	if handler == nil {
+		handler = nilHandler
 	}
-
 	wrapped = handler
 	for i := len(middles) - 1; i >= 0; i-- {
 		m := middles[i]