v1alpha1

type CloudCredentialsRefProvider interface {
	GetCloudCredentialsRef() (*string, *CloudCredentialsReference)
}

type CloudCredentialsReference struct {
	// SecretName is the name of a secret in the same namespace as the resource being provisioned.
	// The secret must contain a key named `clouds.yaml` which contains an OpenStack clouds.yaml file.
	// The secret may optionally contain a key named `cacert` containing a PEM-encoded CA certificate.
	// +kubebuilder:validation:Required
	// +kubebuilder:validation:MinLength:=1
	// +kubebuilder:validation:MaxLength:=253
	SecretName string `json:"secretName"`

	// CloudName specifies the name of the entry in the clouds.yaml file to use.
	// +kubebuilder:validation:Required
	// +kubebuilder:validation:MinLength:=1
	// +kubebuilder:validation:MaxLength:=256
	CloudName string `json:"cloudName"`
}

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

	Spec   ImageSpec   `json:"spec,omitempty"`
	Status ImageStatus `json:"status,omitempty"`
}

type ImageCompression string

type ImageContainerFormat string

type ImageContent struct {
	// ContainerFormat is the format of the image container.
	// qcow2 and raw images do not usually have a container. This is specified as "bare", which is also the default.
	// Permitted values are ami, ari, aki, bare, ovf, ova, and docker.
	// +kubebuilder:default:=bare
	// +optional
	ContainerFormat ImageContainerFormat `json:"containerFormat,omitempty"`

	// DiskFormat is the format of the disk image.
	// Normal values are "qcow2", or "raw". Glance may be configured to support others.
	// +kubebuilder:validation:Required
	DiskFormat ImageDiskFormat `json:"diskFormat"`

	// Download describes how to obtain image data by downloading it from a URL.
	// Must be set when creating a managed image.
	// +kubebuilder:validation:Required
	Download *ImageContentSourceDownload `json:"download,omitempty"`
}

type ImageContentSourceDownload struct {
	// URL containing image data
	// +kubebuilder:validation:Format=uri
	// +kubebuilder:validation:Required
	URL string `json:"url"`

	// Decompress specifies that the source data must be decompressed with the
	// given compression algorithm before being stored. Specifying Decompress
	// will disable the use of Glance's web-download, as web-download cannot
	// currently deterministically decompress downloaded content.
	// +optional
	Decompress *ImageCompression `json:"decompress,omitempty"`

	// Hash is a hash which will be used to verify downloaded data, i.e.
	// before any decompression. If not specified, no hash verification will be
	// performed. Specifying a Hash will disable the use of Glance's
	// web-download, as web-download cannot currently deterministically verify
	// the hash of downloaded content.
	// +kubebuilder:validation:XValidation:rule="self == oldSelf",message="hash is immutable"
	// +optional
	Hash *ImageHash `json:"hash,omitempty"`
}

type ImageDiskFormat string

type ImageFilter struct {
	// Name specifies the name of a Glance image
	// +optional
	// +kubebuilder:validation:MinLength:=1
	// +kubebuilder:validation:MaxLength:=1000
	Name *string `json:"name,omitempty"`
}

type ImageHWBus string

type ImageHash struct {
	// Algorithm is the hash algorithm used to generate value.
	// +kubebuilder:validation:Required
	Algorithm ImageHashAlgorithm `json:"algorithm"`

	// Value is the hash of the image data using Algorithm. It must be hex encoded using lowercase letters.
	// +kubebuilder:validation:MinLength:=1
	// +kubebuilder:validation:MaxLength:=1024
	// +kubebuilder:validation:Pattern:=`^[0-9a-f]+$`
	// +kubebuilder:validation:Required
	Value string `json:"value"`
}

type ImageHashAlgorithm string

type ImageImport struct {
	// ID contains the unique identifier of an existing OpenStack resource. Note
	// that when specifying an import by ID, the resource MUST already exist.
	// The ORC object will enter an error state if the resource does not exist.
	// +optional
	// +kubebuilder:validation:Format:=uuid
	ID *string `json:"id,omitempty"`

	// Filter contains a resource query which is expected to return a single
	// result. The controller will continue to retry if filter returns no
	// results. If filter returns multiple results the controller will set an
	// error state and will not continue to retry.
	// +optional
	Filter *ImageFilter `json:"filter,omitempty"`
}

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

type ImageProperties struct {
	// MinDisk is the minimum amount of disk space in GB that is required to boot the image
	// +kubebuilder:validation:Minimum:=1
	// +optional
	MinDiskGB *int `json:"minDiskGB,omitempty"`

	// MinMemoryMB is the minimum amount of RAM in MB that is required to boot the image.
	// +kubebuilder:validation:Minimum:=1
	// +optional
	MinMemoryMB *int `json:"minMemoryMB,omitempty"`

	// Hardware is a set of properties which control the virtual hardware
	// created by Nova.
	// +optional
	Hardware *ImagePropertiesHardware `json:"hardware,omitempty"`
}

