package server import ( "context" "crypto/tls" "sync" "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/registry" "github.com/unistack-org/micro/v3/tracer" "github.com/unistack-org/micro/v3/network/transport" ) 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 // 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 Wait *sync.WaitGroup // Other options for implementations of the interface // can be stored in a context Context context.Context } 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, Broker: broker.DefaultBroker, Registry: registry.DefaultRegistry, Address: DefaultAddress, Name: DefaultName, Version: DefaultVersion, Id: DefaultId, Transport: transport.DefaultTransport, } for _, o := range opts { o(&options) } return options } // Server name 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 func Logger(l logger.Logger) Option { return func(o *Options) { o.Logger = l } } // Unique server id func Id(id string) Option { return func(o *Options) { o.Id = id } } // Version of the service func Version(v string) Option { return func(o *Options) { o.Version = v } } // Address to bind to - host:port func Address(a string) Option { return func(o *Options) { o.Address = a } } // The address to advertise for discovery - host:port func Advertise(a string) Option { return func(o *Options) { o.Advertise = a } } // Broker to use for pub/sub func Broker(b broker.Broker) Option { return func(o *Options) { o.Broker = b } } // 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 } } // 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 } } // Registry used for discovery func Registry(r registry.Registry) Option { return func(o *Options) { o.Registry = r } } // Tracer mechanism for distributed tracking func Tracer(t tracer.Tracer) Option { 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 } } // Transport mechanism for communication e.g http, rabbitmq, etc func Transport(t transport.Transport) Option { return func(o *Options) { o.Transport = t } } // 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 } } // Register the service with a TTL func RegisterTTL(t time.Duration) Option { return func(o *Options) { o.RegisterTTL = t } } // Register the service with at interval 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), ) } } // WithRouter sets the request router func WithRouter(r Router) Option { return func(o *Options) { o.Router = r } } // 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 { return func(o *Options) { if wg == nil { wg = new(sync.WaitGroup) } o.Wait = wg } } // Adds a handler Wrapper to a list of options passed into the server func WrapHandler(w HandlerWrapper) Option { return func(o *Options) { o.HdlrWrappers = append(o.HdlrWrappers, w) } } // Adds a subscriber Wrapper to a list of options passed into the server func WrapSubscriber(w SubscriberWrapper) Option { return func(o *Options) { o.SubWrappers = append(o.SubWrappers, w) } }