kernel

type ApplicationStage ¶

type ApplicationStage struct{}

func (s ApplicationStage) GetStage() int

type BackgroundModule ¶

type BackgroundModule struct{}

A BackgroundModule has no effect on application termination. If you only have running background modules, the application will exit regardless.

func (m BackgroundModule) IsBackground() bool

func (m BackgroundModule) IsEssential() bool

type DefaultModule ¶

type DefaultModule struct {
	ForegroundModule
	ApplicationStage
}

The DefaultModule type you could use for your application code. Your module will

• Run at the application stage
• Be a foreground module and can therefore shut down the kernel if you don't run other foreground modules
• Implement any future methods we might add to the Module interface with some reasonable default values

type EssentialBackgroundModule ¶

type EssentialBackgroundModule struct{}

An EssentialBackgroundModule is similar to an essential module, but it will not cause the kernel to continue running if only this module remains. From the previous example the database might be a good candidate - the app can't run without the database, but a database alone also is no proper app. The ProducerDaemon is using this module for example.

func (m EssentialBackgroundModule) IsBackground() bool

func (m EssentialBackgroundModule) IsEssential() bool

type EssentialModule ¶

type EssentialModule struct{}

An EssentialModule will cause the application to exit as soon as the first essential module stops running. For example, if you have a web server with a database and API as essential modules the application would exit as soon as either the database is shut down or the API is stopped. In both cases there is no point in running the rest anymore as the main function of the web server can no longer be fulfilled.

func (m EssentialModule) IsBackground() bool

func (m EssentialModule) IsEssential() bool

type EssentialStage ¶

type EssentialStage struct{}

func (s EssentialStage) GetStage() int

type ExitHandler ¶

type ExitHandler func(code int)

type ForegroundModule ¶

type ForegroundModule struct{}

A ForegroundModule will cause the application to exit as soon as the last foreground module exited. For example, if you have three tasks you have to perform and afterwards want to terminate the program, simply declare all three as foreground modules.

func (m ForegroundModule) IsBackground() bool

func (m ForegroundModule) IsEssential() bool

type FullModule ¶

type FullModule interface {
	Module
	TypedModule
	StagedModule
	HealthCheckedModule
}

A FullModule provides all the methods a module can have and thus never relies on defaults.

type HealthCheckResult ¶ added in v0.10.0

type HealthCheckResult []ModuleHealthCheckResult

func (r HealthCheckResult) Err() error

func (r HealthCheckResult) GetUnhealthy() HealthCheckResult

func (r HealthCheckResult) GetUnhealthyNames() []string

func (r HealthCheckResult) IsHealthy() bool

type HealthCheckSettings ¶ added in v0.10.0

type HealthCheckSettings struct {
	Timeout      time.Duration `cfg:"timeout" default:"1m"`
	WaitInterval time.Duration `cfg:"wait_interval" default:"3s"`
}

type HealthCheckedModule ¶ added in v0.10.0

type HealthCheckedModule interface {
	IsHealthy(ctx context.Context) (bool, error)
}

A HealthCheckedModule provides an interface to implement a health check for a module. This health check is used to determine if the module is in a ready state after executing its run method and afterwards to check for the overall application healthyness.

type HealthChecker ¶ added in v0.10.0

type HealthChecker func() HealthCheckResult

func GetHealthChecker(ctx context.Context) (HealthChecker, error)

type Kernel ¶

type Kernel interface {
	HealthCheck() HealthCheckResult
	Running() <-chan struct{}
	Run()
	Stop(reason string)
}

func BuildKernel(ctx context.Context, config cfg.Config, logger log.Logger, options []Option) (Kernel, error)

type Middleware ¶

type Middleware func(next MiddlewareHandler) MiddlewareHandler

type MiddlewareFactory ¶

type MiddlewareFactory func(ctx context.Context, config cfg.Config, logger log.Logger) (Middleware, error)

func BuildSimpleMiddleware(handler func(next MiddlewareHandler)) MiddlewareFactory

type MiddlewareHandler ¶

type MiddlewareHandler func()

type Module ¶

type Module interface {
	// Run the module. If the provided context is canceled you have a few seconds (configurable with kernel.killTimeout)
	// until your module is killed (via exit(1)). If you return from Run, it is assumed that your module is done
	// executing and (depending on the type of your module) this might trigger a kernel shutdown.
	// If one of your modules returns an error, the kernel will stop (thus stopping all other modules).
	Run(ctx context.Context) error
}

A Module provides a single function or service for your application. For example, an HTTP server would be a single module (see "httpserver") while a daemon writing metrics in the background would be a separate module (see "log").

func NewModuleFunc(run ModuleRunFunc) Module

type ModuleFactory ¶

type ModuleFactory func(ctx context.Context, config cfg.Config, logger log.Logger) (Module, error)

type ModuleHealthCheckResult ¶ added in v0.10.0

type ModuleHealthCheckResult struct {
	StageIndex int
	Name       string
	Healthy    bool
	Err        error
}

type ModuleMultiFactory ¶

type ModuleMultiFactory func(ctx context.Context, config cfg.Config, logger log.Logger) (map[string]ModuleFactory, error)

type ModuleOption ¶

type ModuleOption func(ms *moduleConfig)

func MergeOptions(options []ModuleOption) ModuleOption

func ModuleStage(moduleStage int) ModuleOption

func ModuleType(moduleTypeProvider func() TypedModule) ModuleOption

type ModuleRunFunc ¶

type ModuleRunFunc func(ctx context.Context) error

type Option ¶

type Option func(bp *blueprint)

func WithExitHandler(handler func(code int)) Option

func WithKillTimeout(killTimeout time.Duration) Option

func WithMiddlewareFactory(factory MiddlewareFactory, position Position) Option

func WithModuleFactory(name string, factory ModuleFactory, options ...ModuleOption) Option

func WithModuleMultiFactory(factory ModuleMultiFactory) Option

type Position ¶

type Position string

const (
	PositionBeginning Position = "beginning"
	PositionEnd       Position = "end"
)

type ServiceStage ¶

type ServiceStage struct{}

func (s ServiceStage) GetStage() int

type Settings ¶ added in v0.10.0

type Settings struct {
	KillTimeout time.Duration       `cfg:"kill_timeout" default:"10s"`
	HealthCheck HealthCheckSettings `cfg:"health_check"`
}

type StagedModule ¶

type StagedModule interface {
	GetStage() int
}

A module can be associated with a stage describing in which order to boot and invoke different modules. Modules with a smaller stage index are booted sooner and shut down later. You should use the StageEssential, StageService and StageApplication constants unless you have very specific needs and know what you are doing.

type TypedModule ¶

type TypedModule interface {
	IsEssential() bool
	IsBackground() bool
}

TypedModule denotes a module that knows whether it is essential and whether it runs in the foreground or background. If your module is essential, the kernel will shut down after your module stopped. If your module is a background module, it will not keep the kernel running. Thus, an essential background module will kill the kernel if it stops, but it will not keep the kernel from stopping. An example would be the producer daemon, which should not stop, but won't do much good alone. If you don't implement TypedModule it will default to a non-essential foreground module.

func TypeBackground() TypedModule

func TypeEssential() TypedModule

func TypeEssentialBackground() TypedModule

func TypeForeground() TypedModule