go-micro: github.com/micro/go-micro/server Index | Files | Directories

package server

import "github.com/micro/go-micro/server"

Package server is an interface for a micro server


Package Files

context.go handler.go options.go server.go wrapper.go


var (
    DefaultAddress          = ":0"
    DefaultName             = "go.micro.server"
    DefaultVersion          = "latest"
    DefaultId               = uuid.New().String()
    DefaultRegisterCheck    = func(context.Context) error { return nil }
    DefaultRegisterInterval = time.Second * 30
    DefaultRegisterTTL      = time.Second * 90

func NewContext Uses

func NewContext(ctx context.Context, s Server) context.Context

type Handler Uses

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.


type Greeter struct {}

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

type HandlerFunc Uses

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 Uses

type HandlerOption func(*HandlerOptions)

func EndpointMetadata Uses

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

EndpointMetadata is a Handler option that allows metadata to be added to individual endpoints.

func InternalHandler Uses

func InternalHandler(b bool) HandlerOption

Internal Handler options specifies that a handler is not advertised to the discovery system. In the future this may also limit request to the internal network or authorised user.

type HandlerOptions Uses

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

type HandlerWrapper Uses

type HandlerWrapper func(HandlerFunc) HandlerFunc

HandlerWrapper wraps the HandlerFunc and returns the equivalent

type Message Uses

type Message interface {
    // Topic of the message
    Topic() string
    // The decoded payload value
    Payload() interface{}
    // The content type of the payload
    ContentType() string
    // The raw headers of the message
    Header() map[string]string
    // The raw body of the message
    Body() []byte
    // Codec used to decode the message
    Codec() codec.Reader

Message is an async message interface

type Option Uses

type Option func(*Options)

func Address Uses

func Address(a string) Option

Address to bind to - host:port

func Advertise(a string) Option

The address to advertise for discovery - host:port

func Auth Uses

func Auth(a auth.Auth) Option

Auth mechanism for role based access control

func Broker Uses

func Broker(b broker.Broker) Option

Broker to use for pub/sub

func Codec Uses

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

Codec to use to encode/decode requests for a given content type

func Context Uses

func Context(ctx context.Context) Option

Context specifies a context for the service. Can be used to signal shutdown of the service Can be used for extra option values.

func Id Uses

func Id(id string) Option

Unique server id

func Metadata Uses

func Metadata(md map[string]string) Option

Metadata associated with the server

func Name Uses

func Name(n string) Option

Server name

func Namespace Uses

func Namespace(n string) Option

Namespace to register handlers in

func RegisterCheck Uses

func RegisterCheck(fn func(context.Context) error) Option

RegisterCheck run func before registry service

func RegisterInterval Uses

func RegisterInterval(t time.Duration) Option

Register the service with at interval

func RegisterTTL Uses

func RegisterTTL(t time.Duration) Option

Register the service with a TTL

func Registry Uses

func Registry(r registry.Registry) Option

Registry used for discovery

func TLSConfig Uses

func TLSConfig(t *tls.Config) Option

TLSConfig specifies a *tls.Config

func Tracer Uses

func Tracer(t trace.Tracer) Option

Tracer mechanism for distributed tracking

func Transport Uses

func Transport(t transport.Transport) Option

Transport mechanism for communication e.g http, rabbitmq, etc

func Version Uses

func Version(v string) Option

Version of the service

func Wait Uses

func Wait(wg *sync.WaitGroup) Option

Wait tells the server to wait for requests to finish before exiting If `wg` is nil, server only wait for completion of rpc handler. For user need finer grained control, pass a concrete `wg` here, server will wait against it on stop.

func WithRouter Uses

func WithRouter(r Router) Option

WithRouter sets the request router

func WrapHandler Uses

func WrapHandler(w HandlerWrapper) Option

Adds a handler Wrapper to a list of options passed into the server

func WrapSubscriber Uses

func WrapSubscriber(w SubscriberWrapper) Option

Adds a subscriber Wrapper to a list of options passed into the server

type Options Uses

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

    // RegisterCheck runs a check function before registering the service
    RegisterCheck func(context.Context) error
    // The register expiry time
    RegisterTTL time.Duration
    // The interval on which to register
    RegisterInterval time.Duration

    // The router for requests
    Router Router

    // TLSConfig specifies tls.Config for secure serving
    TLSConfig *tls.Config

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

type Request Uses

type Request interface {
    // Service name requested
    Service() string
    // The action requested
    Method() string
    // Endpoint name requested
    Endpoint() string
    // Content type provided
    ContentType() string
    // Header of the request
    Header() map[string]string
    // Body is the initial decoded value
    Body() interface{}
    // 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 Uses

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

Response is the response writer for unencoded messages

type Router Uses

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

Router handle serving messages

type Server Uses

type Server interface {
    // Initialise options
    Init(...Option) error
    // Retrieve the options
    Options() Options
    // Register a handler
    Handle(Handler) error
    // Create a new handler
    NewHandler(interface{}, ...HandlerOption) Handler
    // Create a new subscriber
    NewSubscriber(string, interface{}, ...SubscriberOption) Subscriber
    // Register a subscriber
    Subscribe(Subscriber) error
    // Start the server
    Start() error
    // Stop the server
    Stop() error
    // Server implementation
    String() string

Server is a simple micro server abstraction

func FromContext Uses

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

type Stream Uses

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 Uses

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 Uses

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. It mirrors the handler in its behaviour.

type SubscriberFunc Uses

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 Uses

type SubscriberOption func(*SubscriberOptions)

func DisableAutoAck Uses

func DisableAutoAck() SubscriberOption

DisableAutoAck will disable auto acking of messages after they have been handled.

func InternalSubscriber Uses

func InternalSubscriber(b bool) SubscriberOption

Internal Subscriber options specifies that a subscriber is not advertised to the discovery system.

func SubscriberContext Uses

func SubscriberContext(ctx context.Context) SubscriberOption

SubscriberContext set context options to allow broker SubscriberOption passed

func SubscriberQueue Uses

func SubscriberQueue(n string) SubscriberOption

Shared queue name distributed messages across subscribers

type SubscriberOptions Uses

type SubscriberOptions struct {
    // AutoAck defaults to true. When a handler returns
    // with a nil error the message is acked.
    AutoAck  bool
    Queue    string
    Internal bool
    Context  context.Context

func NewSubscriberOptions Uses

func NewSubscriberOptions(opts ...SubscriberOption) SubscriberOptions

type SubscriberWrapper Uses

type SubscriberWrapper func(SubscriberFunc) SubscriberFunc

SubscriberWrapper wraps the SubscriberFunc and returns the equivalent


grpcPackage grpc provides a grpc server
mucpPackage mucp provides an mucp server

Package server imports 14 packages (graph) and is imported by 667 packages. Updated 2020-08-10. Refresh now. Tools for package owners.