upgrade

type ClusterUpgradeState struct {
	NodeStates map[string][]*NodeUpgradeState
}

type ClusterUpgradeStateManager interface {
	// ApplyState receives a complete cluster upgrade state and, based on upgrade policy, processes each node's state.
	// Based on the current state of the node, it is calculated if the node can be moved to the next state right now
	// or whether any actions need to be scheduled for the node to move to the next state.
	// The function is stateless and idempotent. If the error was returned before all nodes' states were processed,
	// ApplyState would be called again and complete the processing - all the decisions are based on the input data.
	ApplyState(ctx context.Context,
		currentState *ClusterUpgradeState, upgradePolicy *v1alpha1.DriverUpgradePolicySpec) (err error)
	// BuildState builds a point-in-time snapshot of the driver upgrade state in the cluster.
	BuildState(ctx context.Context, namespace string, driverLabels map[string]string) (*ClusterUpgradeState, error)
	// GetTotalManagedNodes returns the total count of nodes managed for driver upgrades
	GetTotalManagedNodes(ctx context.Context, currentState *ClusterUpgradeState) int
	// GetUpgradesInProgress returns count of nodes on which upgrade is in progress
	GetUpgradesInProgress(ctx context.Context, currentState *ClusterUpgradeState) int
	// GetUpgradesDone returns count of nodes on which upgrade is complete
	GetUpgradesDone(ctx context.Context, currentState *ClusterUpgradeState) int
	// GetUpgradesAvailable returns count of nodes on which upgrade can be done
	GetUpgradesAvailable(ctx context.Context,
		currentState *ClusterUpgradeState, maxParallelUpgrades int, maxUnavailable int) int
	// GetUpgradesFailed returns count of nodes on which upgrades have failed
	GetUpgradesFailed(ctx context.Context, currentState *ClusterUpgradeState) int
	// GetUpgradesPending returns count of nodes on which are marked for upgrades and upgrade is pending
	GetUpgradesPending(ctx context.Context, currentState *ClusterUpgradeState) int
	// WithPodDeletionEnabled provides an option to enable the optional 'pod-deletion'
	// state and pass a custom PodDeletionFilter to use
	WithPodDeletionEnabled(filter PodDeletionFilter) ClusterUpgradeStateManager
	// WithValidationEnabled provides an option to enable the optional 'validation' state
	// and pass a podSelector to specify which pods are performing the validation
	WithValidationEnabled(podSelector string) ClusterUpgradeStateManager
	// IsPodDeletionEnabled returns true if 'pod-deletion' state is enabled
	IsPodDeletionEnabled() bool
	// IsValidationEnabled returns true if 'validation' state is enabled
	IsValidationEnabled() bool
}

type ClusterUpgradeStateManagerImpl struct {
	Log           logr.Logger
	K8sClient     client.Client
	K8sInterface  kubernetes.Interface
	EventRecorder record.EventRecorder

	DrainManager             DrainManager
	PodManager               PodManager
	CordonManager            CordonManager
	NodeUpgradeStateProvider NodeUpgradeStateProvider
	ValidationManager        ValidationManager
	SafeDriverLoadManager    SafeDriverLoadManager
	// contains filtered or unexported fields
}

type CordonManager interface {
	Cordon(ctx context.Context, node *corev1.Node) error
	Uncordon(ctx context.Context, node *corev1.Node) error
}

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

type DrainConfiguration struct {
	Spec  *v1alpha1.DrainSpec
	Nodes []*corev1.Node
}

type DrainManager interface {
	ScheduleNodesDrain(ctx context.Context, drainConfig *DrainConfiguration) error
}

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

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

type NodeUpgradeState struct {
	Node            *corev1.Node
	DriverPod       *corev1.Pod
	DriverDaemonSet *appsv1.DaemonSet
}

type NodeUpgradeStateProvider interface {
	GetNode(ctx context.Context, nodeName string) (*corev1.Node, error)
	ChangeNodeUpgradeState(ctx context.Context, node *corev1.Node, newNodeState string) error
	ChangeNodeUpgradeAnnotation(ctx context.Context, node *corev1.Node, key string, value string) error
}

type NodeUpgradeStateProviderImpl struct {
	K8sClient client.Client
	Log       logr.Logger
	// contains filtered or unexported fields
}

type PodDeletionFilter func(corev1.Pod) bool

type PodManager interface {
	ScheduleCheckOnPodCompletion(ctx context.Context, config *PodManagerConfig) error
	SchedulePodsRestart(ctx context.Context, pods []*corev1.Pod) error
	SchedulePodEviction(ctx context.Context, config *PodManagerConfig) error
	GetPodDeletionFilter() PodDeletionFilter
	GetPodControllerRevisionHash(ctx context.Context, pod *corev1.Pod) (string, error)
	GetDaemonsetControllerRevisionHash(ctx context.Context, daemonset *appsv1.DaemonSet) (string, error)
}

type PodManagerConfig struct {
	Nodes                 []*corev1.Node
	DeletionSpec          *v1alpha1.PodDeletionSpec
	WaitForCompletionSpec *v1alpha1.WaitForCompletionSpec
	DrainEnabled          bool
}

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

type SafeDriverLoadManager interface {
	// IsWaitingForSafeDriverLoad checks if driver Pod on the node is waiting for a safe load
	IsWaitingForSafeDriverLoad(ctx context.Context, node *corev1.Node) (bool, error)
	// UnblockLoading unblocks driver loading on the node
	UnblockLoading(ctx context.Context, node *corev1.Node) error
}

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

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

type UnlockFunc = func()

type ValidationManager interface {
	Validate(ctx context.Context, node *corev1.Node) (bool, error)
}

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