♻️ Publishing Acquire and Release Request/Response func (#23)

lab259 · Feb 4, 2020 · 7161fed · 7161fed
1 parent 6616e2b
commit 7161fed
Show file tree

Hide file tree

Showing 6 changed files with 50 additions and 50 deletions.
diff --git a/Makefile b/Makefile
@@ -20,10 +20,10 @@ fmt:
 	@go fmt ./...
 
 test:
-	@ginkgo --failFast ./...
+	@go run github.com/onsi/ginkgo/ginkgo --failFast ./...
 
 test-watch:
-	@ginkgo watch -cover -r ./...
+	@go run github.com/onsi/ginkgo/ginkgo watch -cover -r ./...
 
 bench:
 	@mkdir -p ./bench-results
@@ -37,7 +37,7 @@ plot-mem:
 
 coverage-ci:
 	@mkdir -p $(COVERDIR)
-	@ginkgo -r -covermode=count --cover --trace ./...
+	@go run github.com/onsi/ginkgo/ginkgo -r -covermode=count --cover --trace ./...
 	@echo "mode: count" > "${COVERAGEFILE}"
 	@find . -type f -name '*.coverprofile' -exec cat {} \; -exec rm -f {} \; | grep -h -v "^mode:" >> ${COVERAGEFILE}
 

diff --git a/request.go b/request.go
@@ -11,64 +11,64 @@ import (
 
 var requestPool = &sync.Pool{
 	New: func() interface{} {
-		return &request{
+		return &BaseRequest{
 			validParams: make([]string, 0, 10),
 			params:      make([][]byte, 0, 10),
 		}
 	},
 }
 
-type request struct {
+type BaseRequest struct {
 	ctx         context.Context
 	r           *fasthttp.RequestCtx
 	validParams []string
 	params      [][]byte
 }
 
-func acquireRequest(ctx context.Context, r *fasthttp.RequestCtx) *request {
-	req := requestPool.Get().(*request)
+func AcquireRequest(ctx context.Context, r *fasthttp.RequestCtx) *BaseRequest {
+	req := requestPool.Get().(*BaseRequest)
 	req.r = r
 	req.ctx = ctx
 	return req
 }
 
-func releaseRequest(req *request) {
+func ReleaseRequest(req *BaseRequest) {
 	req.reset()
 	requestPool.Put(req)
 }
 
-func (req *request) reset() {
+func (req *BaseRequest) reset() {
 	req.r = nil
 	req.ctx = nil
 	req.validParams = req.validParams[:0]
 	req.params = req.params[:0]
 }
 
-func (req *request) Raw() *fasthttp.RequestCtx {
+func (req *BaseRequest) Raw() *fasthttp.RequestCtx {
 	return req.r
 }
 
-func (req *request) Path() []byte {
+func (req *BaseRequest) Path() []byte {
 	return req.r.Path()
 }
 
-func (req *request) Method() []byte {
+func (req *BaseRequest) Method() []byte {
 	return req.r.Method()
 }
 
-func (req *request) URI() *fasthttp.URI {
+func (req *BaseRequest) URI() *fasthttp.URI {
 	return req.r.URI()
 }
 
-func (req *request) Header(name string) []byte {
+func (req *BaseRequest) Header(name string) []byte {
 	return req.r.Request.Header.Peek(name)
 }
 
-func (req *request) Host() []byte {
+func (req *BaseRequest) Host() []byte {
 	return req.r.Host()
 }
 
-func (req *request) Param(name string) string {
+func (req *BaseRequest) Param(name string) string {
 	// req.params is not safe, since its reused over requests
 	// but validParams is, so we check if name is one of the
 	// valid params, before actually return the value
@@ -80,47 +80,47 @@ func (req *request) Param(name string) string {
 	return ""
 }
 
-func (req *request) Query(name string) []byte {
+func (req *BaseRequest) Query(name string) []byte {
 	return req.r.QueryArgs().Peek(name)
 }
 
-func (req *request) QueryMulti(name string) [][]byte {
+func (req *BaseRequest) QueryMulti(name string) [][]byte {
 	return req.r.QueryArgs().PeekMulti(name)
 }
 
-func (req *request) Data(dst interface{}) error {
+func (req *BaseRequest) Data(dst interface{}) error {
 	return json.Unmarshal(req.r.PostBody(), dst)
 }
 
-func (req *request) Post(name string) []byte {
+func (req *BaseRequest) Post(name string) []byte {
 	return req.r.PostArgs().Peek(name)
 }
 
-func (req *request) PostMulti(name string) [][]byte {
+func (req *BaseRequest) PostMulti(name string) [][]byte {
 	return req.r.PostArgs().PeekMulti(name)
 }
 
-func (req *request) Cookie(name string) []byte {
+func (req *BaseRequest) Cookie(name string) []byte {
 	return req.r.Request.Header.Cookie(name)
 }
 
-func (req *request) Context() context.Context {
+func (req *BaseRequest) Context() context.Context {
 	return req.ctx
 }
 
-func (req *request) WithContext(ctx context.Context) Request {
+func (req *BaseRequest) WithContext(ctx context.Context) Request {
 	req.ctx = ctx
 	return req
 }
 
-func (req *request) IsJSON() bool {
+func (req *BaseRequest) IsJSON() bool {
 	ct := req.r.Request.Header.ContentType()
 	laj := len(applicationJSON)
 	return bytes.Equal(ct, applicationJSON) ||
 		((laj < len(ct)) && bytes.Equal(ct[:laj], applicationJSON) && (ct[laj] == ';'))
 }
 
-func (req *request) WantsJSON() bool {
+func (req *BaseRequest) WantsJSON() bool {
 	accept := req.r.Request.Header.Peek("Accept")
 	laj := len(applicationJSON)
 	return bytes.Equal(accept, applicationJSON) ||

diff --git a/request_test.go b/request_test.go
@@ -9,8 +9,8 @@ import (
 	"github.com/valyala/fasthttp"
 )
 
-func newRequest() *request {
-	return &request{
+func newRequest() *BaseRequest {
+	return &BaseRequest{
 		ctx: context.Background(),
 		r:   &fasthttp.RequestCtx{},
 	}

diff --git a/response.go b/response.go
@@ -9,66 +9,66 @@ import (
 
 var responsePool = &sync.Pool{
 	New: func() interface{} {
-		return &response{
+		return &BaseResponse{
 			result: result{},
 		}
 	},
 }
 
-type response struct {
+type BaseResponse struct {
 	result result
 }
 
-func (res *response) reset() {
+func (res *BaseResponse) reset() {
 	// result is resetted on .End()
 }
 
-func acquireResponse(r *fasthttp.RequestCtx) *response {
-	res := responsePool.Get().(*response)
+func AcquireResponse(r *fasthttp.RequestCtx) *BaseResponse {
+	res := responsePool.Get().(*BaseResponse)
 	res.result.r = r
 	return res
 }
 
-func releaseResponse(res *response) {
+func ReleaseResponse(res *BaseResponse) {
 	res.reset()
 	responsePool.Put(res)
 }
 
-func (res *response) Cookie(cookie *fasthttp.Cookie) Response {
+func (res *BaseResponse) Cookie(cookie *fasthttp.Cookie) Response {
 	res.result.r.Response.Header.SetCookie(cookie)
 	return res
 }
 
-func (res *response) Status(status int) Response {
+func (res *BaseResponse) Status(status int) Response {
 	res.result.status = status
 	return res
 }
 
-func (res *response) Header(name, value string) Response {
+func (res *BaseResponse) Header(name, value string) Response {
 	res.result.r.Response.Header.Set(name, value)
 	return res
 }
 
-func (res *response) Data(data interface{}) Result {
+func (res *BaseResponse) Data(data interface{}) Result {
 	return res.result.Data(data)
 }
 
-func (res *response) Error(err error, options ...interface{}) Result {
+func (res *BaseResponse) Error(err error, options ...interface{}) Result {
 	return res.result.Error(errors.Wrap(err, options...))
 }
 
-func (res *response) Redirect(uri string, code int) Result {
+func (res *BaseResponse) Redirect(uri string, code int) Result {
 	return res.result.Redirect(uri, code)
 }
 
-func (res *response) File(filepath string) Result {
+func (res *BaseResponse) File(filepath string) Result {
 	return res.result.File(filepath)
 }
 
-func (res *response) FileDownload(filepath, filename string) Result {
+func (res *BaseResponse) FileDownload(filepath, filename string) Result {
 	return res.result.FileDownload(filepath, filename)
 }
 
-func (res *response) End() Result {
+func (res *BaseResponse) End() Result {
 	return &res.result
 }
diff --git a/response_test.go b/response_test.go
@@ -24,8 +24,8 @@ func (*errornousJson) MarshalJSON() ([]byte, error) {
 	return nil, errForced
 }
 
-func newResponse() *response {
-	return &response{
+func newResponse() *BaseResponse {
+	return &BaseResponse{
 		result: result{r: &fasthttp.RequestCtx{}},
 	}
 }

diff --git a/router.go b/router.go
@@ -124,17 +124,17 @@ func (router *router) findHandler(root *node, path *tokensDescriptor, values *to
 	return root.Matches(0, path, values)
 }
 
-func (router *router) releaseResources(req *request, res *response, path *tokensDescriptor, values *tokensDescriptor) {
-	releaseRequest(req)
-	releaseResponse(res)
+func (router *router) releaseResources(req *BaseRequest, res *BaseResponse, path *tokensDescriptor, values *tokensDescriptor) {
+	ReleaseRequest(req)
+	ReleaseResponse(res)
 	releaseTokensDescriptor(path)
 	releaseTokensDescriptor(values)
 }
 
 func (router *router) Handler() fasthttp.RequestHandler {
 	return func(fCtx *fasthttp.RequestCtx) {
-		req := acquireRequest(context.Background(), fCtx)
-		res := acquireResponse(fCtx)
+		req := AcquireRequest(context.Background(), fCtx)
+		res := AcquireResponse(fCtx)
 		values := acquireTokensDescriptor()
 		path := acquireTokensDescriptor()
 		defer router.releaseResources(req, res, path, values)