httptransport

package module
v1.20.2 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Jan 28, 2022 License: MIT Imports: 33 Imported by: 1

README

HTTP Transport

GoDoc Widget codecov Go Report Card

Courier Transport for HTTP.

Documentation

Documentation

Index

Examples

Constants

This section is empty.

Variables

This section is empty.

Functions

func AsRequestOut 

func AsRequestOut(ctx context.Context) context.Context

func ContextWithHttpRequest 

func ContextWithHttpRequest(ctx context.Context, req *http.Request) context.Context

func ContextWithOperationID 

func ContextWithOperationID(ctx context.Context, operationID string) context.Context

func ContextWithOperatorFactory 

func ContextWithOperatorFactory(ctx context.Context, om *courier.OperatorFactory) context.Context

func ContextWithServiceMeta 

func ContextWithServiceMeta(ctx context.Context, meta ServiceMeta) context.Context

func EnableQueryInBodyForHttpGet 

func EnableQueryInBodyForHttpGet(ctx context.Context) context.Context

func HttpRequestFromContext 

func HttpRequestFromContext(ctx context.Context) *http.Request

func OperationIDFromContext 

func OperationIDFromContext(ctx context.Context) string

func OperatorFactoryFromContext 

func OperatorFactoryFromContext(ctx context.Context) *courier.OperatorFactory

func OperatorParamsFromStruct 

func OperatorParamsFromStruct(v interface{}) map[string][]string

func ParamsFromMap 

func ParamsFromMap(m map[string]string) httprouter.Params

func ShouldQueryInBodyForHttpGet 

func ShouldQueryInBodyForHttpGet(ctx context.Context) bool

func TryCatch 

func TryCatch(fn func()) (err error)

Types

type BadRequest 

type BadRequest struct {
	// contains filtered or unexported fields
}

func (*BadRequest) AddErr 

func (e *BadRequest) AddErr(err error, in string, nameOrIdx ...interface{})

func (*BadRequest) EnableErrTalk 

func (e *BadRequest) EnableErrTalk()

func (*BadRequest) Err 

func (e *BadRequest) Err() error

func (*BadRequest) SetMsg 

func (e *BadRequest) SetMsg(msg string)

type BasePathDescriber 

type BasePathDescriber interface {
	BasePath() string
}

type HttpMiddleware 

type HttpMiddleware func(http.Handler) http.Handler

func MiddlewareChain 

func MiddlewareChain(mw ...HttpMiddleware) HttpMiddleware

type HttpRouteHandler 

type HttpRouteHandler struct {
	*RequestTransformerMgr
	*HttpRouteMeta
	// contains filtered or unexported fields
}

func NewHttpRouteHandler 

func NewHttpRouteHandler(serviceMeta *ServiceMeta, httpRoute *HttpRouteMeta, requestTransformerMgr *RequestTransformerMgr) *HttpRouteHandler

func (*HttpRouteHandler) ServeHTTP 

func (handler *HttpRouteHandler) ServeHTTP(rw http.ResponseWriter, r *http.Request)

type HttpRouteMeta 

type HttpRouteMeta struct {
	Route                         *courier.Route
	OperatorFactoryWithRouteMetas []*OperatorFactoryWithRouteMeta
}
Example 
package main

import (
	"fmt"
	"os"
	"sort"

	"github.com/fatih/color"
	"github.com/go-liewhite/httptransport"
	"github.com/go-liewhite/httptransport/__examples__/server/cmd/app/routes"
)

func main() {
	os.Setenv("PROJECT_NAME", "service-example")
	os.Setenv("PROJECT_VERSION", "1.0.0")
	color.NoColor = true

	routeList := routes.RootRouter.Routes()

	sort.Slice(routeList, func(i, j int) bool {
		return httptransport.NewHttpRouteMeta(routeList[i]).Key() <
			httptransport.NewHttpRouteMeta(routeList[j]).Key()
	})

	for i := range routeList {
		httpRouteMeta := httptransport.NewHttpRouteMeta(routeList[i])
		fmt.Println(httpRouteMeta.String())
	}
}

