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

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL