compute

type DaemonEndpoint struct {
	// Port number of the given endpoint.
	Port int32
}

type EFIVar struct {
	// Name is the name of the EFIVar.
	Name string
	// UUID is the uuid of the EFIVar.
	UUID string
	// Value is the value of the EFIVar.
	Value string
}

type EmptyDiskVolumeSource struct {
	// SizeLimit is the total amount of local storage required for this EmptyDisk volume.
	// The default is nil which means that the limit is undefined.
	SizeLimit *resource.Quantity
}

type EphemeralNetworkInterfaceSource struct {
	// NetworkInterfaceTemplate is the template definition of the networking.NetworkInterface.
	NetworkInterfaceTemplate *networking.NetworkInterfaceTemplateSpec
}

type EphemeralVolumeSource struct {
	// VolumeTemplate is the template definition of the storage.Volume.
	VolumeTemplate *storage.VolumeTemplateSpec
}

type Machine struct {
	metav1.TypeMeta
	metav1.ObjectMeta

	Spec   MachineSpec
	Status MachineStatus
}

type MachineClass struct {
	metav1.TypeMeta
	metav1.ObjectMeta

	// Capabilities describes the resources a machine class can provide.
	Capabilities core.ResourceList
}

type MachineClassList struct {
	metav1.TypeMeta
	metav1.ListMeta
	Items []MachineClass
}

type MachineExecOptions struct {
	metav1.TypeMeta
	InsecureSkipTLSVerifyBackend bool
}

type MachineList struct {
	metav1.TypeMeta
	metav1.ListMeta
	Items []Machine
}

type MachinePool struct {
	metav1.TypeMeta
	metav1.ObjectMeta

	Spec   MachinePoolSpec
	Status MachinePoolStatus
}

type MachinePoolAddress struct {
	Type    MachinePoolAddressType
	Address string
}

type MachinePoolAddressType string

type MachinePoolCondition struct {
	// Type is the type of the condition.
	Type MachinePoolConditionType
	// Status is the status of the condition.
	Status corev1.ConditionStatus
	// Reason is a machine-readable indication of why the condition is in a certain state.
	Reason string
	// Message is a human-readable explanation of why the condition has a certain reason / state.
	Message string
	// ObservedGeneration represents the .metadata.generation that the condition was set based upon.
	ObservedGeneration int64
	// LastTransitionTime is the last time the status of a condition has transitioned from one state to another.
	LastTransitionTime metav1.Time
}

type MachinePoolConditionType string

type MachinePoolDaemonEndpoints struct {
	// Endpoint on which machinepoollet is listening.
	// +optional
	MachinepoolletEndpoint DaemonEndpoint
}

type MachinePoolList struct {
	metav1.TypeMeta
	metav1.ListMeta
	Items []MachinePool
}

type MachinePoolSpec struct {
	// ProviderID identifies the MachinePool on provider side.
	ProviderID string
	// Taints of the MachinePool. Only Machines who tolerate all the taints
	// will land in the MachinePool.
	Taints []commonv1alpha1.Taint
}

type MachinePoolState string

type MachinePoolStatus struct {
	State                   MachinePoolState
	Conditions              []MachinePoolCondition
	AvailableMachineClasses []corev1.LocalObjectReference
	Addresses               []MachinePoolAddress
	DaemonEndpoints         MachinePoolDaemonEndpoints
}

type MachineSpec struct {
	// MachineClassRef is a reference to the machine class/flavor of the machine.
	MachineClassRef corev1.LocalObjectReference
	// MachinePoolSelector selects a suitable MachinePoolRef by the given labels.
	MachinePoolSelector map[string]string
	// MachinePoolRef defines machine pool to run the machine in.
	// If empty, a scheduler will figure out an appropriate pool to run the machine in.
	MachinePoolRef *corev1.LocalObjectReference
	// Power is the desired machine power state.
	// Defaults to PowerOn.
	Power Power
	// Image is the optional URL providing the operating system image of the machine.
	Image string
	// ImagePullSecretRef is an optional secret for pulling the image of a machine.
	ImagePullSecretRef *corev1.LocalObjectReference
	// NetworkInterfaces define a list of network interfaces present on the machine
	NetworkInterfaces []NetworkInterface
	// Volumes are volumes attached to this machine.
	Volumes []Volume
	// IgnitionRef is a reference to a secret containing the ignition YAML for the machine to boot up.
	// If key is empty, DefaultIgnitionKey will be used as fallback.
	IgnitionRef *commonv1alpha1.SecretKeySelector
	// EFIVars are variables to pass to EFI while booting up.
	EFIVars []EFIVar
	// Tolerations define tolerations the Machine has. Only MachinePools whose taints
	// covered by Tolerations will be considered to run the Machine.
	Tolerations []commonv1alpha1.Toleration
}

type MachineState string

type MachineStatus struct {
	// MachineID is the provider specific machine ID in the format '<type>://<machine_id>'.
	MachineID string
	// MachinePoolObservedGeneration is the last generation the MachinePool observed of the Machine.
	MachinePoolObservedGeneration int64
	// State is the infrastructure state of the machine.
	State MachineState
	// NetworkInterfaces is the list of network interface states for the machine.
	NetworkInterfaces []NetworkInterfaceStatus
	// Volumes is the list of volume states for the machine.
	Volumes []VolumeStatus
}

type NetworkInterface struct {
	// Name is the name of the network interface.
	Name string
	// NetworkInterfaceSource is where to obtain the interface from.
	NetworkInterfaceSource
}

type NetworkInterfacePhase string

type NetworkInterfaceSource struct {
	// NetworkInterfaceRef instructs to use the NetworkInterface at the target reference.
	NetworkInterfaceRef *corev1.LocalObjectReference
	// Ephemeral instructs to create an ephemeral (i.e. coupled to the lifetime of the surrounding object)
	// NetworkInterface to use.
	Ephemeral *EphemeralNetworkInterfaceSource
}

type NetworkInterfaceState string

type NetworkInterfaceStatus struct {
	// Name is the name of the NetworkInterface to whom the status belongs to.
	Name string
	// Handle is the MachinePool internal handle of the NetworkInterface.
	Handle string
	// NetworkHandle is the handle of the network the NetworkInterface is in.
	NetworkHandle string
	// IPs are the ips allocated for the network interface.
	IPs []commonv1alpha1.IP
	// VirtualIP is the virtual ip allocated for the network interface.
	VirtualIP *commonv1alpha1.IP
	// State represents the attachment state of a NetworkInterface.
	State NetworkInterfaceState
	// LastStateTransitionTime is the last time the State transitioned.
	LastStateTransitionTime *metav1.Time
	// Phase is the NetworkInterface binding phase of the NetworkInterface.
	Phase NetworkInterfacePhase
	// LastPhaseTransitionTime is the last time the Phase transitioned.
	LastPhaseTransitionTime *metav1.Time
}

type Power string

type Volume struct {
	// Name is the name of the Volume
	Name string
	// Device is the device name where the volume should be attached.
	// Pointer to distinguish between explicit zero and not specified.
	// If empty, an unused device name will be determined if possible.
	Device string
	// VolumeSource is the source where the storage for the Volume resides at.
	VolumeSource
}

type VolumePhase string

type VolumeSource struct {
	// VolumeRef instructs to use the specified Volume as source for the attachment.
	VolumeRef *corev1.LocalObjectReference
	// EmptyDisk instructs to use a Volume offered by the machine pool provider.
	EmptyDisk *EmptyDiskVolumeSource
	// Ephemeral instructs to create an ephemeral (i.e. coupled to the lifetime of the surrounding object)
	// Volume to use.
	Ephemeral *EphemeralVolumeSource
}

type VolumeState string

type VolumeStatus struct {
	// Name is the name of a volume attachment.
	Name string
	// Handle is the MachinePool internal handle of the volume.
	Handle string
	// State represents the attachment state of a Volume.
	State VolumeState
	// LastStateTransitionTime is the last time the State transitioned.
	LastStateTransitionTime *metav1.Time
	// Phase represents the binding phase of a Volume.
	Phase VolumePhase
	// LastPhaseTransitionTime is the last time the Phase transitioned.
	LastPhaseTransitionTime *metav1.Time
}