def _update_unknown_device_info(vm): """ Obtain info about unknown devices from libvirt domain and update the corresponding device structures. Unknown device is a device that has an address but wasn't passed during VM creation request. :param vm: VM for which the device info should be updated :type vm: `class:Vm` instance """ def isKnownDevice(alias): for dev in vm.conf['devices']: if dev.get('alias') == alias: return True return False for x in vmxml.children(vm.domain.devices): # Ignore empty nodes and devices without address if vmxml.find_first(x, 'address', None) is None: continue alias = core.find_device_alias(x) if not isKnownDevice(alias): address = vmxml.device_address(x) # In general case we assume that device has attribute 'type', # if it hasn't dom_attribute returns ''. device = vmxml.attr(x, 'type') newDev = {'type': vmxml.tag(x), 'alias': alias, 'device': device, 'address': address} vm.conf['devices'].append(newDev)
def _update_unknown_device_info(vm): """ Obtain info about unknown devices from libvirt domain and update the corresponding device structures. Unknown device is a device that has an address but wasn't passed during VM creation request. :param vm: VM for which the device info should be updated :type vm: `class:Vm` instance """ def isKnownDevice(alias): for dev in vm.conf['devices']: if dev.get('alias') == alias: return True return False for x in vmxml.children(vm.domain.devices): # Ignore empty nodes and devices without address if vmxml.find_first(x, 'address', None) is None: continue alias = core.find_device_alias(x) if not isKnownDevice(alias): address = vmxml.device_address(x) # In general case we assume that device has attribute 'type', # if it hasn't dom_attribute returns ''. device = vmxml.attr(x, 'type') newDev = { 'type': vmxml.tag(x), 'alias': alias, 'device': device, 'address': address } vm.conf['devices'].append(newDev)
def dev_map_from_domain_xml(vmid, dom_desc, md_desc, log): """ Create a device map - same format as empty_dev_map from a domain XML representation. The domain XML is accessed through a Domain Descriptor. :param vmid: UUID of the vm whose devices need to be initialized. :type vmid: basestring :param dom_desc: domain descriptor to provide access to the domain XML :type dom_desc: `class DomainDescriptor` :param md_desc: metadata descriptor to provide access to the device metadata :type md_desc: `class metadata.Descriptor` :param log: logger instance to use for messages, and to pass to device objects. :type log: logger instance, as returned by logging.getLogger() :return: map of initialized devices, map of devices needing refresh. :rtype: A device map, in the same format as empty_dev_map() would return. """ dev_map = empty_dev_map() for dev_elem in vmxml.children(dom_desc.devices): try: dev_type, dev_class = identify_from_xml_elem(dev_elem) except core.SkipDevice: log.debug('skipping unhandled device: %r', dev_elem.tag) continue dev_meta = {'vmid': vmid} attrs = dev_class.get_identifying_attrs(dev_elem) if attrs: with md_desc.device(**attrs) as dev_data: dev_meta.update(dev_data) dev_obj = dev_class.from_xml_tree(log, dev_elem, dev_meta) dev_map[dev_type].append(dev_obj) return dev_map
def _device_elements(dom_desc, log): for dev_elem in vmxml.children(dom_desc.devices): try: dev_type, dev_class = identify_from_xml_elem(dev_elem) except core.SkipDevice: log.debug('skipping unhandled device: %r', dev_elem.tag) else: yield dev_type, dev_class, dev_elem
def _device_elements(dom_desc, log): for dev_elem in vmxml.children(dom_desc.devices): try: dev_type, dev_class = identify_from_xml_elem(dev_elem) except core.SkipDevice: pass else: yield dev_type, dev_class, dev_elem
def dev_elems_from_xml(vm, xml): """ Return device instance building elements from provided XML. The XML must contain <devices> element with a single device subelement, the one to create the instance for. Depending on the device kind <metadata> element may be required to provide device metadata; the element may and needn't contain unrelated metadata. This function is used in device hot(un)plugs. Example `xml` value (top element tag may be arbitrary): <?xml version='1.0' encoding='UTF-8'?> <hotplug> <devices> <interface type="bridge"> <mac address="66:55:44:33:22:11"/> <model type="virtio" /> <source bridge="ovirtmgmt" /> <filterref filter="vdsm-no-mac-spoofing" /> <link state="up" /> <bandwidth /> </interface> </devices> <metadata xmlns:ns0="http://ovirt.org/vm/tune/1.0" xmlns:ovirt-vm="http://ovirt.org/vm/1.0"> <ovirt-vm:vm xmlns:ovirt-vm="http://ovirt.org/vm/1.0"> <ovirt-vm:device mac_address='66:55:44:33:22:11'> <ovirt-vm:network>test</ovirt-vm:network> <ovirt-vm:portMirroring> <ovirt-vm:network>network1</ovirt-vm:network> <ovirt-vm:network>network2</ovirt-vm:network> </ovirt-vm:portMirroring> </ovirt-vm:device> </ovirt-vm:vm> </metadata> </hotplug> :param xml: XML specifying the device as described above. :type xml: basestring :returns: Triplet (device_class, device_element, device_meta) where `device_class` is the class to be used to create the device instance; `device_element` and `device_meta` are objects to be passed as arguments to device_class `from_xml_tree` method. """ dom = xmlutils.fromstring(xml) devices = vmxml.find_first(dom, 'devices') dev_elem = next(vmxml.children(devices)) _dev_type, dev_class = identify_from_xml_elem(dev_elem) meta = vmxml.find_first(dom, 'metadata', None) if meta is None: md_desc = metadata.Descriptor() else: md_desc = metadata.Descriptor.from_xml(xmlutils.tostring(meta)) dev_meta = _get_metadata_from_elem_xml(vm.id, md_desc, dev_class, dev_elem) return dev_class, dev_elem, dev_meta
def parse_volume_chain(self, disk_xml): """ Parses libvirt xml and extracts volume chain from it. Arguments: disk_xml (ElementTree): libvirt xml to parse Returns: list: VolumeChainEntry[] - List of chain entries where each entry contains volume UUID, volume path and volume index. For the 'top' volume index is None, as 'top' volume have no indices at all. VolumeChainEntry is reversed in relation to libvirt xml: xml is ordered from top to base volume, while volume chain is ordered from base to the top. Raises: InvalidBackingStoreIndex exception when index value is not int. """ volChain = [] index = None source_attr = SOURCE_ATTR[self.diskType] while True: path = vmxml.find_attr(disk_xml, 'source', source_attr) if not path: break if index is not None: try: index = int(index) except ValueError: raise InvalidBackingStoreIndex(path, index) # TODO: Allocation information is not available in the XML. Switch # to the new interface once it becomes available in libvirt. alloc = None backingstore = next(vmxml.children(disk_xml, 'backingStore'), None) if backingstore is None: self.log.warning( "<backingStore/> missing from backing " "chain for drive %s", self.name) break entry = VolumeChainEntry(self.volume_id(path), path, alloc, index) volChain.insert(0, entry) disk_xml = backingstore index = vmxml.attr(backingstore, 'index') return volChain or None
def collect_inner_elements(el, d): """ This helper method collects all nodes in el and adds them to dictionary d. :param el: XML DOM element object with text only children :param d: Dictionary to add the values to """ for chel in vmxml.children(el): try: d[vmxml.tag(chel)] = int(vmxml.text(chel)) except (IndexError, ValueError): log.exception("Invalid value for %s", vmxml.tag(chel))
def parse_volume_chain(self, disk_xml): """ Parses libvirt xml and extracts volume chain from it. Arguments: disk_xml (ElementTree): libvirt xml to parse Returns: list: VolumeChainEntry[] - List of chain entries where each entry contains volume UUID, volume path and volume index. For the 'top' volume index is None, as 'top' volume have no indices at all. VolumeChainEntry is reversed in relation to libvirt xml: xml is ordered from top to base volume, while volume chain is ordered from base to the top. Raises: InvalidBackingStoreIndex exception when index value is not int. """ volChain = [] index = None source_attr = SOURCE_ATTR[self.diskType] while True: path = vmxml.find_attr(disk_xml, 'source', source_attr) if not path: break if index is not None: try: index = int(index) except ValueError: raise InvalidBackingStoreIndex(path, index) # TODO: Allocation information is not available in the XML. Switch # to the new interface once it becomes available in libvirt. alloc = None backingstore = next(vmxml.children(disk_xml, 'backingStore'), None) if backingstore is None: self.log.warning("<backingStore/> missing from backing " "chain for drive %s", self.name) break entry = VolumeChainEntry(self.volume_id(path), path, alloc, index) volChain.insert(0, entry) disk_xml = backingstore index = vmxml.attr(backingstore, 'index') return volChain or None
def replace_devices_xml(domxml, devices_xml): devices = vmxml.find_first(domxml, 'devices', None) old_devs = [ dev for dev in vmxml.children(devices) if dev.tag in hwclass.TO_REFRESH ] for old_dev in old_devs: vmxml.remove_child(devices, old_dev) for dev_class in hwclass.TO_REFRESH: for dev in devices_xml[dev_class]: vmxml.append_child(devices, etree_child=dev) return domxml
def replace_device_xml_with_hooks_xml(dom, vm_id, vm_custom, md_desc=None): """ Process the before_device_create hook point. This means that some device XML snippet may be entirely replaced by the output of one hook. Hook are invoked only if a given device has custom properties. Please note that this explicitely required by the contract of the hook point, so we can't really do better than that. """ if md_desc is None: md_desc = metadata.Descriptor.from_tree(dom) # 'devices' MUST be present, so let's fail loudly if it isn't. devs = vmxml.find_first(dom, 'devices') to_remove = [] to_append = [] for dev_elem in vmxml.children(devs): if dev_elem.tag == vmdevices.hwclass.DISK: # disk devices need special processing, to be done separately continue try: dev_meta = vmdevices.common.dev_meta_from_elem( dev_elem, vm_id, md_desc) except vmdevices.core.SkipDevice: # metadata is optional, so it is ok to just skip devices # with no metadata attached. continue try: dev_custom = dev_meta['custom'] except KeyError: # custom properties are optional, and mostly used for # network devices. It is OK to just go ahead. continue hook_xml = hooks.before_device_create( xmlutils.tostring(dev_elem, pretty=True), vm_custom, dev_custom) to_remove.append(dev_elem) to_append.append(xmlutils.fromstring(hook_xml)) for dev_elem in to_remove: vmxml.remove_child(devs, dev_elem) for dev_elem in to_append: vmxml.append_child(devs, etree_child=dev_elem)
def get_bandwidth_xml(specParams, oldBandwidth=None): """Returns a valid libvirt xml dom element object.""" bandwidth = vmxml.Element('bandwidth') old = {} if oldBandwidth is None else dict( (vmxml.tag(elem), elem) for elem in vmxml.children(oldBandwidth)) for key in ('inbound', 'outbound'): elem = specParams.get(key) if elem is None: # Use the old setting if present if key in old: bandwidth.appendChild(etree_element=old[key]) elif elem: # Convert the values to string for adding them to the XML def attrs = dict((key, str(value)) for key, value in elem.items()) bandwidth.appendChildWithArgs(key, **attrs) return bandwidth
def replace_devices_xml(domxml, devices_xml): devices = vmxml.find_first(domxml, 'devices', None) refreshable = get_refreshable_device_classes() old_devs = [ dev for dev in vmxml.children(devices) if dev.tag in refreshable ] for old_dev in old_devs: vmxml.remove_child(devices, old_dev) for dev_class in refreshable: for dev in devices_xml[dev_class]: vmxml.append_child(devices, etree_child=dev) return domxml
def xml_device_by_alias(device_xml, alias): """ Return an XML device having the given alias. :param device_xml: parsed <devices> element, typically taken from DomainDescriptor.devices :type device_xml: DOM object :param alias: device alias :type alias: string :returns: DOM object of the device element having the given alias :raises: `LookupError` if no device with `alias` is found """ for dom in vmxml.children(device_xml): xml_alias = core.find_device_alias(dom) if xml_alias and xml_alias == alias: return dom raise LookupError("Unable to find matching XML for device %r" % (alias, ))
def update_disks_xml_from_objs(vm, dom, disk_devices): """ Perform host-local changes to the XML disk configuration. The XML may change because of the following: - the after_disk_prepare hook point (aka the localdisk hook) The hook may change: * diskType * path * format - Vdsm itself needs to prepare the images. Vdsm may change: * path Engine can sometimes predict the path, but Vdsm is in charge to set up the images locally, so it can (and should be expected to) change the image path. """ # 'devices' MUST be present, so let's fail loudly if it isn't. devs = vmxml.find_first(dom, 'devices') for dev_elem in vmxml.children(devs): if dev_elem.tag != vmdevices.hwclass.DISK: continue # we use the device name because # - `path` uniquely identifies a device, but it is expected to change # - `serial` uniquely identifies a device, but it is not available # for LUN devices # TODO: user-provided aliases are the best solution, we need to # switch to them. attrs = vmdevices.storage.Drive.get_identifying_attrs(dev_elem) if not attrs: vm.log.warning('could not identify drive: %s', xmlutils.tostring(dev_elem)) continue try: disk_obj = vmdevices.lookup.drive_by_name(disk_devices, attrs['name']) except LookupError: vm.log.warning('unknown drive %r, skipped', attrs['name']) continue vmdevices.storagexml.update_disk_element_from_object( dev_elem, disk_obj, vm.log, replace_attribs=True)
def update_sysinfo(dom, osname, osversion, hostserial): sys_info = vmxml.find_first(dom, 'sysinfo/system', None) if sys_info is None: # TODO: log? return replaceables = { 'product': ('OS-NAME:', osname), 'version': ('OS-VERSION:', osversion), 'serial': ('HOST-SERIAL:', hostserial), } for entry in vmxml.children(sys_info): name = entry.attrib.get('name', None) if name not in replaceables: continue placeholder, value = replaceables[name] if entry.text.startswith(placeholder): entry.text = value
def update_leases_xml_from_disk_objs(vm, dom, disk_devices): # 'devices' MUST be present, so let's fail loudly if it isn't. devs = vmxml.find_first(dom, 'devices') for dev_elem in vmxml.children(devs): if dev_elem.tag != vmdevices.hwclass.LEASE: continue params = vmdevices.lease.parse_xml(dev_elem, {}) if not params: vm.log.warning('could not parse lease: %s', xmlutils.tostring(dev_elem)) continue info = vmdevices.lease.find_drive_lease_info( params['sd_id'], params['lease_id'], disk_devices) if info is None: vm.log.debug('lease with not corresponding drive info, skipped') # must be a vm lease, let's skip it continue vmdevices.lease.update_lease_element_from_info( dev_elem, info, params, vm.log)
def replace_disks_xml(dom, disk_devices): """ Replace the XML snippet of all disk devices with fresh configuration obtained from Vdsm. Vdsm initializes its disk device objects from the XML. Vdsm also needs to do some per-host adjustments on the disk devices (e.g. prepare the paths), so we can't avoid this replacement. """ # 'devices' MUST be present, so let's fail loudly if it isn't. devs = vmxml.find_first(dom, 'devices') to_remove = [ dev_elem for dev_elem in vmxml.children(devs) if dev_elem.tag == vmdevices.hwclass.DISK ] for dev_elem in to_remove: vmxml.remove_child(devs, dev_elem) for dev in disk_devices: vmxml.append_child(devs, child=dev.getXML()) return dom
def test_children(self, start_tag, tag, number): element = vmxml.find_first(self._dom, start_tag) self.assertEqual(len(list(vmxml.children(element, tag))), number)
def update_device_info(cls, vm, device_conf): for x in vm.domain.get_device_elements('interface'): devType = vmxml.attr(x, 'type') mac = vmxml.find_attr(x, 'mac', 'address') alias = core.find_device_alias(x) xdrivers = vmxml.find_first(x, 'driver', None) driver = ({ 'name': vmxml.attr(xdrivers, 'name'), 'queues': vmxml.attr(xdrivers, 'queues') } if xdrivers is not None else {}) if devType == 'hostdev': name = alias model = 'passthrough' else: name = vmxml.find_attr(x, 'target', 'dev') model = vmxml.find_attr(x, 'model', 'type') network = None try: if vmxml.find_attr(x, 'link', 'state') == 'down': linkActive = False else: linkActive = True except IndexError: linkActive = True source = vmxml.find_first(x, 'source', None) if source is not None: network = vmxml.attr(source, 'bridge') if not network: network = libvirtnetwork.netname_l2o( vmxml.attr(source, 'network')) # Get nic address address = {} # TODO: fix vmxml.device_address and its users to have this code. for child in vmxml.children(x, 'address'): address = dict((k.strip(), v.strip()) for k, v in vmxml.attributes(child).items()) break for nic in device_conf: if nic.macAddr.lower() == mac.lower(): nic.name = name nic.alias = alias nic.address = address nic.linkActive = linkActive if driver: # If a driver was reported, pass it back to libvirt. # Engine (vm's conf) is not interested in this value. nic.driver = driver # Update vm's conf with address for known nic devices knownDev = False for dev in vm.conf['devices']: if (dev['type'] == hwclass.NIC and dev['macAddr'].lower() == mac.lower()): dev['address'] = address dev['alias'] = alias dev['name'] = name dev['linkActive'] = linkActive knownDev = True # Add unknown nic device to vm's conf if not knownDev: nicDev = { 'type': hwclass.NIC, 'device': devType, 'macAddr': mac, 'nicModel': model, 'address': address, 'alias': alias, 'name': name, 'linkActive': linkActive } if network: nicDev['network'] = network vm.conf['devices'].append(nicDev)