2015-05-27 00:39:48 +03:00
|
|
|
package server
|
|
|
|
|
|
|
|
import (
|
2018-03-03 14:53:52 +03:00
|
|
|
"context"
|
2020-02-15 18:10:26 +03:00
|
|
|
"crypto/tls"
|
2020-12-15 11:52:05 +03:00
|
|
|
"net"
|
2019-05-27 16:17:57 +03:00
|
|
|
"sync"
|
2016-01-27 02:32:27 +03:00
|
|
|
"time"
|
|
|
|
|
2023-04-11 22:20:37 +03:00
|
|
|
"go.unistack.org/micro/v4/codec"
|
|
|
|
"go.unistack.org/micro/v4/logger"
|
|
|
|
"go.unistack.org/micro/v4/metadata"
|
|
|
|
"go.unistack.org/micro/v4/meter"
|
|
|
|
"go.unistack.org/micro/v4/network/transport"
|
|
|
|
"go.unistack.org/micro/v4/options"
|
|
|
|
"go.unistack.org/micro/v4/register"
|
|
|
|
"go.unistack.org/micro/v4/tracer"
|
|
|
|
"go.unistack.org/micro/v4/util/id"
|
2015-05-27 00:39:48 +03:00
|
|
|
)
|
|
|
|
|
2023-05-09 20:04:15 +03:00
|
|
|
var (
|
|
|
|
// ServerRequestDurationSeconds specifies meter metric name
|
|
|
|
ServerRequestDurationSeconds = "server_request_duration_seconds"
|
|
|
|
// ServerRequestLatencyMicroseconds specifies meter metric name
|
|
|
|
ServerRequestLatencyMicroseconds = "server_request_latency_microseconds"
|
|
|
|
// ServerRequestTotal specifies meter metric name
|
|
|
|
ServerRequestTotal = "server_request_total"
|
|
|
|
// ServerRequestInflight specifies meter metric name
|
|
|
|
ServerRequestInflight = "server_request_inflight"
|
|
|
|
)
|
|
|
|
|
2020-12-08 00:38:37 +03:00
|
|
|
// Option func
|
2020-11-26 01:13:05 +03:00
|
|
|
type Option func(*Options)
|
|
|
|
|
2020-11-02 13:25:29 +03:00
|
|
|
// Options server struct
|
2015-12-31 21:11:46 +03:00
|
|
|
type Options struct {
|
2021-03-06 19:45:13 +03:00
|
|
|
// Context holds the external options and can be used for server shutdown
|
|
|
|
Context context.Context
|
|
|
|
// Register holds the register
|
|
|
|
Register register.Register
|
|
|
|
// Tracer holds the tracer
|
|
|
|
Tracer tracer.Tracer
|
|
|
|
// Logger holds the logger
|
|
|
|
Logger logger.Logger
|
|
|
|
// Meter holds the meter
|
|
|
|
Meter meter.Meter
|
|
|
|
// Transport holds the transport
|
|
|
|
Transport transport.Transport
|
2020-12-15 11:52:05 +03:00
|
|
|
// Listener may be passed if already created
|
|
|
|
Listener net.Listener
|
2021-03-06 19:45:13 +03:00
|
|
|
// Wait group
|
|
|
|
Wait *sync.WaitGroup
|
|
|
|
// TLSConfig specifies tls.Config for secure serving
|
|
|
|
TLSConfig *tls.Config
|
|
|
|
// Metadata holds the server metadata
|
|
|
|
Metadata metadata.Metadata
|
|
|
|
// RegisterCheck run before register server
|
|
|
|
RegisterCheck func(context.Context) error
|
|
|
|
// Codecs map to handle content-type
|
|
|
|
Codecs map[string]codec.Codec
|
2021-04-27 08:32:47 +03:00
|
|
|
// ID holds the id of the server
|
|
|
|
ID string
|
2021-03-06 19:45:13 +03:00
|
|
|
// Namespace for te server
|
|
|
|
Namespace string
|
|
|
|
// Name holds the server name
|
|
|
|
Name string
|
|
|
|
// Address holds the server address
|
|
|
|
Address string
|
2021-03-06 23:33:37 +03:00
|
|
|
// Advertise holds the advertise address
|
2021-03-06 19:45:13 +03:00
|
|
|
Advertise string
|
|
|
|
// Version holds the server version
|
|
|
|
Version string
|
|
|
|
// HdlrWrappers holds the handler wrappers
|
|
|
|
HdlrWrappers []HandlerWrapper
|
|
|
|
// RegisterAttempts holds the number of register attempts before error
|
|
|
|
RegisterAttempts int
|
|
|
|
// RegisterInterval holds he interval for re-register
|
|
|
|
RegisterInterval time.Duration
|
|
|
|
// RegisterTTL specifies TTL for register record
|
|
|
|
RegisterTTL time.Duration
|
|
|
|
// MaxConn limits number of connections
|
2020-12-15 11:46:26 +03:00
|
|
|
MaxConn int
|
2021-03-06 19:45:13 +03:00
|
|
|
// DeregisterAttempts holds the number of deregister attempts before error
|
|
|
|
DeregisterAttempts int
|
2023-05-09 20:04:15 +03:00
|
|
|
// Hooks may contains HandlerWrapper or Server func wrapper
|
2023-03-24 00:25:47 +03:00
|
|
|
Hooks options.Hooks
|
2015-12-31 21:11:46 +03:00
|
|
|
}
|
|
|
|
|
2020-11-02 13:25:29 +03:00
|
|
|
// NewOptions returns new options struct with default or passed values
|
2020-09-10 00:25:33 +03:00
|
|
|
func NewOptions(opts ...Option) Options {
|
|
|
|
options := Options{
|
2020-11-23 16:18:47 +03:00
|
|
|
Codecs: make(map[string]codec.Codec),
|
2020-09-05 02:11:29 +03:00
|
|
|
Context: context.Background(),
|
2020-11-18 16:50:41 +03:00
|
|
|
Metadata: metadata.New(0),
|
2019-09-23 19:59:34 +03:00
|
|
|
RegisterInterval: DefaultRegisterInterval,
|
|
|
|
RegisterTTL: DefaultRegisterTTL,
|
2020-09-05 02:11:29 +03:00
|
|
|
RegisterCheck: DefaultRegisterCheck,
|
2020-10-16 09:38:57 +03:00
|
|
|
Logger: logger.DefaultLogger,
|
2021-01-22 23:32:33 +03:00
|
|
|
Meter: meter.DefaultMeter,
|
2020-10-16 09:38:57 +03:00
|
|
|
Tracer: tracer.DefaultTracer,
|
2021-01-29 13:17:32 +03:00
|
|
|
Register: register.DefaultRegister,
|
2020-11-05 22:35:05 +03:00
|
|
|
Transport: transport.DefaultTransport,
|
2020-09-05 02:11:29 +03:00
|
|
|
Address: DefaultAddress,
|
|
|
|
Name: DefaultName,
|
|
|
|
Version: DefaultVersion,
|
2021-11-24 00:57:59 +03:00
|
|
|
ID: id.Must(),
|
2020-11-05 22:35:05 +03:00
|
|
|
Namespace: DefaultNamespace,
|
2015-11-25 22:50:05 +03:00
|
|
|
}
|
2020-09-10 00:25:33 +03:00
|
|
|
|
|
|
|
for _, o := range opts {
|
|
|
|
o(&options)
|
|
|
|
}
|
|
|
|
|
|
|
|
return options
|
2015-05-27 00:39:48 +03:00
|
|
|
}
|
|
|
|
|
2020-11-03 01:08:23 +03:00
|
|
|
// Name sets the server name option
|
2015-06-03 03:25:37 +03:00
|
|
|
func Name(n string) Option {
|
2015-12-31 21:11:46 +03:00
|
|
|
return func(o *Options) {
|
|
|
|
o.Name = n
|
2015-06-03 03:25:37 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-06-19 11:24:32 +03:00
|
|
|
// Namespace to register handlers in
|
|
|
|
func Namespace(n string) Option {
|
|
|
|
return func(o *Options) {
|
|
|
|
o.Namespace = n
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-11-03 01:08:23 +03:00
|
|
|
// Logger sets the logger option
|
2020-08-29 17:44:49 +03:00
|
|
|
func Logger(l logger.Logger) Option {
|
|
|
|
return func(o *Options) {
|
|
|
|
o.Logger = l
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-01-22 23:32:33 +03:00
|
|
|
// Meter sets the meter option
|
|
|
|
func Meter(m meter.Meter) Option {
|
|
|
|
return func(o *Options) {
|
|
|
|
o.Meter = m
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-04-27 08:32:47 +03:00
|
|
|
// ID unique server id
|
|
|
|
func ID(id string) Option {
|
2015-12-31 21:11:46 +03:00
|
|
|
return func(o *Options) {
|
2021-04-27 08:32:47 +03:00
|
|
|
o.ID = id
|
2015-06-03 03:25:37 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-11-26 03:23:36 +03:00
|
|
|
// Version of the service
|
2015-06-03 03:25:37 +03:00
|
|
|
func Version(v string) Option {
|
2015-12-31 21:11:46 +03:00
|
|
|
return func(o *Options) {
|
|
|
|
o.Version = v
|
2015-06-03 03:25:37 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-11-26 03:23:36 +03:00
|
|
|
// Address to bind to - host:port
|
2015-06-03 03:25:37 +03:00
|
|
|
func Address(a string) Option {
|
2015-12-31 21:11:46 +03:00
|
|
|
return func(o *Options) {
|
|
|
|
o.Address = a
|
2015-06-03 03:25:37 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-11-03 01:08:23 +03:00
|
|
|
// Advertise the address to advertise for discovery - host:port
|
2015-11-11 21:22:04 +03:00
|
|
|
func Advertise(a string) Option {
|
2015-12-31 21:11:46 +03:00
|
|
|
return func(o *Options) {
|
|
|
|
o.Advertise = a
|
2015-11-11 21:22:04 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-11-26 03:23:36 +03:00
|
|
|
// Codec to use to encode/decode requests for a given content type
|
2020-11-23 16:18:47 +03:00
|
|
|
func Codec(contentType string, c codec.Codec) Option {
|
2015-12-31 21:11:46 +03:00
|
|
|
return func(o *Options) {
|
|
|
|
o.Codecs[contentType] = c
|
2015-11-25 22:50:05 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-12-05 19:37:03 +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
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-01-29 13:17:32 +03:00
|
|
|
// Register used for discovery
|
|
|
|
func Register(r register.Register) Option {
|
2015-12-31 21:11:46 +03:00
|
|
|
return func(o *Options) {
|
2021-01-29 13:17:32 +03:00
|
|
|
o.Register = r
|
2015-06-03 03:25:37 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-01-29 18:45:11 +03:00
|
|
|
// Tracer mechanism for distributed tracking
|
2020-09-10 00:06:29 +03:00
|
|
|
func Tracer(t tracer.Tracer) Option {
|
2020-01-29 18:45:11 +03:00
|
|
|
return func(o *Options) {
|
|
|
|
o.Tracer = t
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-11-26 03:23:36 +03:00
|
|
|
// Transport mechanism for communication e.g http, rabbitmq, etc
|
2015-06-03 03:25:37 +03:00
|
|
|
func Transport(t transport.Transport) Option {
|
2015-12-31 21:11:46 +03:00
|
|
|
return func(o *Options) {
|
|
|
|
o.Transport = t
|
2015-06-03 03:25:37 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-11-26 03:23:36 +03:00
|
|
|
// Metadata associated with the server
|
2020-11-18 16:50:41 +03:00
|
|
|
func Metadata(md metadata.Metadata) Option {
|
2015-12-31 21:11:46 +03:00
|
|
|
return func(o *Options) {
|
2020-11-18 16:50:41 +03:00
|
|
|
o.Metadata = metadata.Copy(md)
|
2015-06-03 03:25:37 +03:00
|
|
|
}
|
|
|
|
}
|
2015-12-02 03:47:52 +03:00
|
|
|
|
2021-01-29 13:17:32 +03:00
|
|
|
// RegisterCheck run func before register service
|
2019-05-13 01:39:42 +03:00
|
|
|
func RegisterCheck(fn func(context.Context) error) Option {
|
|
|
|
return func(o *Options) {
|
|
|
|
o.RegisterCheck = fn
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-11-03 01:08:23 +03:00
|
|
|
// 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
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-11-03 01:08:23 +03:00
|
|
|
// 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
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-02-15 18:10:26 +03:00
|
|
|
// TLSConfig specifies a *tls.Config
|
|
|
|
func TLSConfig(t *tls.Config) Option {
|
|
|
|
return func(o *Options) {
|
|
|
|
// set the internal tls
|
|
|
|
o.TLSConfig = t
|
2020-02-17 12:28:48 +03:00
|
|
|
|
|
|
|
// set the default transport if one is not
|
|
|
|
// already set. Required for Init call below.
|
|
|
|
|
2020-02-15 18:10:26 +03:00
|
|
|
// set the transport tls
|
2021-09-30 21:13:13 +03:00
|
|
|
_ = o.Transport.Init(
|
2020-02-15 18:10:26 +03:00
|
|
|
transport.TLSConfig(t),
|
|
|
|
)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-05-31 21:47:50 +03:00
|
|
|
// Wait tells the server to wait for requests to finish before exiting
|
2019-05-27 16:17:57 +03:00
|
|
|
// 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) {
|
2019-05-27 16:17:57 +03:00
|
|
|
if wg == nil {
|
|
|
|
wg = new(sync.WaitGroup)
|
|
|
|
}
|
2020-09-20 15:48:07 +03:00
|
|
|
o.Wait = wg
|
2017-05-31 21:47:50 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-11-03 01:08:23 +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 {
|
2015-12-31 21:11:46 +03:00
|
|
|
return func(o *Options) {
|
|
|
|
o.HdlrWrappers = append(o.HdlrWrappers, w)
|
2015-12-02 03:47:52 +03:00
|
|
|
}
|
|
|
|
}
|
2015-12-02 14:54:36 +03:00
|
|
|
|
2020-12-15 11:52:05 +03:00
|
|
|
// MaxConn specifies maximum number of max simultaneous connections to server
|
|
|
|
func MaxConn(n int) Option {
|
|
|
|
return func(o *Options) {
|
|
|
|
o.MaxConn = n
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// Listener specifies the net.Listener to use instead of the default
|
|
|
|
func Listener(l net.Listener) Option {
|
|
|
|
return func(o *Options) {
|
|
|
|
o.Listener = l
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-11-03 01:08:23 +03:00
|
|
|
// HandlerOption func
|
2020-10-16 09:38:57 +03:00
|
|
|
type HandlerOption func(*HandlerOptions)
|
|
|
|
|
2020-11-03 01:08:23 +03:00
|
|
|
// HandlerOptions struct
|
2020-10-16 09:38:57 +03:00
|
|
|
type HandlerOptions struct {
|
2021-03-06 19:45:13 +03:00
|
|
|
// Context holds external options
|
|
|
|
Context context.Context
|
2023-02-13 23:31:38 +03:00
|
|
|
// Metadata for handler
|
2020-11-18 16:50:41 +03:00
|
|
|
Metadata map[string]metadata.Metadata
|
2020-10-16 09:38:57 +03:00
|
|
|
}
|
|
|
|
|
2020-11-03 01:08:23 +03:00
|
|
|
// NewHandlerOptions creates new HandlerOptions
|
2020-10-16 09:38:57 +03:00
|
|
|
func NewHandlerOptions(opts ...HandlerOption) HandlerOptions {
|
|
|
|
options := HandlerOptions{
|
2021-01-10 03:36:23 +03:00
|
|
|
Context: context.Background(),
|
|
|
|
Metadata: make(map[string]metadata.Metadata),
|
2020-10-16 09:38:57 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
for _, o := range opts {
|
|
|
|
o(&options)
|
|
|
|
}
|
|
|
|
|
|
|
|
return options
|
|
|
|
}
|
|
|
|
|
|
|
|
// EndpointMetadata is a Handler option that allows metadata to be added to
|
|
|
|
// individual endpoints.
|
2020-11-18 16:50:41 +03:00
|
|
|
func EndpointMetadata(name string, md metadata.Metadata) HandlerOption {
|
2020-10-16 09:38:57 +03:00
|
|
|
return func(o *HandlerOptions) {
|
2020-11-18 16:50:41 +03:00
|
|
|
o.Metadata[name] = metadata.Copy(md)
|
2020-10-16 09:38:57 +03:00
|
|
|
}
|
|
|
|
}
|