rxd

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

type Daemon interface {
	AddServices(services ...Service) error
	AddService(service Service) error
	Start(ctx context.Context) error
}

type DaemonLog struct {
	Level   log.Level
	Message string
	Fields  []log.Field
}

type DaemonOption func(*daemon)

type DaemonService struct {
	Name   string
	Runner ServiceRunner
}

type ErrUninitialized struct {
	StructName string
	Method     string
}

type Error string

type FilterMode uint8

type ManagerOption func(m *RunContinuousManager)

type ManagerStateTimeouts map[State]time.Duration

type Pipeline interface {
	Add(stage Stage)
	Run(ctx context.Context) <-chan DaemonLog
}

type PrestartConfig struct {
	RestartOnError bool
	RestartDelay   time.Duration
}

type RPCConfig struct {
	Addr string
	Port uint16
}

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

type RunContinuousManager struct {
	DefaultDelay  time.Duration
	StartupDelay  time.Duration
	StateTimeouts ManagerStateTimeouts
}

type RunUntilSuccessManager struct {
	StartupDelay time.Duration
	DefaultDelay time.Duration
}

type Service struct {
	Name    string
	Runner  ServiceRunner
	Manager ServiceManager
}

type ServiceAction uint8

type ServiceContext interface {
	context.Context
	ServiceWatcher
	ServiceLogger
	// WithParent replaces the original context with the provided parent context.
	// It returns the original ServiceContext with the new context and a cancel function.
	// This allows for detaching the service context from its parent and allowing the caller to
	// cancel the context at an earlier time if needed.
	WithParent(ctx context.Context) (ServiceContext, context.CancelFunc)
	// WithName allows the caller to create a new CHILD service context with a specific name.
	// This is useful for creating child contexts to be used for services launches additional
	// worker goroutines where the parent service is managing its own lifecycles of those workers.
	// The returned ServiceContext is composed from the original parent context, therefore it has
	// if the parent is cancelled, the child context will also be cancelled when the daemon is shutting down.
	WithName(name string) (ServiceContext, context.CancelFunc)
	// IntracomRegistry returns the embedded intracom registry used by the daemon for all services.
	// The caller can use this to register new topics, create subscriptions, and publish messages
	// between services.
	// NOTE: Avoid using topics with an _rxd prefix as these are reserved for internal use by the daemon.
	// overlapping this topic name may cause unexpected behavior with internal states tracking by the daemon.
	IntracomRegistry() *intracom.Intracom
	// Logger returns the service logger used to log messages related to the service.
	// This logger should be prefixed with its original service=<service_name> field.
	Logger() log.Logger
}

type ServiceFilter struct {
	Mode  FilterMode
	Names map[string]struct{}
}

type ServiceLogger interface {
	// Log logs a message with the specified level, message, and any additional fields.
	Log(level log.Level, message string, extra ...log.Field)
}

type ServiceManager interface {
	Manage(ctx ServiceContext, dService DaemonService, updateC chan<- ServiceStateUpdate)
}

type ServiceOption func(*Service)

type ServiceRunner interface {
	Init(ServiceContext) error
	Idle(ServiceContext) error
	Run(ServiceContext) error
	Stop(ServiceContext) error
}

type ServiceStateUpdate struct {
	Name       string          // e.g. "service1"
	State      State           // e.g. StateRun
	Transition StateTransition // e.g. TransitionEntering
}

type ServiceStates map[string]StateUpdate

type ServiceWatcher interface {
	// WatchAllStates allows the caller to watch all service states and filter them based on the provided filter.
	// It returns a channel that will signal every time there is a change in the states of the services.
	// The channel will send out the current states of all services that match the filter criteria.
	// If no filter is provided, it will send out all the states of all services for every single change.
	// The filter can be used to include or exclude specific services based on their names.
	// This is useful for scenarios where you want to monitor the states of all services from another reporting-like service.
	//
	// NOTE: The 2nd return value is a cancel function that can be used to stop watching the services.
	// The channel will stay open until this cancel function is called or the parent context is done.
	// The caller should always call the cancel function to avoid leaking resources.
	// The channel will send out the states of all services that match the filter criteria.
	WatchAllStates(ServiceFilter) (<-chan ServiceStates, context.CancelFunc)

	// WatchAnyServices allows the caller to specify a list of services by unique name and their target state and action.
	// It returns a channel that will signal when ANY of the services given match the action and target state.
	// The moment a single service reaches the desired state, the channel will send out the states of those services as a signal.
	// This is useful for scenarios where you want to be notified when any group of services reaches a specific state.
	//
	// NOTE: The 2nd return value is a cancel function that can be used to stop watching the services.
	// The channel will stay open until this cancel function is called or the parent context is done.
	// The caller should always call the cancel function to avoid leaking resources.
	// This is useful for scenarios where you want to be notified when any of the services reaches a specific state.
	WatchAnyServices(action ServiceAction, target State, services ...string) (<-chan ServiceStates, context.CancelFunc)

	// WatchAllServices allows the caller to specify a list of services by unique name and their target state and action.
	// It returns a channel that will only signal when ALL the services given match the action and target state.
	// Only once all the services reach the desired state, the channel will send out the states of those services as a signal.
	// This is useful for scenarios where you want to wait for multiple services to reach a specific state before proceeding.
	//
	// NOTE: The 2nd return value is a cancel function that can be used to stop watching the services.
	// The channel will stay open until this cancel function is called or the parent context is done.
	// The caller should always call the cancel function to avoid leaking resources.
	WatchAllServices(action ServiceAction, target State, services ...string) (<-chan ServiceStates, context.CancelFunc)
}

type Stage struct {
	Name string
	Func StageFunc
}

type StageFunc func(ctx context.Context) error

type State uint8

type StateTransition uint8

type StateUpdate struct {
	State      State           // e.g. StateRun
	Transition StateTransition // e.g. TransitionEntering
}