scheduler

type BackfillRequestType int

type Backfiller struct {
	chasm.UnimplementedComponent

	*schedulerpb.BackfillerState

	Scheduler chasm.ParentPtr[*Scheduler]
}

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

type BackfillerTaskExecutorOptions 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
}

type Generator struct {
	chasm.UnimplementedComponent

	*schedulerpb.GeneratorState

	Scheduler chasm.ParentPtr[*Scheduler]
}

type GeneratorTaskExecutor struct {
	SpecProcessor SpecProcessor
	// contains filtered or unexported fields
}

type GeneratorTaskExecutorOptions 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]
}

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

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

type InvokerTaskExecutorOptions 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

	SchedulerIdleTaskExecutor        *SchedulerIdleTaskExecutor
	GeneratorTaskExecutor            *GeneratorTaskExecutor
	InvokerExecuteTaskExecutor       *InvokerExecuteTaskExecutor
	InvokerProcessBufferTaskExecutor *InvokerProcessBufferTaskExecutor
	BackfillerTaskExecutor           *BackfillerTaskExecutor
	// 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

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

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

type SchedulerIdleTaskExecutorOptions struct {
	fx.In

	Config *Config
}

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
}