diff --git a/Makefile b/Makefile index c36e50018..c43c8c98c 100644 --- a/Makefile +++ b/Makefile @@ -41,7 +41,7 @@ IMAGE_TAG:=$(shell IGNITE_GIT_VERSION=$(GIT_VERSION) DOCKER_USER=$(DOCKER_USER) IS_DIRTY:=$(shell echo ${GIT_VERSION} | grep -c dirty) PROJECT = github.com/weaveworks/ignite APIS_DIR = ${PROJECT}/pkg/apis -API_DIRS = ${APIS_DIR}/ignite,${APIS_DIR}/ignite/v1alpha2,${APIS_DIR}/meta/v1alpha1 +API_DIRS = ${APIS_DIR}/ignite,${APIS_DIR}/ignite/v1alpha2,${APIS_DIR}/ignite/v1alpha3,${APIS_DIR}/meta/v1alpha1 CACHE_DIR = $(shell pwd)/bin/cache # Specifies if this is a CI build or not; if it is, it will save the docker image created to bin/$(GOARCH)/image.tar IS_CI_BUILD ?= 0 diff --git a/cmd/ignite/cmd/vmcmd/ps.go b/cmd/ignite/cmd/vmcmd/ps.go index 98e3e536a..798cfb1b8 100644 --- a/cmd/ignite/cmd/vmcmd/ps.go +++ b/cmd/ignite/cmd/vmcmd/ps.go @@ -23,7 +23,7 @@ func NewCmdPs(out io.Writer) *cobra.Command { also list VMs that are not currently running. Using the -f (--filter) flag, you can give conditions VMs should fullfilled to be displayed. You can filter on all the underlying fields of the VM struct, see the documentation: - https://ignite.readthedocs.io/en/stable/api/ignite_v1alpha2#VM. + https://ignite.readthedocs.io/en/stable/api/ignite_v1alpha3#VM. Different operators can be used: - "=" and "==" for the equal diff --git a/cmd/ignite/run/testdata/input/create-config-no-name.yaml b/cmd/ignite/run/testdata/input/create-config-no-name.yaml index f73153be3..42185cc92 100644 --- a/cmd/ignite/run/testdata/input/create-config-no-name.yaml +++ b/cmd/ignite/run/testdata/input/create-config-no-name.yaml @@ -1,4 +1,4 @@ -apiVersion: ignite.weave.works/v1alpha2 +apiVersion: ignite.weave.works/v1alpha3 kind: VM spec: image: diff --git a/cmd/ignite/run/testdata/input/rm-no-name-uid.yaml b/cmd/ignite/run/testdata/input/rm-no-name-uid.yaml index f00436d09..6fb52b421 100644 --- a/cmd/ignite/run/testdata/input/rm-no-name-uid.yaml +++ b/cmd/ignite/run/testdata/input/rm-no-name-uid.yaml @@ -1,4 +1,4 @@ -apiVersion: ignite.weave.works/v1alpha2 +apiVersion: ignite.weave.works/v1alpha3 kind: VM metadata: name: "" diff --git a/cmd/ignite/run/testdata/input/rm-vm1.yaml b/cmd/ignite/run/testdata/input/rm-vm1.yaml index de37a2bbb..244809059 100644 --- a/cmd/ignite/run/testdata/input/rm-vm1.yaml +++ b/cmd/ignite/run/testdata/input/rm-vm1.yaml @@ -1,4 +1,4 @@ -apiVersion: ignite.weave.works/v1alpha2 +apiVersion: ignite.weave.works/v1alpha3 kind: VM metadata: name: myvm2 diff --git a/cmd/ignite/run/testdata/output/inspect-json.txt b/cmd/ignite/run/testdata/output/inspect-json.txt index c7cdf9e36..b76248ef0 100644 --- a/cmd/ignite/run/testdata/output/inspect-json.txt +++ b/cmd/ignite/run/testdata/output/inspect-json.txt @@ -1,6 +1,6 @@ { "kind": "VM", - "apiVersion": "ignite.weave.works/v1alpha2", + "apiVersion": "ignite.weave.works/v1alpha3", "metadata": { "name": "someVM", "uid": "1699b6ba255cde7f", diff --git a/cmd/ignite/run/testdata/output/inspect-yaml.txt b/cmd/ignite/run/testdata/output/inspect-yaml.txt index 7d4d72bb1..0eefa4596 100644 --- a/cmd/ignite/run/testdata/output/inspect-yaml.txt +++ b/cmd/ignite/run/testdata/output/inspect-yaml.txt @@ -1,4 +1,4 @@ -apiVersion: ignite.weave.works/v1alpha2 +apiVersion: ignite.weave.works/v1alpha3 kind: VM metadata: created: "2000-01-01T01:00:00Z" diff --git a/docs/api/ignite_v1alpha3.md b/docs/api/ignite_v1alpha3.md new file mode 100644 index 000000000..26435612f --- /dev/null +++ b/docs/api/ignite_v1alpha3.md @@ -0,0 +1,492 @@ +# v1alpha3 + +`import "github.com/weaveworks/ignite/pkg/apis/ignite/v1alpha3"` + + - [Overview](#pkg-overview) + - [Index](#pkg-index) + +## Overview + +\+k8s:deepcopy-gen=package +k8s:defaulter-gen=TypeMeta ++k8s:openapi-gen=true ++k8s:conversion-gen=github.com/weaveworks/ignite/pkg/apis/ignite + +## Index + + - [Constants](#pkg-constants) + - [Variables](#pkg-variables) + - [func SetDefaults\_PoolSpec(obj \*PoolSpec)](#SetDefaults_PoolSpec) + - [func SetDefaults\_VMKernelSpec(obj + \*VMKernelSpec)](#SetDefaults_VMKernelSpec) + - [func SetDefaults\_VMSandboxSpec(obj + \*VMSandboxSpec)](#SetDefaults_VMSandboxSpec) + - [func SetDefaults\_VMSpec(obj \*VMSpec)](#SetDefaults_VMSpec) + - [type BlockDeviceVolume](#BlockDeviceVolume) + - [type FileMapping](#FileMapping) + - [type Image](#Image) + - [type ImageSpec](#ImageSpec) + - [type ImageStatus](#ImageStatus) + - [type Kernel](#Kernel) + - [type KernelSpec](#KernelSpec) + - [type KernelStatus](#KernelStatus) + - [type OCIImageSource](#OCIImageSource) + - [type Pool](#Pool) + - [type PoolDevice](#PoolDevice) + - [type PoolDeviceType](#PoolDeviceType) + - [type PoolSpec](#PoolSpec) + - [type PoolStatus](#PoolStatus) + - [type Runtime](#Runtime) + - [type SSH](#SSH) + - [func (s \*SSH) MarshalJSON() (\[\]byte, + error)](#SSH.MarshalJSON) + - [func (s \*SSH) UnmarshalJSON(b \[\]byte) + error](#SSH.UnmarshalJSON) + - [type VM](#VM) + - [type VMImageSpec](#VMImageSpec) + - [type VMKernelSpec](#VMKernelSpec) + - [type VMNetworkSpec](#VMNetworkSpec) + - [type VMSandboxSpec](#VMSandboxSpec) + - [type VMSpec](#VMSpec) + - [type VMStatus](#VMStatus) + - [type VMStorageSpec](#VMStorageSpec) + - [type Volume](#Volume) + - [type VolumeMount](#VolumeMount) + +#### Package files + +[defaults.go](https://github.com/weaveworks/ignite/tree/master/pkg/apis/ignite/v1alpha3/defaults.go) +[doc.go](https://github.com/weaveworks/ignite/tree/master/pkg/apis/ignite/v1alpha3/doc.go) +[json.go](https://github.com/weaveworks/ignite/tree/master/pkg/apis/ignite/v1alpha3/json.go) +[register.go](https://github.com/weaveworks/ignite/tree/master/pkg/apis/ignite/v1alpha3/register.go) +[types.go](https://github.com/weaveworks/ignite/tree/master/pkg/apis/ignite/v1alpha3/types.go) + +## Constants + +``` go +const ( + KindImage runtime.Kind = "Image" + KindKernel runtime.Kind = "Kernel" + KindVM runtime.Kind = "VM" +) +``` + +``` go +const ( + // GroupName is the group name use in this package + GroupName = "ignite.weave.works" +) +``` + +## Variables + +``` go +var ( + // SchemeBuilder the schema builder + SchemeBuilder = runtime.NewSchemeBuilder( + addKnownTypes, + addDefaultingFuncs, + ) + + AddToScheme = localSchemeBuilder.AddToScheme +) +``` + +``` go +var SchemeGroupVersion = schema.GroupVersion{ + Group: GroupName, + Version: "v1alpha3", +} +``` + +SchemeGroupVersion is group version used to register these objects + +## func [SetDefaults\_PoolSpec](https://github.com/weaveworks/ignite/tree/master/pkg/apis/ignite/v1alpha3/defaults.go?s=308:348#L15) + +``` go +func SetDefaults_PoolSpec(obj *PoolSpec) +``` + +## func [SetDefaults\_VMKernelSpec](https://github.com/weaveworks/ignite/tree/master/pkg/apis/ignite/v1alpha3/defaults.go?s=1190:1238#L51) + +``` go +func SetDefaults_VMKernelSpec(obj *VMKernelSpec) +``` + +## func [SetDefaults\_VMSandboxSpec](https://github.com/weaveworks/ignite/tree/master/pkg/apis/ignite/v1alpha3/defaults.go?s=1468:1518#L62) + +``` go +func SetDefaults_VMSandboxSpec(obj *VMSandboxSpec) +``` + +## func [SetDefaults\_VMSpec](https://github.com/weaveworks/ignite/tree/master/pkg/apis/ignite/v1alpha3/defaults.go?s=874:910#L37) + +``` go +func SetDefaults_VMSpec(obj *VMSpec) +``` + +## type [BlockDeviceVolume](https://github.com/weaveworks/ignite/tree/master/pkg/apis/ignite/v1alpha3/types.go?s=7601:7661#L201) + +``` go +type BlockDeviceVolume struct { + Path string `json:"path"` +} +``` + +BlockDeviceVolume defines a block device on the host + +## type [FileMapping](https://github.com/weaveworks/ignite/tree/master/pkg/apis/ignite/v1alpha3/types.go?s=7896:7991#L212) + +``` go +type FileMapping struct { + HostPath string `json:"hostPath"` + VMPath string `json:"vmPath"` +} +``` + +FileMapping defines mappings between files on the host and VM + +## type [Image](https://github.com/weaveworks/ignite/tree/master/pkg/apis/ignite/v1alpha3/types.go?s=390:863#L16) + +``` go +type Image struct { + runtime.TypeMeta `json:",inline"` + // runtime.ObjectMeta is also embedded into the struct, and defines the human-readable name, and the machine-readable ID + // Name is available at the .metadata.name JSON path + // ID is available at the .metadata.uid JSON path (the Go type is k8s.io/apimachinery/pkg/types.UID, which is only a typed string) + runtime.ObjectMeta `json:"metadata"` + + Spec ImageSpec `json:"spec"` + Status ImageStatus `json:"status"` +} +``` + +Image represents a cached OCI image ready to be used with Ignite ++k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object + +## type [ImageSpec](https://github.com/weaveworks/ignite/tree/master/pkg/apis/ignite/v1alpha3/types.go?s=911:971#L28) + +``` go +type ImageSpec struct { + OCI meta.OCIImageRef `json:"oci"` +} +``` + +ImageSpec declares what the image contains + +## type [ImageStatus](https://github.com/weaveworks/ignite/tree/master/pkg/apis/ignite/v1alpha3/types.go?s=1359:1508#L42) + +``` go +type ImageStatus struct { + // OCISource contains the information about how this OCI image was imported + OCISource OCIImageSource `json:"ociSource"` +} +``` + +ImageStatus defines the status of the image + +## type [Kernel](https://github.com/weaveworks/ignite/tree/master/pkg/apis/ignite/v1alpha3/types.go?s=3893:4369#L106) + +``` go +type Kernel struct { + runtime.TypeMeta `json:",inline"` + // runtime.ObjectMeta is also embedded into the struct, and defines the human-readable name, and the machine-readable ID + // Name is available at the .metadata.name JSON path + // ID is available at the .metadata.uid JSON path (the Go type is k8s.io/apimachinery/pkg/types.UID, which is only a typed string) + runtime.ObjectMeta `json:"metadata"` + + Spec KernelSpec `json:"spec"` + Status KernelStatus `json:"status"` +} +``` + +Kernel is a serializable object that caches information about imported +kernels This file is stored in +/var/lib/firecracker/kernels/{oci-image-digest}/metadata.json ++k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object + +## type [KernelSpec](https://github.com/weaveworks/ignite/tree/master/pkg/apis/ignite/v1alpha3/types.go?s=4422:4588#L118) + +``` go +type KernelSpec struct { + OCI meta.OCIImageRef `json:"oci"` +} +``` + +KernelSpec describes the properties of a kernel + +## type [KernelStatus](https://github.com/weaveworks/ignite/tree/master/pkg/apis/ignite/v1alpha3/types.go?s=4639:4755#L125) + +``` go +type KernelStatus struct { + Version string `json:"version"` + OCISource OCIImageSource `json:"ociSource"` +} +``` + +KernelStatus describes the status of a kernel + +## type [OCIImageSource](https://github.com/weaveworks/ignite/tree/master/pkg/apis/ignite/v1alpha3/types.go?s=1078:1310#L34) + +``` go +type OCIImageSource struct { + // ID defines the source's content ID (e.g. the canonical OCI path or Docker image ID) + ID *meta.OCIContentID `json:"id"` + // Size defines the size of the source in bytes + Size meta.Size `json:"size"` +} +``` + +OCIImageSource specifies how the OCI image was imported. It is the +status variant of OCIImageClaim + +## type [Pool](https://github.com/weaveworks/ignite/tree/master/pkg/apis/ignite/v1alpha3/types.go?s=1783:1969#L51) + +``` go +type Pool struct { + runtime.TypeMeta `json:",inline"` + + Spec PoolSpec `json:"spec"` + Status PoolStatus `json:"status"` +} +``` + +Pool defines device mapper pool database This file is managed by the +snapshotter part of Ignite, and the file (existing as a singleton) is +present at /var/lib/firecracker/snapshotter/pool.json ++k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object + +## type [PoolDevice](https://github.com/weaveworks/ignite/tree/master/pkg/apis/ignite/v1alpha3/types.go?s=3260:3650#L93) + +``` go +type PoolDevice struct { + Size meta.Size `json:"size"` + Parent meta.DMID `json:"parent"` + // Type specifies the type of the contents of the device + Type PoolDeviceType `json:"type"` + // MetadataPath points to the JSON/YAML file with metadata about this device + // This is most often of the format /var/lib/firecracker/{type}/{id}/metadata.json + MetadataPath string `json:"metadataPath"` +} +``` + +PoolDevice defines one device in the pool + +## type [PoolDeviceType](https://github.com/weaveworks/ignite/tree/master/pkg/apis/ignite/v1alpha3/types.go?s=2989:3015#L83) + +``` go +type PoolDeviceType string +``` + +``` go +const ( + PoolDeviceTypeImage PoolDeviceType = "Image" + PoolDeviceTypeResize PoolDeviceType = "Resize" + PoolDeviceTypeKernel PoolDeviceType = "Kernel" + PoolDeviceTypeVM PoolDeviceType = "VM" +) +``` + +## type [PoolSpec](https://github.com/weaveworks/ignite/tree/master/pkg/apis/ignite/v1alpha3/types.go?s=2016:2729#L61) + +``` go +type PoolSpec struct { + // MetadataSize specifies the size of the pool's metadata + MetadataSize meta.Size `json:"metadataSize"` + // DataSize specifies the size of the pool's data + DataSize meta.Size `json:"dataSize"` + // AllocationSize specifies the smallest size that can be allocated at a time + AllocationSize meta.Size `json:"allocationSize"` + // MetadataPath points to the file where device mapper stores all metadata information + // Defaults to constants.SNAPSHOTTER_METADATA_PATH + MetadataPath string `json:"metadataPath"` + // DataPath points to the backing physical device or sparse file (to be loop mounted) for the pool + // Defaults to constants.SNAPSHOTTER_DATA_PATH + DataPath string `json:"dataPath"` +} +``` + +PoolSpec defines the Pool’s specification + +## type [PoolStatus](https://github.com/weaveworks/ignite/tree/master/pkg/apis/ignite/v1alpha3/types.go?s=2779:2987#L77) + +``` go +type PoolStatus struct { + // The Devices array needs to contain pointers to accommodate "holes" in the mapping + // Where devices have been deleted, the pointer is nil + Devices []*PoolDevice `json:"devices"` +} +``` + +PoolStatus defines the Pool’s current status + +## type [Runtime](https://github.com/weaveworks/ignite/tree/master/pkg/apis/ignite/v1alpha3/types.go?s=8340:8386#L227) + +``` go +type Runtime struct { + ID string `json:"id"` +} +``` + +Runtime specifies the VM’s runtime information + +## type [SSH](https://github.com/weaveworks/ignite/tree/master/pkg/apis/ignite/v1alpha3/types.go?s=8211:8288#L221) + +``` go +type SSH struct { + Generate bool `json:"-"` + PublicKey string `json:"-"` +} +``` + +SSH specifies different ways to connect via SSH to the VM SSH uses a +custom marshaller/unmarshaller. If generate is true, it marshals to true +(a JSON bool). If PublicKey is set, it marshals to that string. + +### func (\*SSH) [MarshalJSON](https://github.com/weaveworks/ignite/tree/master/pkg/apis/ignite/v1alpha3/json.go?s=117:160#L9) + +``` go +func (s *SSH) MarshalJSON() ([]byte, error) +``` + +### func (\*SSH) [UnmarshalJSON](https://github.com/weaveworks/ignite/tree/master/pkg/apis/ignite/v1alpha3/json.go?s=308:351#L21) + +``` go +func (s *SSH) UnmarshalJSON(b []byte) error +``` + +## type [VM](https://github.com/weaveworks/ignite/tree/master/pkg/apis/ignite/v1alpha3/types.go?s=4957:5421#L133) + +``` go +type VM struct { + runtime.TypeMeta `json:",inline"` + // runtime.ObjectMeta is also embedded into the struct, and defines the human-readable name, and the machine-readable ID + // Name is available at the .metadata.name JSON path + // ID is available at the .metadata.uid JSON path (the Go type is k8s.io/apimachinery/pkg/types.UID, which is only a typed string) + runtime.ObjectMeta `json:"metadata"` + + Spec VMSpec `json:"spec"` + Status VMStatus `json:"status"` +} +``` + +VM represents a virtual machine run by Firecracker These files are +stored in /var/lib/firecracker/vm/{vm-id}/metadata.json ++k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object + +## type [VMImageSpec](https://github.com/weaveworks/ignite/tree/master/pkg/apis/ignite/v1alpha3/types.go?s=6774:6836#L170) + +``` go +type VMImageSpec struct { + OCI meta.OCIImageRef `json:"oci"` +} +``` + +## type [VMKernelSpec](https://github.com/weaveworks/ignite/tree/master/pkg/apis/ignite/v1alpha3/types.go?s=6838:6958#L174) + +``` go +type VMKernelSpec struct { + OCI meta.OCIImageRef `json:"oci"` + CmdLine string `json:"cmdLine,omitempty"` +} +``` + +## type [VMNetworkSpec](https://github.com/weaveworks/ignite/tree/master/pkg/apis/ignite/v1alpha3/types.go?s=7087:7166#L184) + +``` go +type VMNetworkSpec struct { + Ports meta.PortMappings `json:"ports,omitempty"` +} +``` + +## type [VMSandboxSpec](https://github.com/weaveworks/ignite/tree/master/pkg/apis/ignite/v1alpha3/types.go?s=7021:7085#L180) + +``` go +type VMSandboxSpec struct { + OCI meta.OCIImageRef `json:"oci"` +} +``` + +VMSandboxSpec is the spec of the sandbox used for the VM. + +## type [VMSpec](https://github.com/weaveworks/ignite/tree/master/pkg/apis/ignite/v1alpha3/types.go?s=5469:6772#L145) + +``` go +type VMSpec struct { + Image VMImageSpec `json:"image"` + Sandbox VMSandboxSpec `json:"sandbox"` + Kernel VMKernelSpec `json:"kernel"` + CPUs uint64 `json:"cpus"` + Memory meta.Size `json:"memory"` + DiskSize meta.Size `json:"diskSize"` + // TODO: Implement working omitempty without pointers for the following entries + // Currently both will show in the JSON output as empty arrays. Making them + // pointers requires plenty of nil checks (as their contents are accessed directly) + // and is very risky for stability. APIMachinery potentially has a solution. + Network VMNetworkSpec `json:"network,omitempty"` + Storage VMStorageSpec `json:"storage,omitempty"` + // This will be done at either "ignite start" or "ignite create" time + // TODO: We might revisit this later + CopyFiles []FileMapping `json:"copyFiles,omitempty"` + // SSH specifies how the SSH setup should be done + // nil here means "don't do anything special" + // If SSH.Generate is set, Ignite will generate a new SSH key and copy it in to authorized_keys in the VM + // Specifying a path in SSH.Generate means "use this public key" + // If SSH.PublicKey is set, this struct will marshal as a string using that path + // If SSH.Generate is set, this struct will marshal as a bool => true + SSH *SSH `json:"ssh,omitempty"` +} +``` + +VMSpec describes the configuration of a VM + +## type [VMStatus](https://github.com/weaveworks/ignite/tree/master/pkg/apis/ignite/v1alpha3/types.go?s=8427:8766#L232) + +``` go +type VMStatus struct { + Running bool `json:"running"` + Runtime *Runtime `json:"runtime,omitempty"` + StartTime *runtime.Time `json:"startTime,omitempty"` + IPAddresses meta.IPAddresses `json:"ipAddresses,omitempty"` + Image OCIImageSource `json:"image"` + Kernel OCIImageSource `json:"kernel"` +} +``` + +VMStatus defines the status of a VM + +## type [VMStorageSpec](https://github.com/weaveworks/ignite/tree/master/pkg/apis/ignite/v1alpha3/types.go?s=7227:7371#L189) + +``` go +type VMStorageSpec struct { + Volumes []Volume `json:"volumes,omitempty"` + VolumeMounts []VolumeMount `json:"volumeMounts,omitempty"` +} +``` + +VMStorageSpec defines the VM’s Volumes and VolumeMounts + +## type [Volume](https://github.com/weaveworks/ignite/tree/master/pkg/apis/ignite/v1alpha3/types.go?s=7412:7543#L195) + +``` go +type Volume struct { + Name string `json:"name"` + BlockDevice *BlockDeviceVolume `json:"blockDevice,omitempty"` +} +``` + +Volume defines named storage volume + +## type [VolumeMount](https://github.com/weaveworks/ignite/tree/master/pkg/apis/ignite/v1alpha3/types.go?s=7733:7829#L206) + +``` go +type VolumeMount struct { + Name string `json:"name"` + MountPath string `json:"mountPath"` +} +``` + +VolumeMount defines the mount point for a named volume inside a VM + +----- + +Generated by [godoc2md](http://godoc.org/github.com/davecheney/godoc2md) diff --git a/docs/api/index.md b/docs/api/index.md index f36a656b0..c03c82da1 100644 --- a/docs/api/index.md +++ b/docs/api/index.md @@ -13,4 +13,5 @@ Please refer to the (autogenerated) docs for the API types below: - [ignite/v1alpha1](ignite_v1alpha1.md) - [ignite/v1alpha2](ignite_v1alpha2.md) +- [ignite/v1alpha3](ignite_v1alpha3.md) - [meta/v1alpha1](meta_v1alpha1.md) diff --git a/docs/cli/ignite/ignite_ps.md b/docs/cli/ignite/ignite_ps.md index 46825b4d4..e5c63e1f6 100644 --- a/docs/cli/ignite/ignite_ps.md +++ b/docs/cli/ignite/ignite_ps.md @@ -9,7 +9,7 @@ List all running VMs. By specifying the all flag (-a, --all), also list VMs that are not currently running. Using the -f (--filter) flag, you can give conditions VMs should fullfilled to be displayed. You can filter on all the underlying fields of the VM struct, see the documentation: -https://ignite.readthedocs.io/en/stable/api/ignite_v1alpha2#VM. +https://ignite.readthedocs.io/en/stable/api/ignite_v1alpha3#VM. Different operators can be used: - "=" and "==" for the equal diff --git a/docs/cli/ignite/ignite_vm_ps.md b/docs/cli/ignite/ignite_vm_ps.md index 7db7bfd84..68396bd23 100644 --- a/docs/cli/ignite/ignite_vm_ps.md +++ b/docs/cli/ignite/ignite_vm_ps.md @@ -9,7 +9,7 @@ List all running VMs. By specifying the all flag (-a, --all), also list VMs that are not currently running. Using the -f (--filter) flag, you can give conditions VMs should fullfilled to be displayed. You can filter on all the underlying fields of the VM struct, see the documentation: -https://ignite.readthedocs.io/en/stable/api/ignite_v1alpha2#VM. +https://ignite.readthedocs.io/en/stable/api/ignite_v1alpha3#VM. Different operators can be used: - "=" and "==" for the equal diff --git a/docs/declarative-config.md b/docs/declarative-config.md index 5f0cd441b..1c2d68721 100644 --- a/docs/declarative-config.md +++ b/docs/declarative-config.md @@ -9,7 +9,7 @@ The first commands to support this feature are `ignite run` and `ignite create`. Here's an example API object file contents: ```yaml -apiVersion: ignite.weave.works/v1alpha2 +apiVersion: ignite.weave.works/v1alpha3 kind: VM metadata: name: my-vm @@ -35,7 +35,7 @@ INFO[0002] Started Firecracker VM "e04128e6f96176a8" in a container with ID "ign The full reference format for the `VM` kind is as follows: ```yaml -apiVersion: ignite.weave.works/v1alpha2 +apiVersion: ignite.weave.works/v1alpha3 kind: VM metadata: # Automatically set when the object is created diff --git a/docs/gitops.md b/docs/gitops.md index 1a0105d6f..24728c972 100644 --- a/docs/gitops.md +++ b/docs/gitops.md @@ -31,7 +31,7 @@ back to the repository using the default key for it. To edit your root's git con Here's a sample configuration you can push to it (my-vm.yaml): ```yaml -apiVersion: ignite.weave.works/v1alpha2 +apiVersion: ignite.weave.works/v1alpha3 kind: VM metadata: name: my-vm diff --git a/docs/installation.md b/docs/installation.md index 524941606..48db73f7b 100644 --- a/docs/installation.md +++ b/docs/installation.md @@ -139,7 +139,7 @@ for additional details): ```bash VMFILE=/etc/firecracker/manifests/smoke-test.yml tee "$VMFILE" > /dev/null < "/etc/firecracker/manifests/smoke-test.yml" DEBU[2552] FileWatcher: Dispatched events batch and reset the events cache DEBU[2552] GenericMappedRawStorage: AddMapping: "vm/d039cbcd-3606-462d-839e-25ac745cd7c5" -> "/etc/firecracker/manifests/smoke-test.yml" -DEBU[2552] SyncStorage: Received update {{CREATE &TypeMeta{Kind:VM,APIVersion:ignite.weave.works/v1alpha2,}} 0xc0004c7aa0} true -DEBU[2552] SyncStorage: Sent update: {CREATE &TypeMeta{Kind:VM,APIVersion:ignite.weave.works/v1alpha2,}} +DEBU[2552] SyncStorage: Received update {{CREATE &TypeMeta{Kind:VM,APIVersion:ignite.weave.works/v1alpha3,}} 0xc0004c7aa0} true +DEBU[2552] SyncStorage: Sent update: {CREATE &TypeMeta{Kind:VM,APIVersion:ignite.weave.works/v1alpha3,}} DEBU[2552] FileWatcher: Skipping suspended event MODIFY for path: "/etc/firecracker/manifests/smoke-test.yml" DEBU[2552] FileWatcher: Registered inotify events [notify.InCloseWrite: "/etc/firecracker/manifests/smoke-test.yml"] for path "/etc/firecracker/manifests/smoke-test.yml" DEBU[2553] FileWatcher: Sending update: MODIFY -> "/etc/firecracker/manifests/smoke-test.yml" DEBU[2553] FileWatcher: Dispatched events batch and reset the events cache -DEBU[2553] SyncStorage: Received update {{MODIFY &TypeMeta{Kind:VM,APIVersion:ignite.weave.works/v1alpha2,}} 0xc0004c7aa0} true +DEBU[2553] SyncStorage: Received update {{MODIFY &TypeMeta{Kind:VM,APIVersion:ignite.weave.works/v1alpha3,}} 0xc0004c7aa0} true DEBU[2553] FileWatcher: Skipping suspended event MODIFY for path: "/etc/firecracker/manifests/smoke-test.yml" -DEBU[2553] SyncStorage: Sent update: {MODIFY &TypeMeta{Kind:VM,APIVersion:ignite.weave.works/v1alpha2,}} +DEBU[2553] SyncStorage: Sent update: {MODIFY &TypeMeta{Kind:VM,APIVersion:ignite.weave.works/v1alpha3,}} DEBU[2553] FileWatcher: Registered inotify events [notify.InCloseWrite: "/etc/firecracker/manifests/smoke-test.yml"] for path "/etc/firecracker/manifests/smoke-test.yml" DEBU[2554] FileWatcher: Sending update: MODIFY -> "/etc/firecracker/manifests/smoke-test.yml" DEBU[2554] FileWatcher: Dispatched events batch and reset the events cache -DEBU[2554] SyncStorage: Received update {{MODIFY &TypeMeta{Kind:VM,APIVersion:ignite.weave.works/v1alpha2,}} 0xc0004c7aa0} true +DEBU[2554] SyncStorage: Received update {{MODIFY &TypeMeta{Kind:VM,APIVersion:ignite.weave.works/v1alpha3,}} 0xc0004c7aa0} true DEBU[2554] FileWatcher: Registered inotify events [notify.InCloseWrite: "/etc/firecracker/manifests/smoke-test.yml"] for path "/etc/firecracker/manifests/smoke-test.yml" -DEBU[2554] SyncStorage: Sent update: {MODIFY &TypeMeta{Kind:VM,APIVersion:ignite.weave.works/v1alpha2,}} +DEBU[2554] SyncStorage: Sent update: {MODIFY &TypeMeta{Kind:VM,APIVersion:ignite.weave.works/v1alpha3,}} DEBU[2554] FileWatcher: Skipping suspended event MODIFY for path: "/etc/firecracker/manifests/smoke-test.yml" DEBU[2555] FileWatcher: Sending update: MODIFY -> "/etc/firecracker/manifests/smoke-test.yml" DEBU[2555] FileWatcher: Dispatched events batch and reset the events cache -DEBU[2555] SyncStorage: Received update {{MODIFY &TypeMeta{Kind:VM,APIVersion:ignite.weave.works/v1alpha2,}} 0xc0004c7aa0} true -DEBU[2555] SyncStorage: Sent update: {MODIFY &TypeMeta{Kind:VM,APIVersion:ignite.weave.works/v1alpha2,}} +DEBU[2555] SyncStorage: Received update {{MODIFY &TypeMeta{Kind:VM,APIVersion:ignite.weave.works/v1alpha3,}} 0xc0004c7aa0} true +DEBU[2555] SyncStorage: Sent update: {MODIFY &TypeMeta{Kind:VM,APIVersion:ignite.weave.works/v1alpha3,}} DEBU[2555] FileWatcher: Skipping suspended event MODIFY for path: "/etc/firecracker/manifests/smoke-test.yml" DEBU[2556] FileWatcher: Registered inotify events [notify.InCloseWrite: "/etc/firecracker/manifests/smoke-test.yml"] for path "/etc/firecracker/manifests/smoke-test.yml" etc. diff --git a/docs/my-vm.yaml b/docs/my-vm.yaml index 4e4155663..8440b0844 100644 --- a/docs/my-vm.yaml +++ b/docs/my-vm.yaml @@ -1,4 +1,4 @@ -apiVersion: ignite.weave.works/v1alpha2 +apiVersion: ignite.weave.works/v1alpha3 kind: VM metadata: name: my-vm @@ -11,4 +11,4 @@ spec: memory: 800MB ssh: true status: - running: true \ No newline at end of file + running: true diff --git a/go.mod b/go.mod index d8a200ba4..80015949c 100644 --- a/go.mod +++ b/go.mod @@ -54,6 +54,6 @@ require ( golang.org/x/sys v0.0.0-20200610111108-226ff32320da gotest.tools v2.2.0+incompatible k8s.io/apimachinery v0.18.3 - k8s.io/kube-openapi v0.0.0-20200427153329-656914f816f9 + k8s.io/kube-openapi v0.0.0-20200615155156-dffdd1682719 sigs.k8s.io/yaml v1.2.0 ) diff --git a/pkg/apis/ignite/scheme/scheme.go b/pkg/apis/ignite/scheme/scheme.go index ef37d9065..6e04cce46 100644 --- a/pkg/apis/ignite/scheme/scheme.go +++ b/pkg/apis/ignite/scheme/scheme.go @@ -7,6 +7,7 @@ import ( "github.com/weaveworks/ignite/pkg/apis/ignite" "github.com/weaveworks/ignite/pkg/apis/ignite/v1alpha2" + "github.com/weaveworks/ignite/pkg/apis/ignite/v1alpha3" "github.com/weaveworks/libgitops/pkg/serializer" ) @@ -30,5 +31,6 @@ func init() { func AddToScheme(scheme *runtime.Scheme) { utilruntime.Must(ignite.AddToScheme(Scheme)) utilruntime.Must(v1alpha2.AddToScheme(Scheme)) - utilruntime.Must(scheme.SetVersionPriority(v1alpha2.SchemeGroupVersion)) + utilruntime.Must(v1alpha3.AddToScheme(Scheme)) + utilruntime.Must(scheme.SetVersionPriority(v1alpha3.SchemeGroupVersion)) } diff --git a/pkg/apis/ignite/v1alpha3/defaults.go b/pkg/apis/ignite/v1alpha3/defaults.go new file mode 100644 index 000000000..6d41143f8 --- /dev/null +++ b/pkg/apis/ignite/v1alpha3/defaults.go @@ -0,0 +1,75 @@ +package v1alpha3 + +import ( + meta "github.com/weaveworks/ignite/pkg/apis/meta/v1alpha1" + "github.com/weaveworks/ignite/pkg/constants" + "github.com/weaveworks/ignite/pkg/version" + + "k8s.io/apimachinery/pkg/runtime" +) + +func addDefaultingFuncs(scheme *runtime.Scheme) error { + return RegisterDefaults(scheme) +} + +func SetDefaults_PoolSpec(obj *PoolSpec) { + if obj.AllocationSize == meta.EmptySize { + obj.AllocationSize = meta.NewSizeFromSectors(constants.POOL_ALLOCATION_SIZE_SECTORS) + } + + if obj.DataSize == meta.EmptySize { + obj.AllocationSize = meta.NewSizeFromBytes(constants.POOL_DATA_SIZE_BYTES) + } + + if obj.MetadataSize == meta.EmptySize { + obj.AllocationSize = calcMetadataDevSize(obj) + } + + if len(obj.MetadataPath) == 0 { + obj.MetadataPath = constants.SNAPSHOTTER_METADATA_PATH + } + + if len(obj.DataPath) == 0 { + obj.DataPath = constants.SNAPSHOTTER_DATA_PATH + } +} + +func SetDefaults_VMSpec(obj *VMSpec) { + if obj.CPUs == 0 { + obj.CPUs = constants.VM_DEFAULT_CPUS + } + + if obj.Memory == meta.EmptySize { + obj.Memory = meta.NewSizeFromBytes(constants.VM_DEFAULT_MEMORY) + } + + if obj.DiskSize == meta.EmptySize { + obj.DiskSize = meta.NewSizeFromBytes(constants.VM_DEFAULT_SIZE) + } +} + +func SetDefaults_VMKernelSpec(obj *VMKernelSpec) { + // Default the kernel image if unset. + if obj.OCI.IsUnset() { + obj.OCI, _ = meta.NewOCIImageRef(version.GetIgnite().KernelImage.String()) + } + + if len(obj.CmdLine) == 0 { + obj.CmdLine = constants.VM_DEFAULT_KERNEL_ARGS + } +} + +func SetDefaults_VMSandboxSpec(obj *VMSandboxSpec) { + // Default the sandbox image if unset. + if obj.OCI.IsUnset() { + obj.OCI, _ = meta.NewOCIImageRef(version.GetIgnite().SandboxImage.String()) + } +} + +func calcMetadataDevSize(obj *PoolSpec) meta.Size { + // The minimum size is 2 MB and the maximum size is 16 GB + minSize := meta.NewSizeFromBytes(2 * constants.MB) + maxSize := meta.NewSizeFromBytes(16 * constants.GB) + + return meta.NewSizeFromBytes(48 * obj.DataSize.Bytes() / obj.AllocationSize.Bytes()).Min(maxSize).Max(minSize) +} diff --git a/pkg/apis/ignite/v1alpha3/doc.go b/pkg/apis/ignite/v1alpha3/doc.go new file mode 100644 index 000000000..e0d3ecd45 --- /dev/null +++ b/pkg/apis/ignite/v1alpha3/doc.go @@ -0,0 +1,5 @@ +// +k8s:deepcopy-gen=package +// +k8s:defaulter-gen=TypeMeta +// +k8s:openapi-gen=true +// +k8s:conversion-gen=github.com/weaveworks/ignite/pkg/apis/ignite +package v1alpha3 diff --git a/pkg/apis/ignite/v1alpha3/json.go b/pkg/apis/ignite/v1alpha3/json.go new file mode 100644 index 000000000..ac8967b20 --- /dev/null +++ b/pkg/apis/ignite/v1alpha3/json.go @@ -0,0 +1,50 @@ +package v1alpha3 + +import ( + "encoding/json" +) + +// In this package custom marshal/unmarshal functions are registered + +func (s *SSH) MarshalJSON() ([]byte, error) { + if len(s.PublicKey) != 0 { + return json.Marshal(s.PublicKey) + } + + if s.Generate { + return json.Marshal(true) + } + + return []byte("{}"), nil +} + +func (s *SSH) UnmarshalJSON(b []byte) error { + var str string + if err := json.Unmarshal(b, &str); err == nil { + if str == "true" { + *s = SSH{ + Generate: true, + } + } else { + *s = SSH{ + PublicKey: str, + } + } + + return nil + } + + var boolVar bool + if err := json.Unmarshal(b, &boolVar); err == nil { + if boolVar { + *s = SSH{ + Generate: true, + } + + return nil + } + } + + // The user did not specify this field, just return + return nil +} diff --git a/pkg/apis/ignite/v1alpha3/register.go b/pkg/apis/ignite/v1alpha3/register.go new file mode 100644 index 000000000..6769c23fb --- /dev/null +++ b/pkg/apis/ignite/v1alpha3/register.go @@ -0,0 +1,39 @@ +package v1alpha3 + +import ( + "k8s.io/apimachinery/pkg/runtime" + "k8s.io/apimachinery/pkg/runtime/schema" +) + +var ( + // SchemeBuilder the schema builder + SchemeBuilder = runtime.NewSchemeBuilder( + addKnownTypes, + addDefaultingFuncs, + ) + + localSchemeBuilder = &SchemeBuilder + AddToScheme = localSchemeBuilder.AddToScheme +) + +const ( + // GroupName is the group name use in this package + GroupName = "ignite.weave.works" +) + +// SchemeGroupVersion is group version used to register these objects +var SchemeGroupVersion = schema.GroupVersion{ + Group: GroupName, + Version: "v1alpha3", +} + +// Adds the list of known types to the given scheme. +func addKnownTypes(scheme *runtime.Scheme) error { + scheme.AddKnownTypes(SchemeGroupVersion, + &VM{}, + &Kernel{}, + &Pool{}, + &Image{}, + ) + return nil +} diff --git a/pkg/apis/ignite/v1alpha3/types.go b/pkg/apis/ignite/v1alpha3/types.go new file mode 100644 index 000000000..417ed4d1c --- /dev/null +++ b/pkg/apis/ignite/v1alpha3/types.go @@ -0,0 +1,239 @@ +package v1alpha3 + +import ( + meta "github.com/weaveworks/ignite/pkg/apis/meta/v1alpha1" + "github.com/weaveworks/libgitops/pkg/runtime" +) + +const ( + KindImage runtime.Kind = "Image" + KindKernel runtime.Kind = "Kernel" + KindVM runtime.Kind = "VM" +) + +// Image represents a cached OCI image ready to be used with Ignite +// +k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object +type Image struct { + runtime.TypeMeta `json:",inline"` + // runtime.ObjectMeta is also embedded into the struct, and defines the human-readable name, and the machine-readable ID + // Name is available at the .metadata.name JSON path + // ID is available at the .metadata.uid JSON path (the Go type is k8s.io/apimachinery/pkg/types.UID, which is only a typed string) + runtime.ObjectMeta `json:"metadata"` + + Spec ImageSpec `json:"spec"` + Status ImageStatus `json:"status"` +} + +// ImageSpec declares what the image contains +type ImageSpec struct { + OCI meta.OCIImageRef `json:"oci"` +} + +// OCIImageSource specifies how the OCI image was imported. +// It is the status variant of OCIImageClaim +type OCIImageSource struct { + // ID defines the source's content ID (e.g. the canonical OCI path or Docker image ID) + ID *meta.OCIContentID `json:"id"` + // Size defines the size of the source in bytes + Size meta.Size `json:"size"` +} + +// ImageStatus defines the status of the image +type ImageStatus struct { + // OCISource contains the information about how this OCI image was imported + OCISource OCIImageSource `json:"ociSource"` +} + +// Pool defines device mapper pool database +// This file is managed by the snapshotter part of Ignite, and the file (existing as a singleton) +// is present at /var/lib/firecracker/snapshotter/pool.json +// +k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object +type Pool struct { + runtime.TypeMeta `json:",inline"` + // Not needed (yet) + // runtime.ObjectMeta `json:"metadata"` + + Spec PoolSpec `json:"spec"` + Status PoolStatus `json:"status"` +} + +// PoolSpec defines the Pool's specification +type PoolSpec struct { + // MetadataSize specifies the size of the pool's metadata + MetadataSize meta.Size `json:"metadataSize"` + // DataSize specifies the size of the pool's data + DataSize meta.Size `json:"dataSize"` + // AllocationSize specifies the smallest size that can be allocated at a time + AllocationSize meta.Size `json:"allocationSize"` + // MetadataPath points to the file where device mapper stores all metadata information + // Defaults to constants.SNAPSHOTTER_METADATA_PATH + MetadataPath string `json:"metadataPath"` + // DataPath points to the backing physical device or sparse file (to be loop mounted) for the pool + // Defaults to constants.SNAPSHOTTER_DATA_PATH + DataPath string `json:"dataPath"` +} + +// PoolStatus defines the Pool's current status +type PoolStatus struct { + // The Devices array needs to contain pointers to accommodate "holes" in the mapping + // Where devices have been deleted, the pointer is nil + Devices []*PoolDevice `json:"devices"` +} + +type PoolDeviceType string + +const ( + PoolDeviceTypeImage PoolDeviceType = "Image" + PoolDeviceTypeResize PoolDeviceType = "Resize" + PoolDeviceTypeKernel PoolDeviceType = "Kernel" + PoolDeviceTypeVM PoolDeviceType = "VM" +) + +// PoolDevice defines one device in the pool +type PoolDevice struct { + Size meta.Size `json:"size"` + Parent meta.DMID `json:"parent"` + // Type specifies the type of the contents of the device + Type PoolDeviceType `json:"type"` + // MetadataPath points to the JSON/YAML file with metadata about this device + // This is most often of the format /var/lib/firecracker/{type}/{id}/metadata.json + MetadataPath string `json:"metadataPath"` +} + +// Kernel is a serializable object that caches information about imported kernels +// This file is stored in /var/lib/firecracker/kernels/{oci-image-digest}/metadata.json +// +k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object +type Kernel struct { + runtime.TypeMeta `json:",inline"` + // runtime.ObjectMeta is also embedded into the struct, and defines the human-readable name, and the machine-readable ID + // Name is available at the .metadata.name JSON path + // ID is available at the .metadata.uid JSON path (the Go type is k8s.io/apimachinery/pkg/types.UID, which is only a typed string) + runtime.ObjectMeta `json:"metadata"` + + Spec KernelSpec `json:"spec"` + Status KernelStatus `json:"status"` +} + +// KernelSpec describes the properties of a kernel +type KernelSpec struct { + OCI meta.OCIImageRef `json:"oci"` + // Optional future feature, support per-kernel specific default command lines + // DefaultCmdLine string +} + +// KernelStatus describes the status of a kernel +type KernelStatus struct { + Version string `json:"version"` + OCISource OCIImageSource `json:"ociSource"` +} + +// VM represents a virtual machine run by Firecracker +// These files are stored in /var/lib/firecracker/vm/{vm-id}/metadata.json +// +k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object +type VM struct { + runtime.TypeMeta `json:",inline"` + // runtime.ObjectMeta is also embedded into the struct, and defines the human-readable name, and the machine-readable ID + // Name is available at the .metadata.name JSON path + // ID is available at the .metadata.uid JSON path (the Go type is k8s.io/apimachinery/pkg/types.UID, which is only a typed string) + runtime.ObjectMeta `json:"metadata"` + + Spec VMSpec `json:"spec"` + Status VMStatus `json:"status"` +} + +// VMSpec describes the configuration of a VM +type VMSpec struct { + Image VMImageSpec `json:"image"` + Sandbox VMSandboxSpec `json:"sandbox"` + Kernel VMKernelSpec `json:"kernel"` + CPUs uint64 `json:"cpus"` + Memory meta.Size `json:"memory"` + DiskSize meta.Size `json:"diskSize"` + // TODO: Implement working omitempty without pointers for the following entries + // Currently both will show in the JSON output as empty arrays. Making them + // pointers requires plenty of nil checks (as their contents are accessed directly) + // and is very risky for stability. APIMachinery potentially has a solution. + Network VMNetworkSpec `json:"network,omitempty"` + Storage VMStorageSpec `json:"storage,omitempty"` + // This will be done at either "ignite start" or "ignite create" time + // TODO: We might revisit this later + CopyFiles []FileMapping `json:"copyFiles,omitempty"` + // SSH specifies how the SSH setup should be done + // nil here means "don't do anything special" + // If SSH.Generate is set, Ignite will generate a new SSH key and copy it in to authorized_keys in the VM + // Specifying a path in SSH.Generate means "use this public key" + // If SSH.PublicKey is set, this struct will marshal as a string using that path + // If SSH.Generate is set, this struct will marshal as a bool => true + SSH *SSH `json:"ssh,omitempty"` +} + +type VMImageSpec struct { + OCI meta.OCIImageRef `json:"oci"` +} + +type VMKernelSpec struct { + OCI meta.OCIImageRef `json:"oci"` + CmdLine string `json:"cmdLine,omitempty"` +} + +// VMSandboxSpec is the spec of the sandbox used for the VM. +type VMSandboxSpec struct { + OCI meta.OCIImageRef `json:"oci"` +} + +type VMNetworkSpec struct { + Ports meta.PortMappings `json:"ports,omitempty"` +} + +// VMStorageSpec defines the VM's Volumes and VolumeMounts +type VMStorageSpec struct { + Volumes []Volume `json:"volumes,omitempty"` + VolumeMounts []VolumeMount `json:"volumeMounts,omitempty"` +} + +// Volume defines named storage volume +type Volume struct { + Name string `json:"name"` + BlockDevice *BlockDeviceVolume `json:"blockDevice,omitempty"` +} + +// BlockDeviceVolume defines a block device on the host +type BlockDeviceVolume struct { + Path string `json:"path"` +} + +// VolumeMount defines the mount point for a named volume inside a VM +type VolumeMount struct { + Name string `json:"name"` + MountPath string `json:"mountPath"` +} + +// FileMapping defines mappings between files on the host and VM +type FileMapping struct { + HostPath string `json:"hostPath"` + VMPath string `json:"vmPath"` +} + +// SSH specifies different ways to connect via SSH to the VM +// SSH uses a custom marshaller/unmarshaller. If generate is true, +// it marshals to true (a JSON bool). If PublicKey is set, it marshals +// to that string. +type SSH struct { + Generate bool `json:"-"` + PublicKey string `json:"-"` +} + +// Runtime specifies the VM's runtime information +type Runtime struct { + ID string `json:"id"` +} + +// VMStatus defines the status of a VM +type VMStatus struct { + Running bool `json:"running"` + Runtime *Runtime `json:"runtime,omitempty"` + StartTime *runtime.Time `json:"startTime,omitempty"` + IPAddresses meta.IPAddresses `json:"ipAddresses,omitempty"` + Image OCIImageSource `json:"image"` + Kernel OCIImageSource `json:"kernel"` +} diff --git a/pkg/apis/ignite/v1alpha3/zz_generated.conversion.go b/pkg/apis/ignite/v1alpha3/zz_generated.conversion.go new file mode 100644 index 000000000..2f0d1222a --- /dev/null +++ b/pkg/apis/ignite/v1alpha3/zz_generated.conversion.go @@ -0,0 +1,923 @@ +// +build !ignore_autogenerated + +// Code generated by conversion-gen. DO NOT EDIT. + +package v1alpha3 + +import ( + unsafe "unsafe" + + ignite "github.com/weaveworks/ignite/pkg/apis/ignite" + v1alpha1 "github.com/weaveworks/ignite/pkg/apis/meta/v1alpha1" + pkgruntime "github.com/weaveworks/libgitops/pkg/runtime" + conversion "k8s.io/apimachinery/pkg/conversion" + runtime "k8s.io/apimachinery/pkg/runtime" +) + +func init() { + localSchemeBuilder.Register(RegisterConversions) +} + +// RegisterConversions adds conversion functions to the given scheme. +// Public to allow building arbitrary schemes. +func RegisterConversions(s *runtime.Scheme) error { + if err := s.AddGeneratedConversionFunc((*BlockDeviceVolume)(nil), (*ignite.BlockDeviceVolume)(nil), func(a, b interface{}, scope conversion.Scope) error { + return Convert_v1alpha3_BlockDeviceVolume_To_ignite_BlockDeviceVolume(a.(*BlockDeviceVolume), b.(*ignite.BlockDeviceVolume), scope) + }); err != nil { + return err + } + if err := s.AddGeneratedConversionFunc((*ignite.BlockDeviceVolume)(nil), (*BlockDeviceVolume)(nil), func(a, b interface{}, scope conversion.Scope) error { + return Convert_ignite_BlockDeviceVolume_To_v1alpha3_BlockDeviceVolume(a.(*ignite.BlockDeviceVolume), b.(*BlockDeviceVolume), scope) + }); err != nil { + return err + } + if err := s.AddGeneratedConversionFunc((*FileMapping)(nil), (*ignite.FileMapping)(nil), func(a, b interface{}, scope conversion.Scope) error { + return Convert_v1alpha3_FileMapping_To_ignite_FileMapping(a.(*FileMapping), b.(*ignite.FileMapping), scope) + }); err != nil { + return err + } + if err := s.AddGeneratedConversionFunc((*ignite.FileMapping)(nil), (*FileMapping)(nil), func(a, b interface{}, scope conversion.Scope) error { + return Convert_ignite_FileMapping_To_v1alpha3_FileMapping(a.(*ignite.FileMapping), b.(*FileMapping), scope) + }); err != nil { + return err + } + if err := s.AddGeneratedConversionFunc((*Image)(nil), (*ignite.Image)(nil), func(a, b interface{}, scope conversion.Scope) error { + return Convert_v1alpha3_Image_To_ignite_Image(a.(*Image), b.(*ignite.Image), scope) + }); err != nil { + return err + } + if err := s.AddGeneratedConversionFunc((*ignite.Image)(nil), (*Image)(nil), func(a, b interface{}, scope conversion.Scope) error { + return Convert_ignite_Image_To_v1alpha3_Image(a.(*ignite.Image), b.(*Image), scope) + }); err != nil { + return err + } + if err := s.AddGeneratedConversionFunc((*ImageSpec)(nil), (*ignite.ImageSpec)(nil), func(a, b interface{}, scope conversion.Scope) error { + return Convert_v1alpha3_ImageSpec_To_ignite_ImageSpec(a.(*ImageSpec), b.(*ignite.ImageSpec), scope) + }); err != nil { + return err + } + if err := s.AddGeneratedConversionFunc((*ignite.ImageSpec)(nil), (*ImageSpec)(nil), func(a, b interface{}, scope conversion.Scope) error { + return Convert_ignite_ImageSpec_To_v1alpha3_ImageSpec(a.(*ignite.ImageSpec), b.(*ImageSpec), scope) + }); err != nil { + return err + } + if err := s.AddGeneratedConversionFunc((*ImageStatus)(nil), (*ignite.ImageStatus)(nil), func(a, b interface{}, scope conversion.Scope) error { + return Convert_v1alpha3_ImageStatus_To_ignite_ImageStatus(a.(*ImageStatus), b.(*ignite.ImageStatus), scope) + }); err != nil { + return err + } + if err := s.AddGeneratedConversionFunc((*ignite.ImageStatus)(nil), (*ImageStatus)(nil), func(a, b interface{}, scope conversion.Scope) error { + return Convert_ignite_ImageStatus_To_v1alpha3_ImageStatus(a.(*ignite.ImageStatus), b.(*ImageStatus), scope) + }); err != nil { + return err + } + if err := s.AddGeneratedConversionFunc((*Kernel)(nil), (*ignite.Kernel)(nil), func(a, b interface{}, scope conversion.Scope) error { + return Convert_v1alpha3_Kernel_To_ignite_Kernel(a.(*Kernel), b.(*ignite.Kernel), scope) + }); err != nil { + return err + } + if err := s.AddGeneratedConversionFunc((*ignite.Kernel)(nil), (*Kernel)(nil), func(a, b interface{}, scope conversion.Scope) error { + return Convert_ignite_Kernel_To_v1alpha3_Kernel(a.(*ignite.Kernel), b.(*Kernel), scope) + }); err != nil { + return err + } + if err := s.AddGeneratedConversionFunc((*KernelSpec)(nil), (*ignite.KernelSpec)(nil), func(a, b interface{}, scope conversion.Scope) error { + return Convert_v1alpha3_KernelSpec_To_ignite_KernelSpec(a.(*KernelSpec), b.(*ignite.KernelSpec), scope) + }); err != nil { + return err + } + if err := s.AddGeneratedConversionFunc((*ignite.KernelSpec)(nil), (*KernelSpec)(nil), func(a, b interface{}, scope conversion.Scope) error { + return Convert_ignite_KernelSpec_To_v1alpha3_KernelSpec(a.(*ignite.KernelSpec), b.(*KernelSpec), scope) + }); err != nil { + return err + } + if err := s.AddGeneratedConversionFunc((*KernelStatus)(nil), (*ignite.KernelStatus)(nil), func(a, b interface{}, scope conversion.Scope) error { + return Convert_v1alpha3_KernelStatus_To_ignite_KernelStatus(a.(*KernelStatus), b.(*ignite.KernelStatus), scope) + }); err != nil { + return err + } + if err := s.AddGeneratedConversionFunc((*ignite.KernelStatus)(nil), (*KernelStatus)(nil), func(a, b interface{}, scope conversion.Scope) error { + return Convert_ignite_KernelStatus_To_v1alpha3_KernelStatus(a.(*ignite.KernelStatus), b.(*KernelStatus), scope) + }); err != nil { + return err + } + if err := s.AddGeneratedConversionFunc((*OCIImageSource)(nil), (*ignite.OCIImageSource)(nil), func(a, b interface{}, scope conversion.Scope) error { + return Convert_v1alpha3_OCIImageSource_To_ignite_OCIImageSource(a.(*OCIImageSource), b.(*ignite.OCIImageSource), scope) + }); err != nil { + return err + } + if err := s.AddGeneratedConversionFunc((*ignite.OCIImageSource)(nil), (*OCIImageSource)(nil), func(a, b interface{}, scope conversion.Scope) error { + return Convert_ignite_OCIImageSource_To_v1alpha3_OCIImageSource(a.(*ignite.OCIImageSource), b.(*OCIImageSource), scope) + }); err != nil { + return err + } + if err := s.AddGeneratedConversionFunc((*Pool)(nil), (*ignite.Pool)(nil), func(a, b interface{}, scope conversion.Scope) error { + return Convert_v1alpha3_Pool_To_ignite_Pool(a.(*Pool), b.(*ignite.Pool), scope) + }); err != nil { + return err + } + if err := s.AddGeneratedConversionFunc((*ignite.Pool)(nil), (*Pool)(nil), func(a, b interface{}, scope conversion.Scope) error { + return Convert_ignite_Pool_To_v1alpha3_Pool(a.(*ignite.Pool), b.(*Pool), scope) + }); err != nil { + return err + } + if err := s.AddGeneratedConversionFunc((*PoolDevice)(nil), (*ignite.PoolDevice)(nil), func(a, b interface{}, scope conversion.Scope) error { + return Convert_v1alpha3_PoolDevice_To_ignite_PoolDevice(a.(*PoolDevice), b.(*ignite.PoolDevice), scope) + }); err != nil { + return err + } + if err := s.AddGeneratedConversionFunc((*ignite.PoolDevice)(nil), (*PoolDevice)(nil), func(a, b interface{}, scope conversion.Scope) error { + return Convert_ignite_PoolDevice_To_v1alpha3_PoolDevice(a.(*ignite.PoolDevice), b.(*PoolDevice), scope) + }); err != nil { + return err + } + if err := s.AddGeneratedConversionFunc((*PoolSpec)(nil), (*ignite.PoolSpec)(nil), func(a, b interface{}, scope conversion.Scope) error { + return Convert_v1alpha3_PoolSpec_To_ignite_PoolSpec(a.(*PoolSpec), b.(*ignite.PoolSpec), scope) + }); err != nil { + return err + } + if err := s.AddGeneratedConversionFunc((*ignite.PoolSpec)(nil), (*PoolSpec)(nil), func(a, b interface{}, scope conversion.Scope) error { + return Convert_ignite_PoolSpec_To_v1alpha3_PoolSpec(a.(*ignite.PoolSpec), b.(*PoolSpec), scope) + }); err != nil { + return err + } + if err := s.AddGeneratedConversionFunc((*PoolStatus)(nil), (*ignite.PoolStatus)(nil), func(a, b interface{}, scope conversion.Scope) error { + return Convert_v1alpha3_PoolStatus_To_ignite_PoolStatus(a.(*PoolStatus), b.(*ignite.PoolStatus), scope) + }); err != nil { + return err + } + if err := s.AddGeneratedConversionFunc((*ignite.PoolStatus)(nil), (*PoolStatus)(nil), func(a, b interface{}, scope conversion.Scope) error { + return Convert_ignite_PoolStatus_To_v1alpha3_PoolStatus(a.(*ignite.PoolStatus), b.(*PoolStatus), scope) + }); err != nil { + return err + } + if err := s.AddGeneratedConversionFunc((*Runtime)(nil), (*ignite.Runtime)(nil), func(a, b interface{}, scope conversion.Scope) error { + return Convert_v1alpha3_Runtime_To_ignite_Runtime(a.(*Runtime), b.(*ignite.Runtime), scope) + }); err != nil { + return err + } + if err := s.AddGeneratedConversionFunc((*ignite.Runtime)(nil), (*Runtime)(nil), func(a, b interface{}, scope conversion.Scope) error { + return Convert_ignite_Runtime_To_v1alpha3_Runtime(a.(*ignite.Runtime), b.(*Runtime), scope) + }); err != nil { + return err + } + if err := s.AddGeneratedConversionFunc((*SSH)(nil), (*ignite.SSH)(nil), func(a, b interface{}, scope conversion.Scope) error { + return Convert_v1alpha3_SSH_To_ignite_SSH(a.(*SSH), b.(*ignite.SSH), scope) + }); err != nil { + return err + } + if err := s.AddGeneratedConversionFunc((*ignite.SSH)(nil), (*SSH)(nil), func(a, b interface{}, scope conversion.Scope) error { + return Convert_ignite_SSH_To_v1alpha3_SSH(a.(*ignite.SSH), b.(*SSH), scope) + }); err != nil { + return err + } + if err := s.AddGeneratedConversionFunc((*VM)(nil), (*ignite.VM)(nil), func(a, b interface{}, scope conversion.Scope) error { + return Convert_v1alpha3_VM_To_ignite_VM(a.(*VM), b.(*ignite.VM), scope) + }); err != nil { + return err + } + if err := s.AddGeneratedConversionFunc((*ignite.VM)(nil), (*VM)(nil), func(a, b interface{}, scope conversion.Scope) error { + return Convert_ignite_VM_To_v1alpha3_VM(a.(*ignite.VM), b.(*VM), scope) + }); err != nil { + return err + } + if err := s.AddGeneratedConversionFunc((*VMImageSpec)(nil), (*ignite.VMImageSpec)(nil), func(a, b interface{}, scope conversion.Scope) error { + return Convert_v1alpha3_VMImageSpec_To_ignite_VMImageSpec(a.(*VMImageSpec), b.(*ignite.VMImageSpec), scope) + }); err != nil { + return err + } + if err := s.AddGeneratedConversionFunc((*ignite.VMImageSpec)(nil), (*VMImageSpec)(nil), func(a, b interface{}, scope conversion.Scope) error { + return Convert_ignite_VMImageSpec_To_v1alpha3_VMImageSpec(a.(*ignite.VMImageSpec), b.(*VMImageSpec), scope) + }); err != nil { + return err + } + if err := s.AddGeneratedConversionFunc((*VMKernelSpec)(nil), (*ignite.VMKernelSpec)(nil), func(a, b interface{}, scope conversion.Scope) error { + return Convert_v1alpha3_VMKernelSpec_To_ignite_VMKernelSpec(a.(*VMKernelSpec), b.(*ignite.VMKernelSpec), scope) + }); err != nil { + return err + } + if err := s.AddGeneratedConversionFunc((*ignite.VMKernelSpec)(nil), (*VMKernelSpec)(nil), func(a, b interface{}, scope conversion.Scope) error { + return Convert_ignite_VMKernelSpec_To_v1alpha3_VMKernelSpec(a.(*ignite.VMKernelSpec), b.(*VMKernelSpec), scope) + }); err != nil { + return err + } + if err := s.AddGeneratedConversionFunc((*VMNetworkSpec)(nil), (*ignite.VMNetworkSpec)(nil), func(a, b interface{}, scope conversion.Scope) error { + return Convert_v1alpha3_VMNetworkSpec_To_ignite_VMNetworkSpec(a.(*VMNetworkSpec), b.(*ignite.VMNetworkSpec), scope) + }); err != nil { + return err + } + if err := s.AddGeneratedConversionFunc((*ignite.VMNetworkSpec)(nil), (*VMNetworkSpec)(nil), func(a, b interface{}, scope conversion.Scope) error { + return Convert_ignite_VMNetworkSpec_To_v1alpha3_VMNetworkSpec(a.(*ignite.VMNetworkSpec), b.(*VMNetworkSpec), scope) + }); err != nil { + return err + } + if err := s.AddGeneratedConversionFunc((*VMSandboxSpec)(nil), (*ignite.VMSandboxSpec)(nil), func(a, b interface{}, scope conversion.Scope) error { + return Convert_v1alpha3_VMSandboxSpec_To_ignite_VMSandboxSpec(a.(*VMSandboxSpec), b.(*ignite.VMSandboxSpec), scope) + }); err != nil { + return err + } + if err := s.AddGeneratedConversionFunc((*ignite.VMSandboxSpec)(nil), (*VMSandboxSpec)(nil), func(a, b interface{}, scope conversion.Scope) error { + return Convert_ignite_VMSandboxSpec_To_v1alpha3_VMSandboxSpec(a.(*ignite.VMSandboxSpec), b.(*VMSandboxSpec), scope) + }); err != nil { + return err + } + if err := s.AddGeneratedConversionFunc((*VMSpec)(nil), (*ignite.VMSpec)(nil), func(a, b interface{}, scope conversion.Scope) error { + return Convert_v1alpha3_VMSpec_To_ignite_VMSpec(a.(*VMSpec), b.(*ignite.VMSpec), scope) + }); err != nil { + return err + } + if err := s.AddGeneratedConversionFunc((*ignite.VMSpec)(nil), (*VMSpec)(nil), func(a, b interface{}, scope conversion.Scope) error { + return Convert_ignite_VMSpec_To_v1alpha3_VMSpec(a.(*ignite.VMSpec), b.(*VMSpec), scope) + }); err != nil { + return err + } + if err := s.AddGeneratedConversionFunc((*VMStatus)(nil), (*ignite.VMStatus)(nil), func(a, b interface{}, scope conversion.Scope) error { + return Convert_v1alpha3_VMStatus_To_ignite_VMStatus(a.(*VMStatus), b.(*ignite.VMStatus), scope) + }); err != nil { + return err + } + if err := s.AddGeneratedConversionFunc((*ignite.VMStatus)(nil), (*VMStatus)(nil), func(a, b interface{}, scope conversion.Scope) error { + return Convert_ignite_VMStatus_To_v1alpha3_VMStatus(a.(*ignite.VMStatus), b.(*VMStatus), scope) + }); err != nil { + return err + } + if err := s.AddGeneratedConversionFunc((*VMStorageSpec)(nil), (*ignite.VMStorageSpec)(nil), func(a, b interface{}, scope conversion.Scope) error { + return Convert_v1alpha3_VMStorageSpec_To_ignite_VMStorageSpec(a.(*VMStorageSpec), b.(*ignite.VMStorageSpec), scope) + }); err != nil { + return err + } + if err := s.AddGeneratedConversionFunc((*ignite.VMStorageSpec)(nil), (*VMStorageSpec)(nil), func(a, b interface{}, scope conversion.Scope) error { + return Convert_ignite_VMStorageSpec_To_v1alpha3_VMStorageSpec(a.(*ignite.VMStorageSpec), b.(*VMStorageSpec), scope) + }); err != nil { + return err + } + if err := s.AddGeneratedConversionFunc((*Volume)(nil), (*ignite.Volume)(nil), func(a, b interface{}, scope conversion.Scope) error { + return Convert_v1alpha3_Volume_To_ignite_Volume(a.(*Volume), b.(*ignite.Volume), scope) + }); err != nil { + return err + } + if err := s.AddGeneratedConversionFunc((*ignite.Volume)(nil), (*Volume)(nil), func(a, b interface{}, scope conversion.Scope) error { + return Convert_ignite_Volume_To_v1alpha3_Volume(a.(*ignite.Volume), b.(*Volume), scope) + }); err != nil { + return err + } + if err := s.AddGeneratedConversionFunc((*VolumeMount)(nil), (*ignite.VolumeMount)(nil), func(a, b interface{}, scope conversion.Scope) error { + return Convert_v1alpha3_VolumeMount_To_ignite_VolumeMount(a.(*VolumeMount), b.(*ignite.VolumeMount), scope) + }); err != nil { + return err + } + if err := s.AddGeneratedConversionFunc((*ignite.VolumeMount)(nil), (*VolumeMount)(nil), func(a, b interface{}, scope conversion.Scope) error { + return Convert_ignite_VolumeMount_To_v1alpha3_VolumeMount(a.(*ignite.VolumeMount), b.(*VolumeMount), scope) + }); err != nil { + return err + } + return nil +} + +func autoConvert_v1alpha3_BlockDeviceVolume_To_ignite_BlockDeviceVolume(in *BlockDeviceVolume, out *ignite.BlockDeviceVolume, s conversion.Scope) error { + out.Path = in.Path + return nil +} + +// Convert_v1alpha3_BlockDeviceVolume_To_ignite_BlockDeviceVolume is an autogenerated conversion function. +func Convert_v1alpha3_BlockDeviceVolume_To_ignite_BlockDeviceVolume(in *BlockDeviceVolume, out *ignite.BlockDeviceVolume, s conversion.Scope) error { + return autoConvert_v1alpha3_BlockDeviceVolume_To_ignite_BlockDeviceVolume(in, out, s) +} + +func autoConvert_ignite_BlockDeviceVolume_To_v1alpha3_BlockDeviceVolume(in *ignite.BlockDeviceVolume, out *BlockDeviceVolume, s conversion.Scope) error { + out.Path = in.Path + return nil +} + +// Convert_ignite_BlockDeviceVolume_To_v1alpha3_BlockDeviceVolume is an autogenerated conversion function. +func Convert_ignite_BlockDeviceVolume_To_v1alpha3_BlockDeviceVolume(in *ignite.BlockDeviceVolume, out *BlockDeviceVolume, s conversion.Scope) error { + return autoConvert_ignite_BlockDeviceVolume_To_v1alpha3_BlockDeviceVolume(in, out, s) +} + +func autoConvert_v1alpha3_FileMapping_To_ignite_FileMapping(in *FileMapping, out *ignite.FileMapping, s conversion.Scope) error { + out.HostPath = in.HostPath + out.VMPath = in.VMPath + return nil +} + +// Convert_v1alpha3_FileMapping_To_ignite_FileMapping is an autogenerated conversion function. +func Convert_v1alpha3_FileMapping_To_ignite_FileMapping(in *FileMapping, out *ignite.FileMapping, s conversion.Scope) error { + return autoConvert_v1alpha3_FileMapping_To_ignite_FileMapping(in, out, s) +} + +func autoConvert_ignite_FileMapping_To_v1alpha3_FileMapping(in *ignite.FileMapping, out *FileMapping, s conversion.Scope) error { + out.HostPath = in.HostPath + out.VMPath = in.VMPath + return nil +} + +// Convert_ignite_FileMapping_To_v1alpha3_FileMapping is an autogenerated conversion function. +func Convert_ignite_FileMapping_To_v1alpha3_FileMapping(in *ignite.FileMapping, out *FileMapping, s conversion.Scope) error { + return autoConvert_ignite_FileMapping_To_v1alpha3_FileMapping(in, out, s) +} + +func autoConvert_v1alpha3_Image_To_ignite_Image(in *Image, out *ignite.Image, s conversion.Scope) error { + out.TypeMeta = in.TypeMeta + out.ObjectMeta = in.ObjectMeta + if err := Convert_v1alpha3_ImageSpec_To_ignite_ImageSpec(&in.Spec, &out.Spec, s); err != nil { + return err + } + if err := Convert_v1alpha3_ImageStatus_To_ignite_ImageStatus(&in.Status, &out.Status, s); err != nil { + return err + } + return nil +} + +// Convert_v1alpha3_Image_To_ignite_Image is an autogenerated conversion function. +func Convert_v1alpha3_Image_To_ignite_Image(in *Image, out *ignite.Image, s conversion.Scope) error { + return autoConvert_v1alpha3_Image_To_ignite_Image(in, out, s) +} + +func autoConvert_ignite_Image_To_v1alpha3_Image(in *ignite.Image, out *Image, s conversion.Scope) error { + out.TypeMeta = in.TypeMeta + out.ObjectMeta = in.ObjectMeta + if err := Convert_ignite_ImageSpec_To_v1alpha3_ImageSpec(&in.Spec, &out.Spec, s); err != nil { + return err + } + if err := Convert_ignite_ImageStatus_To_v1alpha3_ImageStatus(&in.Status, &out.Status, s); err != nil { + return err + } + return nil +} + +// Convert_ignite_Image_To_v1alpha3_Image is an autogenerated conversion function. +func Convert_ignite_Image_To_v1alpha3_Image(in *ignite.Image, out *Image, s conversion.Scope) error { + return autoConvert_ignite_Image_To_v1alpha3_Image(in, out, s) +} + +func autoConvert_v1alpha3_ImageSpec_To_ignite_ImageSpec(in *ImageSpec, out *ignite.ImageSpec, s conversion.Scope) error { + out.OCI = in.OCI + return nil +} + +// Convert_v1alpha3_ImageSpec_To_ignite_ImageSpec is an autogenerated conversion function. +func Convert_v1alpha3_ImageSpec_To_ignite_ImageSpec(in *ImageSpec, out *ignite.ImageSpec, s conversion.Scope) error { + return autoConvert_v1alpha3_ImageSpec_To_ignite_ImageSpec(in, out, s) +} + +func autoConvert_ignite_ImageSpec_To_v1alpha3_ImageSpec(in *ignite.ImageSpec, out *ImageSpec, s conversion.Scope) error { + out.OCI = in.OCI + return nil +} + +// Convert_ignite_ImageSpec_To_v1alpha3_ImageSpec is an autogenerated conversion function. +func Convert_ignite_ImageSpec_To_v1alpha3_ImageSpec(in *ignite.ImageSpec, out *ImageSpec, s conversion.Scope) error { + return autoConvert_ignite_ImageSpec_To_v1alpha3_ImageSpec(in, out, s) +} + +func autoConvert_v1alpha3_ImageStatus_To_ignite_ImageStatus(in *ImageStatus, out *ignite.ImageStatus, s conversion.Scope) error { + if err := Convert_v1alpha3_OCIImageSource_To_ignite_OCIImageSource(&in.OCISource, &out.OCISource, s); err != nil { + return err + } + return nil +} + +// Convert_v1alpha3_ImageStatus_To_ignite_ImageStatus is an autogenerated conversion function. +func Convert_v1alpha3_ImageStatus_To_ignite_ImageStatus(in *ImageStatus, out *ignite.ImageStatus, s conversion.Scope) error { + return autoConvert_v1alpha3_ImageStatus_To_ignite_ImageStatus(in, out, s) +} + +func autoConvert_ignite_ImageStatus_To_v1alpha3_ImageStatus(in *ignite.ImageStatus, out *ImageStatus, s conversion.Scope) error { + if err := Convert_ignite_OCIImageSource_To_v1alpha3_OCIImageSource(&in.OCISource, &out.OCISource, s); err != nil { + return err + } + return nil +} + +// Convert_ignite_ImageStatus_To_v1alpha3_ImageStatus is an autogenerated conversion function. +func Convert_ignite_ImageStatus_To_v1alpha3_ImageStatus(in *ignite.ImageStatus, out *ImageStatus, s conversion.Scope) error { + return autoConvert_ignite_ImageStatus_To_v1alpha3_ImageStatus(in, out, s) +} + +func autoConvert_v1alpha3_Kernel_To_ignite_Kernel(in *Kernel, out *ignite.Kernel, s conversion.Scope) error { + out.TypeMeta = in.TypeMeta + out.ObjectMeta = in.ObjectMeta + if err := Convert_v1alpha3_KernelSpec_To_ignite_KernelSpec(&in.Spec, &out.Spec, s); err != nil { + return err + } + if err := Convert_v1alpha3_KernelStatus_To_ignite_KernelStatus(&in.Status, &out.Status, s); err != nil { + return err + } + return nil +} + +// Convert_v1alpha3_Kernel_To_ignite_Kernel is an autogenerated conversion function. +func Convert_v1alpha3_Kernel_To_ignite_Kernel(in *Kernel, out *ignite.Kernel, s conversion.Scope) error { + return autoConvert_v1alpha3_Kernel_To_ignite_Kernel(in, out, s) +} + +func autoConvert_ignite_Kernel_To_v1alpha3_Kernel(in *ignite.Kernel, out *Kernel, s conversion.Scope) error { + out.TypeMeta = in.TypeMeta + out.ObjectMeta = in.ObjectMeta + if err := Convert_ignite_KernelSpec_To_v1alpha3_KernelSpec(&in.Spec, &out.Spec, s); err != nil { + return err + } + if err := Convert_ignite_KernelStatus_To_v1alpha3_KernelStatus(&in.Status, &out.Status, s); err != nil { + return err + } + return nil +} + +// Convert_ignite_Kernel_To_v1alpha3_Kernel is an autogenerated conversion function. +func Convert_ignite_Kernel_To_v1alpha3_Kernel(in *ignite.Kernel, out *Kernel, s conversion.Scope) error { + return autoConvert_ignite_Kernel_To_v1alpha3_Kernel(in, out, s) +} + +func autoConvert_v1alpha3_KernelSpec_To_ignite_KernelSpec(in *KernelSpec, out *ignite.KernelSpec, s conversion.Scope) error { + out.OCI = in.OCI + return nil +} + +// Convert_v1alpha3_KernelSpec_To_ignite_KernelSpec is an autogenerated conversion function. +func Convert_v1alpha3_KernelSpec_To_ignite_KernelSpec(in *KernelSpec, out *ignite.KernelSpec, s conversion.Scope) error { + return autoConvert_v1alpha3_KernelSpec_To_ignite_KernelSpec(in, out, s) +} + +func autoConvert_ignite_KernelSpec_To_v1alpha3_KernelSpec(in *ignite.KernelSpec, out *KernelSpec, s conversion.Scope) error { + out.OCI = in.OCI + return nil +} + +// Convert_ignite_KernelSpec_To_v1alpha3_KernelSpec is an autogenerated conversion function. +func Convert_ignite_KernelSpec_To_v1alpha3_KernelSpec(in *ignite.KernelSpec, out *KernelSpec, s conversion.Scope) error { + return autoConvert_ignite_KernelSpec_To_v1alpha3_KernelSpec(in, out, s) +} + +func autoConvert_v1alpha3_KernelStatus_To_ignite_KernelStatus(in *KernelStatus, out *ignite.KernelStatus, s conversion.Scope) error { + out.Version = in.Version + if err := Convert_v1alpha3_OCIImageSource_To_ignite_OCIImageSource(&in.OCISource, &out.OCISource, s); err != nil { + return err + } + return nil +} + +// Convert_v1alpha3_KernelStatus_To_ignite_KernelStatus is an autogenerated conversion function. +func Convert_v1alpha3_KernelStatus_To_ignite_KernelStatus(in *KernelStatus, out *ignite.KernelStatus, s conversion.Scope) error { + return autoConvert_v1alpha3_KernelStatus_To_ignite_KernelStatus(in, out, s) +} + +func autoConvert_ignite_KernelStatus_To_v1alpha3_KernelStatus(in *ignite.KernelStatus, out *KernelStatus, s conversion.Scope) error { + out.Version = in.Version + if err := Convert_ignite_OCIImageSource_To_v1alpha3_OCIImageSource(&in.OCISource, &out.OCISource, s); err != nil { + return err + } + return nil +} + +// Convert_ignite_KernelStatus_To_v1alpha3_KernelStatus is an autogenerated conversion function. +func Convert_ignite_KernelStatus_To_v1alpha3_KernelStatus(in *ignite.KernelStatus, out *KernelStatus, s conversion.Scope) error { + return autoConvert_ignite_KernelStatus_To_v1alpha3_KernelStatus(in, out, s) +} + +func autoConvert_v1alpha3_OCIImageSource_To_ignite_OCIImageSource(in *OCIImageSource, out *ignite.OCIImageSource, s conversion.Scope) error { + out.ID = (*v1alpha1.OCIContentID)(unsafe.Pointer(in.ID)) + out.Size = in.Size + return nil +} + +// Convert_v1alpha3_OCIImageSource_To_ignite_OCIImageSource is an autogenerated conversion function. +func Convert_v1alpha3_OCIImageSource_To_ignite_OCIImageSource(in *OCIImageSource, out *ignite.OCIImageSource, s conversion.Scope) error { + return autoConvert_v1alpha3_OCIImageSource_To_ignite_OCIImageSource(in, out, s) +} + +func autoConvert_ignite_OCIImageSource_To_v1alpha3_OCIImageSource(in *ignite.OCIImageSource, out *OCIImageSource, s conversion.Scope) error { + out.ID = (*v1alpha1.OCIContentID)(unsafe.Pointer(in.ID)) + out.Size = in.Size + return nil +} + +// Convert_ignite_OCIImageSource_To_v1alpha3_OCIImageSource is an autogenerated conversion function. +func Convert_ignite_OCIImageSource_To_v1alpha3_OCIImageSource(in *ignite.OCIImageSource, out *OCIImageSource, s conversion.Scope) error { + return autoConvert_ignite_OCIImageSource_To_v1alpha3_OCIImageSource(in, out, s) +} + +func autoConvert_v1alpha3_Pool_To_ignite_Pool(in *Pool, out *ignite.Pool, s conversion.Scope) error { + out.TypeMeta = in.TypeMeta + if err := Convert_v1alpha3_PoolSpec_To_ignite_PoolSpec(&in.Spec, &out.Spec, s); err != nil { + return err + } + if err := Convert_v1alpha3_PoolStatus_To_ignite_PoolStatus(&in.Status, &out.Status, s); err != nil { + return err + } + return nil +} + +// Convert_v1alpha3_Pool_To_ignite_Pool is an autogenerated conversion function. +func Convert_v1alpha3_Pool_To_ignite_Pool(in *Pool, out *ignite.Pool, s conversion.Scope) error { + return autoConvert_v1alpha3_Pool_To_ignite_Pool(in, out, s) +} + +func autoConvert_ignite_Pool_To_v1alpha3_Pool(in *ignite.Pool, out *Pool, s conversion.Scope) error { + out.TypeMeta = in.TypeMeta + if err := Convert_ignite_PoolSpec_To_v1alpha3_PoolSpec(&in.Spec, &out.Spec, s); err != nil { + return err + } + if err := Convert_ignite_PoolStatus_To_v1alpha3_PoolStatus(&in.Status, &out.Status, s); err != nil { + return err + } + return nil +} + +// Convert_ignite_Pool_To_v1alpha3_Pool is an autogenerated conversion function. +func Convert_ignite_Pool_To_v1alpha3_Pool(in *ignite.Pool, out *Pool, s conversion.Scope) error { + return autoConvert_ignite_Pool_To_v1alpha3_Pool(in, out, s) +} + +func autoConvert_v1alpha3_PoolDevice_To_ignite_PoolDevice(in *PoolDevice, out *ignite.PoolDevice, s conversion.Scope) error { + out.Size = in.Size + out.Parent = in.Parent + out.Type = ignite.PoolDeviceType(in.Type) + out.MetadataPath = in.MetadataPath + return nil +} + +// Convert_v1alpha3_PoolDevice_To_ignite_PoolDevice is an autogenerated conversion function. +func Convert_v1alpha3_PoolDevice_To_ignite_PoolDevice(in *PoolDevice, out *ignite.PoolDevice, s conversion.Scope) error { + return autoConvert_v1alpha3_PoolDevice_To_ignite_PoolDevice(in, out, s) +} + +func autoConvert_ignite_PoolDevice_To_v1alpha3_PoolDevice(in *ignite.PoolDevice, out *PoolDevice, s conversion.Scope) error { + out.Size = in.Size + out.Parent = in.Parent + out.Type = PoolDeviceType(in.Type) + out.MetadataPath = in.MetadataPath + return nil +} + +// Convert_ignite_PoolDevice_To_v1alpha3_PoolDevice is an autogenerated conversion function. +func Convert_ignite_PoolDevice_To_v1alpha3_PoolDevice(in *ignite.PoolDevice, out *PoolDevice, s conversion.Scope) error { + return autoConvert_ignite_PoolDevice_To_v1alpha3_PoolDevice(in, out, s) +} + +func autoConvert_v1alpha3_PoolSpec_To_ignite_PoolSpec(in *PoolSpec, out *ignite.PoolSpec, s conversion.Scope) error { + out.MetadataSize = in.MetadataSize + out.DataSize = in.DataSize + out.AllocationSize = in.AllocationSize + out.MetadataPath = in.MetadataPath + out.DataPath = in.DataPath + return nil +} + +// Convert_v1alpha3_PoolSpec_To_ignite_PoolSpec is an autogenerated conversion function. +func Convert_v1alpha3_PoolSpec_To_ignite_PoolSpec(in *PoolSpec, out *ignite.PoolSpec, s conversion.Scope) error { + return autoConvert_v1alpha3_PoolSpec_To_ignite_PoolSpec(in, out, s) +} + +func autoConvert_ignite_PoolSpec_To_v1alpha3_PoolSpec(in *ignite.PoolSpec, out *PoolSpec, s conversion.Scope) error { + out.MetadataSize = in.MetadataSize + out.DataSize = in.DataSize + out.AllocationSize = in.AllocationSize + out.MetadataPath = in.MetadataPath + out.DataPath = in.DataPath + return nil +} + +// Convert_ignite_PoolSpec_To_v1alpha3_PoolSpec is an autogenerated conversion function. +func Convert_ignite_PoolSpec_To_v1alpha3_PoolSpec(in *ignite.PoolSpec, out *PoolSpec, s conversion.Scope) error { + return autoConvert_ignite_PoolSpec_To_v1alpha3_PoolSpec(in, out, s) +} + +func autoConvert_v1alpha3_PoolStatus_To_ignite_PoolStatus(in *PoolStatus, out *ignite.PoolStatus, s conversion.Scope) error { + out.Devices = *(*[]*ignite.PoolDevice)(unsafe.Pointer(&in.Devices)) + return nil +} + +// Convert_v1alpha3_PoolStatus_To_ignite_PoolStatus is an autogenerated conversion function. +func Convert_v1alpha3_PoolStatus_To_ignite_PoolStatus(in *PoolStatus, out *ignite.PoolStatus, s conversion.Scope) error { + return autoConvert_v1alpha3_PoolStatus_To_ignite_PoolStatus(in, out, s) +} + +func autoConvert_ignite_PoolStatus_To_v1alpha3_PoolStatus(in *ignite.PoolStatus, out *PoolStatus, s conversion.Scope) error { + out.Devices = *(*[]*PoolDevice)(unsafe.Pointer(&in.Devices)) + return nil +} + +// Convert_ignite_PoolStatus_To_v1alpha3_PoolStatus is an autogenerated conversion function. +func Convert_ignite_PoolStatus_To_v1alpha3_PoolStatus(in *ignite.PoolStatus, out *PoolStatus, s conversion.Scope) error { + return autoConvert_ignite_PoolStatus_To_v1alpha3_PoolStatus(in, out, s) +} + +func autoConvert_v1alpha3_Runtime_To_ignite_Runtime(in *Runtime, out *ignite.Runtime, s conversion.Scope) error { + out.ID = in.ID + return nil +} + +// Convert_v1alpha3_Runtime_To_ignite_Runtime is an autogenerated conversion function. +func Convert_v1alpha3_Runtime_To_ignite_Runtime(in *Runtime, out *ignite.Runtime, s conversion.Scope) error { + return autoConvert_v1alpha3_Runtime_To_ignite_Runtime(in, out, s) +} + +func autoConvert_ignite_Runtime_To_v1alpha3_Runtime(in *ignite.Runtime, out *Runtime, s conversion.Scope) error { + out.ID = in.ID + return nil +} + +// Convert_ignite_Runtime_To_v1alpha3_Runtime is an autogenerated conversion function. +func Convert_ignite_Runtime_To_v1alpha3_Runtime(in *ignite.Runtime, out *Runtime, s conversion.Scope) error { + return autoConvert_ignite_Runtime_To_v1alpha3_Runtime(in, out, s) +} + +func autoConvert_v1alpha3_SSH_To_ignite_SSH(in *SSH, out *ignite.SSH, s conversion.Scope) error { + out.Generate = in.Generate + out.PublicKey = in.PublicKey + return nil +} + +// Convert_v1alpha3_SSH_To_ignite_SSH is an autogenerated conversion function. +func Convert_v1alpha3_SSH_To_ignite_SSH(in *SSH, out *ignite.SSH, s conversion.Scope) error { + return autoConvert_v1alpha3_SSH_To_ignite_SSH(in, out, s) +} + +func autoConvert_ignite_SSH_To_v1alpha3_SSH(in *ignite.SSH, out *SSH, s conversion.Scope) error { + out.Generate = in.Generate + out.PublicKey = in.PublicKey + return nil +} + +// Convert_ignite_SSH_To_v1alpha3_SSH is an autogenerated conversion function. +func Convert_ignite_SSH_To_v1alpha3_SSH(in *ignite.SSH, out *SSH, s conversion.Scope) error { + return autoConvert_ignite_SSH_To_v1alpha3_SSH(in, out, s) +} + +func autoConvert_v1alpha3_VM_To_ignite_VM(in *VM, out *ignite.VM, s conversion.Scope) error { + out.TypeMeta = in.TypeMeta + out.ObjectMeta = in.ObjectMeta + if err := Convert_v1alpha3_VMSpec_To_ignite_VMSpec(&in.Spec, &out.Spec, s); err != nil { + return err + } + if err := Convert_v1alpha3_VMStatus_To_ignite_VMStatus(&in.Status, &out.Status, s); err != nil { + return err + } + return nil +} + +// Convert_v1alpha3_VM_To_ignite_VM is an autogenerated conversion function. +func Convert_v1alpha3_VM_To_ignite_VM(in *VM, out *ignite.VM, s conversion.Scope) error { + return autoConvert_v1alpha3_VM_To_ignite_VM(in, out, s) +} + +func autoConvert_ignite_VM_To_v1alpha3_VM(in *ignite.VM, out *VM, s conversion.Scope) error { + out.TypeMeta = in.TypeMeta + out.ObjectMeta = in.ObjectMeta + if err := Convert_ignite_VMSpec_To_v1alpha3_VMSpec(&in.Spec, &out.Spec, s); err != nil { + return err + } + if err := Convert_ignite_VMStatus_To_v1alpha3_VMStatus(&in.Status, &out.Status, s); err != nil { + return err + } + return nil +} + +// Convert_ignite_VM_To_v1alpha3_VM is an autogenerated conversion function. +func Convert_ignite_VM_To_v1alpha3_VM(in *ignite.VM, out *VM, s conversion.Scope) error { + return autoConvert_ignite_VM_To_v1alpha3_VM(in, out, s) +} + +func autoConvert_v1alpha3_VMImageSpec_To_ignite_VMImageSpec(in *VMImageSpec, out *ignite.VMImageSpec, s conversion.Scope) error { + out.OCI = in.OCI + return nil +} + +// Convert_v1alpha3_VMImageSpec_To_ignite_VMImageSpec is an autogenerated conversion function. +func Convert_v1alpha3_VMImageSpec_To_ignite_VMImageSpec(in *VMImageSpec, out *ignite.VMImageSpec, s conversion.Scope) error { + return autoConvert_v1alpha3_VMImageSpec_To_ignite_VMImageSpec(in, out, s) +} + +func autoConvert_ignite_VMImageSpec_To_v1alpha3_VMImageSpec(in *ignite.VMImageSpec, out *VMImageSpec, s conversion.Scope) error { + out.OCI = in.OCI + return nil +} + +// Convert_ignite_VMImageSpec_To_v1alpha3_VMImageSpec is an autogenerated conversion function. +func Convert_ignite_VMImageSpec_To_v1alpha3_VMImageSpec(in *ignite.VMImageSpec, out *VMImageSpec, s conversion.Scope) error { + return autoConvert_ignite_VMImageSpec_To_v1alpha3_VMImageSpec(in, out, s) +} + +func autoConvert_v1alpha3_VMKernelSpec_To_ignite_VMKernelSpec(in *VMKernelSpec, out *ignite.VMKernelSpec, s conversion.Scope) error { + out.OCI = in.OCI + out.CmdLine = in.CmdLine + return nil +} + +// Convert_v1alpha3_VMKernelSpec_To_ignite_VMKernelSpec is an autogenerated conversion function. +func Convert_v1alpha3_VMKernelSpec_To_ignite_VMKernelSpec(in *VMKernelSpec, out *ignite.VMKernelSpec, s conversion.Scope) error { + return autoConvert_v1alpha3_VMKernelSpec_To_ignite_VMKernelSpec(in, out, s) +} + +func autoConvert_ignite_VMKernelSpec_To_v1alpha3_VMKernelSpec(in *ignite.VMKernelSpec, out *VMKernelSpec, s conversion.Scope) error { + out.OCI = in.OCI + out.CmdLine = in.CmdLine + return nil +} + +// Convert_ignite_VMKernelSpec_To_v1alpha3_VMKernelSpec is an autogenerated conversion function. +func Convert_ignite_VMKernelSpec_To_v1alpha3_VMKernelSpec(in *ignite.VMKernelSpec, out *VMKernelSpec, s conversion.Scope) error { + return autoConvert_ignite_VMKernelSpec_To_v1alpha3_VMKernelSpec(in, out, s) +} + +func autoConvert_v1alpha3_VMNetworkSpec_To_ignite_VMNetworkSpec(in *VMNetworkSpec, out *ignite.VMNetworkSpec, s conversion.Scope) error { + out.Ports = *(*v1alpha1.PortMappings)(unsafe.Pointer(&in.Ports)) + return nil +} + +// Convert_v1alpha3_VMNetworkSpec_To_ignite_VMNetworkSpec is an autogenerated conversion function. +func Convert_v1alpha3_VMNetworkSpec_To_ignite_VMNetworkSpec(in *VMNetworkSpec, out *ignite.VMNetworkSpec, s conversion.Scope) error { + return autoConvert_v1alpha3_VMNetworkSpec_To_ignite_VMNetworkSpec(in, out, s) +} + +func autoConvert_ignite_VMNetworkSpec_To_v1alpha3_VMNetworkSpec(in *ignite.VMNetworkSpec, out *VMNetworkSpec, s conversion.Scope) error { + out.Ports = *(*v1alpha1.PortMappings)(unsafe.Pointer(&in.Ports)) + return nil +} + +// Convert_ignite_VMNetworkSpec_To_v1alpha3_VMNetworkSpec is an autogenerated conversion function. +func Convert_ignite_VMNetworkSpec_To_v1alpha3_VMNetworkSpec(in *ignite.VMNetworkSpec, out *VMNetworkSpec, s conversion.Scope) error { + return autoConvert_ignite_VMNetworkSpec_To_v1alpha3_VMNetworkSpec(in, out, s) +} + +func autoConvert_v1alpha3_VMSandboxSpec_To_ignite_VMSandboxSpec(in *VMSandboxSpec, out *ignite.VMSandboxSpec, s conversion.Scope) error { + out.OCI = in.OCI + return nil +} + +// Convert_v1alpha3_VMSandboxSpec_To_ignite_VMSandboxSpec is an autogenerated conversion function. +func Convert_v1alpha3_VMSandboxSpec_To_ignite_VMSandboxSpec(in *VMSandboxSpec, out *ignite.VMSandboxSpec, s conversion.Scope) error { + return autoConvert_v1alpha3_VMSandboxSpec_To_ignite_VMSandboxSpec(in, out, s) +} + +func autoConvert_ignite_VMSandboxSpec_To_v1alpha3_VMSandboxSpec(in *ignite.VMSandboxSpec, out *VMSandboxSpec, s conversion.Scope) error { + out.OCI = in.OCI + return nil +} + +// Convert_ignite_VMSandboxSpec_To_v1alpha3_VMSandboxSpec is an autogenerated conversion function. +func Convert_ignite_VMSandboxSpec_To_v1alpha3_VMSandboxSpec(in *ignite.VMSandboxSpec, out *VMSandboxSpec, s conversion.Scope) error { + return autoConvert_ignite_VMSandboxSpec_To_v1alpha3_VMSandboxSpec(in, out, s) +} + +func autoConvert_v1alpha3_VMSpec_To_ignite_VMSpec(in *VMSpec, out *ignite.VMSpec, s conversion.Scope) error { + if err := Convert_v1alpha3_VMImageSpec_To_ignite_VMImageSpec(&in.Image, &out.Image, s); err != nil { + return err + } + if err := Convert_v1alpha3_VMSandboxSpec_To_ignite_VMSandboxSpec(&in.Sandbox, &out.Sandbox, s); err != nil { + return err + } + if err := Convert_v1alpha3_VMKernelSpec_To_ignite_VMKernelSpec(&in.Kernel, &out.Kernel, s); err != nil { + return err + } + out.CPUs = in.CPUs + out.Memory = in.Memory + out.DiskSize = in.DiskSize + if err := Convert_v1alpha3_VMNetworkSpec_To_ignite_VMNetworkSpec(&in.Network, &out.Network, s); err != nil { + return err + } + if err := Convert_v1alpha3_VMStorageSpec_To_ignite_VMStorageSpec(&in.Storage, &out.Storage, s); err != nil { + return err + } + out.CopyFiles = *(*[]ignite.FileMapping)(unsafe.Pointer(&in.CopyFiles)) + out.SSH = (*ignite.SSH)(unsafe.Pointer(in.SSH)) + return nil +} + +// Convert_v1alpha3_VMSpec_To_ignite_VMSpec is an autogenerated conversion function. +func Convert_v1alpha3_VMSpec_To_ignite_VMSpec(in *VMSpec, out *ignite.VMSpec, s conversion.Scope) error { + return autoConvert_v1alpha3_VMSpec_To_ignite_VMSpec(in, out, s) +} + +func autoConvert_ignite_VMSpec_To_v1alpha3_VMSpec(in *ignite.VMSpec, out *VMSpec, s conversion.Scope) error { + if err := Convert_ignite_VMImageSpec_To_v1alpha3_VMImageSpec(&in.Image, &out.Image, s); err != nil { + return err + } + if err := Convert_ignite_VMSandboxSpec_To_v1alpha3_VMSandboxSpec(&in.Sandbox, &out.Sandbox, s); err != nil { + return err + } + if err := Convert_ignite_VMKernelSpec_To_v1alpha3_VMKernelSpec(&in.Kernel, &out.Kernel, s); err != nil { + return err + } + out.CPUs = in.CPUs + out.Memory = in.Memory + out.DiskSize = in.DiskSize + if err := Convert_ignite_VMNetworkSpec_To_v1alpha3_VMNetworkSpec(&in.Network, &out.Network, s); err != nil { + return err + } + if err := Convert_ignite_VMStorageSpec_To_v1alpha3_VMStorageSpec(&in.Storage, &out.Storage, s); err != nil { + return err + } + out.CopyFiles = *(*[]FileMapping)(unsafe.Pointer(&in.CopyFiles)) + out.SSH = (*SSH)(unsafe.Pointer(in.SSH)) + return nil +} + +// Convert_ignite_VMSpec_To_v1alpha3_VMSpec is an autogenerated conversion function. +func Convert_ignite_VMSpec_To_v1alpha3_VMSpec(in *ignite.VMSpec, out *VMSpec, s conversion.Scope) error { + return autoConvert_ignite_VMSpec_To_v1alpha3_VMSpec(in, out, s) +} + +func autoConvert_v1alpha3_VMStatus_To_ignite_VMStatus(in *VMStatus, out *ignite.VMStatus, s conversion.Scope) error { + out.Running = in.Running + out.Runtime = (*ignite.Runtime)(unsafe.Pointer(in.Runtime)) + out.StartTime = (*pkgruntime.Time)(unsafe.Pointer(in.StartTime)) + out.IPAddresses = *(*v1alpha1.IPAddresses)(unsafe.Pointer(&in.IPAddresses)) + if err := Convert_v1alpha3_OCIImageSource_To_ignite_OCIImageSource(&in.Image, &out.Image, s); err != nil { + return err + } + if err := Convert_v1alpha3_OCIImageSource_To_ignite_OCIImageSource(&in.Kernel, &out.Kernel, s); err != nil { + return err + } + return nil +} + +// Convert_v1alpha3_VMStatus_To_ignite_VMStatus is an autogenerated conversion function. +func Convert_v1alpha3_VMStatus_To_ignite_VMStatus(in *VMStatus, out *ignite.VMStatus, s conversion.Scope) error { + return autoConvert_v1alpha3_VMStatus_To_ignite_VMStatus(in, out, s) +} + +func autoConvert_ignite_VMStatus_To_v1alpha3_VMStatus(in *ignite.VMStatus, out *VMStatus, s conversion.Scope) error { + out.Running = in.Running + out.Runtime = (*Runtime)(unsafe.Pointer(in.Runtime)) + out.StartTime = (*pkgruntime.Time)(unsafe.Pointer(in.StartTime)) + out.IPAddresses = *(*v1alpha1.IPAddresses)(unsafe.Pointer(&in.IPAddresses)) + if err := Convert_ignite_OCIImageSource_To_v1alpha3_OCIImageSource(&in.Image, &out.Image, s); err != nil { + return err + } + if err := Convert_ignite_OCIImageSource_To_v1alpha3_OCIImageSource(&in.Kernel, &out.Kernel, s); err != nil { + return err + } + return nil +} + +// Convert_ignite_VMStatus_To_v1alpha3_VMStatus is an autogenerated conversion function. +func Convert_ignite_VMStatus_To_v1alpha3_VMStatus(in *ignite.VMStatus, out *VMStatus, s conversion.Scope) error { + return autoConvert_ignite_VMStatus_To_v1alpha3_VMStatus(in, out, s) +} + +func autoConvert_v1alpha3_VMStorageSpec_To_ignite_VMStorageSpec(in *VMStorageSpec, out *ignite.VMStorageSpec, s conversion.Scope) error { + out.Volumes = *(*[]ignite.Volume)(unsafe.Pointer(&in.Volumes)) + out.VolumeMounts = *(*[]ignite.VolumeMount)(unsafe.Pointer(&in.VolumeMounts)) + return nil +} + +// Convert_v1alpha3_VMStorageSpec_To_ignite_VMStorageSpec is an autogenerated conversion function. +func Convert_v1alpha3_VMStorageSpec_To_ignite_VMStorageSpec(in *VMStorageSpec, out *ignite.VMStorageSpec, s conversion.Scope) error { + return autoConvert_v1alpha3_VMStorageSpec_To_ignite_VMStorageSpec(in, out, s) +} + +func autoConvert_ignite_VMStorageSpec_To_v1alpha3_VMStorageSpec(in *ignite.VMStorageSpec, out *VMStorageSpec, s conversion.Scope) error { + out.Volumes = *(*[]Volume)(unsafe.Pointer(&in.Volumes)) + out.VolumeMounts = *(*[]VolumeMount)(unsafe.Pointer(&in.VolumeMounts)) + return nil +} + +// Convert_ignite_VMStorageSpec_To_v1alpha3_VMStorageSpec is an autogenerated conversion function. +func Convert_ignite_VMStorageSpec_To_v1alpha3_VMStorageSpec(in *ignite.VMStorageSpec, out *VMStorageSpec, s conversion.Scope) error { + return autoConvert_ignite_VMStorageSpec_To_v1alpha3_VMStorageSpec(in, out, s) +} + +func autoConvert_v1alpha3_Volume_To_ignite_Volume(in *Volume, out *ignite.Volume, s conversion.Scope) error { + out.Name = in.Name + out.BlockDevice = (*ignite.BlockDeviceVolume)(unsafe.Pointer(in.BlockDevice)) + return nil +} + +// Convert_v1alpha3_Volume_To_ignite_Volume is an autogenerated conversion function. +func Convert_v1alpha3_Volume_To_ignite_Volume(in *Volume, out *ignite.Volume, s conversion.Scope) error { + return autoConvert_v1alpha3_Volume_To_ignite_Volume(in, out, s) +} + +func autoConvert_ignite_Volume_To_v1alpha3_Volume(in *ignite.Volume, out *Volume, s conversion.Scope) error { + out.Name = in.Name + out.BlockDevice = (*BlockDeviceVolume)(unsafe.Pointer(in.BlockDevice)) + return nil +} + +// Convert_ignite_Volume_To_v1alpha3_Volume is an autogenerated conversion function. +func Convert_ignite_Volume_To_v1alpha3_Volume(in *ignite.Volume, out *Volume, s conversion.Scope) error { + return autoConvert_ignite_Volume_To_v1alpha3_Volume(in, out, s) +} + +func autoConvert_v1alpha3_VolumeMount_To_ignite_VolumeMount(in *VolumeMount, out *ignite.VolumeMount, s conversion.Scope) error { + out.Name = in.Name + out.MountPath = in.MountPath + return nil +} + +// Convert_v1alpha3_VolumeMount_To_ignite_VolumeMount is an autogenerated conversion function. +func Convert_v1alpha3_VolumeMount_To_ignite_VolumeMount(in *VolumeMount, out *ignite.VolumeMount, s conversion.Scope) error { + return autoConvert_v1alpha3_VolumeMount_To_ignite_VolumeMount(in, out, s) +} + +func autoConvert_ignite_VolumeMount_To_v1alpha3_VolumeMount(in *ignite.VolumeMount, out *VolumeMount, s conversion.Scope) error { + out.Name = in.Name + out.MountPath = in.MountPath + return nil +} + +// Convert_ignite_VolumeMount_To_v1alpha3_VolumeMount is an autogenerated conversion function. +func Convert_ignite_VolumeMount_To_v1alpha3_VolumeMount(in *ignite.VolumeMount, out *VolumeMount, s conversion.Scope) error { + return autoConvert_ignite_VolumeMount_To_v1alpha3_VolumeMount(in, out, s) +} diff --git a/pkg/apis/ignite/v1alpha3/zz_generated.deepcopy.go b/pkg/apis/ignite/v1alpha3/zz_generated.deepcopy.go new file mode 100644 index 000000000..d93e6e870 --- /dev/null +++ b/pkg/apis/ignite/v1alpha3/zz_generated.deepcopy.go @@ -0,0 +1,553 @@ +// +build !ignore_autogenerated + +// Code generated by deepcopy-gen. DO NOT EDIT. + +package v1alpha3 + +import ( + net "net" + + v1alpha1 "github.com/weaveworks/ignite/pkg/apis/meta/v1alpha1" + pkgruntime "github.com/weaveworks/libgitops/pkg/runtime" + runtime "k8s.io/apimachinery/pkg/runtime" +) + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *BlockDeviceVolume) DeepCopyInto(out *BlockDeviceVolume) { + *out = *in + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new BlockDeviceVolume. +func (in *BlockDeviceVolume) DeepCopy() *BlockDeviceVolume { + if in == nil { + return nil + } + out := new(BlockDeviceVolume) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *FileMapping) DeepCopyInto(out *FileMapping) { + *out = *in + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new FileMapping. +func (in *FileMapping) DeepCopy() *FileMapping { + if in == nil { + return nil + } + out := new(FileMapping) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *Image) DeepCopyInto(out *Image) { + *out = *in + out.TypeMeta = in.TypeMeta + in.ObjectMeta.DeepCopyInto(&out.ObjectMeta) + out.Spec = in.Spec + in.Status.DeepCopyInto(&out.Status) + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new Image. +func (in *Image) DeepCopy() *Image { + if in == nil { + return nil + } + out := new(Image) + in.DeepCopyInto(out) + return out +} + +// DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object. +func (in *Image) DeepCopyObject() runtime.Object { + if c := in.DeepCopy(); c != nil { + return c + } + return nil +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *ImageSpec) DeepCopyInto(out *ImageSpec) { + *out = *in + out.OCI = in.OCI + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ImageSpec. +func (in *ImageSpec) DeepCopy() *ImageSpec { + if in == nil { + return nil + } + out := new(ImageSpec) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *ImageStatus) DeepCopyInto(out *ImageStatus) { + *out = *in + in.OCISource.DeepCopyInto(&out.OCISource) + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ImageStatus. +func (in *ImageStatus) DeepCopy() *ImageStatus { + if in == nil { + return nil + } + out := new(ImageStatus) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *Kernel) DeepCopyInto(out *Kernel) { + *out = *in + out.TypeMeta = in.TypeMeta + in.ObjectMeta.DeepCopyInto(&out.ObjectMeta) + out.Spec = in.Spec + in.Status.DeepCopyInto(&out.Status) + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new Kernel. +func (in *Kernel) DeepCopy() *Kernel { + if in == nil { + return nil + } + out := new(Kernel) + in.DeepCopyInto(out) + return out +} + +// DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object. +func (in *Kernel) DeepCopyObject() runtime.Object { + if c := in.DeepCopy(); c != nil { + return c + } + return nil +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *KernelSpec) DeepCopyInto(out *KernelSpec) { + *out = *in + out.OCI = in.OCI + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new KernelSpec. +func (in *KernelSpec) DeepCopy() *KernelSpec { + if in == nil { + return nil + } + out := new(KernelSpec) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *KernelStatus) DeepCopyInto(out *KernelStatus) { + *out = *in + in.OCISource.DeepCopyInto(&out.OCISource) + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new KernelStatus. +func (in *KernelStatus) DeepCopy() *KernelStatus { + if in == nil { + return nil + } + out := new(KernelStatus) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *OCIImageSource) DeepCopyInto(out *OCIImageSource) { + *out = *in + if in.ID != nil { + in, out := &in.ID, &out.ID + *out = new(v1alpha1.OCIContentID) + **out = **in + } + out.Size = in.Size + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new OCIImageSource. +func (in *OCIImageSource) DeepCopy() *OCIImageSource { + if in == nil { + return nil + } + out := new(OCIImageSource) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *Pool) DeepCopyInto(out *Pool) { + *out = *in + out.TypeMeta = in.TypeMeta + out.Spec = in.Spec + in.Status.DeepCopyInto(&out.Status) + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new Pool. +func (in *Pool) DeepCopy() *Pool { + if in == nil { + return nil + } + out := new(Pool) + in.DeepCopyInto(out) + return out +} + +// DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object. +func (in *Pool) DeepCopyObject() runtime.Object { + if c := in.DeepCopy(); c != nil { + return c + } + return nil +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *PoolDevice) DeepCopyInto(out *PoolDevice) { + *out = *in + out.Size = in.Size + out.Parent = in.Parent + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new PoolDevice. +func (in *PoolDevice) DeepCopy() *PoolDevice { + if in == nil { + return nil + } + out := new(PoolDevice) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *PoolSpec) DeepCopyInto(out *PoolSpec) { + *out = *in + out.MetadataSize = in.MetadataSize + out.DataSize = in.DataSize + out.AllocationSize = in.AllocationSize + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new PoolSpec. +func (in *PoolSpec) DeepCopy() *PoolSpec { + if in == nil { + return nil + } + out := new(PoolSpec) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *PoolStatus) DeepCopyInto(out *PoolStatus) { + *out = *in + if in.Devices != nil { + in, out := &in.Devices, &out.Devices + *out = make([]*PoolDevice, len(*in)) + for i := range *in { + if (*in)[i] != nil { + in, out := &(*in)[i], &(*out)[i] + *out = new(PoolDevice) + **out = **in + } + } + } + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new PoolStatus. +func (in *PoolStatus) DeepCopy() *PoolStatus { + if in == nil { + return nil + } + out := new(PoolStatus) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *Runtime) DeepCopyInto(out *Runtime) { + *out = *in + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new Runtime. +func (in *Runtime) DeepCopy() *Runtime { + if in == nil { + return nil + } + out := new(Runtime) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *SSH) DeepCopyInto(out *SSH) { + *out = *in + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new SSH. +func (in *SSH) DeepCopy() *SSH { + if in == nil { + return nil + } + out := new(SSH) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *VM) DeepCopyInto(out *VM) { + *out = *in + out.TypeMeta = in.TypeMeta + in.ObjectMeta.DeepCopyInto(&out.ObjectMeta) + in.Spec.DeepCopyInto(&out.Spec) + in.Status.DeepCopyInto(&out.Status) + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new VM. +func (in *VM) DeepCopy() *VM { + if in == nil { + return nil + } + out := new(VM) + in.DeepCopyInto(out) + return out +} + +// DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object. +func (in *VM) DeepCopyObject() runtime.Object { + if c := in.DeepCopy(); c != nil { + return c + } + return nil +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *VMImageSpec) DeepCopyInto(out *VMImageSpec) { + *out = *in + out.OCI = in.OCI + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new VMImageSpec. +func (in *VMImageSpec) DeepCopy() *VMImageSpec { + if in == nil { + return nil + } + out := new(VMImageSpec) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *VMKernelSpec) DeepCopyInto(out *VMKernelSpec) { + *out = *in + out.OCI = in.OCI + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new VMKernelSpec. +func (in *VMKernelSpec) DeepCopy() *VMKernelSpec { + if in == nil { + return nil + } + out := new(VMKernelSpec) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *VMNetworkSpec) DeepCopyInto(out *VMNetworkSpec) { + *out = *in + if in.Ports != nil { + in, out := &in.Ports, &out.Ports + *out = make(v1alpha1.PortMappings, len(*in)) + for i := range *in { + (*in)[i].DeepCopyInto(&(*out)[i]) + } + } + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new VMNetworkSpec. +func (in *VMNetworkSpec) DeepCopy() *VMNetworkSpec { + if in == nil { + return nil + } + out := new(VMNetworkSpec) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *VMSandboxSpec) DeepCopyInto(out *VMSandboxSpec) { + *out = *in + out.OCI = in.OCI + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new VMSandboxSpec. +func (in *VMSandboxSpec) DeepCopy() *VMSandboxSpec { + if in == nil { + return nil + } + out := new(VMSandboxSpec) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *VMSpec) DeepCopyInto(out *VMSpec) { + *out = *in + out.Image = in.Image + out.Sandbox = in.Sandbox + out.Kernel = in.Kernel + out.Memory = in.Memory + out.DiskSize = in.DiskSize + in.Network.DeepCopyInto(&out.Network) + in.Storage.DeepCopyInto(&out.Storage) + if in.CopyFiles != nil { + in, out := &in.CopyFiles, &out.CopyFiles + *out = make([]FileMapping, len(*in)) + copy(*out, *in) + } + if in.SSH != nil { + in, out := &in.SSH, &out.SSH + *out = new(SSH) + **out = **in + } + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new VMSpec. +func (in *VMSpec) DeepCopy() *VMSpec { + if in == nil { + return nil + } + out := new(VMSpec) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *VMStatus) DeepCopyInto(out *VMStatus) { + *out = *in + if in.Runtime != nil { + in, out := &in.Runtime, &out.Runtime + *out = new(Runtime) + **out = **in + } + if in.StartTime != nil { + in, out := &in.StartTime, &out.StartTime + *out = new(pkgruntime.Time) + (*in).DeepCopyInto(*out) + } + if in.IPAddresses != nil { + in, out := &in.IPAddresses, &out.IPAddresses + *out = make(v1alpha1.IPAddresses, len(*in)) + for i := range *in { + if (*in)[i] != nil { + in, out := &(*in)[i], &(*out)[i] + *out = make(net.IP, len(*in)) + copy(*out, *in) + } + } + } + in.Image.DeepCopyInto(&out.Image) + in.Kernel.DeepCopyInto(&out.Kernel) + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new VMStatus. +func (in *VMStatus) DeepCopy() *VMStatus { + if in == nil { + return nil + } + out := new(VMStatus) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *VMStorageSpec) DeepCopyInto(out *VMStorageSpec) { + *out = *in + if in.Volumes != nil { + in, out := &in.Volumes, &out.Volumes + *out = make([]Volume, len(*in)) + for i := range *in { + (*in)[i].DeepCopyInto(&(*out)[i]) + } + } + if in.VolumeMounts != nil { + in, out := &in.VolumeMounts, &out.VolumeMounts + *out = make([]VolumeMount, len(*in)) + copy(*out, *in) + } + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new VMStorageSpec. +func (in *VMStorageSpec) DeepCopy() *VMStorageSpec { + if in == nil { + return nil + } + out := new(VMStorageSpec) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *Volume) DeepCopyInto(out *Volume) { + *out = *in + if in.BlockDevice != nil { + in, out := &in.BlockDevice, &out.BlockDevice + *out = new(BlockDeviceVolume) + **out = **in + } + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new Volume. +func (in *Volume) DeepCopy() *Volume { + if in == nil { + return nil + } + out := new(Volume) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *VolumeMount) DeepCopyInto(out *VolumeMount) { + *out = *in + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new VolumeMount. +func (in *VolumeMount) DeepCopy() *VolumeMount { + if in == nil { + return nil + } + out := new(VolumeMount) + in.DeepCopyInto(out) + return out +} diff --git a/pkg/apis/ignite/v1alpha3/zz_generated.defaults.go b/pkg/apis/ignite/v1alpha3/zz_generated.defaults.go new file mode 100644 index 000000000..949dbd545 --- /dev/null +++ b/pkg/apis/ignite/v1alpha3/zz_generated.defaults.go @@ -0,0 +1,28 @@ +// +build !ignore_autogenerated + +// Code generated by defaulter-gen. DO NOT EDIT. + +package v1alpha3 + +import ( + runtime "k8s.io/apimachinery/pkg/runtime" +) + +// RegisterDefaults adds defaulters functions to the given scheme. +// Public to allow building arbitrary schemes. +// All generated defaulters are covering - they call all nested defaulters. +func RegisterDefaults(scheme *runtime.Scheme) error { + scheme.AddTypeDefaultingFunc(&Pool{}, func(obj interface{}) { SetObjectDefaults_Pool(obj.(*Pool)) }) + scheme.AddTypeDefaultingFunc(&VM{}, func(obj interface{}) { SetObjectDefaults_VM(obj.(*VM)) }) + return nil +} + +func SetObjectDefaults_Pool(in *Pool) { + SetDefaults_PoolSpec(&in.Spec) +} + +func SetObjectDefaults_VM(in *VM) { + SetDefaults_VMSpec(&in.Spec) + SetDefaults_VMSandboxSpec(&in.Spec.Sandbox) + SetDefaults_VMKernelSpec(&in.Spec.Kernel) +} diff --git a/pkg/openapi/openapi_generated.go b/pkg/openapi/openapi_generated.go index cdbc43cb3..f8c7d3373 100644 --- a/pkg/openapi/openapi_generated.go +++ b/pkg/openapi/openapi_generated.go @@ -38,6 +38,31 @@ func GetOpenAPIDefinitions(ref common.ReferenceCallback) map[string]common.OpenA "github.com/weaveworks/ignite/pkg/apis/ignite/v1alpha2.VMStorageSpec": schema_pkg_apis_ignite_v1alpha2_VMStorageSpec(ref), "github.com/weaveworks/ignite/pkg/apis/ignite/v1alpha2.Volume": schema_pkg_apis_ignite_v1alpha2_Volume(ref), "github.com/weaveworks/ignite/pkg/apis/ignite/v1alpha2.VolumeMount": schema_pkg_apis_ignite_v1alpha2_VolumeMount(ref), + "github.com/weaveworks/ignite/pkg/apis/ignite/v1alpha3.BlockDeviceVolume": schema_pkg_apis_ignite_v1alpha3_BlockDeviceVolume(ref), + "github.com/weaveworks/ignite/pkg/apis/ignite/v1alpha3.FileMapping": schema_pkg_apis_ignite_v1alpha3_FileMapping(ref), + "github.com/weaveworks/ignite/pkg/apis/ignite/v1alpha3.Image": schema_pkg_apis_ignite_v1alpha3_Image(ref), + "github.com/weaveworks/ignite/pkg/apis/ignite/v1alpha3.ImageSpec": schema_pkg_apis_ignite_v1alpha3_ImageSpec(ref), + "github.com/weaveworks/ignite/pkg/apis/ignite/v1alpha3.ImageStatus": schema_pkg_apis_ignite_v1alpha3_ImageStatus(ref), + "github.com/weaveworks/ignite/pkg/apis/ignite/v1alpha3.Kernel": schema_pkg_apis_ignite_v1alpha3_Kernel(ref), + "github.com/weaveworks/ignite/pkg/apis/ignite/v1alpha3.KernelSpec": schema_pkg_apis_ignite_v1alpha3_KernelSpec(ref), + "github.com/weaveworks/ignite/pkg/apis/ignite/v1alpha3.KernelStatus": schema_pkg_apis_ignite_v1alpha3_KernelStatus(ref), + "github.com/weaveworks/ignite/pkg/apis/ignite/v1alpha3.OCIImageSource": schema_pkg_apis_ignite_v1alpha3_OCIImageSource(ref), + "github.com/weaveworks/ignite/pkg/apis/ignite/v1alpha3.Pool": schema_pkg_apis_ignite_v1alpha3_Pool(ref), + "github.com/weaveworks/ignite/pkg/apis/ignite/v1alpha3.PoolDevice": schema_pkg_apis_ignite_v1alpha3_PoolDevice(ref), + "github.com/weaveworks/ignite/pkg/apis/ignite/v1alpha3.PoolSpec": schema_pkg_apis_ignite_v1alpha3_PoolSpec(ref), + "github.com/weaveworks/ignite/pkg/apis/ignite/v1alpha3.PoolStatus": schema_pkg_apis_ignite_v1alpha3_PoolStatus(ref), + "github.com/weaveworks/ignite/pkg/apis/ignite/v1alpha3.Runtime": schema_pkg_apis_ignite_v1alpha3_Runtime(ref), + "github.com/weaveworks/ignite/pkg/apis/ignite/v1alpha3.SSH": schema_pkg_apis_ignite_v1alpha3_SSH(ref), + "github.com/weaveworks/ignite/pkg/apis/ignite/v1alpha3.VM": schema_pkg_apis_ignite_v1alpha3_VM(ref), + "github.com/weaveworks/ignite/pkg/apis/ignite/v1alpha3.VMImageSpec": schema_pkg_apis_ignite_v1alpha3_VMImageSpec(ref), + "github.com/weaveworks/ignite/pkg/apis/ignite/v1alpha3.VMKernelSpec": schema_pkg_apis_ignite_v1alpha3_VMKernelSpec(ref), + "github.com/weaveworks/ignite/pkg/apis/ignite/v1alpha3.VMNetworkSpec": schema_pkg_apis_ignite_v1alpha3_VMNetworkSpec(ref), + "github.com/weaveworks/ignite/pkg/apis/ignite/v1alpha3.VMSandboxSpec": schema_pkg_apis_ignite_v1alpha3_VMSandboxSpec(ref), + "github.com/weaveworks/ignite/pkg/apis/ignite/v1alpha3.VMSpec": schema_pkg_apis_ignite_v1alpha3_VMSpec(ref), + "github.com/weaveworks/ignite/pkg/apis/ignite/v1alpha3.VMStatus": schema_pkg_apis_ignite_v1alpha3_VMStatus(ref), + "github.com/weaveworks/ignite/pkg/apis/ignite/v1alpha3.VMStorageSpec": schema_pkg_apis_ignite_v1alpha3_VMStorageSpec(ref), + "github.com/weaveworks/ignite/pkg/apis/ignite/v1alpha3.Volume": schema_pkg_apis_ignite_v1alpha3_Volume(ref), + "github.com/weaveworks/ignite/pkg/apis/ignite/v1alpha3.VolumeMount": schema_pkg_apis_ignite_v1alpha3_VolumeMount(ref), "github.com/weaveworks/ignite/pkg/apis/meta/v1alpha1.DMID": schema_pkg_apis_meta_v1alpha1_DMID(ref), "github.com/weaveworks/ignite/pkg/apis/meta/v1alpha1.OCIContentID": schema_pkg_apis_meta_v1alpha1_OCIContentID(ref), "github.com/weaveworks/ignite/pkg/apis/meta/v1alpha1.OCIImageRef": schema_pkg_apis_meta_v1alpha1_OCIImageRef(ref), @@ -818,6 +843,778 @@ func schema_pkg_apis_ignite_v1alpha2_VolumeMount(ref common.ReferenceCallback) c } } +func schema_pkg_apis_ignite_v1alpha3_BlockDeviceVolume(ref common.ReferenceCallback) common.OpenAPIDefinition { + return common.OpenAPIDefinition{ + Schema: spec.Schema{ + SchemaProps: spec.SchemaProps{ + Description: "BlockDeviceVolume defines a block device on the host", + Type: []string{"object"}, + Properties: map[string]spec.Schema{ + "path": { + SchemaProps: spec.SchemaProps{ + Type: []string{"string"}, + Format: "", + }, + }, + }, + Required: []string{"path"}, + }, + }, + } +} + +func schema_pkg_apis_ignite_v1alpha3_FileMapping(ref common.ReferenceCallback) common.OpenAPIDefinition { + return common.OpenAPIDefinition{ + Schema: spec.Schema{ + SchemaProps: spec.SchemaProps{ + Description: "FileMapping defines mappings between files on the host and VM", + Type: []string{"object"}, + Properties: map[string]spec.Schema{ + "hostPath": { + SchemaProps: spec.SchemaProps{ + Type: []string{"string"}, + Format: "", + }, + }, + "vmPath": { + SchemaProps: spec.SchemaProps{ + Type: []string{"string"}, + Format: "", + }, + }, + }, + Required: []string{"hostPath", "vmPath"}, + }, + }, + } +} + +func schema_pkg_apis_ignite_v1alpha3_Image(ref common.ReferenceCallback) common.OpenAPIDefinition { + return common.OpenAPIDefinition{ + Schema: spec.Schema{ + SchemaProps: spec.SchemaProps{ + Description: "Image represents a cached OCI image ready to be used with Ignite", + Type: []string{"object"}, + Properties: map[string]spec.Schema{ + "TypeMeta": { + SchemaProps: spec.SchemaProps{ + Ref: ref("k8s.io/apimachinery/pkg/apis/meta/v1.TypeMeta"), + }, + }, + "metadata": { + SchemaProps: spec.SchemaProps{ + Description: "runtime.ObjectMeta is also embedded into the struct, and defines the human-readable name, and the machine-readable ID Name is available at the .metadata.name JSON path ID is available at the .metadata.uid JSON path (the Go type is k8s.io/apimachinery/pkg/types.UID, which is only a typed string)", + Ref: ref("github.com/weaveworks/libgitops/pkg/runtime.ObjectMeta"), + }, + }, + "spec": { + SchemaProps: spec.SchemaProps{ + Ref: ref("github.com/weaveworks/ignite/pkg/apis/ignite/v1alpha3.ImageSpec"), + }, + }, + "status": { + SchemaProps: spec.SchemaProps{ + Ref: ref("github.com/weaveworks/ignite/pkg/apis/ignite/v1alpha3.ImageStatus"), + }, + }, + }, + Required: []string{"TypeMeta", "metadata", "spec", "status"}, + }, + }, + Dependencies: []string{ + "github.com/weaveworks/ignite/pkg/apis/ignite/v1alpha3.ImageSpec", "github.com/weaveworks/ignite/pkg/apis/ignite/v1alpha3.ImageStatus", "github.com/weaveworks/libgitops/pkg/runtime.ObjectMeta", "k8s.io/apimachinery/pkg/apis/meta/v1.TypeMeta"}, + } +} + +func schema_pkg_apis_ignite_v1alpha3_ImageSpec(ref common.ReferenceCallback) common.OpenAPIDefinition { + return common.OpenAPIDefinition{ + Schema: spec.Schema{ + SchemaProps: spec.SchemaProps{ + Description: "ImageSpec declares what the image contains", + Type: []string{"object"}, + Properties: map[string]spec.Schema{ + "oci": { + SchemaProps: spec.SchemaProps{ + Ref: ref("github.com/weaveworks/ignite/pkg/apis/meta/v1alpha1.OCIImageRef"), + }, + }, + }, + Required: []string{"oci"}, + }, + }, + Dependencies: []string{ + "github.com/weaveworks/ignite/pkg/apis/meta/v1alpha1.OCIImageRef"}, + } +} + +func schema_pkg_apis_ignite_v1alpha3_ImageStatus(ref common.ReferenceCallback) common.OpenAPIDefinition { + return common.OpenAPIDefinition{ + Schema: spec.Schema{ + SchemaProps: spec.SchemaProps{ + Description: "ImageStatus defines the status of the image", + Type: []string{"object"}, + Properties: map[string]spec.Schema{ + "ociSource": { + SchemaProps: spec.SchemaProps{ + Description: "OCISource contains the information about how this OCI image was imported", + Ref: ref("github.com/weaveworks/ignite/pkg/apis/ignite/v1alpha3.OCIImageSource"), + }, + }, + }, + Required: []string{"ociSource"}, + }, + }, + Dependencies: []string{ + "github.com/weaveworks/ignite/pkg/apis/ignite/v1alpha3.OCIImageSource"}, + } +} + +func schema_pkg_apis_ignite_v1alpha3_Kernel(ref common.ReferenceCallback) common.OpenAPIDefinition { + return common.OpenAPIDefinition{ + Schema: spec.Schema{ + SchemaProps: spec.SchemaProps{ + Description: "Kernel is a serializable object that caches information about imported kernels This file is stored in /var/lib/firecracker/kernels/{oci-image-digest}/metadata.json", + Type: []string{"object"}, + Properties: map[string]spec.Schema{ + "TypeMeta": { + SchemaProps: spec.SchemaProps{ + Ref: ref("k8s.io/apimachinery/pkg/apis/meta/v1.TypeMeta"), + }, + }, + "metadata": { + SchemaProps: spec.SchemaProps{ + Description: "runtime.ObjectMeta is also embedded into the struct, and defines the human-readable name, and the machine-readable ID Name is available at the .metadata.name JSON path ID is available at the .metadata.uid JSON path (the Go type is k8s.io/apimachinery/pkg/types.UID, which is only a typed string)", + Ref: ref("github.com/weaveworks/libgitops/pkg/runtime.ObjectMeta"), + }, + }, + "spec": { + SchemaProps: spec.SchemaProps{ + Ref: ref("github.com/weaveworks/ignite/pkg/apis/ignite/v1alpha3.KernelSpec"), + }, + }, + "status": { + SchemaProps: spec.SchemaProps{ + Ref: ref("github.com/weaveworks/ignite/pkg/apis/ignite/v1alpha3.KernelStatus"), + }, + }, + }, + Required: []string{"TypeMeta", "metadata", "spec", "status"}, + }, + }, + Dependencies: []string{ + "github.com/weaveworks/ignite/pkg/apis/ignite/v1alpha3.KernelSpec", "github.com/weaveworks/ignite/pkg/apis/ignite/v1alpha3.KernelStatus", "github.com/weaveworks/libgitops/pkg/runtime.ObjectMeta", "k8s.io/apimachinery/pkg/apis/meta/v1.TypeMeta"}, + } +} + +func schema_pkg_apis_ignite_v1alpha3_KernelSpec(ref common.ReferenceCallback) common.OpenAPIDefinition { + return common.OpenAPIDefinition{ + Schema: spec.Schema{ + SchemaProps: spec.SchemaProps{ + Description: "KernelSpec describes the properties of a kernel", + Type: []string{"object"}, + Properties: map[string]spec.Schema{ + "oci": { + SchemaProps: spec.SchemaProps{ + Ref: ref("github.com/weaveworks/ignite/pkg/apis/meta/v1alpha1.OCIImageRef"), + }, + }, + }, + Required: []string{"oci"}, + }, + }, + Dependencies: []string{ + "github.com/weaveworks/ignite/pkg/apis/meta/v1alpha1.OCIImageRef"}, + } +} + +func schema_pkg_apis_ignite_v1alpha3_KernelStatus(ref common.ReferenceCallback) common.OpenAPIDefinition { + return common.OpenAPIDefinition{ + Schema: spec.Schema{ + SchemaProps: spec.SchemaProps{ + Description: "KernelStatus describes the status of a kernel", + Type: []string{"object"}, + Properties: map[string]spec.Schema{ + "version": { + SchemaProps: spec.SchemaProps{ + Type: []string{"string"}, + Format: "", + }, + }, + "ociSource": { + SchemaProps: spec.SchemaProps{ + Ref: ref("github.com/weaveworks/ignite/pkg/apis/ignite/v1alpha3.OCIImageSource"), + }, + }, + }, + Required: []string{"version", "ociSource"}, + }, + }, + Dependencies: []string{ + "github.com/weaveworks/ignite/pkg/apis/ignite/v1alpha3.OCIImageSource"}, + } +} + +func schema_pkg_apis_ignite_v1alpha3_OCIImageSource(ref common.ReferenceCallback) common.OpenAPIDefinition { + return common.OpenAPIDefinition{ + Schema: spec.Schema{ + SchemaProps: spec.SchemaProps{ + Description: "OCIImageSource specifies how the OCI image was imported. It is the status variant of OCIImageClaim", + Type: []string{"object"}, + Properties: map[string]spec.Schema{ + "id": { + SchemaProps: spec.SchemaProps{ + Description: "ID defines the source's content ID (e.g. the canonical OCI path or Docker image ID)", + Ref: ref("github.com/weaveworks/ignite/pkg/apis/meta/v1alpha1.OCIContentID"), + }, + }, + "size": { + SchemaProps: spec.SchemaProps{ + Description: "Size defines the size of the source in bytes", + Ref: ref("github.com/weaveworks/ignite/pkg/apis/meta/v1alpha1.Size"), + }, + }, + }, + Required: []string{"id", "size"}, + }, + }, + Dependencies: []string{ + "github.com/weaveworks/ignite/pkg/apis/meta/v1alpha1.OCIContentID", "github.com/weaveworks/ignite/pkg/apis/meta/v1alpha1.Size"}, + } +} + +func schema_pkg_apis_ignite_v1alpha3_Pool(ref common.ReferenceCallback) common.OpenAPIDefinition { + return common.OpenAPIDefinition{ + Schema: spec.Schema{ + SchemaProps: spec.SchemaProps{ + Description: "Pool defines device mapper pool database This file is managed by the snapshotter part of Ignite, and the file (existing as a singleton) is present at /var/lib/firecracker/snapshotter/pool.json", + Type: []string{"object"}, + Properties: map[string]spec.Schema{ + "TypeMeta": { + SchemaProps: spec.SchemaProps{ + Ref: ref("k8s.io/apimachinery/pkg/apis/meta/v1.TypeMeta"), + }, + }, + "spec": { + SchemaProps: spec.SchemaProps{ + Ref: ref("github.com/weaveworks/ignite/pkg/apis/ignite/v1alpha3.PoolSpec"), + }, + }, + "status": { + SchemaProps: spec.SchemaProps{ + Ref: ref("github.com/weaveworks/ignite/pkg/apis/ignite/v1alpha3.PoolStatus"), + }, + }, + }, + Required: []string{"TypeMeta", "spec", "status"}, + }, + }, + Dependencies: []string{ + "github.com/weaveworks/ignite/pkg/apis/ignite/v1alpha3.PoolSpec", "github.com/weaveworks/ignite/pkg/apis/ignite/v1alpha3.PoolStatus", "k8s.io/apimachinery/pkg/apis/meta/v1.TypeMeta"}, + } +} + +func schema_pkg_apis_ignite_v1alpha3_PoolDevice(ref common.ReferenceCallback) common.OpenAPIDefinition { + return common.OpenAPIDefinition{ + Schema: spec.Schema{ + SchemaProps: spec.SchemaProps{ + Description: "PoolDevice defines one device in the pool", + Type: []string{"object"}, + Properties: map[string]spec.Schema{ + "size": { + SchemaProps: spec.SchemaProps{ + Ref: ref("github.com/weaveworks/ignite/pkg/apis/meta/v1alpha1.Size"), + }, + }, + "parent": { + SchemaProps: spec.SchemaProps{ + Ref: ref("github.com/weaveworks/ignite/pkg/apis/meta/v1alpha1.DMID"), + }, + }, + "type": { + SchemaProps: spec.SchemaProps{ + Description: "Type specifies the type of the contents of the device", + Type: []string{"string"}, + Format: "", + }, + }, + "metadataPath": { + SchemaProps: spec.SchemaProps{ + Description: "MetadataPath points to the JSON/YAML file with metadata about this device This is most often of the format /var/lib/firecracker/{type}/{id}/metadata.json", + Type: []string{"string"}, + Format: "", + }, + }, + }, + Required: []string{"size", "parent", "type", "metadataPath"}, + }, + }, + Dependencies: []string{ + "github.com/weaveworks/ignite/pkg/apis/meta/v1alpha1.DMID", "github.com/weaveworks/ignite/pkg/apis/meta/v1alpha1.Size"}, + } +} + +func schema_pkg_apis_ignite_v1alpha3_PoolSpec(ref common.ReferenceCallback) common.OpenAPIDefinition { + return common.OpenAPIDefinition{ + Schema: spec.Schema{ + SchemaProps: spec.SchemaProps{ + Description: "PoolSpec defines the Pool's specification", + Type: []string{"object"}, + Properties: map[string]spec.Schema{ + "metadataSize": { + SchemaProps: spec.SchemaProps{ + Description: "MetadataSize specifies the size of the pool's metadata", + Ref: ref("github.com/weaveworks/ignite/pkg/apis/meta/v1alpha1.Size"), + }, + }, + "dataSize": { + SchemaProps: spec.SchemaProps{ + Description: "DataSize specifies the size of the pool's data", + Ref: ref("github.com/weaveworks/ignite/pkg/apis/meta/v1alpha1.Size"), + }, + }, + "allocationSize": { + SchemaProps: spec.SchemaProps{ + Description: "AllocationSize specifies the smallest size that can be allocated at a time", + Ref: ref("github.com/weaveworks/ignite/pkg/apis/meta/v1alpha1.Size"), + }, + }, + "metadataPath": { + SchemaProps: spec.SchemaProps{ + Description: "MetadataPath points to the file where device mapper stores all metadata information Defaults to constants.SNAPSHOTTER_METADATA_PATH", + Type: []string{"string"}, + Format: "", + }, + }, + "dataPath": { + SchemaProps: spec.SchemaProps{ + Description: "DataPath points to the backing physical device or sparse file (to be loop mounted) for the pool Defaults to constants.SNAPSHOTTER_DATA_PATH", + Type: []string{"string"}, + Format: "", + }, + }, + }, + Required: []string{"metadataSize", "dataSize", "allocationSize", "metadataPath", "dataPath"}, + }, + }, + Dependencies: []string{ + "github.com/weaveworks/ignite/pkg/apis/meta/v1alpha1.Size"}, + } +} + +func schema_pkg_apis_ignite_v1alpha3_PoolStatus(ref common.ReferenceCallback) common.OpenAPIDefinition { + return common.OpenAPIDefinition{ + Schema: spec.Schema{ + SchemaProps: spec.SchemaProps{ + Description: "PoolStatus defines the Pool's current status", + Type: []string{"object"}, + Properties: map[string]spec.Schema{ + "devices": { + SchemaProps: spec.SchemaProps{ + Description: "The Devices array needs to contain pointers to accommodate \"holes\" in the mapping Where devices have been deleted, the pointer is nil", + Type: []string{"array"}, + Items: &spec.SchemaOrArray{ + Schema: &spec.Schema{ + SchemaProps: spec.SchemaProps{ + Ref: ref("github.com/weaveworks/ignite/pkg/apis/ignite/v1alpha3.PoolDevice"), + }, + }, + }, + }, + }, + }, + Required: []string{"devices"}, + }, + }, + Dependencies: []string{ + "github.com/weaveworks/ignite/pkg/apis/ignite/v1alpha3.PoolDevice"}, + } +} + +func schema_pkg_apis_ignite_v1alpha3_Runtime(ref common.ReferenceCallback) common.OpenAPIDefinition { + return common.OpenAPIDefinition{ + Schema: spec.Schema{ + SchemaProps: spec.SchemaProps{ + Description: "Runtime specifies the VM's runtime information", + Type: []string{"object"}, + Properties: map[string]spec.Schema{ + "id": { + SchemaProps: spec.SchemaProps{ + Type: []string{"string"}, + Format: "", + }, + }, + }, + Required: []string{"id"}, + }, + }, + } +} + +func schema_pkg_apis_ignite_v1alpha3_SSH(ref common.ReferenceCallback) common.OpenAPIDefinition { + return common.OpenAPIDefinition{ + Schema: spec.Schema{ + SchemaProps: spec.SchemaProps{ + Description: "SSH specifies different ways to connect via SSH to the VM SSH uses a custom marshaller/unmarshaller. If generate is true, it marshals to true (a JSON bool). If PublicKey is set, it marshals to that string.", + Type: []string{"object"}, + }, + }, + } +} + +func schema_pkg_apis_ignite_v1alpha3_VM(ref common.ReferenceCallback) common.OpenAPIDefinition { + return common.OpenAPIDefinition{ + Schema: spec.Schema{ + SchemaProps: spec.SchemaProps{ + Description: "VM represents a virtual machine run by Firecracker These files are stored in /var/lib/firecracker/vm/{vm-id}/metadata.json", + Type: []string{"object"}, + Properties: map[string]spec.Schema{ + "TypeMeta": { + SchemaProps: spec.SchemaProps{ + Ref: ref("k8s.io/apimachinery/pkg/apis/meta/v1.TypeMeta"), + }, + }, + "metadata": { + SchemaProps: spec.SchemaProps{ + Description: "runtime.ObjectMeta is also embedded into the struct, and defines the human-readable name, and the machine-readable ID Name is available at the .metadata.name JSON path ID is available at the .metadata.uid JSON path (the Go type is k8s.io/apimachinery/pkg/types.UID, which is only a typed string)", + Ref: ref("github.com/weaveworks/libgitops/pkg/runtime.ObjectMeta"), + }, + }, + "spec": { + SchemaProps: spec.SchemaProps{ + Ref: ref("github.com/weaveworks/ignite/pkg/apis/ignite/v1alpha3.VMSpec"), + }, + }, + "status": { + SchemaProps: spec.SchemaProps{ + Ref: ref("github.com/weaveworks/ignite/pkg/apis/ignite/v1alpha3.VMStatus"), + }, + }, + }, + Required: []string{"TypeMeta", "metadata", "spec", "status"}, + }, + }, + Dependencies: []string{ + "github.com/weaveworks/ignite/pkg/apis/ignite/v1alpha3.VMSpec", "github.com/weaveworks/ignite/pkg/apis/ignite/v1alpha3.VMStatus", "github.com/weaveworks/libgitops/pkg/runtime.ObjectMeta", "k8s.io/apimachinery/pkg/apis/meta/v1.TypeMeta"}, + } +} + +func schema_pkg_apis_ignite_v1alpha3_VMImageSpec(ref common.ReferenceCallback) common.OpenAPIDefinition { + return common.OpenAPIDefinition{ + Schema: spec.Schema{ + SchemaProps: spec.SchemaProps{ + Type: []string{"object"}, + Properties: map[string]spec.Schema{ + "oci": { + SchemaProps: spec.SchemaProps{ + Ref: ref("github.com/weaveworks/ignite/pkg/apis/meta/v1alpha1.OCIImageRef"), + }, + }, + }, + Required: []string{"oci"}, + }, + }, + Dependencies: []string{ + "github.com/weaveworks/ignite/pkg/apis/meta/v1alpha1.OCIImageRef"}, + } +} + +func schema_pkg_apis_ignite_v1alpha3_VMKernelSpec(ref common.ReferenceCallback) common.OpenAPIDefinition { + return common.OpenAPIDefinition{ + Schema: spec.Schema{ + SchemaProps: spec.SchemaProps{ + Type: []string{"object"}, + Properties: map[string]spec.Schema{ + "oci": { + SchemaProps: spec.SchemaProps{ + Ref: ref("github.com/weaveworks/ignite/pkg/apis/meta/v1alpha1.OCIImageRef"), + }, + }, + "cmdLine": { + SchemaProps: spec.SchemaProps{ + Type: []string{"string"}, + Format: "", + }, + }, + }, + Required: []string{"oci"}, + }, + }, + Dependencies: []string{ + "github.com/weaveworks/ignite/pkg/apis/meta/v1alpha1.OCIImageRef"}, + } +} + +func schema_pkg_apis_ignite_v1alpha3_VMNetworkSpec(ref common.ReferenceCallback) common.OpenAPIDefinition { + return common.OpenAPIDefinition{ + Schema: spec.Schema{ + SchemaProps: spec.SchemaProps{ + Type: []string{"object"}, + Properties: map[string]spec.Schema{ + "ports": { + SchemaProps: spec.SchemaProps{ + Type: []string{"array"}, + Items: &spec.SchemaOrArray{ + Schema: &spec.Schema{ + SchemaProps: spec.SchemaProps{ + Ref: ref("github.com/weaveworks/ignite/pkg/apis/meta/v1alpha1.PortMapping"), + }, + }, + }, + }, + }, + }, + }, + }, + Dependencies: []string{ + "github.com/weaveworks/ignite/pkg/apis/meta/v1alpha1.PortMapping"}, + } +} + +func schema_pkg_apis_ignite_v1alpha3_VMSandboxSpec(ref common.ReferenceCallback) common.OpenAPIDefinition { + return common.OpenAPIDefinition{ + Schema: spec.Schema{ + SchemaProps: spec.SchemaProps{ + Description: "VMSandboxSpec is the spec of the sandbox used for the VM.", + Type: []string{"object"}, + Properties: map[string]spec.Schema{ + "oci": { + SchemaProps: spec.SchemaProps{ + Ref: ref("github.com/weaveworks/ignite/pkg/apis/meta/v1alpha1.OCIImageRef"), + }, + }, + }, + Required: []string{"oci"}, + }, + }, + Dependencies: []string{ + "github.com/weaveworks/ignite/pkg/apis/meta/v1alpha1.OCIImageRef"}, + } +} + +func schema_pkg_apis_ignite_v1alpha3_VMSpec(ref common.ReferenceCallback) common.OpenAPIDefinition { + return common.OpenAPIDefinition{ + Schema: spec.Schema{ + SchemaProps: spec.SchemaProps{ + Description: "VMSpec describes the configuration of a VM", + Type: []string{"object"}, + Properties: map[string]spec.Schema{ + "image": { + SchemaProps: spec.SchemaProps{ + Ref: ref("github.com/weaveworks/ignite/pkg/apis/ignite/v1alpha3.VMImageSpec"), + }, + }, + "sandbox": { + SchemaProps: spec.SchemaProps{ + Ref: ref("github.com/weaveworks/ignite/pkg/apis/ignite/v1alpha3.VMSandboxSpec"), + }, + }, + "kernel": { + SchemaProps: spec.SchemaProps{ + Ref: ref("github.com/weaveworks/ignite/pkg/apis/ignite/v1alpha3.VMKernelSpec"), + }, + }, + "cpus": { + SchemaProps: spec.SchemaProps{ + Type: []string{"integer"}, + Format: "int64", + }, + }, + "memory": { + SchemaProps: spec.SchemaProps{ + Ref: ref("github.com/weaveworks/ignite/pkg/apis/meta/v1alpha1.Size"), + }, + }, + "diskSize": { + SchemaProps: spec.SchemaProps{ + Ref: ref("github.com/weaveworks/ignite/pkg/apis/meta/v1alpha1.Size"), + }, + }, + "network": { + SchemaProps: spec.SchemaProps{ + Description: "Currently both will show in the JSON output as empty arrays. Making them pointers requires plenty of nil checks (as their contents are accessed directly) and is very risky for stability. APIMachinery potentially has a solution.", + Ref: ref("github.com/weaveworks/ignite/pkg/apis/ignite/v1alpha3.VMNetworkSpec"), + }, + }, + "storage": { + SchemaProps: spec.SchemaProps{ + Ref: ref("github.com/weaveworks/ignite/pkg/apis/ignite/v1alpha3.VMStorageSpec"), + }, + }, + "copyFiles": { + SchemaProps: spec.SchemaProps{ + Description: "This will be done at either \"ignite start\" or \"ignite create\" time", + Type: []string{"array"}, + Items: &spec.SchemaOrArray{ + Schema: &spec.Schema{ + SchemaProps: spec.SchemaProps{ + Ref: ref("github.com/weaveworks/ignite/pkg/apis/ignite/v1alpha3.FileMapping"), + }, + }, + }, + }, + }, + "ssh": { + SchemaProps: spec.SchemaProps{ + Description: "SSH specifies how the SSH setup should be done nil here means \"don't do anything special\" If SSH.Generate is set, Ignite will generate a new SSH key and copy it in to authorized_keys in the VM Specifying a path in SSH.Generate means \"use this public key\" If SSH.PublicKey is set, this struct will marshal as a string using that path If SSH.Generate is set, this struct will marshal as a bool => true", + Ref: ref("github.com/weaveworks/ignite/pkg/apis/ignite/v1alpha3.SSH"), + }, + }, + }, + Required: []string{"image", "sandbox", "kernel", "cpus", "memory", "diskSize"}, + }, + }, + Dependencies: []string{ + "github.com/weaveworks/ignite/pkg/apis/ignite/v1alpha3.FileMapping", "github.com/weaveworks/ignite/pkg/apis/ignite/v1alpha3.SSH", "github.com/weaveworks/ignite/pkg/apis/ignite/v1alpha3.VMImageSpec", "github.com/weaveworks/ignite/pkg/apis/ignite/v1alpha3.VMKernelSpec", "github.com/weaveworks/ignite/pkg/apis/ignite/v1alpha3.VMNetworkSpec", "github.com/weaveworks/ignite/pkg/apis/ignite/v1alpha3.VMSandboxSpec", "github.com/weaveworks/ignite/pkg/apis/ignite/v1alpha3.VMStorageSpec", "github.com/weaveworks/ignite/pkg/apis/meta/v1alpha1.Size"}, + } +} + +func schema_pkg_apis_ignite_v1alpha3_VMStatus(ref common.ReferenceCallback) common.OpenAPIDefinition { + return common.OpenAPIDefinition{ + Schema: spec.Schema{ + SchemaProps: spec.SchemaProps{ + Description: "VMStatus defines the status of a VM", + Type: []string{"object"}, + Properties: map[string]spec.Schema{ + "running": { + SchemaProps: spec.SchemaProps{ + Type: []string{"boolean"}, + Format: "", + }, + }, + "runtime": { + SchemaProps: spec.SchemaProps{ + Ref: ref("github.com/weaveworks/ignite/pkg/apis/ignite/v1alpha3.Runtime"), + }, + }, + "startTime": { + SchemaProps: spec.SchemaProps{ + Ref: ref("github.com/weaveworks/libgitops/pkg/runtime.Time"), + }, + }, + "ipAddresses": { + SchemaProps: spec.SchemaProps{ + Type: []string{"array"}, + Items: &spec.SchemaOrArray{ + Schema: &spec.Schema{ + SchemaProps: spec.SchemaProps{ + Type: []string{"string"}, + Format: "byte", + }, + }, + }, + }, + }, + "image": { + SchemaProps: spec.SchemaProps{ + Ref: ref("github.com/weaveworks/ignite/pkg/apis/ignite/v1alpha3.OCIImageSource"), + }, + }, + "kernel": { + SchemaProps: spec.SchemaProps{ + Ref: ref("github.com/weaveworks/ignite/pkg/apis/ignite/v1alpha3.OCIImageSource"), + }, + }, + }, + Required: []string{"running", "image", "kernel"}, + }, + }, + Dependencies: []string{ + "github.com/weaveworks/ignite/pkg/apis/ignite/v1alpha3.OCIImageSource", "github.com/weaveworks/ignite/pkg/apis/ignite/v1alpha3.Runtime", "github.com/weaveworks/libgitops/pkg/runtime.Time"}, + } +} + +func schema_pkg_apis_ignite_v1alpha3_VMStorageSpec(ref common.ReferenceCallback) common.OpenAPIDefinition { + return common.OpenAPIDefinition{ + Schema: spec.Schema{ + SchemaProps: spec.SchemaProps{ + Description: "VMStorageSpec defines the VM's Volumes and VolumeMounts", + Type: []string{"object"}, + Properties: map[string]spec.Schema{ + "volumes": { + SchemaProps: spec.SchemaProps{ + Type: []string{"array"}, + Items: &spec.SchemaOrArray{ + Schema: &spec.Schema{ + SchemaProps: spec.SchemaProps{ + Ref: ref("github.com/weaveworks/ignite/pkg/apis/ignite/v1alpha3.Volume"), + }, + }, + }, + }, + }, + "volumeMounts": { + SchemaProps: spec.SchemaProps{ + Type: []string{"array"}, + Items: &spec.SchemaOrArray{ + Schema: &spec.Schema{ + SchemaProps: spec.SchemaProps{ + Ref: ref("github.com/weaveworks/ignite/pkg/apis/ignite/v1alpha3.VolumeMount"), + }, + }, + }, + }, + }, + }, + }, + }, + Dependencies: []string{ + "github.com/weaveworks/ignite/pkg/apis/ignite/v1alpha3.Volume", "github.com/weaveworks/ignite/pkg/apis/ignite/v1alpha3.VolumeMount"}, + } +} + +func schema_pkg_apis_ignite_v1alpha3_Volume(ref common.ReferenceCallback) common.OpenAPIDefinition { + return common.OpenAPIDefinition{ + Schema: spec.Schema{ + SchemaProps: spec.SchemaProps{ + Description: "Volume defines named storage volume", + Type: []string{"object"}, + Properties: map[string]spec.Schema{ + "name": { + SchemaProps: spec.SchemaProps{ + Type: []string{"string"}, + Format: "", + }, + }, + "blockDevice": { + SchemaProps: spec.SchemaProps{ + Ref: ref("github.com/weaveworks/ignite/pkg/apis/ignite/v1alpha3.BlockDeviceVolume"), + }, + }, + }, + Required: []string{"name"}, + }, + }, + Dependencies: []string{ + "github.com/weaveworks/ignite/pkg/apis/ignite/v1alpha3.BlockDeviceVolume"}, + } +} + +func schema_pkg_apis_ignite_v1alpha3_VolumeMount(ref common.ReferenceCallback) common.OpenAPIDefinition { + return common.OpenAPIDefinition{ + Schema: spec.Schema{ + SchemaProps: spec.SchemaProps{ + Description: "VolumeMount defines the mount point for a named volume inside a VM", + Type: []string{"object"}, + Properties: map[string]spec.Schema{ + "name": { + SchemaProps: spec.SchemaProps{ + Type: []string{"string"}, + Format: "", + }, + }, + "mountPath": { + SchemaProps: spec.SchemaProps{ + Type: []string{"string"}, + Format: "", + }, + }, + }, + Required: []string{"name", "mountPath"}, + }, + }, + } +} + func schema_pkg_apis_meta_v1alpha1_DMID(ref common.ReferenceCallback) common.OpenAPIDefinition { return common.OpenAPIDefinition{ Schema: spec.Schema{ diff --git a/pkg/openapi/violations.txt b/pkg/openapi/violations.txt index 54ab47793..fa5578e6a 100644 --- a/pkg/openapi/violations.txt +++ b/pkg/openapi/violations.txt @@ -2,7 +2,12 @@ API rule violation: list_type_missing,github.com/weaveworks/ignite/pkg/apis/igni API rule violation: list_type_missing,github.com/weaveworks/ignite/pkg/apis/ignite/v1alpha2,VMSpec,CopyFiles API rule violation: list_type_missing,github.com/weaveworks/ignite/pkg/apis/ignite/v1alpha2,VMStorageSpec,VolumeMounts API rule violation: list_type_missing,github.com/weaveworks/ignite/pkg/apis/ignite/v1alpha2,VMStorageSpec,Volumes +API rule violation: list_type_missing,github.com/weaveworks/ignite/pkg/apis/ignite/v1alpha3,PoolStatus,Devices +API rule violation: list_type_missing,github.com/weaveworks/ignite/pkg/apis/ignite/v1alpha3,VMSpec,CopyFiles +API rule violation: list_type_missing,github.com/weaveworks/ignite/pkg/apis/ignite/v1alpha3,VMStorageSpec,VolumeMounts +API rule violation: list_type_missing,github.com/weaveworks/ignite/pkg/apis/ignite/v1alpha3,VMStorageSpec,Volumes API rule violation: names_match,github.com/weaveworks/ignite/pkg/apis/ignite/v1alpha2,VMSpec,CPUs +API rule violation: names_match,github.com/weaveworks/ignite/pkg/apis/ignite/v1alpha3,VMSpec,CPUs API rule violation: names_match,github.com/weaveworks/ignite/pkg/apis/meta/v1alpha1,DMID,index API rule violation: names_match,github.com/weaveworks/ignite/pkg/apis/meta/v1alpha1,OCIContentID,digest API rule violation: names_match,github.com/weaveworks/ignite/pkg/apis/meta/v1alpha1,OCIContentID,repoName diff --git a/vendor/modules.txt b/vendor/modules.txt index d912de932..e44c53afa 100644 --- a/vendor/modules.txt +++ b/vendor/modules.txt @@ -613,7 +613,7 @@ k8s.io/apimachinery/third_party/forked/golang/json k8s.io/apimachinery/third_party/forked/golang/reflect # k8s.io/klog v1.0.0 k8s.io/klog -# k8s.io/kube-openapi v0.0.0-20200427153329-656914f816f9 => k8s.io/kube-openapi v0.0.0-20200121204235-bf4fb3bd569c +# k8s.io/kube-openapi v0.0.0-20200615155156-dffdd1682719 => k8s.io/kube-openapi v0.0.0-20200121204235-bf4fb3bd569c ## explicit k8s.io/kube-openapi/pkg/common k8s.io/kube-openapi/pkg/util/proto