v1alpha1

type Bootstrap struct {
	// Static boostrapping requires that we know the network names of the
	// other peers ahead of time.
	// +optional
	Static *StaticBootstrap `json:"static,omitempty"`

	// This is passed through directly to the underlying etcd instance as the `ETCD_INITIAL_CLUSTER_STATE` envvar or
	// `--initial-cluster-state` flag. Like all bootstrap instructions, this is ignored if the data directory already
	// exists, which for us is if an underlying persistent volume already exists.
	//
	// When peers are created during bootstrapping of a new cluster this should be set to `New`. When adding peers to
	// an existing cluster during a scale-up event this should be set to `Existing`.
	InitialClusterState InitialClusterState `json:"initialClusterState"`
}

type EtcdBackup struct {
	metav1.TypeMeta   `json:",inline"`
	metav1.ObjectMeta `json:"metadata,omitempty"`

	Spec   EtcdBackupSpec   `json:"spec,omitempty"`
	Status EtcdBackupStatus `json:"status,omitempty"`
}

type EtcdBackupDestination struct {
	// Local, when set, will copy the backup into a local volume on the pod taking the backup.
	// +optional
	Local *EtcdBackupDestinationLocal `json:"local,omitempty"`
	// GCSBucket, when set, will push the backup to a Google Cloud Storage bucket.
	// +optional
	GCSBucket *EtcdBackupDestinationGCSBucket `json:"gcsBucket,omitempty"`
}

type EtcdBackupDestinationGCSBucket struct {
	// BucketName is the name of the storage bucket.
	//+kubebuilder:validation:MinLength=3
	//+kubebuilder:validation:MaxLength=222
	BucketName string `json:"bucketName"`
	// Credentials holds the method of obtaining credentials that will be provided to the
	// Google Cloud APIs in order to write backup data.
	// +optional
	Credentials *GoogleCloudCredentials `json:"credentials,omitempty"`
}

type EtcdBackupDestinationLocal struct {
	// Directory is an absolute filepath to a directory where backups will be placed.
	Directory string `json:"path"`
}

type EtcdBackupList struct {
	metav1.TypeMeta `json:",inline"`
	metav1.ListMeta `json:"metadata,omitempty"`
	Items           []EtcdBackup `json:"items"`
}

type EtcdBackupPhase string

type EtcdBackupSchedule struct {
	metav1.TypeMeta   `json:",inline"`
	metav1.ObjectMeta `json:"metadata,omitempty"`

	Spec   EtcdBackupScheduleSpec   `json:"spec,omitempty"`
	Status EtcdBackupScheduleStatus `json:"status,omitempty"`
}

type EtcdBackupScheduleList struct {
	metav1.TypeMeta `json:",inline"`
	metav1.ListMeta `json:"metadata,omitempty"`
	Items           []EtcdBackupSchedule `json:"items"`
}

type EtcdBackupScheduleSpec struct {
	// Schedule holds a crontab-like scheule holding defining the schedule in which backups will be started.
	Schedule string `json:"schedule"`
	// BackupTemplate describes the template used to create backup resources. Every time the schedule fires
	// an `EtcdBackup' will be created with this template.
	BackupTemplate EtcdBackupSpec `json:"backupSpec"`
}

type EtcdBackupScheduleStatus struct {
}

type EtcdBackupSpec struct {
	// ClusterEndpoints holds one or more endpoints fronting etcd's gRPC API.
	// Multiple endpoints may only be supported by some backup types.
	ClusterEndpoints []EtcdClusterEndpoint `json:"clusterEndpoints"`
	// Destination is the remote location where the backup will be placed.
	Destination EtcdBackupDestination `json:"destination"`
}

type EtcdBackupStatus struct {
	// Phase defines the current operation that the backup process is taking.
	Phase EtcdBackupPhase `json:"phase,omitempty"`
	// StartTime is the times that this backup entered the `BackingUp' phase.
	// +optional
	StartTime *metav1.Time `json:"startTime,omitempty"`
	// CompletionTime is the time that this backup entered the `Completed' phase.
	// +optional
	CompletionTime *metav1.Time `json:"completionTime,omitempty"`
	// BackupPath is the path to the final backup file inside of the destination.
	// The format of this string varies based on the destination.
	BackupPath string `json:"backupPath,omitempty"`
}

type EtcdCluster struct {
	metav1.TypeMeta   `json:",inline"`
	metav1.ObjectMeta `json:"metadata,omitempty"`

	Spec   EtcdClusterSpec   `json:"spec,omitempty"`
	Status EtcdClusterStatus `json:"status,omitempty"`
}

type EtcdClusterEndpoint struct {
	// Port that is exposing the etcd client API for this member.
	Port int `json:"port"`
	// An IP address or DNS name of an endpoint.
	Host string `json:"host"`
	// Scheme to use for connecting to the host.
	Scheme corev1.URIScheme `json:"scheme"`
}

type EtcdClusterList struct {
	metav1.TypeMeta `json:",inline"`
	metav1.ListMeta `json:"metadata,omitempty"`
	Items           []EtcdCluster `json:"items"`
}

type EtcdClusterSpec struct {
	// Version determines the version of Etcd that will be used for this cluster.
	// +kubebuilder:validation:Required
	Version string `json:"version"`

	// Number of instances of etcd to assemble into this cluster
	//+kubebuilder:validation:Required
	//+kubebuilder:validation:Minimum=1
	Replicas *int32 `json:"replicas"`

	// Storage is the configuration of the disks and mount points of the Etcd
	// peers.
	Storage *EtcdPeerStorage `json:"storage,omitempty"`

	// PodTemplate describes metadata that should be applied to the underlying Pods. This may not be applied verbatim,
	// as additional metadata may be added by the operator. In particular the operator reserves label and annotation
	// names starting with `etcd.improbable.io`, and pod templates containing these are considered invalid and will be
	// rejected.
	// +optional
	PodTemplate *EtcdPodTemplateSpec `json:"podTemplate,omitempty"`
}

