def set_boot_device(self, bootdevice):
if bootdevice == 'network':
self.server.update(vm=types.Vm(os=types.OperatingSystem(
boot=types.Boot(devices=[types.BootDevice.NETWORK]))))
else:
self.server.update(vm=types.Vm(os=types.OperatingSystem(
boot=types.Boot(devices=[types.BootDevice.HD]))))
self.log('Set boot device to', bootdevice)
def build_entity(self):
return otypes.Vm(
name=self._module.params['name'],
cluster=otypes.Cluster(name=self._module.params['cluster'])
if self._module.params['cluster'] else None,
template=otypes.Template(name=self._module.params['template'])
if self._module.params['template'] else None,
stateless=self._module.params['stateless'],
delete_protected=self._module.params['delete_protected'],
high_availability=otypes.HighAvailability(
enabled=self._module.params['high_availability'])
if self._module.params['high_availability'] is not None else None,
cpu=otypes.Cpu(topology=otypes.CpuTopology(
cores=self._module.params['cpu_cores'],
sockets=self._module.params['cpu_sockets'],
)) if (self._module.params['cpu_cores']
or self._module.params['cpu_sockets']) else None,
cpu_shares=self._module.params['cpu_shares'],
os=otypes.OperatingSystem(
type=self._module.params['operating_system'],
boot=otypes.Boot(devices=[
otypes.BootDevice(dev)
for dev in self._module.params['boot_devices']
], ) if self._module.params['boot_devices'] else None,
) if (self._module.params['operating_system']
or self._module.params['boot_devices']) else None,
type=otypes.VmType(self._module.params['type'])
if self._module.params['type'] else None,
memory=convert_to_bytes(self._module.params['memory'])
if self._module.params['memory'] else None,
memory_policy=otypes.MemoryPolicy(guaranteed=convert_to_bytes(
self._module.params['memory_guaranteed']), )
if self._module.params['memory_guaranteed'] else None,
)
def createVM(session):
""" Creates a virtual maschine """
print "\n\n=================[ CREATING VMS ]================="
try:
for vm in configFile['vms']:
hostname = vm['hostname']
cluster = vm['cluster']
template = vm['template']
memory = vm['memory']
vmService = session.system_service().vms_service()
vm = vmService.add(
types.Vm(
name=hostname,
memory = memory * 2**30,
cluster=types.Cluster(
name=cluster),
template=types.Template(
name=template),
os=types.OperatingSystem(
boot=types.Boot(
devices=[types.BootDevice.HD])),
)
)
print ("Created VM \"%s\" on cluster \"%s\" with template \"%s\"." % (hostname, cluster, template))
except Exception as e:
print str(e)
sys.exit(1)
def set_boot_device(self, task, device, persistent=False):
"""Set the boot device for a node.
:param task: a task from TaskManager.
:param device: ironic.common.boot_devices
:param persistent: This argument is ignored.
:raises: MissingParameterValue, if some required parameter(s) are
missing in the node's driver_info.
:raises: InvalidParameterValue, if some parameter(s) have invalid
value(s) in the node's driver_info.
"""
try:
boot_dev = IRONIC_TO_OVIRT_DEVICE_MAPPING[device]
except KeyError:
raise exception.InvalidParameterValue(
_("Invalid boot device %s specified.") % device)
driver_info = _parse_driver_info(task.node)
vm = _getvm(driver_info)
try:
boot = otypes.Boot(devices=[otypes.BootDevice(boot_dev)])
bootos = otypes.OperatingSystem(boot=boot)
vm.update(otypes.Vm(os=bootos))
except sdk.Error as e:
LOG.error(
"Setting boot device failed for node %(node_id)s "
"with error: %(error)s", {
'node_id': task.node.uuid,
'error': e
})
raise staging_exception.OVirtError(err=e)
def start_vm_with_pxe(api, options):
"""Add PXE Boot option to vm."""
search_name = "name=" + options['vm_name']
vms_service = api.system_service().vms_service()
vm = vms_service.list(search=search_name)[0]
vm_service = vms_service.vm_service(vm.id)
vm_service.start(vm=types.Vm(os=types.OperatingSystem(boot=types.Boot(
devices=[types.BootDevice.HD, types.BootDevice.NETWORK]))))
def boot_device(self, vmname, bootdevice):
if bootdevice == "network":
vm = self.find_vm(vmname)
vm_service = self.vms_service.vm_service(vm.id)
vm_service.update(vm=types.Vm(os=types.OperatingSystem(
boot=types.Boot(devices=[types.BootDevice.NETWORK]))))
if bootdevice == "hd":
vm = self.find_vm(vmname)
vm_service = self.vms_service.vm_service(vm.id)
vm_service.update(vm=types.Vm(os=types.OperatingSystem(
boot=types.Boot(devices=[types.BootDevice.HD]))))
if bootdevice == "optical":
vm = self.find_vm(vmname)
vm_service = self.vms_service.vm_service(vm.id)
vm_service.update(vm=types.Vm(os=types.OperatingSystem(
boot=types.Boot(devices=[types.BootDevice.CDROM]))))
return
def add_vm_blank(api):
# Get the vms service
vms_service=api.system_service().vms_service()
#Create VM from blank template
vm_memory=256*MB
vm=types.Vm(
name=VM0_NAME,
memory=vm_memory,
type=types.VmType.SERVER,
os=types.OperatingSystem(
type='other_linux',
boot=types.Boot(
devices=[types.BootDevice.HD, types.BootDevice.NETWORK]
),
),
high_availability=types.HighAvailability(
enabled=False
),
cluster=types.Cluster(
name=TEST_CLUSTER
),
template=types.Template(
name=TEMPLATE_BLANK
),
display=types.Display(
smartcard_enabled=True,
keyboard_layout='en-us',
file_transfer_enabled=True,
copy_paste_enabled=True
),
memory_policy=types.MemoryPolicy(
guaranteed=vm_memory//2
)
)
#Add this VM
vm=vms_service.add(vm)
#Check that VM was added
vm_service=vms_service.vm_service(vm.id)
testlib.assert_true_within_short(
lambda: vm_service.get().status == types.VmStatus.DOWN
)
#Add another VM
vm.id=None
vm.name=VM1_NAME
vm.initialization=None
vm=vms_service.add(vm)
#Check that the second VM was added
vm_service=vms_service.vm_service(vm.id)
testlib.assert_true_within_short(
lambda: vm_service.get().status == types.VmStatus.DOWN
)
def start_vm_with_cdrom(api, vm_id, isoname='ks.iso'):
"""Add CDROM and boot vm."""
vms_service = api.system_service().vms_service()
vm_service = vms_service.vm_service(vm_id)
cdroms_service = vm_service.cdroms_service()
cdrom = cdroms_service.list()[0]
cdrom_service = cdroms_service.cdrom_service(cdrom.id)
cdrom_service.update(
cdrom=types.Cdrom(file=types.File(id=isoname), ),
current=False,
)
vm_service.start(vm=types.Vm(os=types.OperatingSystem(boot=types.Boot(
devices=[types.BootDevice.HD, types.BootDevice.CDROM]))))
def build_entity(self):
template = self.__get_template_with_version()
return otypes.Vm(
name=self.param('name'),
cluster=otypes.Cluster(
name=self.param('cluster')) if self.param('cluster') else None,
template=otypes.Template(id=template.id, ) if template else None,
use_latest_template_version=self.param(
'use_latest_template_version'),
stateless=self.param('stateless')
or self.param('use_latest_template_version'),
delete_protected=self.param('delete_protected'),
high_availability=otypes.HighAvailability(
enabled=self.param('high_availability'))
if self.param('high_availability') is not None else None,
cpu=otypes.Cpu(topology=otypes.CpuTopology(
cores=self.param('cpu_cores'),
sockets=self.param('cpu_sockets'),
)) if
(self.param('cpu_cores') or self.param('cpu_sockets')) else None,
cpu_shares=self.param('cpu_shares'),
os=otypes.OperatingSystem(
type=self.param('operating_system'),
boot=otypes.Boot(devices=[
otypes.BootDevice(dev)
for dev in self.param('boot_devices')
], ) if self.param('boot_devices') else None,
) if (self.param('operating_system')
or self.param('boot_devices')) else None,
type=otypes.VmType(self.param('type'))
if self.param('type') else None,
memory=convert_to_bytes(self.param('memory'))
if self.param('memory') else None,
memory_policy=otypes.MemoryPolicy(guaranteed=convert_to_bytes(
self.param('memory_guaranteed')), )
if self.param('memory_guaranteed') else None,
instance_type=otypes.InstanceType(id=get_id_by_name(
self._connection.system_service().instance_types_service(),
self.param('instance_type'),
), ) if self.param('instance_type') else None,
description=self.param('description'),
comment=self.param('comment'),
time_zone=otypes.TimeZone(name=self.param('timezone'), )
if self.param('timezone') else None,
serial_number=otypes.SerialNumber(
policy=otypes.SerialNumberPolicy(self.param('serial_policy')),
value=self.param('serial_policy_value'),
) if (self.param('serial_policy') is not None
or self.param('serial_policy_value') is not None) else None,
)
def start_vm_with_cdrom(api, options):
"""Add CDROM and boot vm."""
search_name = "name=" + options['vm_name']
vms_service = api.system_service().vms_service()
vm = vms_service.list(search=search_name)[0]
vm_service = vms_service.vm_service(vm.id)
cdroms_service = vm_service.cdroms_service()
cdrom = cdroms_service.list()[0]
cdrom_service = cdroms_service.cdrom_service(cdrom.id)
cdrom_service.update(
cdrom=types.Cdrom(file=types.File(id=options['cdrom']), ),
current=False,
)
vm_service.start(vm=types.Vm(os=types.OperatingSystem(boot=types.Boot(
devices=[types.BootDevice.HD, types.BootDevice.CDROM]))))
def add_vm_blank(api):
engine = api.system_service()
vms = engine.vms_service()
new_vm = types.Vm(
os=types.OperatingSystem(
type='other_linux',
boot=types.Boot(devices=[types.BootDevice.NETWORK])
),
type=types.VmType.SERVER,
cluster=types.Cluster(name=TEST_CLUSTER),
template=types.Template(name=TEMPLATE_BLANK),
name=VM_NAME
)
new_vm = vms.add(new_vm)
vm_service = vms.vm_service(new_vm.id)
testlib.assert_true_within_short(
lambda: vm_service.get().status == types.VmStatus.DOWN
)
def startVMOverNetwork(session):
""" Starts created virtual machines via pxe"""
print "\n\n=================[ BOOTING VMS OVER NETWORK ]================="
for vm in configFile['vms']:
hostname = vm['hostname']
vmService = session.system_service().vms_service()
machine = vmService.list(search='name=%s' % str(hostname))[0]
startService = vmService.vm_service(machine.id)
startService.start(
vm=types.Vm(
os=types.OperatingSystem(
boot=types.Boot(
devices=[
types.BootDevice.NETWORK,
types.BootDevice.CDROM
]
)
)
)
)
print "Booting \"%s\"." % (hostname)
)
# Get the reference to the "vms" service:
vms_service = connection.system_service().vms_service()
# Find the virtual machine:
vm = vms_service.list(search='name=myvm')[0]
# Locate the service that manages the virtual machine, as that is where
# the action methods are defined:
vm_service = vms_service.vm_service(vm.id)
# Call the "start" method of the service to start it with
# additional properties in a run once configuration
vm_service.start(vm=types.Vm(os=types.OperatingSystem(boot=types.Boot(
devices=[types.BootDevice.NETWORK, types.BootDevice.CDROM]))))
# additional documentation about attributes and types that can be changed:
# https://your.rhv.host/ovirt-engine/api/model#types/vm
# https://your.rhv.host/ovirt-engine/api/model#types/operating_system
# https://your.rhv.host/ovirt-engine/api/model#types/boot
# https://your.rhv.host/ovirt-engine/api/model#types/boot_device
# Wait till the virtual machine is up:
while True:
time.sleep(5)
vm = vm_service.get()
if vm.status == types.VmStatus.UP:
break
# Close the connection to the server:
password=RHVMPass,
ca_file='/etc/pki/vdsm/certs/cacert.pem',
)
# Get the reference to the "vms" service:
vms_service = connection.system_service().vms_service()
vm = types.Vm()
vm.name = VMName
vm.comment = VMComment
vm.description = VMDescription
cpu = types.CpuTopology(cores=VMCores, sockets=VMSockets)
vm.cpu = types.Cpu(topology=cpu)
vm.cluster = types.Cluster(name=VMCluster)
vm.template = types.Template(name=VMTemplate)
vm.os = types.OperatingSystem(boot=types.Boot(devices=[types.BootDevice.HD]),
type='rhel_8x64')
#vm.instance_type = types.InstanceType(id="00000003-0003-0003-0003-0000000000be")
vm.memory = VMMemory
vm.time_zone = types.TimeZone(name='Asia/Tehran')
netlist = connection.system_service().operating_systems_service().list()
for host in netlist:
if host.name == 'rhel_8x64':
myos = host
print("%s (%s)" % (host.name, host.id))
vm.type = types.VmType.SERVER
vm.soundcard_enabled = False
provider = connection.system_service().external_host_providers_service().list(
)[0]
#vm.externalhostproviders = types.ExternalHostProvider(id='d78051b5-37c8-43bc-8eeb-04e49e59bf3')
#vm.memory_policy=types.MemoryPolicy( guaranteed=VMMemoryGuaranteed )
def build_entity(self):
return otypes.InstanceType(
id=self.param('id'),
name=self.param('name'),
console=(
otypes.Console(enabled=self.param('serial_console'))
) if self.param('serial_console') is not None else None,
usb=(
otypes.Usb(enabled=self.param('usb_support'))
) if self.param('usb_support') is not None else None,
high_availability=otypes.HighAvailability(
enabled=self.param('high_availability'),
priority=self.param('high_availability_priority'),
) if self.param('high_availability') is not None or self.param('high_availability_priority') else None,
cpu=otypes.Cpu(
topology=otypes.CpuTopology(
cores=self.param('cpu_cores'),
sockets=self.param('cpu_sockets'),
threads=self.param('cpu_threads'),
) if any((
self.param('cpu_cores'),
self.param('cpu_sockets'),
self.param('cpu_threads')
)) else None,
cpu_tune=otypes.CpuTune(
vcpu_pins=[
otypes.VcpuPin(vcpu=int(pin['vcpu']), cpu_set=str(pin['cpu'])) for pin in self.param('cpu_pinning')
],
) if self.param('cpu_pinning') else None,
mode=otypes.CpuMode(self.param('cpu_mode')) if self.param(
'cpu_mode') else None,
) if any((
self.param('cpu_cores'),
self.param('cpu_sockets'),
self.param('cpu_threads'),
self.param('cpu_mode'),
self.param('cpu_pinning')
)) else None,
os=otypes.OperatingSystem(
type=self.param('operating_system'),
boot=otypes.Boot(
devices=[
otypes.BootDevice(dev) for dev in self.param('boot_devices')
],
) if self.param('boot_devices') else None
),
rng_device=otypes.RngDevice(
source=otypes.RngSource(self.param('rng_device')),
rate=otypes.Rate(
bytes=self.param('rng_bytes'),
period=self.param('rng_period')
)
) if self.param('rng_device') else None,
memory=convert_to_bytes(
self.param('memory')
) if self.param('memory') else None,
virtio_scsi=otypes.VirtioScsi(
enabled=self.param('virtio_scsi')
) if self.param('virtio_scsi') else None,
memory_policy=otypes.MemoryPolicy(
guaranteed=convert_to_bytes(self.param('memory_guaranteed')),
ballooning=self.param('ballooning_enabled'),
max=convert_to_bytes(self.param('memory_max')),
) if any((
self.param('memory_guaranteed'),
self.param('ballooning_enabled') is not None,
self.param('memory_max')
)) else None,
description=self.param('description'),
placement_policy=otypes.VmPlacementPolicy(
affinity=otypes.VmAffinity(self.param('placement_policy')),
hosts=[
otypes.Host(name=self.param('host')),
] if self.param('host') else None,
) if self.param('placement_policy') else None,
soundcard_enabled=self.param('soundcard_enabled'),
display=otypes.Display(
smartcard_enabled=self.param('smartcard_enabled')
) if self.param('smartcard_enabled') is not None else None,
io=otypes.Io(
threads=self.param('io_threads'),
) if self.param('io_threads') is not None else None,
)
def create_vm(kwargs, call=None):
'''
Create VM based on YAML file (must include parameter @ filename = "path/to/file" @ )
- If C(cow) format is used, disk will by created as sparse, so space will be allocated for the volume as needed, also known as I(thin provision).
- If C(raw) format is used, disk storage will be allocated right away, also known as I(preallocated).
'''
assert "filename" in kwargs, "Can't find filename parameter in function call"
vm_info = parse_yaml(kwargs["filename"])
boot_devices = []
if "boot_first_device" in vm_info["common"]:
if vm_info["common"]["boot_first_device"].lower() in [
"hd", "network", "cdrom"
]:
if vm_info["common"]["boot_first_device"].lower() == "hd":
boot_devices.append(types.BootDevice.HD)
elif vm_info["common"]["boot_first_device"].lower() == "cdrom":
boot_devices.append(types.BootDevice.CDROM)
elif vm_info["common"]["boot_first_device"].lower() == "network":
boot_devices.append(types.BootDevice.NETWORK)
else:
boot_devices.append(None)
if "boot_second_device" in vm_info["common"]:
if vm_info["common"]["boot_second_device"].lower() in [
"hd", "network", "cdrom"
]:
if vm_info["common"]["boot_second_device"].lower() == "hd":
boot_devices.append(types.BootDevice.HD)
elif vm_info["common"]["boot_second_device"].lower() == "cdrom":
boot_devices.append(types.BootDevice.CDROM)
elif vm_info["common"]["boot_second_device"].lower() == "network":
boot_devices.append(types.BootDevice.NETWORK)
else:
boot_devices.append(None)
connection()
vms_service = connection.system_service().vms_service()
vms_service.add(
types.Vm(
name=vm_info["name"],
os=types.OperatingSystem(
type=vm_info["os_type"] if "os_type" in vm_info else "Other",
boot=types.Boot(devices=boot_devices)),
# type=vm_info["common"]["type"],
placement_policy=types.VmPlacementPolicy(
hosts=[types.Host(name=vm_info["common"]["host"])]),
cpu=types.Cpu(topology=types.CpuTopology(
cores=vm_info["CPU"]["cores"]
if "cores" in vm_info["CPU"] else 1,
sockets=vm_info["CPU"]["sockets"]
if "sockets" in vm_info["CPU"] else 1,
threads=vm_info["CPU"]["threads"]
if "threads" in vm_info["CPU"] else 1,
), ),
memory=1024 * 1024 * 1024 * int(vm_info["memory"]["memory"]),
memory_policy=types.MemoryPolicy(
guaranteed=1024 * 1024 * 1024 * vm_info["memory"]["guaranteed"]
if "guaranteed" in vm_info["memory"] else 512 * 1024 * 1024 *
int(vm_info["memory"]["memory"]),
ballooning=vm_info["memory"]["ballooning"]
if "ballooning" in vm_info["memory"] else True,
max=1024 * 1024 * 1024 * vm_info["memory"]["maximum"]
if "maximum" in vm_info["memory"] else 2048 * 1024 * 1024 *
int(vm_info["memory"]["memory"]),
),
cluster=types.Cluster(name=vm_info["common"]["cluster"], ),
template=types.Template(
name=vm_info["common"]["template"]
if "template" in vm_info["common"] else "Blank", ),
description=vm_info["common"]["description"]
if "description" in vm_info["common"] else "Not provided",
comment=vm_info["common"]["comment"]
if "comment" in vm_info["common"] else "Not provided",
soundcard_enabled=vm_info["common"]["soundcard_enabled"]
if "soundcard_enabled" in vm_info["common"] else False,
), )
if "disks" in vm_info:
for disk in vm_info["disks"]:
attach_disk(disk, vm_info["name"])
if "networks" in vm_info:
for network in vm_info["networks"]:
attach_network(network, vm_info["name"])
# Check according to salt:
if call != 'function':
raise SaltCloudSystemExit(
'The show_instance action must be called with -f or --function.')
connection.close()
return {'Created': '{0} was created.'.format(vm_info["name"])}
def start_vm_with_pxe(api, vm_id):
"""Add PXE Boot option to vm."""
vms_service = api.system_service().vms_service()
vm_service = vms_service.vm_service(vm_id)
vm_service.start(vm=types.Vm(os=types.OperatingSystem(boot=types.Boot(
devices=[types.BootDevice.HD, types.BootDevice.NETWORK]))))
