constants

Documentation

Index

• Constants
• Variables
• func E2ETestsName(name string) string
• func E2ETestsRandomName(name string) string
• func ToStringBoolean(value bool) string
• type CreateVMMode
• type EnvScope
• type ExecInVMMode
• type LibguestfsTaskType
• type TargetNamespace

Constants

const (
	CopyTemplateTaskName    = "copy-template"
	CopyTemplateTaskRunName = "taskrun-copy-template"
	NewTemplateName         = "test-template"

	SourceTemplateNameOptionName      = "sourceTemplateName"
	SourceTemplateNamespaceOptionName = "sourceTemplateNamespace"
	TargetTemplateNameOptionName      = "targetTemplateName"
	TargetTemplateNamespaceOptionName = "targetTemplateNamespace"
	AllowReplaceOptionName            = "allowReplace"
)

const (
	ModifyDataObjectTaskName    = "modify-data-object"
	ModifyDataObjectTaskrunName = "taskrun-modify-data-object"

	UnusualRestartCountThreshold = 3
	ReasonError                  = "Error"
)

const (
	ModifyTemplateTaskName    = "modify-vm-template"
	ModifyTemplateTaskRunName = "taskrun-modify-vm-template"

	TemplateNameOptionName             = "templateName"
	TemplateNamespaceOptionName        = "templateNamespace"
	CPUCoresOptionName                 = "cpuCores"
	CPUSocketsOptionName               = "cpuSockets"
	CPUThreadsOptionName               = "cpuThreads"
	MemoryOptionName                   = "memory"
	TemplateLabelsOptionName           = "templateLabels"
	TemplateAnnotationsOptionName      = "templateAnnotations"
	VMLabelsOptionName                 = "vmLabels"
	VMAnnotationsOptionName            = "vmAnnotations"
	DisksOptionName                    = "disks"
	VolumesOptionName                  = "volumes"
	DataVolumeTemplatesOptionName      = "datavolumeTemplates"
	DeleteDatavolumeTemplateOptionName = "deleteDatavolumeTemplate"
	DeleteDisksOptionName              = "deleteDisks"
	DeleteVolumesOptionName            = "deleteVolumes"
	DeleteTemplateParametersOptionName = "deleteTemplateParameters"
	DeleteTemplateOptionName           = "deleteTemplate"
	TemplateParametersOptionName       = "templateParameters"

	CPUSocketsTopologyNumber    uint32 = 1
	CPUCoresTopologyNumber      uint32 = 2
	CPUThreadsTopologyNumber    uint32 = 3
	CPUSocketsTopologyNumberStr        = "1"
	CPUCoresTopologyNumberStr          = "2"
	CPUThreadsTopologyNumberStr        = "3"

	MemoryValue = "180M"
)

const CleanupVMTaskName = "cleanup-vm"

const CreateVMFromManifestTaskName = "create-vm-from-manifest"

const CreateVMFromTemplateTaskName = "create-vm-from-template"

const DiskVirtCustomizeTaskName = "disk-virt-customize"

const DiskVirtSysprepTaskName = "disk-virt-sysprep"

const ExecuteInVMTaskName = "execute-in-vm"

const ExpectedGenerateSshKeysMessage = "The key fingerprint is"

const ExpectedSuccessfulVMCreation = "apiVersion: kubevirt.io/v1\nkind: VirtualMachine\n"

const (
	GenerateSshKeysTaskName = "generate-ssh-keys"
)

const (
	PollInterval = 1 * time.Second
)

const SpacesSmall = "  "

const (
	WaitForVMIStatusTaskName = "wait-for-vmi-status"
)

Variables