Output:

GET /demo openapi.OpenAPI
GET /demo/binary/files routes.DownloadFile
GET /demo/binary/images routes.ShowImage
POS /demo/cookie routes.Cookie
POS /demo/forms/multipart routes.FormMultipartWithFile
POS /demo/forms/multipart-with-files routes.FormMultipartWithFiles
POS /demo/forms/urlencoded routes.FormURLEncoded
GET /demo/proxy routes.Proxy
GET /demo/redirect routes.Redirect
POS /demo/redirect routes.RedirectWhenError
POS /demo/restful routes.Create
HEA /demo/restful routes.HealthCheck
GET /demo/restful/{id} routes.DataProvider routes.GetByID
DEL /demo/restful/{id} routes.DataProvider routes.RemoveByID
PUT /demo/restful/{id} routes.DataProvider routes.UpdateByID
GET /demo/v2/proxy routes.ProxyV2

func NewHttpRouteMeta 

func NewHttpRouteMeta(route *courier.Route) *HttpRouteMeta

func (*HttpRouteMeta) Key 

func (route *HttpRouteMeta) Key() string

func (*HttpRouteMeta) Log 

func (route *HttpRouteMeta) Log()

func (*HttpRouteMeta) Method 

func (route *HttpRouteMeta) Method() string

func (*HttpRouteMeta) OperatorNames 

func (route *HttpRouteMeta) OperatorNames() string

func (*HttpRouteMeta) Path 

func (route *HttpRouteMeta) Path() string

func (*HttpRouteMeta) String 

func (route *HttpRouteMeta) String() string

type HttpTransport 

type HttpTransport struct {
	ServiceMeta

	Port int

	// for modifying http.Server
	ServerModifiers []ServerModifier

	// Middlewares
	// can use https://github.com/gorilla/handlers
	Middlewares []HttpMiddleware

	// validator mgr for parameter validating
	ValidatorMgr validator.ValidatorMgr
	// transformer mgr for parameter transforming
	TransformerMgr transformers.TransformerMgr

	CertFile string
	KeyFile  string
	// contains filtered or unexported fields
}

func NewHttpTransport 

func NewHttpTransport(serverModifiers ...ServerModifier) *HttpTransport

func (*HttpTransport) Serve 

func (t *HttpTransport) Serve(router *courier.Router) error

func (*HttpTransport) ServeContext 

func (t *HttpTransport) ServeContext(ctx context.Context, router *courier.Router) error

func (*HttpTransport) ServeHTTP 

func (t *HttpTransport) ServeHTTP(w http.ResponseWriter, req *http.Request)

func (*HttpTransport) SetDefaults 

func (t *HttpTransport) SetDefaults()

type MetaOperator 

type MetaOperator struct {
	courier.EmptyOperator
	// contains filtered or unexported fields
}

func BasePath 

func BasePath(basePath string) *MetaOperator

func Group 

func Group(path string) *MetaOperator
Example 
package main

import (
	"fmt"

	"github.com/go-liewhite/httptransport"
)

func main() {
	g := httptransport.Group("/test")
	fmt.Println(g.Path())
}

Output:

/test

func (*MetaOperator) BasePath 

func (g *MetaOperator) BasePath() string

func (*MetaOperator) Path 

func (g *MetaOperator) Path() string

type MethodDescriber 

type MethodDescriber interface {
	Method() string
}

type OperatorFactoryWithRouteMeta 

type OperatorFactoryWithRouteMeta struct {
	*courier.OperatorFactory
	RouteMeta
}

func NewOperatorFactoryWithRouteMeta 

func NewOperatorFactoryWithRouteMeta(op courier.Operator, last bool) *OperatorFactoryWithRouteMeta

