rpcs

type Decoder interface {
	// Decode decodes the provided payload with its format from the
	// provided reader. In case of failure it is possible a partial
	// read has occurred
	Decode(r io.Reader, v interface{}) error
}

type DeserializeFunc func(r io.Reader) error

type Deserializer interface {
	// Deserialize the contents of the reader into an object owned
	// by the deserializer
	Deserialize(r io.Reader) error
}

type Encoder interface {
	// Encode encodes the provided payload with its format to the
	// provided writer. In case of failure it is possible a partial
	// write of the serialization to the writer
	Encode(w io.Writer, v interface{}) error
}

type EntityFactory interface {
	Create() interface{}
}

type EntityFactoryFunc func() interface{}

type ErrMsgs error

type Handler interface {
	// Handle handlers an rpc request and returns a response or error if needed.
	// Implementations should ensure that if a context is cancelled the request
	// handling should be halt gracefully and return an appropriate error.
	Handle(ctx context.Context, req interface{}) (interface{}, error)
}

type HandlerBinder interface {
	// Bind binds a handler for a specific method and path, so that the handler
	// will be dispatched when method and path combination is provided
	Bind(method string, path string, handler Handler, factory EntityFactory)
}

type HandlerFunc func(ctx context.Context, req interface{}) (interface{}, error)

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

type HttpBinderProperties struct {
	Encoder        Encoder
	Logger         logs.Logger
	HandlerFactory HttpHandlerFactory
}

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

type HttpCorsPreProcessorProps struct {
	// Enabled if true the HttpCorsHandler will verify requests, if false
	// the handler will just pass on a request to the next middleware
	Enabled bool

	// AllowedOrigins is a list of origins a cross-domain request can be executed from.
	// If the special "*" value is present in the list, all origins will be allowed.
	// An origin may contain a wildcard (*) to replace 0 or more characters
	// (i.e.: http://*.domain.com). Usage of wildcards implies a small performance penalty.
	// Only one wildcard can be used per origin.
	// Default value is ["*"]
	AllowedOrigins []string

	// AllowedMethods is a list of methods the client is allowed to use with
	// cross-domain requests. Default value is simple methods (HEAD, GET and POST).
	AllowedMethods []string

	// AllowedHeaders is list of non simple headers the client is allowed to use with
	// cross-domain requests.
	// If the special "*" value is present in the list, all headers will be allowed.
	// Default value is [] but "Origin" is always appended to the list.
	AllowedHeaders []string

	// ExposedHeaders indicates which headers are safe to expose to the API of a CORS
	// API specification
	ExposedHeaders []string

	// MaxAge indicates how long (in seconds) the results of a preflight request
	// can be cached
	MaxAge int

	// AllowCredentials indicates whether the request can include user credentials like
	// cookies, HTTP authentication or client side SSL certificates.
	AllowCredentials bool
}

type HttpError struct {
	// Cause of the creation of this HttpError instance
	Cause error

	// StatusCode is the HTTP status code that defines the error cause
	StatusCode int

	// Message is the human-readable string that defines the error cause
	Message string
}

type HttpHandlerFactory interface {
	Make(factory EntityFactory, handler Handler) HttpMiddleware
}

type HttpHandlerFactoryFunc func(factory EntityFactory, handler Handler) HttpMiddleware

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

type HttpJsonHandlerProperties struct {
	// Limit is the maximum number of bytes an Http body can have. Bodies
	// with a higher limit will fail to deserialize and be rejected
	Limit uint

	// Handler is the rpc handler that will be used to handle the request
	Handler Handler

	// Logger
	Logger logs.Logger

	// Factory for creating new instances of objects to which the Http body
	// will be deserialized. Those instances will be passed to the handler
	Factory EntityFactory
}

type HttpMiddleware interface {
	// ServeHTTP allows to handle an http request. The response will be serialized
	// by an HttpRouter
	ServeHTTP(req *http.Request) (interface{}, error)
}

type HttpMiddlewareFunc func(req *http.Request) (interface{}, error)

type HttpPreProcessor interface {
	// ServeHTTP is a similar interface to http.Handler with the difference that
	// it returns true parameters. The boolean parameter indicates in case of its
	// value being true that the request can be further processed by another handler.
	// In case that it's false, no further processing of the request is required.
	// The *http.Request returned is a potentially modified request resulting of
	// mutating the original *http.Request
	ServeHTTP(w http.ResponseWriter, req *http.Request) (HttpPreProcessorResult, error)
}

type HttpPreProcessorResult struct {
	Request  *http.Request
	Continue bool
}

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

type HttpRouteProps struct {
	Logger        logs.Logger
	Encoder       Encoder
	Handlers      MethodHandlers
	PreProcessors []HttpPreProcessor
}

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

type JsonDecoder struct{}

type JsonEncoder struct{}

type MethodHandlers map[string]HttpMiddleware

type SerializeFunc func(w io.Writer) error

type Serializer interface {
	// Serialize an object into the provided writer
	Serialize(w io.Writer) error
}

type SimpleJsonDeserializer struct {
	O interface{}
}

type SimpleJsonSerializer struct {
	O interface{}
}