updater

type Actor interface {
	// ScaleOut creates a new update instance
	ScaleOut(ctx context.Context) error

	// Update will update an instance CR
	// unavailable means update must choose an unavailable instance to update
	Update(ctx context.Context, unavailable bool) error

	// ScaleInOutdated will scale in an outdated instance
	// If unavailable is true, the chosen instance is unavailable
	ScaleInUpdate(ctx context.Context) (unavailable bool, _ error)

	// ScaleInUpdate will scale in an updated instance
	// If unavailable is true, the chosen instance is unavailable
	ScaleInOutdated(ctx context.Context) (unavailable bool, _ error)

	// Cleanup deletes all instances marked as defer deletion
	Cleanup(ctx context.Context) error
}

type AddHook[R runtime.Instance] interface {
	Add(update R) R
}

type AddHookFunc[PT runtime.Instance] func(update PT) PT

type Builder[R runtime.Instance] interface {
	WithInstances(...R) Builder[R]
	WithDesired(desired int) Builder[R]
	WithMaxSurge(maxSurge int) Builder[R]
	WithMaxUnavailable(maxUnavailable int) Builder[R]
	WithRevision(rev string) Builder[R]
	WithClient(c client.Client) Builder[R]
	WithNewFactory(NewFactory[R]) Builder[R]
	WithAddHooks(hooks ...AddHook[R]) Builder[R]
	WithUpdateHooks(hooks ...UpdateHook[R]) Builder[R]
	WithDelHooks(hooks ...DelHook[R]) Builder[R]
	WithScaleInPreferPolicy(ps ...PreferPolicy[R]) Builder[R]
	WithUpdatePreferPolicy(ps ...PreferPolicy[R]) Builder[R]
	// NoInPlaceUpdate if true, actor will use Scale in and Scale out to replace Update operation
	WithNoInPaceUpdate(noUpdate bool) Builder[R]
	// MinReadySeconds means instances are available only when they keep ready more than minReadySeconds
	WithMinReadySeconds(minReadySeconds int64) Builder[R]
	Build() Executor
}

type DelHook[R runtime.Instance] interface {
	Delete(name string)
}

type DelHookFunc[PT runtime.Instance] func(name string)

type Executor interface {
	Do(ctx context.Context) (bool, error)
}

type Metadata struct {
	ResourceVersion string             `json:"resourceVersion"`
	Annotations     map[string]*string `json:"annotations,omitempty"`
}

type NewFactory[R runtime.Instance] interface {
	// New will generate a new object for scaling out and update.
	New() R
	// Adopt is only called when scaling out.
	// UnlockFunc will be called if apply is failed.
	// If no obj can be adopted, obj is nil and exists is false.
	//
	// This interface cannot ensure that R is a pointer(of course it is), so a
	// return val 'exists' is added to check whether the obj is nil.
	// We can add a new generic type param(runtime.InstanceSet) to ensure that R is a pointer, but it changes too much.
	Adopt() (obj R, fn UnlockFunc, exists bool)
}

type NewFunc[R runtime.Instance] func() R

type Patch struct {
	Metadata Metadata `json:"metadata"`
	Spec     *Spec    `json:"spec,omitempty"`
}

type PreferPolicy[R runtime.Instance] interface {
	Prefer([]R) []R
}

type PreferPolicyFunc[R runtime.Instance] func([]R) []R

type Score uint32

type ScoredPreferPolicy[R runtime.Instance] interface {
	Score() Score
	Prefer([]R) []R
}

type Selector[R runtime.Instance] interface {
	Choose([]R) string
}

type Spec struct {
	Offline bool `json:"offline"`
}

type State[R runtime.Instance] interface {
	Add(obj R)
	Del(name string) R
	Get(name string) R
	List() []R
	Len() int
}

type UnlockFunc func()

type UpdateHook[R runtime.Instance] interface {
	Update(update, outdated R) R
}

type UpdateHookFunc[R runtime.Instance] func(update, outdated R) R