type PathDescriber 

type PathDescriber interface {
	Path() string
}

type PathnamePattern 

type PathnamePattern struct {
	// contains filtered or unexported fields
}

func NewPathnamePattern 

func NewPathnamePattern(p string) *PathnamePattern

func (*PathnamePattern) Parse 

func (pattern *PathnamePattern) Parse(pathname string) (params httprouter.Params, err error)

func (*PathnamePattern) String 

func (pattern *PathnamePattern) String() string

func (*PathnamePattern) Stringify 

func (pattern *PathnamePattern) Stringify(params httprouter.Params) string

type PostValidator 

type PostValidator interface {
	PostValidate(badRequest *BadRequest)
}

type RequestInfo 

type RequestInfo struct {
	Request *http.Request
	// contains filtered or unexported fields
}

func NewRequestInfo 

func NewRequestInfo(r *http.Request) *RequestInfo

func (*RequestInfo) Body 

func (info *RequestInfo) Body() io.Reader

func (*RequestInfo) CookieValues 

func (info *RequestInfo) CookieValues(name string) []string

func (*RequestInfo) HeaderValues 

func (info *RequestInfo) HeaderValues(name string) []string

func (*RequestInfo) Param 

func (info *RequestInfo) Param(name string) string

func (*RequestInfo) QueryValues 

func (info *RequestInfo) QueryValues(name string) []string

func (*RequestInfo) Value 

func (info *RequestInfo) Value(in string, name string) string

func (*RequestInfo) Values 

func (info *RequestInfo) Values(in string, name string) []string

type RequestParameter 

type RequestParameter struct {
	Name string
	In   string
	transformers.CommonTransformOption
	Transformer transformers.Transformer
	Validator   validator.Validator
}

func NewRequestParameter 

func NewRequestParameter(name string, in string) *RequestParameter

type RequestTransformer 

type RequestTransformer struct {
	Type       reflect.Type
	Parameters map[string]*RequestParameter
}

func (*RequestTransformer) DecodeFrom 

func (t *RequestTransformer) DecodeFrom(info *RequestInfo, meta *courier.OperatorFactory, v interface{}) error
Example (RequestInfo_failedOfPost) 
package main

import (
	"context"
	"fmt"
	"net/http"
	"reflect"
	"sort"

	"github.com/go-liewhite/courier"
	"github.com/go-liewhite/statuserror"

	perrors "github.com/pkg/errors"

	"github.com/go-liewhite/httptransport"
)

type ReqWithPostValidate struct {
	StartedAt string `in:"query"`
}

func (ReqWithPostValidate) PostValidate(badRequest *httptransport.BadRequest) {
	badRequest.AddErr(perrors.Errorf("ops"), "query", "StartedAt")
}

func main() {
	mgr := httptransport.NewRequestTransformerMgr(nil, nil)

	rtForSomeRequest, err := mgr.NewRequestTransformer(context.Background(), reflect.TypeOf(&ReqWithPostValidate{}))
	if err != nil {
		return
	}

	req, err := rtForSomeRequest.NewRequest(http.MethodPost, "/:id", &ReqWithPostValidate{})
	if err != nil {
		return
	}

	e := rtForSomeRequest.DecodeFrom(httptransport.NewRequestInfo(req), &courier.OperatorFactory{}, &ReqWithPostValidate{})
	if e == nil {
		return
	}

	errFields := e.(*statuserror.StatusErr).ErrorFields

	sort.Slice(errFields, func(i, j int) bool {
		return errFields[i].Field < errFields[j].Field
	})

	for _, ef := range errFields {
		fmt.Println(ef)
	}
}

Output:

StartedAt in query - missing required field
StartedAt in query - ops

func (*RequestTransformer) NewRequest 

func (t *RequestTransformer) NewRequest(method string, rawUrl string, v interface{}) (*http.Request, error)

func (*RequestTransformer) NewRequestWithContext 

