Moves throttiling logic from backend to middleware

backend.go

@@ -10,18 +10,12 @@ type RequestFactory func(req Request) (*http.Request, error)
 type HTTPBackend struct {
 	factory RequestFactory
 	client  *http.Client
-	sem     chan struct{}
 }
 
-const (
-	MaxConcurrentRequests = 50
-)
-
 func NewBackend(factory RequestFactory) *HTTPBackend {
 	return &HTTPBackend{
 		factory: factory,
 		client:  &http.Client{},
-		sem:     make(chan struct{}, MaxConcurrentRequests),
 	}
 }
 
@@ -31,17 +25,7 @@ func (b *HTTPBackend) Handle(conn Connection, r Request) error {
 		return err
 	}
 
-	ctx := r.Context()
-
-	select {
-	case <-ctx.Done():
-		return ctx.Err()
-	case b.sem <- struct{}{}:
-	}
-
 	resp, err := b.client.Do(httpReq)
-	<-b.sem
-
 	if err != nil {
 		return err
 	}

examples/http_backend/main.go

@@ -47,6 +47,7 @@ func main() {
 	connRegistry := wasabi.NewDefaultConnectionRegistry()
 	dispatcher := wasabi.NewPipeDispatcher(backend)
 	dispatcher.Use(ErrHandler)
+	dispatcher.Use(request.NewTrottlerMiddleware(10))
 
 	server := wasabi.NewServer(Port)
 	channel := wasabi.NewDefaultChannel("/", dispatcher, connRegistry)

middleware/request/throttler.go

@@ -0,0 +1,22 @@
+package request
+
+import "github.com/ksysoev/wasabi"
+
+type token struct{}
+
+func NewTrottlerMiddleware(limit uint) func(next wasabi.RequestHandler) wasabi.RequestHandler {
+	sem := make(chan token, limit)
+
+	return func(next wasabi.RequestHandler) wasabi.RequestHandler {
+		return wasabi.RequestHandlerFunc(func(conn wasabi.Connection, req wasabi.Request) error {
+
+			select {
+			case sem <- token{}:
+				defer func() { <-sem }()
+				return next.Handle(conn, req)
+			case <-conn.Context().Done():
+				return conn.Context().Err()
+			}
+		})
+	}
+}