micro/server/options.go

363 lines
8.3 KiB
Go
Raw Normal View History

2015-05-27 00:39:48 +03:00
package server
import (
2018-03-03 14:53:52 +03:00
"context"
"crypto/tls"
"sync"
2016-01-27 02:32:27 +03:00
"time"
"github.com/unistack-org/micro/v3/auth"
"github.com/unistack-org/micro/v3/broker"
"github.com/unistack-org/micro/v3/codec"
"github.com/unistack-org/micro/v3/logger"
"github.com/unistack-org/micro/v3/network/transport"
"github.com/unistack-org/micro/v3/registry"
"github.com/unistack-org/micro/v3/tracer"
2015-05-27 00:39:48 +03:00
)
// Options server struct
type Options struct {
Codecs map[string]codec.NewCodec
Broker broker.Broker
Registry registry.Registry
Tracer tracer.Tracer
Auth auth.Auth
Logger logger.Logger
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
2019-01-08 23:32:47 +03:00
// The register expiry time
2016-01-27 15:23:18 +03:00
RegisterTTL time.Duration
2019-01-24 16:22:17 +03:00
// The interval on which to register
RegisterInterval time.Duration
// RegisterAttempts specify how many times try to register
RegisterAttempts int
// DeegisterAttempts specify how many times try to deregister
DeregisterAttempts int
2016-01-27 15:23:18 +03:00
2019-01-08 23:32:47 +03:00
// The router for requests
Router Router
// TLSConfig specifies tls.Config for secure serving
TLSConfig *tls.Config
Wait *sync.WaitGroup
// Other options for implementations of the interface
// can be stored in a context
Context context.Context
}
// NewOptions returns new options struct with default or passed values
func NewOptions(opts ...Option) Options {
options := Options{
Auth: auth.DefaultAuth,
Codecs: make(map[string]codec.NewCodec),
Context: context.Background(),
Metadata: map[string]string{},
RegisterInterval: DefaultRegisterInterval,
RegisterTTL: DefaultRegisterTTL,
RegisterCheck: DefaultRegisterCheck,
Logger: logger.DefaultLogger,
Tracer: tracer.DefaultTracer,
Broker: broker.DefaultBroker,
Registry: registry.DefaultRegistry,
Address: DefaultAddress,
Name: DefaultName,
Version: DefaultVersion,
Id: DefaultId,
Transport: transport.DefaultTransport,
2015-11-25 22:50:05 +03:00
}
for _, o := range opts {
o(&options)
}
return options
2015-05-27 00:39:48 +03:00
}
// Name sets the server name option
func Name(n string) Option {
return func(o *Options) {
o.Name = n
}
}
// Namespace to register handlers in
func Namespace(n string) Option {
return func(o *Options) {
o.Namespace = n
}
}
// Logger sets the logger option
func Logger(l logger.Logger) Option {
return func(o *Options) {
o.Logger = l
}
}
// Id unique server id
func Id(id string) Option {
return func(o *Options) {
o.Id = id
}
}
2015-11-26 03:23:36 +03:00
// Version of the service
func Version(v string) Option {
return func(o *Options) {
o.Version = v
}
}
2015-11-26 03:23:36 +03:00
// Address to bind to - host:port
func Address(a string) Option {
return func(o *Options) {
o.Address = a
}
}
// Advertise the address to advertise for discovery - host:port
2015-11-11 21:22:04 +03:00
func Advertise(a string) Option {
return func(o *Options) {
o.Advertise = a
2015-11-11 21:22:04 +03:00
}
}
2015-11-26 03:23:36 +03:00
// Broker to use for pub/sub
func Broker(b broker.Broker) Option {
return func(o *Options) {
o.Broker = b
}
}
2015-11-26 03:23:36 +03:00
// Codec to use to encode/decode requests for a given content type
func Codec(contentType string, c codec.NewCodec) Option {
return func(o *Options) {
o.Codecs[contentType] = c
2015-11-25 22:50:05 +03:00
}
}
// Context specifies a context for the service.
// Can be used to signal shutdown of the service
// Can be used for extra option values.
func Context(ctx context.Context) Option {
return func(o *Options) {
o.Context = ctx
}
}
2015-11-26 03:23:36 +03:00
// Registry used for discovery
func Registry(r registry.Registry) Option {
return func(o *Options) {
o.Registry = r
}
}
2020-01-29 18:45:11 +03:00
// Tracer mechanism for distributed tracking
func Tracer(t tracer.Tracer) Option {
2020-01-29 18:45:11 +03:00
return func(o *Options) {
o.Tracer = t
}
}
// Auth mechanism for role based access control
func Auth(a auth.Auth) Option {
return func(o *Options) {
o.Auth = a
}
}
2015-11-26 03:23:36 +03:00
// Transport mechanism for communication e.g http, rabbitmq, etc
func Transport(t transport.Transport) Option {
return func(o *Options) {
o.Transport = t
}
}
2015-11-26 03:23:36 +03:00
// Metadata associated with the server
func Metadata(md map[string]string) Option {
return func(o *Options) {
o.Metadata = md
}
}
// RegisterCheck run func before registry service
func RegisterCheck(fn func(context.Context) error) Option {
return func(o *Options) {
o.RegisterCheck = fn
}
}
// RegisterTTL registers service with a TTL
2016-01-27 15:23:18 +03:00
func RegisterTTL(t time.Duration) Option {
return func(o *Options) {
o.RegisterTTL = t
}
}
// RegisterInterval registers service with at interval
2019-01-24 16:22:17 +03:00
func RegisterInterval(t time.Duration) Option {
return func(o *Options) {
o.RegisterInterval = t
}
}
// TLSConfig specifies a *tls.Config
func TLSConfig(t *tls.Config) Option {
return func(o *Options) {
// set the internal tls
o.TLSConfig = t
// set the default transport if one is not
// already set. Required for Init call below.
// set the transport tls
o.Transport.Init(
transport.Secure(true),
transport.TLSConfig(t),
)
}
}
2019-01-08 23:32:47 +03:00
// WithRouter sets the request router
func WithRouter(r Router) Option {
return func(o *Options) {
o.Router = r
}
}
2017-05-31 21:47:50 +03:00
// 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 Wait(wg *sync.WaitGroup) Option {
2017-05-31 21:47:50 +03:00
return func(o *Options) {
if wg == nil {
wg = new(sync.WaitGroup)
}
o.Wait = wg
2017-05-31 21:47:50 +03:00
}
}
// WrapHandler adds a handler Wrapper to a list of options passed into the server
2015-12-02 14:54:36 +03:00
func WrapHandler(w HandlerWrapper) Option {
return func(o *Options) {
o.HdlrWrappers = append(o.HdlrWrappers, w)
}
}
2015-12-02 14:54:36 +03:00
// WrapSubscriber adds a subscriber Wrapper to a list of options passed into the server
2015-12-02 14:54:36 +03:00
func WrapSubscriber(w SubscriberWrapper) Option {
return func(o *Options) {
o.SubWrappers = append(o.SubWrappers, w)
2015-12-02 14:54:36 +03:00
}
}
// HandlerOption func
type HandlerOption func(*HandlerOptions)
// HandlerOptions struct
type HandlerOptions struct {
Internal bool
Metadata map[string]map[string]string
Context context.Context
}
// NewHandlerOptions creates new HandlerOptions
func NewHandlerOptions(opts ...HandlerOption) HandlerOptions {
options := HandlerOptions{
Context: context.Background(),
}
for _, o := range opts {
o(&options)
}
return options
}
// SubscriberOption func
type SubscriberOption func(*SubscriberOptions)
// SubscriberOptions struct
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
}
// NewSubscriberOptions create new SubscriberOptions
func NewSubscriberOptions(opts ...SubscriberOption) SubscriberOptions {
options := SubscriberOptions{
AutoAck: true,
Context: context.Background(),
}
for _, o := range opts {
o(&options)
}
return options
}
// EndpointMetadata is a Handler option that allows metadata to be added to
// individual endpoints.
func EndpointMetadata(name string, md map[string]string) HandlerOption {
return func(o *HandlerOptions) {
o.Metadata[name] = md
}
}
// InternalHandler 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.
func InternalHandler(b bool) HandlerOption {
return func(o *HandlerOptions) {
o.Internal = b
}
}
// InternalSubscriber options specifies that a subscriber is not advertised
// to the discovery system.
func InternalSubscriber(b bool) SubscriberOption {
return func(o *SubscriberOptions) {
o.Internal = b
}
}
// DisableAutoAck will disable auto acking of messages
// after they have been handled.
func DisableAutoAck() SubscriberOption {
return func(o *SubscriberOptions) {
o.AutoAck = false
}
}
// SubscriberQueue sets the shared queue name distributed messages across subscribers
func SubscriberQueue(n string) SubscriberOption {
return func(o *SubscriberOptions) {
o.Queue = n
}
}
// SubscriberContext set context options to allow broker SubscriberOption passed
func SubscriberContext(ctx context.Context) SubscriberOption {
return func(o *SubscriberOptions) {
o.Context = ctx
}
}