Os type

client_vm.go

@@ -228,6 +228,22 @@ type VMData interface {
 	InstanceTypeID() *InstanceTypeID
 	// VMType returns the VM type for the current VM.
 	VMType() VMType
+
+	// OS returns the operating system structure.
+	OS() VMOS
+}
+
+// VMOS is the structure describing the virtual machine operating system, if set.
+type VMOS interface {
+	Type() string
+}
+
+type vmOS struct {
+	t string
+}
+
+func (v vmOS) Type() string {
+	return v.t
 }
 
 // VMPlacementPolicy is the structure that holds the rules for VM migration to other hosts.
@@ -651,6 +667,9 @@ type OptionalVMParameters interface {
 
 	// VMType is the type of the VM created.
 	VMType() *VMType
+
+	// OS returns the operating system parameters, and true if the OS parameter has been set.
+	OS() (VMOSParameters, bool)
 }
 
 // BuildableVMParameters is a variant of OptionalVMParameters that can be changed using the supplied
@@ -715,6 +734,49 @@ type BuildableVMParameters interface {
 	WithVMType(vmType VMType) (BuildableVMParameters, error)
 	// MustWithVMType is identical to WithVMType, but panics instead of returning an error.
 	MustWithVMType(vmType VMType) BuildableVMParameters
+
+	// WithOS adds the operating system parameters to the VM creation.
+	WithOS(parameters VMOSParameters) BuildableVMParameters
+}
+
+// VMOSParameters contains the VM parameters pertaining to the operating system.
+type VMOSParameters interface {
+	// Type returns the type-string for the operating system.
+	Type() *string
+}
+
+// BuildableVMOSParameters is a buildable version of VMOSParameters.
+type BuildableVMOSParameters interface {
+	VMOSParameters
+
+	WithType(t string) (BuildableVMOSParameters, error)
+	MustWithType(t string) BuildableVMOSParameters
+}
+
+// NewVMOSParameters creates a new VMOSParameters structure.
+func NewVMOSParameters() BuildableVMOSParameters {
+	return &vmOSParameters{}
+}
+
+type vmOSParameters struct {
+	t *string
+}
+
+func (v *vmOSParameters) Type() *string {
+	return v.t
+}
+
+func (v *vmOSParameters) WithType(t string) (BuildableVMOSParameters, error) {
+	v.t = &t
+	return v, nil
+}
+
+func (v *vmOSParameters) MustWithType(t string) BuildableVMOSParameters {
+	builder, err := v.WithType(t)
+	if err != nil {
+		panic(err)
+	}
+	return builder
 }
 
 // VMType contains some preconfigured settings, such as the availability of remote desktop, for the VM.
@@ -1162,6 +1224,19 @@ type vmParams struct {
 	instanceTypeID *InstanceTypeID
 
 	vmType *VMType
+
+	os    VMOSParameters
+	osSet bool
+}
+
+func (v *vmParams) OS() (VMOSParameters, bool) {
+	return v.os, v.osSet
+}
+
+func (v *vmParams) WithOS(os VMOSParameters) BuildableVMParameters {
+	v.os = os
+	v.osSet = true
+	return v
 }
 
 func (v *vmParams) VMType() *VMType {
@@ -1409,6 +1484,11 @@ type vm struct {
 	memoryPolicy    *memoryPolicy
 	instanceTypeID  *InstanceTypeID
 	vmType          VMType
+	os              *vmOS
+}
+
+func (v *vm) OS() VMOS {
+	return v.os
 }
 
 func (v *vm) VMType() VMType {
@@ -1516,6 +1596,7 @@ func (v *vm) withName(name string) *vm {
 		v.memoryPolicy,
 		v.instanceTypeID,
 		v.vmType,
+		v.os,
 	}
 }
 
@@ -1540,6 +1621,7 @@ func (v *vm) withComment(comment string) *vm {
 		v.memoryPolicy,
 		v.instanceTypeID,
 		v.vmType,
+		v.os,
 	}
 }
 