type ImagePropertiesHardware struct {
	// CPUSockets is the preferred number of sockets to expose to the guest
	// +optional
	CPUSockets *int `json:"cpuSockets,omitempty" glance:"hw_cpu_sockets"`

	// CPUCores is the preferred number of cores to expose to the guest
	// +optional
	CPUCores *int `json:"cpuCores,omitempty" glance:"hw_cpu_cores"`

	// CPUThreads is the preferred number of threads to expose to the guest
	// +optional
	CPUThreads *int `json:"cpuThreads,omitempty" glance:"hw_cpu_threads"`

	// CPUPolicy is used to pin the virtual CPUs (vCPUs) of instances to the
	// host's physical CPU cores (pCPUs). Host aggregates should be used to
	// separate these pinned instances from unpinned instances as the latter
	// will not respect the resourcing requirements of the former.
	//
	// Permitted values are shared (the default), and dedicated.
	//
	// shared: The guest vCPUs will be allowed to freely float across host
	// pCPUs, albeit potentially constrained by NUMA policy.
	//
	// dedicated: The guest vCPUs will be strictly pinned to a set of host
	// pCPUs. In the absence of an explicit vCPU topology request, the
	// drivers typically expose all vCPUs as sockets with one core and one
	// thread. When strict CPU pinning is in effect the guest CPU topology
	// will be setup to match the topology of the CPUs to which it is
	// pinned. This option implies an overcommit ratio of 1.0. For example,
	// if a two vCPU guest is pinned to a single host core with two threads,
	// then the guest will get a topology of one socket, one core, two
	// threads.
	// +kubebuilder:validation:Enum:=shared;dedicated
	// +optional
	CPUPolicy *string `json:"cpuPolicy,omitempty" glance:"hw_cpu_policy"`

	// CPUThreadPolicy further refines a CPUPolicy of 'dedicated' by stating
	// how hardware CPU threads in a simultaneous multithreading-based (SMT)
	// architecture be used. SMT-based architectures include Intel
	// processors with Hyper-Threading technology. In these architectures,
	// processor cores share a number of components with one or more other
	// cores. Cores in such architectures are commonly referred to as
	// hardware threads, while the cores that a given core share components
	// with are known as thread siblings.
	//
	// Permitted values are prefer (the default), isolate, and require.
	//
	// prefer: The host may or may not have an SMT architecture. Where an
	// SMT architecture is present, thread siblings are preferred.
	//
	// isolate: The host must not have an SMT architecture or must emulate a
	// non-SMT architecture. If the host does not have an SMT architecture,
	// each vCPU is placed on a different core as expected. If the host does
	// have an SMT architecture - that is, one or more cores have thread
	// siblings - then each vCPU is placed on a different physical core. No
	// vCPUs from other guests are placed on the same core. All but one
	// thread sibling on each utilized core is therefore guaranteed to be
	// unusable.
	//
	// require: The host must have an SMT architecture. Each vCPU is
	// allocated on thread siblings. If the host does not have an SMT
	// architecture, then it is not used. If the host has an SMT
	// architecture, but not enough cores with free thread siblings are
	// available, then scheduling fails.
	// +kubebuilder:validation:Enum:=prefer;isolate;require
	// +optional
	CPUThreadPolicy *string `json:"cpuThreadPolicy,omitempty" glance:"hw_cpu_thread_policy"`

	// CDROMBus specifies the type of disk controller to attach CD-ROM devices to.
	// +optional
	CDROMBus *ImageHWBus `json:"cdromBus,omitempty" glance:"hw_cdrom_bus"`

	// DiskBus specifies the type of disk controller to attach disk devices to.
	// +optional
	DiskBus *ImageHWBus `json:"diskBus,omitempty" glance:"hw_disk_bus"`

	// SCSIModel enables the use of VirtIO SCSI (virtio-scsi) to provide
	// block device access for compute instances; by default, instances use
	// VirtIO Block (virtio-blk). VirtIO SCSI is a para-virtualized SCSI
	// controller device that provides improved scalability and performance,
	// and supports advanced SCSI hardware.
	//
	// The only permitted value is virtio-scsi.
	// +kubebuilder:validation:Enum:=virtio-scsi
	// +optional
	SCSIModel *string `json:"scsiModel,omitempty" glance:"hw_scsi_model"`

	// VIFModel specifies the model of virtual network interface device to use.
	//
	// Permitted values are e1000, e1000e, ne2k_pci, pcnet, rtl8139, virtio,
	// and vmxnet3.
	// +kubebuilder:validation:Enum:=e1000;e1000e;ne2k_pci;pcnet;rtl8139;virtio;vmxnet3
	// +optional
	VIFModel *string `json:"vifModel,omitempty" glance:"hw_vif_model"`
}

