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]))))