rollout

type ContainerImage struct {
	Name  string // the container's own name field
	Init  bool   // an initContainer
	Image string
}

type DeploymentStatus struct {
	Namespace, Name string
	Images          []ContainerImage
	// Complete reports whether the rollout has finished, by kubectl's own four-condition test
	// (deploymentRolloutComplete). DeadlineExceeded is the one condition kubectl treats as a
	// hard failure rather than "still rolling out" — the Deployment's own progressDeadlineSeconds
	// has been exceeded — and is reported here rather than as a Go error, since it is a fact
	// about cluster state, not a call failure.
	Complete         bool
	DeadlineExceeded bool
	// Detail is a short, kubectl-style human-readable line: what's still pending, or why the
	// deadline was exceeded, or that the rollout finished.
	Detail string
	// RestartedAt is the pod template's RestartAnnotation value, "" when it has never been
	// restarted this way. Read so a restart can say what it supersedes, and so a caller can
	// tell its own stamp from someone else's.
	RestartedAt string
	// The fields below describe whether a restart of this Deployment can actually be graceful
	// (WorkloadStatus.GracefulRestartConcerns, through DeploymentStatus.Workload).
	// They are read here because the read that fetches them is already being made; hoist warns
	// on them and never blocks (AGENTS.md principle 5), since "roll it anyway" is a legitimate
	// thing to want and the operator is the one who knows.
	//
	// Replicas is spec.replicas (1 when unset, matching Kubernetes' own default). Strategy is
	// spec.strategy.type ("RollingUpdate" when unset). MaxUnavailable and MaxSurge are that
	// strategy's own values already RESOLVED against Replicas by Kubernetes' own rules —
	// percentages round down for unavailable and up for surge — because the raw 25%/25%
	// defaults say nothing on their own: at one replica they resolve to 0 and 1, which is
	// precisely the case where a naive "one replica means downtime" claim is wrong.
	// ReadinessProbes counts containers that declare one.
	Replicas        int32
	Strategy        string
	MaxUnavailable  int32
	MaxSurge        int32
	ReadinessProbes int
}

type Fake struct {
	Deployments map[depKey]DeploymentStatus
	// Workloads holds StatefulSets and DaemonSets, keyed by kind. A Deployment always lives in
	// Deployments, and Workload for one reads it from there, so a Deployment has one record in
	// the fake as it has one object in a cluster.
	Workloads map[jobKey]WorkloadStatus
	JobLikes  map[jobKey]JobLikeStatus
	// DeploymentErr, WorkloadErr and JobLikeErr, when set, are returned by every call to the
	// matching method instead of the configured/zero-value behavior. A Workload read of a
	// Deployment is a Deployment read and honours DeploymentErr; WorkloadErr covers the other
	// kinds.
	DeploymentErr, WorkloadErr, JobLikeErr, RestartErr error
	// Strict makes an unknown Deployment (or StatefulSet, or DaemonSet) return ErrNotFound, as the real client does, instead
	// of a zero-value status. Opt-in rather than the default because most tests here configure
	// only the Deployments they care about and rely on the zero value for the rest — but a test
	// about ABSENCE cannot use a fake that reports everything as present, and shipping code that
	// distinguishes the two deserves a fake that can too.
	Strict bool
	// OnRestart, when set, runs on every successful Restart — how a test models what the real
	// API server does next (the pods actually rolling), since the fake has no controller.
	OnRestart func(namespace, name string, at time.Time)
	// RestartLandsDespiteErr models the one outcome a patch cannot report: the API server
	// committed the write and the response was lost. With it set alongside RestartErr, the
	// stamp is recorded AND the error returned — which is the only way to exercise a caller's
	// did-it-actually-land recovery. Without it, RestartErr means the write did not happen.
	RestartLandsDespiteErr bool

	Calls []string
	// contains filtered or unexported fields
}

type JobLikeStatus struct {
	Namespace, Name, Kind string // Kind is "Job" or "CronJob"
	Detail                string
}

type Rollout interface {
	// Deployment reads namespace/name's current images and rollout completeness.
	Deployment(ctx context.Context, namespace, name string) (DeploymentStatus, error)
	// Workload reads namespace/name's current state for a restart, for any kind in
	// RestartableKinds. A Deployment's answer is Deployment's own, converted.
	Workload(ctx context.Context, namespace, name, kind string) (WorkloadStatus, error)
	// JobLike reads namespace/name's current state, for kind "Job" or "CronJob".
	JobLike(ctx context.Context, namespace, name, kind string) (JobLikeStatus, error)
	// Restart rolls namespace/name's pods without changing what it runs, by stamping the pod
	// template's restart annotation — exactly what `kubectl rollout restart` does — for any kind
	// in RestartableKinds. It is the ONE write in this package; everything else here reads (see
	// the package doc, and pkg/argo.Refresh, which holds the same position there).
	Restart(ctx context.Context, namespace, name, kind string, at time.Time) error
}

type WorkloadStatus struct {
	Kind, Namespace, Name string
	Images                []ContainerImage
	// Complete and DeadlineExceeded mean what they mean on DeploymentStatus, by kubectl's own
	// per-kind `rollout status` test. Only a Deployment has a progress deadline. An OnDelete
	// workload is never Complete: its rollout does not happen until someone deletes its pods.
	Complete         bool
	DeadlineExceeded bool
	Detail           string
	// RestartedAt is the pod template's RestartAnnotation value, "" when never restarted this way.
	RestartedAt string
	// Replicas is spec.replicas for a Deployment or StatefulSet (1 when unset), and for a
	// DaemonSet status.desiredNumberScheduled — one pod per node it should run on, which is the
	// number a DaemonSet's own maxUnavailable and maxSurge are resolved against.
	Replicas int32
	// Strategy is spec.strategy.type for a Deployment and spec.updateStrategy.type otherwise,
	// with Kubernetes' own default ("RollingUpdate") when unset.
	Strategy string
	// MaxUnavailable and MaxSurge are resolved against Replicas by the kind's own controller
	// rules (DeploymentStatus documents a Deployment's; see Workload for the others). A
	// StatefulSet never surges, so its MaxSurge is always 0.
	MaxUnavailable int32
	MaxSurge       int32
	// Partition is a StatefulSet's rollingUpdate.partition: pods with an ordinal below it keep
	// the old template through a rolling update. 0 for every other kind. It is an ordinal, not a
	// count: with spec.ordinals.start the pods are numbered from OrdinalStart.
	Partition int32
	// OrdinalStart is a StatefulSet's spec.ordinals.start (0 when unset, and for every other
	// kind): its pods are numbered OrdinalStart .. OrdinalStart+Replicas-1.
	OrdinalStart int32
	// ParallelPods is true for a StatefulSet whose podManagementPolicy is Parallel, the one
	// policy under which its rollingUpdate.maxUnavailable is honoured; under the default
	// OrderedReady pods are replaced one at a time whatever that field says.
	ParallelPods bool
	// ReadinessProbes counts containers that declare one.
	ReadinessProbes int
}