func (t *RequestTransformer) NewRequestWithContext(ctx context.Context, method string, rawUrl string, v interface{}) (*http.Request, error)

type RequestTransformerMgr 

type RequestTransformerMgr struct {
	validator.ValidatorMgr
	transformers.TransformerMgr
	// contains filtered or unexported fields
}

func NewRequestTransformerMgr 

func NewRequestTransformerMgr(
	transformerMgr transformers.TransformerMgr,
	validatorMgr validator.ValidatorMgr,
) *RequestTransformerMgr
Example 
package main

import (
	"context"
	"fmt"
	"reflect"
	"strconv"

	"github.com/go-liewhite/httptransport/__examples__/server/pkg/types"
	"github.com/go-liewhite/validator/errors"

	"github.com/go-liewhite/httptransport"
)

func main() {
	mgr := httptransport.NewRequestTransformerMgr(nil, nil)

	type PlainBody struct {
		A   string `json:"a" validate:"@string[2,]"`
		Int int    `json:"int,omitempty" default:"0" validate:"@int[0,]"`
	}

	type Req struct {
		Protocol  types.Protocol `name:"protocol,omitempty" in:"query" default:"HTTP"`
		QString   string         `name:"string,omitempty" in:"query" default:"s"`
		PlainBody PlainBody      `in:"body" mime:"plain" validate:"@struct<json>"`
	}

	req := &Req{}
	req.PlainBody.A = "1"

	rtForSomeRequest, err := mgr.NewRequestTransformer(context.Background(), reflect.TypeOf(req))
	if err != nil {
		panic(err)
	}

	statusErr := rtForSomeRequest.Parameters["PlainBody"].Validator.Validate(req.PlainBody)

	statusErr.(*errors.ErrorSet).Each(func(fieldErr *errors.FieldError) {
		fmt.Println(fieldErr.Field, strconv.Quote(fieldErr.Error.Error()))
	})
}

Output:

a "string length should be larger than 2, but got invalid value 1"

func (*RequestTransformerMgr) NewRequest 

func (mgr *RequestTransformerMgr) NewRequest(method string, rawUrl string, v interface{}) (*http.Request, error)

func (*RequestTransformerMgr) NewRequestTransformer 

func (mgr *RequestTransformerMgr) NewRequestTransformer(ctx context.Context, typ reflect.Type) (*RequestTransformer, error)

func (*RequestTransformerMgr) NewRequestWithContext 

func (mgr *RequestTransformerMgr) NewRequestWithContext(ctx context.Context, method string, rawUrl string, v interface{}) (*http.Request, error)

func (*RequestTransformerMgr) SetDefaults 

func (mgr *RequestTransformerMgr) SetDefaults()

type ResponseWithError 

type ResponseWithError interface {
	WriteErrer(err error)
}

type RouteMeta 

type RouteMeta struct {
	ID         string
	Method     string
	Path       string
	BasePath   string
	Summary    string
	Deprecated bool
}

type ServerModifier 

type ServerModifier func(server *http.Server) error

type ServiceMeta 

type ServiceMeta struct {
	Name    string
	Version string
}

func ServerMetaFromContext 

func ServerMetaFromContext(ctx context.Context) ServiceMeta

func (*ServiceMeta) SetDefaults 

func (s *ServiceMeta) SetDefaults()

func (ServiceMeta) String 

func (s ServiceMeta) String() string

Source Files

View all Source files

Directories

Path Synopsis
__examples__
server/cmd/app
server/cmd/app/routes
server/pkg/errors
server/pkg/types
generator
roundtrippers
__codegen__/method
__codegen__/mimes
__codegen__/redirect
generator
generator/__examples__/definition_scanner
generator/__examples__/definition_scanner/time
generator/__examples__/router_scanner
generator/__examples__/router_scanner/auth
generator/__examples__/router_scanner/group
generator/__examples__/status_err_scanner

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.