var (
	MockTemplateAnnotations = []string{"newKey: TemplateAnnotation", "testTemplateAnnotation: true"}
	MockTemplateLabels      = []string{"newKey: TemplateLabel", "testTemplateLabel: true"}
	MockVMAnnotations       = []string{"newKey: VMAnnotation", "testVMAnnotation: true"}
	MockVMLabels            = []string{"newKey: VMLabel", "testVMLabel: true"}
	WrongStrSlice           = []string{"wrong value"}
	MockDisk                = []string{"{\"name\": \"test\", \"cdrom\": {\"bus\": \"sata\"}}"}
	MockDisks               = []string{"{\"name\": \"test\", \"cdrom\": {\"bus\": \"sata\"}}", "{\"name\": \"containerdisk\", \"disk\": {\"bus\": \"sata\"}, \"bootOrder\": 2}"}
	MockVolume              = []string{"{\"name\": \"test3\"}"}
	MockVolumes             = []string{"{\"name\": \"containerdisk\", \"containerDisk\": {\"image\": \"URL\"}}", "{\"name\": \"cloudinitdisk\"}", "{\"name\": \"test3\"}"}
	MockDataVolumeTemplates = []string{"{\"apiVersion\": \"cdi.kubevirt.io/v1beta1\", \"kind\": \"DataVolume\", \"metadata\":{\"name\": \"test1\"}, \"spec\": {\"source\": {\"http\": {\"url\": \"test.somenonexisting\"}}}}"}
	MockTemplateParameter   = []string{"{\"name\": \"test\", \"value\": \"test\"}"}

	TemplateAnnotationsMap = map[string]string{
		"newKey":                 "TemplateAnnotation",
		"testTemplateAnnotation": "true",
	}
	TemplateLabelsMap = map[string]string{
		"newKey":            "TemplateLabel",
		"testTemplateLabel": "true",
	}
	VMAnnotationsMap = map[string]string{
		"newKey":           "VMAnnotation",
		"testVMAnnotation": "true",
	}
	VMLabelsMap = map[string]string{
		"newKey":      "VMLabel",
		"testVMLabel": "true",
	}
	Disks = []kubevirtv1.Disk{
		{
			Name: "containerdisk",
			DiskDevice: kubevirtv1.DiskDevice{
				Disk: &kubevirtv1.DiskTarget{
					Bus: "sata",
				},
			},
			BootOrder: &bootOrder,
		}, {
			Name: "cloudinitdisk",
			DiskDevice: kubevirtv1.DiskDevice{
				Disk: &kubevirtv1.DiskTarget{
					Bus: "virtio",
				},
			},
		}, {
			Name: "test",
			DiskDevice: kubevirtv1.DiskDevice{
				CDRom: &kubevirtv1.CDRomTarget{
					Bus: "sata",
				},
			},
		},
	}
	Disk = kubevirtv1.Disk{
		Name: "test",
		DiskDevice: kubevirtv1.DiskDevice{
			CDRom: &kubevirtv1.CDRomTarget{
				Bus: "sata",
			},
		},
	}
	Volume = kubevirtv1.Volume{
		Name: "test3",
	}

	Volumes = []kubevirtv1.Volume{
		{
			Name: "containerdisk",
			VolumeSource: kubevirtv1.VolumeSource{
				ContainerDisk: &kubevirtv1.ContainerDiskSource{
					Image: "URL",
				},
			},
		},
		{
			Name: "cloudinitdisk",
		},
		{
			Name: "test3",
		},
	}

	TemplateParameters = []templatev1.Parameter{
		{
			Name:  "test",
			Value: "test",
		},
	}

	DataVolumeTemplates = []kubevirtv1.DataVolumeTemplateSpec{
		{
			TypeMeta: metav1.TypeMeta{
				Kind:       "DataVolume",
				APIVersion: "cdi.kubevirt.io/v1beta1",
			},
			ObjectMeta: metav1.ObjectMeta{
				Name: "test1",
			},
			Spec: cdiv1.DataVolumeSpec{
				Source: &cdiv1.DataVolumeSource{
					HTTP: &cdiv1.DataVolumeSourceHTTP{
						URL: "test.somenonexisting",
					},
				},
			},
		},
	}
)

var CreateVMFromManifestParams = createVMFromManifestParams{
	Namespace: "namespace",
	Manifest:  "manifest",
	Virtctl:   "virtctl",
}

var CreateVMFromTemplateParams = createVMFromTemplateParams{
	TemplateName:      "templateName",
	TemplateNamespace: "templateNamespace",
	TemplateParams:    "templateParams",
	VmNamespace:       "vmNamespace",
	StartVM:           "startVM",
	RunStrategy:       "runStrategy",
}

var CreateVMResults = createVMResults{
	Name:      "name",
	Namespace: "namespace",
}

var DiskVirtLibguestfsTasksParams = diskVirtLibguestfsTasksParams{
	PVCName:           "pvc",
	CustomizeCommands: "customizeCommands",
	SysprepCommands:   "sysprepCommands",
	AdditionalOptions: "additionalOptions",
	Verbose:           "verbose",
}

