feat: ability to use middlewares for clients (#5)

Author: frankli0324

example_test.go

@@ -3,6 +3,7 @@ package requests
 import (
 	"context"
 	"fmt"
+	"net/http"
 
 	"github.com/frankli0324/go-requests/request"
 )
@@ -17,3 +18,28 @@ func ExampleCtxDo() {
 	c, err := resp.Body()
 	fmt.Println(string(c))
 }
+
+func ExampleMiddleware() {
+	cli, _ := NewClient()
+	cli.Use(func(next Handler) Handler {
+		return func(rc *RequestCtx) error {
+			if rc.Request.Headers == nil {
+				rc.Request.Headers = make(http.Header)
+			}
+			rc.Request.Headers.Add("handler-ok", "1")
+			err := next(rc)
+			if err == nil {
+				fmt.Println(rc.Response.Header.Get("Date"))
+			}
+			return err
+		}
+	})
+	done, resp, err := cli.CtxDo(context.Background(), request.Get("https://www.google.com", nil))
+	if err != nil {
+		panic(err)
+	}
+	defer done()
+
+	c, err := resp.Body()
+	fmt.Println(string(c))
+}

internal/client/client.go

@@ -4,14 +4,23 @@ import (
 	"context"
 	"net"
 	"net/http"
+	"sync"
 	"time"
 
 	"github.com/frankli0324/go-requests/internal/request"
 	"github.com/frankli0324/go-requests/internal/response"
 )
 
+type Handler = func(*RequestCtx) error
+type Middleware = func(next Handler) Handler
+
 type Client struct {
 	Client http.Client
+
+	// I miss partial classes in C#
+	middlewares    []Middleware
+	chainedHandler Handler
+	mwLock         sync.RWMutex
 }
 
 func New(opts ...Option) (*Client, error) {
@@ -39,24 +48,31 @@ func New(opts ...Option) (*Client, error) {
 			},
 		},
 	}
+	cli.chainedHandler = cli.request
 	return cli, cli.Configure(opts...)
 }
 
 func (c *Client) CtxDo(
 	ctx context.Context, req *request.Request,
 ) (func(), *response.Response, error) {
-	r, err := req.Build(ctx)
+	rctx := getRequestCtx(ctx)
+	rctx.Request = req
+	c.mwLock.RLock()
+	call := c.chainedHandler
+	c.mwLock.RUnlock()
+	return rctx.Done, rctx.Response, call(rctx)
+}
+
+func (c *Client) request(rc *RequestCtx) error {
+	r, err := rc.Request.Build(rc.Context)
 	if err != nil {
-		return func() {}, nil, err
+		return err
 	}
 	resp, err := c.Client.Do(r)
 	if err != nil {
 		// on error, return a Response that won't be recovered
-		return func() {}, response.Wrap(resp), err
+		return err
 	}
-	ret := response.Wrap(resp)
-	return func() {
-		ret.Done()
-		request.PutRequest(r)
-	}, ret, nil
+	rc.Response = response.Wrap(resp)
+	return nil
 }

internal/client/middleware.go

@@ -0,0 +1,30 @@
+package client
+
+// Use appends the passed middleware to the end of the list
+func (c *Client) Use(mw Middleware) {
+	c.mwLock.Lock()
+	defer c.mwLock.Unlock()
+	c.middlewares = append(c.middlewares, mw)
+	c.buildHandler()
+}
+
+func (c *Client) UseIndex(mw Middleware, idx int) {
+	c.mwLock.Lock()
+	defer c.mwLock.Unlock()
+	if len(c.middlewares) <= idx {
+		c.middlewares = append(c.middlewares, mw)
+	} else {
+		c.middlewares = append(c.middlewares[:idx+1], c.middlewares[idx:]...)
+		c.middlewares[idx] = mw
+	}
+	c.buildHandler()
+}
+
+func (c *Client) buildHandler() {
+	// rebuilds the entire middleware chain
+	chain := c.request
+	for _, mw := range c.middlewares {
+		chain = mw(chain)
+	}
+	c.chainedHandler = chain
+}

internal/client/requestctx.go

@@ -0,0 +1,47 @@
+package client
+
+import (
+	"context"
+	"sync"
+
+	"github.com/frankli0324/go-requests/internal/request"
+	"github.com/frankli0324/go-requests/internal/response"
+)
+
+type RequestCtx struct {
+	context.Context
+	Error    error
+	Request  *request.Request
+	Response *response.Response
+}
+
+// Done recycles the resources used by request context,
+// after calling this function, the request context
+// MUST NOT be used again.
+func (rc *RequestCtx) Done() {
+	if rc.Request != nil {
+		rc.Request.Done()
+	}
+	if rc.Response != nil {
+		rc.Response.Done()
+	}
+	putRequestCtx(rc)
+}
+
+var p = sync.Pool{New: func() interface{} {
+	return &RequestCtx{}
+}}
+
+func getRequestCtx(ctx context.Context) *RequestCtx {
+	c := p.Get().(*RequestCtx)
+	c.Context = ctx
+	return c
+}
+
+func putRequestCtx(ctx *RequestCtx) {
+	ctx.Context = nil
+	ctx.Request = nil
+	ctx.Response = nil
+	ctx.Error = nil
+	p.Put(ctx)
+}

internal/request/pool.go

@@ -13,6 +13,6 @@ func getRequest() *http.Request {
 	return p.Get().(*http.Request)
 }
 
-func PutRequest(req *http.Request) {
+func putRequest(req *http.Request) {
 	p.Put(req)
 }

internal/request/request.go

@@ -19,6 +19,8 @@ type Request struct {
 	Encoders []func(io.ReadCloser) (string, io.ReadCloser)
 
 	NoRedirect bool
+
+	innerReq *http.Request
 }
 
 func (r *Request) Build(ctx context.Context) (*http.Request, error) {
@@ -36,8 +38,13 @@ func (r *Request) Build(ctx context.Context) (*http.Request, error) {
 		ctx = context.WithValue(ctx, KRedirect, false)
 	}
 	req = req.WithContext(ctx) // copy occurred here
+	r.innerReq = req
 
 	r.buildContent(req)
 	r.buildEncoding(req)
 	return req, nil
 }
+
+func (r *Request) Done() {
+	putRequest(r.innerReq)
+}

requests.go

@@ -15,6 +15,10 @@ type ClientOption = client.Option
 type Request = request.Request
 type Response = response.Response
 
+type RequestCtx = client.RequestCtx
+type Handler = client.Handler
+type Middleware = client.Middleware
+
 var defaultClient = Client{}
 
 func Configure(baseProfile string, opts ...client.Option) error {