interfaces

Documentation

Index

• Variables
• type CertStorage
• type EventTypeProcess
• type Interceptor
• type Limiter
• type Listener
• type Method
• type MethodMultipleHandler
• type MultipleHandlerOption
• type Options
• type Port
• type RequestContext
  • func (c *RequestContext) GetQuery() (val func() url.Values)
  • func (c *RequestContext) GetRequestID() (val string)
  • func (c *RequestContext) SetQuery(val func() url.Values)
  • func (c *RequestContext) SetRequestID(val string)
• type RequestContextType
• type TLSCerts
• type TcpConnectionInformation
• type TcpHandler
• type TcpHandlerOnDone
• type UseAuthCallback
• type WebSocketHandler
• type WebSocketHandlerOnMsg

Variables

var DefaultServices = map[string]bool{
	"debug.Testing/Input":  true,
	"debug.Testing/Stream": true,
	"debug.Info/Request":   true,
	"grpc.reflection.v1alpha.ServerReflection/ServerReflectionInfo": true,
}

Types

type CertStorage

type CertStorage interface {
	Init() error
	GetCrt() (s [][]byte)
	OnChange(func())
}

type EventTypeProcess

type EventTypeProcess string

const (
	EventTypeProcessSplitter               EventTypeProcess = "http.splitter"
	EventTypeProcessHttpHandler            EventTypeProcess = "http.handler"
	EventTypeProcessHttpController         EventTypeProcess = "http.controller"
	EventTypeProcessGRPCWebController      EventTypeProcess = "grpc.web.controller"
	EventTypeProcessGRPCController         EventTypeProcess = "grpc.controller"
	EventTypeProcessHttpMiddlewareCompress EventTypeProcess = "http.middleware.compress"
)

type Interceptor

type Interceptor interface {
	Handler(http.Handler) http.Handler
	UnaryServerInterceptor() grpc.UnaryServerInterceptor
	StreamServerInterceptor() grpc.StreamServerInterceptor
}

type Limiter

type Limiter struct {
	Enable      bool    `yaml:"enable" default:"false"`
	Max         float64 `yaml:"max" default:"100"`
	PerIp       bool    `yaml:"perIp" default:"false"`
	EveryMinute bool    `yaml:"everyMinute" default:"false"`
}

type Listener

type Listener interface {
	Init(opt Options, interceptor ...Interceptor)
	//InitProcess - Without starting listener
	InitProcess(opt Options, interceptor ...Interceptor)
	Run() (err error)
	Close()
	RegisterMultipleHandler(MethodMultipleHandler)
	RegisterHttpHandler(path, method string, handler http.Handler)
	SetTracer(tracing.Tracing)
	UseWebSocket(pa string, onConnected WebSocketHandler, onMsg WebSocketHandlerOnMsg,
		onDisconnected WebSocketHandler) error
	GetInterceptor() (interceptor []Interceptor)
	GetServices() []string
	GetAllServices() (res []*proto.ServicesItems)
	GetOptions() Options
	GetTracer() tracing.Tracing
	NewMonitor() (mm interface{})
	SetMonitor(interface{})
	GetMonitor() (mm interface{})
	GetMonitorResponse() *proto.MonitorResponse
	GetLimiter() *limiter.Limiter
	GetGrpcServer() *grpc.Server
	GetTLSCerts() TLSCerts
	GlobalContext() context.Context
}

type Method

type Method string

const (
	MethodGET    Method = "GET"
	MethodPOST   Method = "POST"
	MethodPUT    Method = "PUT"
	MethodDELETE Method = "DELETE"
)

type MethodMultipleHandler

type MethodMultipleHandler interface{}

type MultipleHandlerOption

type MultipleHandlerOption interface {
	GetServiceDesc() []*grpc.ServiceDesc
	AllowMethod(string) []Method
}

MultipleHandlerOption -

type Options

type Options struct {
	ServiceName         string
	Listen              string
	Port                Port
	Logger              logger.Logger
	Pem                 string
	Vault               *proto.Vault
	AutoReloadPemDir    bool
	DisableSecure       bool
	EnableEncryption    bool
	Driver              string
	UseAuthCallback     UseAuthCallback
	ServiceInfo         *proto.ServicesInfo
	DisableMonitor      bool
	DefaultAllowHeaders []string
	Limiter             Limiter
	TraceLog            tracingInterface.DefaultLogSpanSave
}

type Port

type Port struct {
	Insecure int
	Secure   int
}

type RequestContext

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

func (*RequestContext) GetQuery

func (c *RequestContext) GetQuery() (val func() url.Values)

func (*RequestContext) GetRequestID

func (c *RequestContext) GetRequestID() (val string)

func (*RequestContext) SetQuery

func (c *RequestContext) SetQuery(val func() url.Values)

func (*RequestContext) SetRequestID

func (c *RequestContext) SetRequestID(val string)

type RequestContextType

type RequestContextType string

const RequestContextWebSocket RequestContextType = "RequestContextWebSocket"

type TLSCerts

type TLSCerts interface {
	Init()
	NewConfig(name string, dir string, autoReload bool, disableHttp2 bool, vault *proto.Vault) *tls.Config
}

type TcpConnectionInformation

type TcpConnectionInformation struct {
	Secure      bool
	ClientHello *tls.ClientHelloInfo
}

type TcpHandler

type TcpHandler func(conn net.Conn, info *TcpConnectionInformation, onDone TcpHandlerOnDone)

type TcpHandlerOnDone

type TcpHandlerOnDone func()

type UseAuthCallback

type UseAuthCallback func(r *http.Request) bool

type WebSocketHandler

type WebSocketHandler func(ctx context.Context, c *websocket.Conn) error

type WebSocketHandlerOnMsg

type WebSocketHandlerOnMsg func(ctx context.Context, data []byte, c *websocket.Conn) error