type ImageResourceSpec struct {
	// Name will be the name of the created Glance image. If not specified, the
	// name of the Image object will be used.
	// +optional
	Name *OpenStackName `json:"name,omitempty"`

	// Protected specifies that the image is protected from deletion.
	// If not specified, the default is false.
	// +optional
	Protected *bool `json:"protected,omitempty"`

	// Tags is a list of tags which will be applied to the image. A tag has a maximum length of 255 characters.
	// +listType=set
	// +optional
	Tags []ImageTag `json:"tags,omitempty"`

	// Visibility of the image
	// +kubebuilder:validation:XValidation:rule="self == oldSelf",message="visibility is immutable"
	// +optional
	Visibility *ImageVisibility `json:"visibility,omitempty"`

	// Properties is metadata available to consumers of the image
	// +optional
	Properties *ImageProperties `json:"properties,omitempty"`

	// Content specifies how to obtain the image content.
	// +kubebuilder:validation:XValidation:rule="self == oldSelf",message="content is immutable"
	// +optional
	Content *ImageContent `json:"content,omitempty"`
}

type ImageResourceStatus struct {
	// Status is the image status as reported by Glance
	// +optional
	Status *string `json:"status,omitempty"`

	// Hash is the hash of the image data published by Glance. Note that this is
	// a hash of the data stored internally by Glance, which will have been
	// decompressed and potentially format converted depending on server-side
	// configuration which is not visible to clients. It is expected that this
	// hash will usually differ from the download hash.
	// +optional
	Hash *ImageHash `json:"hash,omitempty"`

	// SizeB is the size of the image data, in bytes
	// +optional
	SizeB *int64 `json:"sizeB,omitempty"`

	// VirtualSizeB is the size of the disk the image data represents, in bytes
	// +optional
	VirtualSizeB *int64 `json:"virtualSizeB,omitempty"`
}

type ImageSpec struct {
	// Import refers to an existing OpenStack resource which will be imported instead of
	// creating a new one.
	// +optional
	Import *ImageImport `json:"import,omitempty"`

	// Resource specifies the desired state of the resource.
	//
	// Resource may not be specified if the management policy is `unmanaged`.
	//
	// Resource must be specified if the management policy is `managed`.
	// +optional
	Resource *ImageResourceSpec `json:"resource,omitempty"`

	// ManagementPolicy defines how ORC will treat the object. Valid values are
	// `managed`: ORC will create, update, and delete the resource; `unmanaged`:
	// ORC will import an existing resource, and will not apply updates to it or
	// delete it.
	// +kubebuilder:validation:XValidation:rule="self == oldSelf",message="managementPolicy is immutable"
	// +kubebuilder:default:=managed
	// +optional
	ManagementPolicy ManagementPolicy `json:"managementPolicy,omitempty"`

	// ManagedOptions specifies options which may be applied to managed objects.
	// +optional
	ManagedOptions *ManagedOptions `json:"managedOptions,omitempty"`

	// CloudCredentialsRef points to a secret containing OpenStack credentials
	// +kubebuilder:validation:Required
	CloudCredentialsRef CloudCredentialsReference `json:"cloudCredentialsRef"`
}

type ImageStatus struct {
	// Conditions represents the observed status of the object.
	// Known .status.conditions.type are: "Available", "Progressing"
	//
	// Available represents the availability of the OpenStack resource. If it is
	// true then the resource is ready for use.
	//
	// Progressing indicates whether the controller is still attempting to
	// reconcile the current state of the OpenStack resource to the desired
	// state. Progressing will be False either because the desired state has
	// been achieved, or because some terminal error prevents it from ever being
	// achieved and the controller is no longer attempting to reconcile. If
	// Progressing is True, an observer waiting on the resource should continue
	// to wait.
	//
	// +patchMergeKey=type
	// +patchStrategy=merge
	// +listType=map
	// +listMapKey=type
	Conditions []metav1.Condition `json:"conditions,omitempty" patchStrategy:"merge" patchMergeKey:"type"`

	// ID is the unique identifier of the OpenStack resource.
	// +optional
	ID *string `json:"id,omitempty"`

	// Resource contains the observed state of the OpenStack resource.
	// +optional
	Resource *ImageResourceStatus `json:"resource,omitempty"`

	ImageStatusExtra `json:",inline"`
}

type ImageStatusExtra struct {
	// DownloadAttempts is the number of times the controller has attempted to download the image contents
	// +optional
	DownloadAttempts *int `json:"downloadAttempts,omitempty"`
}

type ImageTag string

type ImageVisibility string

type ManagedOptions struct {
	// OnDelete specifies the behaviour of the controller when the ORC
	// object is deleted. Options are `delete` - delete the OpenStack resource;
	// `detach` - do not delete the OpenStack resource. If not specified, the
	// default is `delete`.
	// +kubebuilder:default:=delete
	// +optional
	OnDelete OnDelete `json:"onDelete,omitempty"`
}

type ManagementPolicy string

type ObjectWithConditions interface {
	metav1.Object
	GetConditions() []metav1.Condition
}

type OnDelete string

type OpenStackDescription string

type OpenStackName string

type UUID string