feat: add Request

Author: hhk7734

context.go

@@ -13,8 +13,7 @@ const abortIndex int8 = math.MaxInt8 >> 1
 type Context struct {
 	engine *Engine
 
-	Event *event.Event
-	ctx   context.Context
+	Request *Request
 
 	handlers HandlersChain
 	index    int8
@@ -88,5 +87,5 @@ func (c *Context) Error(err error) *Error {
 }
 
 func (c *Context) Done() <-chan struct{} {
-	return c.ctx.Done()
+	return c.Request.Context().Done()
 }

equeue.go

@@ -297,16 +297,20 @@ func (w *worker) run() {
 	c := w.engine.pool.Get().(*Context)
 	c.reset()
 
+	var ctx context.Context
+	ctx, w.cancelCtx = context.WithCancel(context.Background())
+
 	var err error
-	c.Event, err = binding.ToEvent(context.Background(), w.message)
+	e, err := binding.ToEvent(context.Background(), w.message)
 	if err != nil {
 		_, filename, line, _ := runtime.Caller(0)
 		c.Error(err).SetType(ErrorTypeBind).SetMeta(H{
 			"filename": filename,
 			"line":     line + 1})
 	}
+	c.Request = &Request{Event: e, ctx: ctx}
+
 	c.handlers = w.subscription.handlers
-	c.ctx, w.cancelCtx = context.WithCancel(context.Background())
 	c.Next()
 
 	if c.IsNack() {

request.go

@@ -0,0 +1,51 @@
+package equeue
+
+import (
+	"context"
+
+	"github.com/cloudevents/sdk-go/v2/event"
+)
+
+// http.Request
+type Request struct {
+	Event *event.Event
+
+	ctx context.Context
+}
+
+// Context returns the request's context. To change the context, use
+// Clone or WithContext.
+//
+// The returned context is always non-nil; it defaults to the
+// background context.
+//
+// For outgoing client requests, the context controls cancellation.
+//
+// For incoming server requests, the context is canceled when the
+// client's connection closes, the request is canceled (with HTTP/2),
+// or when the ServeHTTP method returns.
+func (r *Request) Context() context.Context {
+	if r.ctx != nil {
+		return r.ctx
+	}
+	return context.Background()
+}
+
+// WithContext returns a shallow copy of r with its context changed
+// to ctx. The provided ctx must be non-nil.
+//
+// For outgoing client request, the context controls the entire
+// lifetime of a request and its response: obtaining a connection,
+// sending the request, and reading the response headers and body.
+//
+// To create a new request with a context, use NewRequestWithContext.
+// To make a deep copy of a request with a new context, use Request.Clone.
+func (r *Request) WithContext(ctx context.Context) *Request {
+	if ctx == nil {
+		panic("nil context")
+	}
+	r2 := new(Request)
+	*r2 = *r
+	r2.ctx = ctx
+	return r2
+}