@@ -1664,6 +1746,7 @@ func convertSDKVM(sdkObject *ovirtsdk.Vm, client Client) (VM, error) {
 		vmMemoryPolicyConverter,
 		vmInstanceTypeIDConverter,
 		vmTypeConverter,
+		vmOSConverter,
 	}
 	for _, converter := range vmConverters {
 		if err := converter(sdkObject, vmObject); err != nil {
@@ -1674,6 +1757,20 @@ func convertSDKVM(sdkObject *ovirtsdk.Vm, client Client) (VM, error) {
 	return vmObject, nil
 }
 
+func vmOSConverter(object *ovirtsdk.Vm, v *vm) error {
+	sdkOS, ok := object.Os()
+	if !ok {
+		return newFieldNotFound("vm", "os")
+	}
+	v.os = &vmOS{}
+	osType, ok := sdkOS.Type()
+	if !ok {
+		return newFieldNotFound("os on vm", "type")
+	}
+	v.os.t = osType
+	return nil
+}
+
 func vmTypeConverter(object *ovirtsdk.Vm, v *vm) error {
 	vmType, ok := object.Type()
 	if !ok {

client_vm_create.go

@@ -149,6 +149,7 @@ func createSDKVM(
 		vmBuilderMemoryPolicy,
 		vmInstanceTypeID,
 		vmTypeCreator,
+		vmOSCreator,
 	}
 
 	for _, part := range parts {
@@ -184,6 +185,16 @@ func createSDKVM(
 	return vm, nil
 }
 
+func vmOSCreator(params OptionalVMParameters, builder *ovirtsdk.VmBuilder) {
+	if os, ok := params.OS(); ok {
+		osBuilder := ovirtsdk.NewOperatingSystemBuilder()
+		if t := os.Type(); t != nil {
+			osBuilder.Type(*t)
+		}
+		builder.OsBuilder(osBuilder)
+	}
+}
+
 func vmTypeCreator(params OptionalVMParameters, builder *ovirtsdk.VmBuilder) {
 	if vmType := params.VMType(); vmType != nil {
 		builder.Type(ovirtsdk.VmType(*vmType))

client_vm_test.go

@@ -561,6 +561,21 @@ func TestPlacementPolicy(t *testing.T) {
 	}
 }
 
+func TestVMOSParameter(t *testing.T) {
+	helper := getHelper(t)
+
+	vm := assertCanCreateVM(
+		t,
+		helper,
+		fmt.Sprintf("%s-%s", t.Name(), helper.GenerateRandomID(5)),
+		ovirtclient.NewCreateVMParams().WithOS(ovirtclient.NewVMOSParameters().MustWithType("rhcos_x64")),
+	)
+	os := vm.OS()
+	if os.Type() != "rhcos_x64" {
+		t.Fatalf("Incorrect OS type (expected: %s, got: %s)", "rhcos_x64", os.Type())
+	}
+}
+
 func assertCanCreateVMFromTemplate(
 	t *testing.T,
 	helper ovirtclient.TestHelper,

mock_vm_create.go

@@ -82,10 +82,40 @@ func (m *mockClient) createVM(
 	if init == nil {
 		init = &initialization{}
 	}
+
+	vm := &vm{
+		m,
+		id,
+		name,
+		params.Comment(),
+		clusterID,
+		templateID,
+		VMStatusDown,
+		cpu,
+		m.createVMMemory(params),
+		nil,
+		params.HugePages(),
+		init,
+		nil,
+		m.createPlacementPolicy(params),
+		m.createVMMemoryPolicy(params),
+		params.InstanceTypeID(),
+		m.createVMType(params),
+		m.createVMOS(params),
+	}
+	m.vms[id] = vm
+	return vm
+}
+
+func (m *mockClient) createVMMemory(params OptionalVMParameters) int64 {
 	memory := int64(1073741824)
 	if params.Memory() != nil {
 		memory = *params.Memory()
 	}
+	return memory
+}
+
+func (m *mockClient) createVMMemoryPolicy(params OptionalVMParameters) *memoryPolicy {
 	var memPolicy *memoryPolicy
 	if memoryPolicyParams := params.MemoryPolicy(); memoryPolicyParams != nil {
 		var guaranteed *int64
@@ -96,41 +126,39 @@ func (m *mockClient) createVM(
 			guaranteed,
 		}
 	}
+	return memPolicy
+}
 
-	var pp *vmPlacementPolicy
-	if params.PlacementPolicy() != nil {
-		placementPolicyParams := *params.PlacementPolicy()
-		pp = &vmPlacementPolicy{
-			placementPolicyParams.Affinity(),
-			placementPolicyParams.HostIDs(),
+func (m *mockClient) createVMOS(params OptionalVMParameters) *vmOS {
+	os := &vmOS{
+		t: "other",
+	}
+	if osParams, ok := params.OS(); ok {
+		if osType := osParams.Type(); osType != nil {
+			os.t = *osType
 		}
 	}
+	return os
+}
+
+func (m *mockClient) createVMType(params OptionalVMParameters) VMType {
 	vmType := VMTypeServer
 	if paramVMType := params.VMType(); paramVMType != nil {
 		vmType = *paramVMType
 	}
+	return vmType
+}
 
-	vm := &vm{
-		m,
-		id,
-		name,
-		params.Comment(),
-		clusterID,
-		templateID,
-		VMStatusDown,
-		cpu,
-		memory,
-		nil,
-		params.HugePages(),
-		init,
-		nil,
-		pp,
-		memPolicy,
-		params.InstanceTypeID(),
-		vmType,
+func (m *mockClient) createPlacementPolicy(params OptionalVMParameters) *vmPlacementPolicy {
+	var pp *vmPlacementPolicy
+	if params.PlacementPolicy() != nil {
+		placementPolicyParams := *params.PlacementPolicy()
+		pp = &vmPlacementPolicy{
+			placementPolicyParams.Affinity(),
+			placementPolicyParams.HostIDs(),
+		}
 	}
-	m.vms[id] = vm
-	return vm
+	return pp
 }
 
 func (m *mockClient) attachVMDisksFromTemplate(tpl *template, vm *vm, params OptionalVMParameters) {