scheduler

type BackfillRequestType int

type Backfiller struct {
	chasm.UnimplementedComponent

	*schedulerpb.BackfillerState

	Scheduler chasm.ParentPtr[*Scheduler]

	EventLog chasm.Field[*EventLog]
}

type BackfillerTaskHandler struct {
	chasm.PureTaskHandlerBase
	// contains filtered or unexported fields
}

type BackfillerTaskHandlerOptions struct {
	fx.In

	Config         *Config
	MetricsHandler metrics.Handler
	BaseLogger     log.Logger
	SpecProcessor  SpecProcessor
}

type Config struct {
	Tweakables                      dynamicconfig.TypedPropertyFnWithNamespaceFilter[Tweakables]
	ServiceCallTimeout              dynamicconfig.DurationPropertyFn
	RetryPolicy                     func() backoff.RetryPolicy
	EncodeInternalTokenWithEnvelope dynamicconfig.BoolPropertyFnWithNamespaceFilter
}

type EventLog struct {
	chasm.UnimplementedComponent

	*schedulerpb.EventLog
}

type Generator struct {
	chasm.UnimplementedComponent

	*schedulerpb.GeneratorState

	Scheduler chasm.ParentPtr[*Scheduler]

	EventLog chasm.Field[*EventLog]
}

type GeneratorTaskHandler struct {
	chasm.PureTaskHandlerBase

	SpecProcessor SpecProcessor
	// contains filtered or unexported fields
}

type GeneratorTaskHandlerOptions struct {
	fx.In

	Config         *Config
	MetricsHandler metrics.Handler
	BaseLogger     log.Logger
	SpecProcessor  SpecProcessor
	SpecBuilder    *scheduler.SpecBuilder
}

type Invoker struct {
	chasm.UnimplementedComponent

	*schedulerpb.InvokerState

	Scheduler chasm.ParentPtr[*Scheduler]

	EventLog chasm.Field[*EventLog]
}

type InvokerExecuteTaskHandler struct {
	chasm.SideEffectTaskHandlerBase[*schedulerpb.InvokerExecuteTask]
	// contains filtered or unexported fields
}

type InvokerProcessBufferTaskHandler struct {
	chasm.PureTaskHandlerBase
	// contains filtered or unexported fields
}

type InvokerTaskHandlerOptions struct {
	fx.In

	Config         *Config
	MetricsHandler metrics.Handler
	BaseLogger     log.Logger
	SpecProcessor  SpecProcessor

	HistoryClient resource.HistoryClient

	// FrontendClient is used for specifically StartWorkflow calls, to ensure that
	// the request makes it through metering's interceptor. Because we don't change for
	// terminate/cancels, we can go directly to history for other service calls.
	FrontendClient workflowservice.WorkflowServiceClient
}

type Library struct {
	chasm.UnimplementedLibrary

	SchedulerIdleTaskHandler        *SchedulerIdleTaskHandler
	SchedulerCallbacksTaskHandler   *SchedulerCallbacksTaskHandler
	GeneratorTaskHandler            *GeneratorTaskHandler
	InvokerExecuteTaskHandler       *InvokerExecuteTaskHandler
	InvokerProcessBufferTaskHandler *InvokerProcessBufferTaskHandler
	BackfillerTaskHandler           *BackfillerTaskHandler
	MigrateToWorkflowTaskHandler    *SchedulerMigrateToWorkflowTaskHandler
	// contains filtered or unexported fields
}

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

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

type ProcessedTimeRange struct {
	NextWakeupTime time.Time
	LastActionTime time.Time
	BufferedStarts []*schedulespb.BufferedStart
	// DroppedCount is the number of actions that would have been buffered but
	// were dropped due to the limit being reached. Only populated when a limit
	// is provided.
	DroppedCount int64
}

type Scheduler struct {
	chasm.UnimplementedComponent

	// Persisted internal state, consisting of state relevant to all components in
	// the scheduler tree.
	*schedulerpb.SchedulerState

	// Last success/failure payloads, stored on this separate data node
	// to minimize write traffic.
	LastCompletionResult chasm.Field[*schedulerpb.LastCompletionResult]

	Generator   chasm.Field[*Generator]
	Invoker     chasm.Field[*Invoker]
	Backfillers chasm.Map[string, *Backfiller] // Backfill ID => *Backfiller

	// Human-readable event history used for debugging.
	EventLog chasm.Field[*EventLog]

	Visibility chasm.Field[*chasm.Visibility]
	// contains filtered or unexported fields
}

type SchedulerCallbacksTaskHandler struct {
	chasm.SideEffectTaskHandlerBase[*schedulerpb.SchedulerCallbacksTask]
	// contains filtered or unexported fields
}

type SchedulerCallbacksTaskHandlerOptions struct {
	fx.In

	Config         *Config
	HistoryClient  resource.HistoryClient
	FrontendClient workflowservice.WorkflowServiceClient
}

type SchedulerIdleTaskHandler struct {
	chasm.PureTaskHandlerBase
	// contains filtered or unexported fields
}

type SchedulerIdleTaskHandlerOptions struct {
	fx.In

	Config         *Config
	MetricsHandler metrics.Handler
	BaseLogger     log.Logger
}

type SchedulerMigrateToWorkflowTaskHandler struct {
	chasm.SideEffectTaskHandlerBase[*schedulerpb.SchedulerMigrateToWorkflowTask]
	// contains filtered or unexported fields
}

type SchedulerMigrateToWorkflowTaskHandlerOptions struct {
	fx.In

	Config           *Config
	MetricsHandler   metrics.Handler
	BaseLogger       log.Logger
	HistoryClient    resource.HistoryClient
	SaMapperProvider searchattribute.MapperProvider
}

type SpecProcessor interface {
	// ProcessTimeRange generates buffered actions according to the schedule spec for
	// the given time range.
	//
	// The parameter manual is propagated to the returned BufferedStarts. When the limit
	// is set to a non-nil pointer, it will be decremented for each buffered start, and
	// the function will return early should limit reach 0.
	//
	// If backfillID is set, it will be used to generate request IDs.
	ProcessTimeRange(
		scheduler *Scheduler,
		start, end time.Time,
		overlapPolicy enumspb.ScheduleOverlapPolicy,
		workflowID string,
		backfillID string,
		manual bool,
		limit *int,
	) (*ProcessedTimeRange, error)

	// NextTime provides a peek at the next time in the spec following 'after'.
	NextTime(scheduler *Scheduler, after time.Time) (legacyscheduler.GetNextTimeResult, error)
}

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

type Tweakables struct {
	DefaultCatchupWindow              time.Duration // Default for catchup window
	MinCatchupWindow                  time.Duration // Minimum for catchup window
	MaxBufferSize                     int           // MaxBufferSize limits the number of buffered actions pending execution in total
	GeneratorBufferReserveSize        int           // Minimum number of spaces in `BufferedStarts` reserved for automated actions.
	CanceledTerminatedCountAsFailures bool          // Whether cancelled+terminated count for pause-on-failure
	MaxActionsPerExecution            int           // Limits the number of actions (startWorkflow, terminate/cancel) taken by ExecuteTask in a single iteration
	IdleTime                          time.Duration // How long to keep schedules after they're done
	EventLogMaxEntries                int           // Maximum EventLog entries retained per component; the earliest entries are dropped beyond this.
	EventLogMaxMessageLen             int           // Maximum byte length of an EventLog message; longer messages are truncated at a UTF-8 boundary.
}