ddmsync

type DrainResult struct {
	// Deferred enrollments were left for a later drain because a change
	// arrived within Window.
	Deferred int
	// Queued enrollments received a new command; Deduped ones already had
	// one pending and were pushed anyway; Skipped ones cannot be
	// commanded (disabled or unknown) and were completed without a push.
	Queued, Deduped, Skipped int
	// Failed enrollments had their change rows scheduled for a retry.
	Failed int
	// Pushed counts enrollments handed to the Pusher.
	Pushed int
}

type Enqueuer interface {
	Enqueue(
		ctx context.Context,
		ids []mdm.EnrollmentID,
		cmd *mdm.Command,
		o storage.EnqueueOptions,
	) (storage.EnqueueResult, error)
}

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

type NotifierConfig struct {
	Store    ddm.ChangeStore
	Tokens   TokenSource
	Enqueuer Enqueuer
	Pusher   Pusher
	Bus      event.Publisher
	Clock    clock.Clock
	Logger   *slog.Logger
	// Window defers an enrollment while its newest change is younger than
	// this, so a burst of uploads becomes one command. Default 2s.
	Window time.Duration
	// Poll is how often Run drains without a Kick. Default 1s.
	Poll time.Duration
	// Batch bounds the change rows read per drain. Default 500.
	Batch int
	// Backoff maps the attempt count to the retry delay. Default
	// storage.NotNowBackoff.
	Backoff func(attempt int) time.Duration
	// DedupeKey suppresses a new DeclarativeManagement while one is still
	// pending for the same enrollment. Nil uses DefaultDedupeKey; an empty
	// string turns suppression off, so every drain queues a command.
	//
	// It is a pointer for the same reason service.Config.ValidateTargets is:
	// the zero value has to mean "not set" so that "" can mean "off".
	// Whether to suppress is the consumer's decision, not this package's.
	DedupeKey *string
	// OnDrain, when set, is called with the outcome of every drain. A
	// suppressed command is counted in DrainResult.Deduped and is otherwise
	// invisible, which is the whole problem with suppression: it has to be
	// observable to be defensible.
	OnDrain func(ctx context.Context, res DrainResult)
}

type Pusher interface {
	Notify(ctx context.Context, ids []mdm.EnrollmentID) (map[mdm.EnrollmentID]push.Result, error)
}

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

type TokenSource interface {
	Tokens(ctx context.Context, id mdm.EnrollmentID) ([]byte, error)
}