baseservice

type Archetype ¶

type Archetype struct {
	// Logger is a structured logger.
	Logger *slog.Logger

	// Time returns a time generator to get the current time in UTC. Normally
	// it's implemented as UnStubbableTimeGenerator which just calls through to
	// `time.Now().UTC()`, but is riverinternaltest.timeStub in tests to allow
	// the current time to be stubbed.  Services should try to use this function
	// instead of the vanilla ones from the `time` package for testing purposes.
	Time TimeGenerator
}

Archetype contains the set of base service properties that are immutable, or otherwise safe for services to copy from another service. The struct is also embedded in BaseService, so these properties are available on services directly.

func NewArchetype(logger *slog.Logger) *Archetype

type BaseService ¶

type BaseService struct {
	Archetype

	// Name is a name of the service. It should generally be used to prefix all
	// log lines the service emits.
	Name string
}

BaseService is a struct that's meant to be embedded on "service-like" objects (e.g. client, producer, queue maintainer) and which provides a number of convenient properties that are widely needed so that they don't have to be defined on every individual service and can easily be copied from each other.

An initial Archetype should be defined near the program's entrypoint (currently in Client), and then each service should invoke Init along with the archetype to initialize its own base service. This is often done in the service's constructor, but if it doesn't have one, it's the job of the caller which instantiates it to invoke Init.

func (s *BaseService) GetBaseService() *BaseService

type TimeGenerator ¶

type TimeGenerator interface {
	// NowUTC returns the current time. This may be a stubbed time if the time
	// has been actively stubbed in a test.
	NowUTC() time.Time

	// NowUTCOrNil returns if the currently stubbed time _if_ the current time
	// is stubbed, and returns nil otherwise. This is generally useful in cases
	// where a component may want to use a stubbed time if the time is stubbed,
	// but to fall back to a database time default otherwise.
	NowUTCOrNil() *time.Time

	// StubNowUTC stubs the current time. It will panic if invoked outside of
	// tests. Returns the same time passed as parameter for convenience.
	StubNowUTC(nowUTC time.Time) time.Time
}

TimeGenerator generates a current time in UTC. In test environments it's implemented by riverinternaltest.timeStub which lets the current time be stubbed. Otherwise, it's implemented as UnStubbableTimeGenerator which doesn't allow stubbing.

type UnStubbableTimeGenerator ¶

type UnStubbableTimeGenerator struct{}

UnStubbableTimeGenerator is a TimeGenerator implementation that can't be stubbed. It's always the generator used outside of tests.

func (g *UnStubbableTimeGenerator) NowUTC() time.Time

func (g *UnStubbableTimeGenerator) NowUTCOrNil() *time.Time

func (g *UnStubbableTimeGenerator) StubNowUTC(nowUTC time.Time) time.Time