var ExecuteOrCleanupVMParams = executeOrCleanupVMParams{
	VMName:      "vmName",
	VMNamespace: "vmNamespace",
	SecretName:  "secretName",
	Command:     "command",
	Args:        "args",
	Script:      "script",
	Stop:        "stop",
	Delete:      "delete",
	Timeout:     "timeout",
}

var GenerateSshKeysParams = generateSshKeysParams{
	PublicKeySecretName:         "publicKeySecretName",
	PublicKeySecretNamespace:    "publicKeySecretNamespace",
	PrivateKeySecretName:        "privateKeySecretName",
	PrivateKeySecretNamespace:   "privateKeySecretNamespace",
	PrivateKeyConnectionOptions: "privateKeyConnectionOptions",
	AdditionalSSHKeygenOptions:  "additionalSSHKeygenOptions",
}

var GenerateSshKeysResults = generateSshKeysResults{
	PublicKeySecretName:       "publicKeySecretName",
	PublicKeySecretNamespace:  "publicKeySecretNamespace",
	PrivateKeySecretName:      "privateKeySecretName",
	PrivateKeySecretNamespace: "privateKeySecretNamespace",
}

var ModifyDataObjectParams = modifyDataObjectParams{
	Manifest:            "manifest",
	WaitForSuccess:      "waitForSuccess",
	AllowReplace:        "allowReplace",
	DeleteObject:        "deleteObject",
	DeleteObjectName:    "deleteObjectName",
	DeleteObjectKind:    "deleteObjectKind",
	DataObjectNamespace: "namespace",
}

var ModifyDataObjectResults = modifyDataObjectResults{
	Name:      "name",
	Namespace: "namespace",
}

var PrivateKeyConnectionOptions = privateKeyConnectionOptions{
	Type:                             "type",
	User:                             "user",
	PrivateKey:                       "ssh-privatekey",
	HostPublicKey:                    "host-public-key",
	DisableStrictHostKeyCheckingAttr: "disable-strict-host-key-checking",
	AdditionalSSHOptionsAttr:         "additional-ssh-options",
}

var Timeouts = timeouts{
	Zero:                      &metav1.Duration{0 * time.Second},
	TaskRunExtraWaitDelay:     &metav1.Duration{5 * time.Minute},
	SmallDVCreation:           &metav1.Duration{15 * time.Minute},
	QuickTaskRun:              &metav1.Duration{5 * time.Minute},
	DefaultTaskRun:            &metav1.Duration{10 * time.Minute},
	WaitBeforeExecutingVM:     &metav1.Duration{30 * time.Second},
	WaitForVMStart:            &metav1.Duration{5 * time.Minute},
	PipelineRunExtraWaitDelay: &metav1.Duration{30 * time.Minute},
}

var WaitForVMIStatusTasksParams = waitForVMIStatusTasksParams{
	VMIName:          "vmiName",
	VMINamespace:     "vmiNamespace",
	SuccessCondition: "successCondition",
	FailureCondition: "failureCondition",
}

Functions

func E2ETestsName

func E2ETestsName(name string) string

func E2ETestsRandomName

func E2ETestsRandomName(name string) string

func ToStringBoolean

func ToStringBoolean(value bool) string

Types

type CreateVMMode

type CreateVMMode string

const (
	CreateVMTemplateMode   CreateVMMode = "CreateVMTemplateMode"
	CreateVMVMManifestMode CreateVMMode = "CreateVMVMManifestMode"
	CreateVMVirtctlMode    CreateVMMode = "CreateVMVirtctlMode"
)

type EnvScope

type EnvScope string

const (
	OKDEnvScope        EnvScope = "okd"
	KubernetesEnvScope EnvScope = "kubernetes"
)

type ExecInVMMode

type ExecInVMMode string

const (
	ExecuteInVMMode ExecInVMMode = "execute-in-vm"
	CleanupVMMode   ExecInVMMode = "cleanup-vm"
)

type LibguestfsTaskType

type LibguestfsTaskType string

const (
	VirtSysPrepTaskType   LibguestfsTaskType = "virt-sysprep"
	VirtCustomizeTaskType LibguestfsTaskType = "virt-customize"
)

type TargetNamespace

type TargetNamespace string

const (
	DeployTargetNS TargetNamespace = "deploy"
	SystemTargetNS TargetNamespace = "system"
	EmptyTargetNS  TargetNamespace = "empty"
)