type EtcdClusterStatus struct {
	// Replicas is the number of etcd peer resources we are managing. This doesn't mean the number of pods that exist
	// (as we may have just created a peer resource that doesn't have a pod yet, or the pod could be restarting), and it
	// doesn't mean the number of members the etcd cluster has live, as pods may not be ready yet or network problems
	// may mean the cluster has lost a member.
	// +optional
	Replicas int32 `json:"replicas"`

	// Members contains information about each member from the etcd cluster.
	// +optional
	Members []EtcdMember `json:"members"`

	// ClusterVersion contains the cluster API version
	// +optional
	ClusterVersion string `json:"clusterVersion"`
}

type EtcdMember struct {
	// Name is a human-readable name for the member. Will *typically* match the name we gave the peer that manages this
	// member.
	Name string `json:"name"`

	// ID is the internal unique identifier for the member that defines its identity with the etcd cluster. We do not
	// define this.
	ID string `json:"id"`
}

type EtcdPeer struct {
	metav1.TypeMeta   `json:",inline"`
	metav1.ObjectMeta `json:"metadata,omitempty"`

	Spec   EtcdPeerSpec   `json:"spec,omitempty"`
	Status EtcdPeerStatus `json:"status,omitempty"`
}

type EtcdPeerList struct {
	metav1.TypeMeta `json:",inline"`
	metav1.ListMeta `json:"metadata,omitempty"`
	Items           []EtcdPeer `json:"items"`
}

type EtcdPeerSpec struct {
	// The name of the etcd cluster that this peer should join. This will be
	// used to set the `spec.subdomain` field and the
	// `etcd.improbable.io/cluster-name` label on the Pod running etcd.
	// +kubebuilder:validation:MaxLength:=64
	ClusterName string `json:"clusterName"`

	// Version determines the version of Etcd that will be used for this peer.
	// +kubebuilder:validation:Required
	Version string `json:"version"`

	// Bootstrap is the bootstrap configuration to pass down into the etcd
	// pods. As per the etcd documentation, etcd will ignore bootstrap
	// instructions if it already knows where it's peers are.
	// +optional
	Bootstrap *Bootstrap `json:"bootstrap,omitempty"`

	// Storage is the configuration of the disks and mount points of the Etcd
	// pod.
	Storage *EtcdPeerStorage `json:"storage,omitempty"`

	// PodTemplate describes metadata that should be applied to the underlying Pods. This may not be applied verbatim,
	// as additional metadata may be added by the operator. In particular the operator reserves label and annotation
	// names starting with `etcd.improbable.io`, and pod templates containing these are considered invalid and will be
	// rejected.
	PodTemplate *EtcdPodTemplateSpec `json:"podTemplate,omitempty"`
}

type EtcdPeerStatus struct {
	// ServerVersion contains the Member server version
	ServerVersion string `json:"serverVersion"`
}

type EtcdPeerStorage struct {
	// VolumeClaimTemplates is a claim that pods are allowed to reference.
	// The EtcdPeer controller will create a new PersistentVolumeClaim using the
	// StorageClass and the Storage Resource Request in this template.
	// That PVC will then be mounted in the Pod for this EtcdPeer and the Etcd
	// process when it starts will persist its data to the PV bound to that PVC.
	VolumeClaimTemplate *corev1.PersistentVolumeClaimSpec `json:"volumeClaimTemplate,omitempty"`
}

type EtcdPodTemplateObjectMeta struct {

	// Annotations are an unstructured string:string map of annotations to be applied to the underlying pods.
	// +optional
	Annotations map[string]string `json:"annotations,omitempty"`
}

type EtcdPodTemplateSpec struct {

	// Metadata is elements to be applied to the final metadata of the underlying pods.
	// +optional
	Metadata *EtcdPodTemplateObjectMeta `json:"metadata,omitempty"`

	// Resources is for configuring the compute resources required by the etcd container. More info:
	// https://kubernetes.io/docs/concepts/configuration/manage-compute-resources-container/
	// +optional
	Resources *corev1.ResourceRequirements `json:"resources,omitempty"`

	// Affinity is the affinity scheduling rules to be applied to the underlying pods.
	// +optional
	Affinity *corev1.Affinity `json:"affinity,omitempty"`
}

type GoogleCloudCredentials struct {
	// Credentials are taken from the key of a Kubernetes secret.
	SecretKeyRef *corev1.SecretKeySelector `json:"secretKeySelector,omitempty"`
}

type InitialClusterMember struct {
	// Name is a friendly name for the peer, used as a means to identify the
	// peer once it has joined a cluster. This should match the `name` field
	// of the `EtcdPeer` resource representing that peer.
	Name string `json:"name"`

	// Host forms part of the Advertise URL - the URL at which this peer can
	// be contacted. The port and scheme are hardcoded to 2380 and http
	// respectively.
	Host string `json:"host"`
}

type InitialClusterState string

type StaticBootstrap struct {
	// InitialCluster provides details of all initial cluster members,
	// and should include ourselves.
	// +kubebuilder:validation:MinItems:=1
	InitialCluster []InitialClusterMember `json:"initialCluster,omitempty"`
}