// MachineDeployment is the Schema for the machinedeployments API
// +k8s:openapi-gen=true
// +kubebuilder:resource:shortName=md
// +kubebuilder:subresource:status
// +kubebuilder:subresource:scale:specpath=.spec.replicas,statuspath=.status.replicas,selectorpath=.status.labelSelector
type MachineDeployment struct {
    metav1.TypeMeta   `json:",inline"`
    metav1.ObjectMeta `json:"metadata,omitempty"`

    Spec   MachineDeploymentSpec   `json:"spec,omitempty"`
    Status MachineDeploymentStatus `json:"status,omitempty"`
}

// MachineDeploymentSpec defines the desired state of MachineDeployment
type MachineDeploymentSpec struct {
    // Number of desired machines. Defaults to 1.
    // This is a pointer to distinguish between explicit zero and not specified.
    Replicas *int32 `json:"replicas,omitempty"`

    // Label selector for machines. Existing MachineSets whose machines are
    // selected by this will be the ones affected by this deployment.
    // It must match the machine template's labels.
    Selector metav1.LabelSelector `json:"selector"`

    // Template describes the machines that will be created.
    Template MachineTemplateSpec `json:"template"`

    // The deployment strategy to use to replace existing machines with
    // new ones.
    // +optional
    Strategy *MachineDeploymentStrategy `json:"strategy,omitempty"`

    // Minimum number of seconds for which a newly created machine should
    // be ready.
    // Defaults to 0 (machine will be considered available as soon as it
    // is ready)
    // +optional
    MinReadySeconds *int32 `json:"minReadySeconds,omitempty"`

    // The number of old MachineSets to retain to allow rollback.
    // This is a pointer to distinguish between explicit zero and not specified.
    // Defaults to 1.
    // +optional
    RevisionHistoryLimit *int32 `json:"revisionHistoryLimit,omitempty"`

    // Indicates that the deployment is paused.
    // +optional
    Paused bool `json:"paused,omitempty"`

    // The maximum time in seconds for a deployment to make progress before it
    // is considered to be failed. The deployment controller will continue to
    // process failed deployments and a condition with a ProgressDeadlineExceeded
    // reason will be surfaced in the deployment status. Note that progress will
    // not be estimated during the time a deployment is paused. Defaults to 600s.
    ProgressDeadlineSeconds *int32 `json:"progressDeadlineSeconds,omitempty"`
}

// MachineDeploymentStrategy describes how to replace existing machines
// with new ones.
type MachineDeploymentStrategy struct {
    // Type of deployment. Currently the only supported strategy is
    // "RollingUpdate".
    // Default is RollingUpdate.
    // +optional
    Type common.MachineDeploymentStrategyType `json:"type,omitempty"`

    // Rolling update config params. Present only if
    // MachineDeploymentStrategyType = RollingUpdate.
    // +optional
    RollingUpdate *MachineRollingUpdateDeployment `json:"rollingUpdate,omitempty"`
}

// Spec to control the desired behavior of rolling update.
type MachineRollingUpdateDeployment struct {
    // The maximum number of machines that can be unavailable during the update.
    // Value can be an absolute number (ex: 5) or a percentage of desired
    // machines (ex: 10%).
    // Absolute number is calculated from percentage by rounding down.
    // This can not be 0 if MaxSurge is 0.
    // Defaults to 0.
    // Example: when this is set to 30%, the old MachineSet can be scaled
    // down to 70% of desired machines immediately when the rolling update
    // starts. Once new machines are ready, old MachineSet can be scaled
    // down further, followed by scaling up the new MachineSet, ensuring
    // that the total number of machines available at all times
    // during the update is at least 70% of desired machines.
    // +optional
    MaxUnavailable *intstr.IntOrString `json:"maxUnavailable,omitempty" protobuf:"bytes,1,opt,name=maxUnavailable"`

    // The maximum number of machines that can be scheduled above the
    // desired number of machines.
    // Value can be an absolute number (ex: 5) or a percentage of
    // desired machines (ex: 10%).
    // This can not be 0 if MaxUnavailable is 0.
    // Absolute number is calculated from percentage by rounding up.
    // Defaults to 1.
    // Example: when this is set to 30%, the new MachineSet can be scaled
    // up immediately when the rolling update starts, such that the total
    // number of old and new machines do not exceed 130% of desired
    // machines. Once old machines have been killed, new MachineSet can
    // be scaled up further, ensuring that total number of machines running
    // at any time during the update is at most 130% of desired machines.
    // +optional
    MaxSurge *intstr.IntOrString `json:"maxSurge,omitempty" protobuf:"bytes,2,opt,name=maxSurge"`
}

// MachineDeploymentStatus defines the observed state of MachineDeployment
type MachineDeploymentStatus struct {
    // The generation observed by the deployment controller.
    // +optional
    ObservedGeneration int64 `json:"observedGeneration,omitempty" protobuf:"varint,1,opt,name=observedGeneration"`

    // Total number of non-terminated machines targeted by this deployment
    // (their labels match the selector).
    // +optional
    Replicas int32 `json:"replicas,omitempty" protobuf:"varint,2,opt,name=replicas"`

    // Total number of non-terminated machines targeted by this deployment
    // that have the desired template spec.
    // +optional
    UpdatedReplicas int32 `json:"updatedReplicas,omitempty" protobuf:"varint,3,opt,name=updatedReplicas"`

    // Total number of ready machines targeted by this deployment.
    // +optional
    ReadyReplicas int32 `json:"readyReplicas,omitempty" protobuf:"varint,7,opt,name=readyReplicas"`

    // Total number of available machines (ready for at least minReadySeconds)
    // targeted by this deployment.
    // +optional
    AvailableReplicas int32 `json:"availableReplicas,omitempty" protobuf:"varint,4,opt,name=availableReplicas"`

    // Total number of unavailable machines targeted by this deployment.
    // This is the total number of machines that are still required for
    // the deployment to have 100% available capacity. They may either
    // be machines that are running but not yet available or machines
    // that still have not been created.
    // +optional
    UnavailableReplicas int32 `json:"unavailableReplicas,omitempty" protobuf:"varint,5,opt,name=unavailableReplicas"`
}