server

type Config ¶

type Config struct {
	Middlewares []MiddlewareConfig          `json:"middlewares,omitempty" yaml:"middlewares,omitempty"`
	Handlers    []string                    `json:"handlers,omitempty"    yaml:"handlers,omitempty"`
	Entrypoints map[string]EntrypointConfig `json:"entrypoints,omitempty" yaml:"entrypoints,omitempty"`
	// contains filtered or unexported fields
}

Config is the global config for servers.

func NewConfig(opts ...ConfigOption) Config

type ConfigOption ¶ added in v0.1.0

type ConfigOption func(*Config)

ConfigOption allows to set options for MyConfig.

func WithEntrypointConfig(epName string, config EntrypointConfigType) ConfigOption

type Entrypoint ¶

type Entrypoint interface {
	types.Component

	// Name returns the entrypoints name.
	Name() string

	// Enabled returns if this entrypoint has been enabled in config.
	Enabled() bool

	// AddHandler adds a handler for registration during startup.
	AddHandler(fun RegistrationFunc)

	// Register is used to register handlers.
	//
	// A registration function takes a pointer to the server, which can then
	// be used to register handlers in the server specific way.
	Register(fun RegistrationFunc)

	// Transport returns the client transport that is required to talk to this entrypoint.
	Transport() string

	// Network returns the network the entrypoint is listening on.
	Network() string

	// Address returns the address the entrypoint is listening on.
	Address() string
}

Entrypoint is a server, and represents an entrypoint into the web.

type EntrypointConfig ¶

type EntrypointConfig struct {
	Plugin  string `json:"plugin"  yaml:"plugin"`
	Enabled bool   `json:"enabled" yaml:"enabled"`

	OptMiddlewares []Middleware       `json:"-" yaml:"-"`
	OptHandlers    []RegistrationFunc `json:"-" yaml:"-"`
}

EntrypointConfig is the base config for all entrypoints.

func NewEntrypointConfig(opts ...Option) *EntrypointConfig

type EntrypointConfigType ¶ added in v0.1.0

type EntrypointConfigType interface {
	// contains filtered or unexported methods
}

EntrypointConfigType is here so we can do magic work on options.

type EntrypointNew ¶ added in v0.1.0

type EntrypointNew func(
	name string,
	version string,
	epName string,
	acfg any,
	logger log.Logger,
	reg registry.Type,
) (Entrypoint, error)

EntrypointNew is the function type to create a new entrypoint.

type EntrypointProvider ¶ added in v0.1.0

type EntrypointProvider func(
	name string,
	version string,
	epName string,
	configData map[string]any,
	logger log.Logger,
	reg registry.Type,
	opts ...Option,
) (Entrypoint, error)

EntrypointProvider is the function type to create a new entrypoint. It should create a new config, configure it the run EntrypointFromConfig with it.

type Middleware ¶ added in v0.1.0

type Middleware interface {
	// Start/Stop will be called many times, if you require the call once, you have to ensure it on your own.
	types.Component

	Call(next MiddlewareCallHandler) MiddlewareCallHandler
}

Middleware is an interface that must be implemented by server Middlewares.

type MiddlewareCallHandler ¶ added in v0.1.0

type MiddlewareCallHandler func(ctx context.Context, req any) (any, error)

MiddlewareCallHandler is the Handler for unary RPC Calls.

type MiddlewareConfig ¶ added in v0.1.0

type MiddlewareConfig struct {
	Plugin string `json:"plugin,omitempty" yaml:"plugin,omitempty"`
}

MiddlewareConfig is the base config for all middlewares.

type MiddlewareProvider ¶ added in v0.1.0

type MiddlewareProvider func(
	configSection []string,
	configKey string,
	configData map[string]any,
	logger log.Logger,
) (Middleware, error)

MiddlewareProvider is the provider for a middleware, each Middleware must supply this to register itself.

type MiddlewareStreamHandler ¶ added in v0.1.0

type MiddlewareStreamHandler func(ctx context.Context) error

MiddlewareStreamHandler is the handler for streaming RPC calls.

type Option ¶

type Option func(EntrypointConfigType)

Option is a functional entrypoint option.

func WithEntrypointDisabled() Option

func WithEntrypointHandlers(hs ...RegistrationFunc) Option

func WithEntrypointMiddlewares(mws ...Middleware) Option

func WithEntrypointPlugin(p string) Option

type RegistrationFunc ¶

type RegistrationFunc func(srv any)

RegistrationFunc is executed to register a handler to a server (entrypoint) passed as srv. srv can be of any of the various server types, should be a pointer.

You can write your own custom registration functions to register extra handlers.

Inside the registration function, you need to convert the server type and assert that you are working with the server type you are expecting, and otherwise no-op. For an example, see the implementation of NewRegistrationFunc.

func NewRegistrationFunc[Tsrv any, Thandler any](register func(Tsrv, Thandler), handler Thandler) RegistrationFunc

type Server ¶ added in v0.1.0

type Server struct {
	// contains filtered or unexported fields
}

Server is responsible for managing entrypoints. Entrypoints are the actual servers that bind to a port and accept connections. Entrypoints can be dynamically configured.

For more info look at the entrypoint types.

func New(
	name string,
	version string,
	configData map[string]any,
	logger log.Logger,
	reg registry.Type,
	opts ...ConfigOption,
) (Server, error)

func Provide(
	svcCtx *cli.ServiceContextWithConfig,
	components *types.Components,
	logger log.Logger,
	reg registry.Type,
	opts ...ConfigOption,
) (Server, error)

func ProvideNoOpts(
	svcCtx *cli.ServiceContextWithConfig,
	components *types.Components,
	logger log.Logger,
	reg registry.Type,
) (Server, error)

func (s *Server) GetEntrypoint(name string) (Entrypoint, error)

func (s *Server) GetEntrypoints() *container.Map[string, Entrypoint]

func (s *Server) Start(ctx context.Context) error

func (s *Server) Stop(ctx context.Context) error

func (s *Server) String() string

func (s *Server) Type() string