server

type Debug ¶

type Debug struct {
	debug.DebugHandler
}

We use this to wrap any debug handlers so we preserve the signature Debug.{Method}

type Handler ¶

type Handler interface {
	Name() string
	Handler() interface{}
	Endpoints() []*registry.Endpoint
	Options() HandlerOptions
}

Handler interface represents a request handler. It's generated by passing any type of public concrete object with endpoints into server.NewHandler. Most will pass in a struct.

Example:

type Greeter struct {}

func (g *Greeter) Hello(context, request, response) error {
        return nil
}

func NewHandler(h interface{}, opts ...HandlerOption) Handler

type Foo struct {}
func (f *Foo) Bar(ctx, req, rsp) error {
	return nil
}

type HandlerFunc ¶

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

HandlerFunc represents a single method of a handler. It's used primarily for the wrappers. What's handed to the actual method is the concrete request and response types.

type HandlerOption ¶

type HandlerOption func(*HandlerOptions)

func EndpointMetadata(name string, md map[string]string) HandlerOption

func InternalHandler(b bool) HandlerOption

type HandlerOptions ¶

type HandlerOptions struct {
	Internal bool
	Metadata map[string]map[string]string
}

type HandlerWrapper ¶

type HandlerWrapper func(HandlerFunc) HandlerFunc

HandlerWrapper wraps the HandlerFunc and returns the equivalent

type Message ¶ added in v0.8.0

type Message interface {
	Topic() string
	Payload() interface{}
	ContentType() string
}

Message is an async message interface

type Option ¶

type Option func(*Options)

func Address(a string) Option

func Advertise(a string) Option

func Broker(b broker.Broker) Option

func Codec(contentType string, c codec.NewCodec) Option

func DebugHandler(d debug.DebugHandler) Option

func Id(id string) Option

func Metadata(md map[string]string) Option

func Name(n string) Option

func RegisterTTL(t time.Duration) Option

func Registry(r registry.Registry) Option

func Transport(t transport.Transport) Option

func Version(v string) Option

func Wait(b bool) Option

func WithRouter(r Router) Option

func WrapHandler(w HandlerWrapper) Option

func WrapSubscriber(w SubscriberWrapper) Option

type Options ¶

type Options struct {
	Codecs       map[string]codec.NewCodec
	Broker       broker.Broker
	Registry     registry.Registry
	Transport    transport.Transport
	Metadata     map[string]string
	Name         string
	Address      string
	Advertise    string
	Id           string
	Version      string
	HdlrWrappers []HandlerWrapper
	SubWrappers  []SubscriberWrapper

	// The register expiry time
	RegisterTTL time.Duration

	// The router for requests
	Router Router

	// Debug Handler which can be set by a user
	DebugHandler debug.DebugHandler

	// Other options for implementations of the interface
	// can be stored in a context
	Context context.Context
}

func DefaultOptions() Options

type Request ¶

type Request interface {
	// Service name requested
	Service() string
	// Endpoint name requested
	Endpoint() string
	// Content type provided
	ContentType() string
	// Header of the request
	Header() map[string]string
	// Read the undecoded request body
	Read() ([]byte, error)
	// The encoded message stream
	Codec() codec.Reader
	// Indicates whether its a stream
	Stream() bool
}

Request is a synchronous request interface

type Response ¶ added in v0.20.0

type Response interface {
	// Encoded writer
	Codec() codec.Writer
	// Write the header
	WriteHeader(map[string]string)
	// write a response directly to the client
	Write([]byte) error
}

Response is the response writer for unencoded messages

type Router ¶ added in v0.20.0

type Router interface {
	// ServeRequest processes a request to completion
	ServeRequest(context.Context, Request, Response) error
}

Router handle serving messages

type Server ¶

type Server interface {
	Options() Options
	Init(...Option) error
	Handle(Handler) error
	NewHandler(interface{}, ...HandlerOption) Handler
	NewSubscriber(string, interface{}, ...SubscriberOption) Subscriber
	Subscribe(Subscriber) error
	Register() error
	Deregister() error
	Start() error
	Stop() error
	String() string
}

Server is a simple micro server abstraction

func FromContext(ctx context.Context) (Server, bool)

func NewServer(opt ...Option) Server

type Stream ¶ added in v0.8.0

type Stream interface {
	Context() context.Context
	Request() Request
	Send(interface{}) error
	Recv(interface{}) error
	Error() error
	Close() error
}

Stream represents a stream established with a client. A stream can be bidirectional which is indicated by the request. The last error will be left in Error(). EOF indicates end of the stream.

type StreamWrapper ¶ added in v0.8.0

type StreamWrapper func(Stream) Stream

StreamWrapper wraps a Stream interface and returns the equivalent. Because streams exist for the lifetime of a method invocation this is a convenient way to wrap a Stream as its in use for trace, monitoring, metrics, etc.

type Subscriber ¶

type Subscriber interface {
	Topic() string
	Subscriber() interface{}
	Endpoints() []*registry.Endpoint
	Options() SubscriberOptions
}

Subscriber interface represents a subscription to a given topic using a specific subscriber function or object with endpoints.

func NewSubscriber(topic string, h interface{}, opts ...SubscriberOption) Subscriber

type SubscriberFunc ¶

type SubscriberFunc func(ctx context.Context, msg Message) error

SubscriberFunc represents a single method of a subscriber. It's used primarily for the wrappers. What's handed to the actual method is the concrete publication message.

type SubscriberOption ¶

type SubscriberOption func(*SubscriberOptions)

func InternalSubscriber(b bool) SubscriberOption

func SubscriberQueue(n string) SubscriberOption

type SubscriberOptions ¶

type SubscriberOptions struct {
	Queue    string
	Internal bool
}

type SubscriberWrapper ¶

type SubscriberWrapper func(SubscriberFunc) SubscriberFunc

SubscriberWrapper wraps the SubscriberFunc and returns the equivalent