httptransport

package module
v1.0.7 Latest Latest
Warning

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

 Go to latest Published: Mar 14, 2024 License: MIT Imports: 31 Imported by: 0

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 IsRequestOut 

func IsRequestOut(ctx context.Context) bool

func OperationIDFromContext 

func OperationIDFromContext(ctx context.Context) string

func OperatorFactoryFromContext 

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

func ShouldQueryInBodyForHttpGet 

func ShouldQueryInBodyForHttpGet(ctx context.Context) bool

Types

type BadRequestError 

type BadRequestError interface {
	EnableErrTalk()
	SetMsg(msg string)
	AddErr(err error, nameOrIdx ...interface{})
}

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"

	"gitee.com/go-genie/httptransport"
	"gitee.com/go-genie/httptransport/testdata/server/cmd/app/routes"
	"github.com/fatih/color"
)

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"

	"gitee.com/go-genie/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 PostValidator 

type PostValidator interface {
	PostValidate(badRequest BadRequestError)
}

type RequestTransformer 

type RequestTransformer struct {
	Type         reflect.Type
	InParameters map[string][]transformers.RequestParameter
}

func (*RequestTransformer) DecodeAndValidate 

func (t *RequestTransformer) DecodeAndValidate(ctx context.Context, info httpx.RequestInfo, v interface{}) error
Example (RequestInfo_failedOfPost) 
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.DecodeAndValidate(context.Background(), httpx.NewRequestInfo(req), &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) DecodeFromRequestInfo 

func (t *RequestTransformer) DecodeFromRequestInfo(ctx context.Context, info httpx.RequestInfo, v interface{}) error

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 
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.InParameters["body"][0].Validator.Validate(req.PlainBody)

statusErr.(*errors.ErrorSet).Each(func(fieldErr *errors.FieldError) {
	fmt.Println(fieldErr.Path, 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 {
	WriteError(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

type WithFromRequestInfo 

type WithFromRequestInfo interface {
	FromRequestInfo(req *httpx.RequestInfo) error
}

Source Files

View all Source files

Directories

Path Synopsis
roundtrippers
generators
client
openapi
__codegen__/mimes
__codegen__/redirect
Each Validator have at least two process methods, one for 'Parsing' and one for 'Validating'.
 Each Validator have at least two process methods, one for 'Parsing' and one for 'Validating'.
rules
strfmt

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.