Python utils.xpath_get_text函数代码示例

    def test_ip_xml(self):
        """
        Test network ip xml
        """
        dhcp_range = {"start": "192.168.122.100", "end": "192.168.122.254"}
        params = {}

        dhcp = nxml._get_dhcp_elem(**params)
        self.assertEquals(None, dhcp)

        params["net"] = "192.168.122.0/255.255.255.0"
        params["dhcp"] = {'range': dhcp_range}
        xml = ET.tostring(nxml._get_ip_elem(**params))
        start = xpath_get_text(xml, "/ip/dhcp/range/@start")[0]
        end = xpath_get_text(xml, "/ip/dhcp/range/@end")[0]
        self.assertEquals(dhcp_range['start'], start)
        self.assertEquals(dhcp_range['end'], end)

        address = xpath_get_text(xml, "/ip/@address")[0]
        netmask = xpath_get_text(xml, "/ip/@netmask")[0]
        self.assertEquals(address, params["net"].split("/")[0])
        self.assertEquals(netmask, params["net"].split("/")[1])

        # test _get_ip_xml can accepts strings: '192.168.122.0/24',
        # which is same as "192.168.122.0/255.255.255.0"
        params["net"] = "192.168.122.0/24"
        xml = ET.tostring(nxml._get_ip_elem(**params))
        netmask = xpath_get_text(xml, "/ip/@netmask")[0]
        self.assertEquals(netmask,
                          str(ipaddr.IPNetwork(params["net"]).netmask))

    def test_dhcp_xml(self):
        """
        Test network dhcp xml
        """
        dhcp_range = {'start': '192.168.122.100', 'end': '192.168.122.254'}
        host1 = {
            'mac': '00:16:3e:77:e2:ed',
            'name': 'foo.example.com',
            'ip': '192.168.122.10',
        }
        host2 = {
            'mac': '00:16:3e:3e:a9:1a',
            'name': 'bar.example.com',
            'ip': '192.168.122.11',
        }
        params = {}

        dhcp = nxml._get_dhcp_elem(**params)
        self.assertEqual(None, dhcp)

        params['range'] = dhcp_range
        xml = ET.tostring(nxml._get_dhcp_elem(**params))
        start = xpath_get_text(xml, '/dhcp/range/@start')
        end = xpath_get_text(xml, '/dhcp/range/@end')
        self.assertEqual(dhcp_range['start'], start[0])
        self.assertEqual(dhcp_range['end'], end[0])

        params['hosts'] = [host1, host2]
        xml = ET.tostring(nxml._get_dhcp_elem(**params))
        ip = xpath_get_text(xml, '/dhcp/host/@ip')
        self.assertEqual(ip, [host1['ip'], host2['ip']])

    def test_ip_xml(self):
        """
        Test network ip xml
        """
        dhcp_range = {'start': '192.168.122.100', 'end': '192.168.122.254'}
        params = {}

        dhcp = nxml._get_dhcp_elem(**params)
        self.assertEqual(None, dhcp)

        params['net'] = '192.168.122.0/255.255.255.0'
        params['dhcp'] = {'range': dhcp_range}
        xml = ET.tostring(nxml._get_ip_elem(**params))
        start = xpath_get_text(xml, '/ip/dhcp/range/@start')[0]
        end = xpath_get_text(xml, '/ip/dhcp/range/@end')[0]
        self.assertEqual(dhcp_range['start'], start)
        self.assertEqual(dhcp_range['end'], end)

        address = xpath_get_text(xml, '/ip/@address')[0]
        netmask = xpath_get_text(xml, '/ip/@netmask')[0]
        self.assertEqual(address, params['net'].split('/')[0])
        self.assertEqual(netmask, params['net'].split('/')[1])

        # test _get_ip_xml can accepts strings: '192.168.122.0/24',
        # which is same as "192.168.122.0/255.255.255.0"
        params['net'] = '192.168.122.0/24'
        xml = ET.tostring(nxml._get_ip_elem(**params))
        netmask = xpath_get_text(xml, '/ip/@netmask')[0]
        self.assertEqual(netmask, str(ipaddr.IPNetwork(params['net']).netmask))

    def test_dhcp_xml(self):
        """
        Test network dhcp xml
        """
        dhcp_range = {"start": "192.168.122.100", "end": "192.168.122.254"}
        host1 = {"mac": "00:16:3e:77:e2:ed",
                 "name": "foo.example.com",
                 "ip": "192.168.122.10"}
        host2 = {"mac": "00:16:3e:3e:a9:1a",
                 "name": "bar.example.com",
                 "ip": "192.168.122.11"}
        params = {}

        dhcp = nxml._get_dhcp_elem(**params)
        self.assertEquals(None, dhcp)

        params["range"] = dhcp_range
        xml = ET.tostring(nxml._get_dhcp_elem(**params))
        start = xpath_get_text(xml, "/dhcp/range/@start")
        end = xpath_get_text(xml, "/dhcp/range/@end")
        self.assertEquals(dhcp_range['start'], start[0])
        self.assertEquals(dhcp_range['end'], end[0])

        params["hosts"] = [host1, host2]
        xml = ET.tostring(nxml._get_dhcp_elem(**params))
        ip = xpath_get_text(xml, "/dhcp/host/@ip")
        self.assertEquals(ip, [host1['ip'], host2['ip']])

    def get_network_from_xml(xml):
        address = xpath_get_text(xml, "/network/ip/@address")
        address = address and address[0] or ""
        netmask = xpath_get_text(xml, "/network/ip/@netmask")
        netmask = netmask and netmask[0] or ""
        net = address and netmask and "/".join([address, netmask]) or ""

        dhcp_start = xpath_get_text(xml, "/network/ip/dhcp/range/@start")
        dhcp_start = dhcp_start and dhcp_start[0] or ""
        dhcp_end = xpath_get_text(xml, "/network/ip/dhcp/range/@end")
        dhcp_end = dhcp_end and dhcp_end[0] or ""
        dhcp = {"start": dhcp_start, "end": dhcp_end}

        forward_mode = xpath_get_text(xml, "/network/forward/@mode")
        forward_mode = forward_mode and forward_mode[0] or ""
        forward_if = xpath_get_text(xml, "/network/forward/interface/@dev")
        forward_pf = xpath_get_text(xml, "/network/forward/pf/@dev")
        bridge = xpath_get_text(xml, "/network/bridge/@name")
        bridge = bridge and bridge[0] or ""
        return {
            "subnet": net,
            "dhcp": dhcp,
            "bridge": bridge,
            "forward": {"mode": forward_mode, "interface": forward_if, "pf": forward_pf},
        }

    def test_to_xml(self):
        graphics = {'type': 'spice', 'listen': '127.0.0.1'}
        vm_uuid = str(uuid.uuid4()).replace('-', '')
        t = VMTemplate({'name': 'test-template', 'cdrom': self.iso})
        xml = t.to_vm_xml('test-vm', vm_uuid, graphics=graphics)
        self.assertEquals(vm_uuid, xpath_get_text(xml, "/domain/uuid")[0])
        self.assertEquals('test-vm', xpath_get_text(xml, "/domain/name")[0])
        expr = "/domain/devices/graphics/@type"
        self.assertEquals(graphics['type'], xpath_get_text(xml, expr)[0])
        expr = "/domain/devices/graphics/@listen"
        self.assertEquals(graphics['listen'], xpath_get_text(xml, expr)[0])
        expr = "/domain/maxMemory/@slots"
        self.assertEquals('3', xpath_get_text(xml, expr)[0])
        expr = "/domain/maxMemory"
        self.assertEquals(str((1024 * 4) << 10), xpath_get_text(xml, expr)[0])

        if hasattr(psutil, 'virtual_memory'):
            host_memory = psutil.virtual_memory().total >> 10
        else:
            host_memory = psutil.TOTAL_PHYMEM >> 10
        t = VMTemplate({'name': 'test-template', 'cdrom': self.iso,
                        'memory': (host_memory >> 10) - 512})
        xml = t.to_vm_xml('test-vm', vm_uuid, graphics=graphics)
        expr = "/domain/maxMemory"
        self.assertEquals(str(host_memory), xpath_get_text(xml, expr)[0])
        expr = "/domain/maxMemory/@slots"
        self.assertEquals('1', xpath_get_text(xml, expr)[0])

    def get_network_from_xml(xml):
        address = xpath_get_text(xml, '/network/ip/@address')
        address = address and address[0] or ''
        netmask = xpath_get_text(xml, '/network/ip/@netmask')
        netmask = netmask and netmask[0] or ''
        net = address and netmask and '/'.join([address, netmask]) or ''

        dhcp_start = xpath_get_text(xml, '/network/ip/dhcp/range/@start')
        dhcp_start = dhcp_start and dhcp_start[0] or ''
        dhcp_end = xpath_get_text(xml, '/network/ip/dhcp/range/@end')
        dhcp_end = dhcp_end and dhcp_end[0] or ''
        dhcp = {'start': dhcp_start, 'end': dhcp_end}

        forward_mode = xpath_get_text(xml, '/network/forward/@mode')
        forward_mode = forward_mode and forward_mode[0] or ''
        forward_if = xpath_get_text(xml, '/network/forward/interface/@dev')
        forward_pf = xpath_get_text(xml, '/network/forward/pf/@dev')
        bridge = xpath_get_text(xml, '/network/bridge/@name')
        bridge = bridge and bridge[0] or ''
        return {
            'subnet': net,
            'dhcp': dhcp,
            'bridge': bridge,
            'forward': {
                'mode': forward_mode,
                'interface': forward_if,
                'pf': forward_pf,
            },
        }

    def lookup(self, name):
        pool = self.get_storagepool(name, self.conn)
        info = pool.info()
        autostart = True if pool.autostart() else False
        persistent = True if pool.isPersistent() else False
        xml = pool.XMLDesc(0)
        path = xpath_get_text(xml, '/pool/target/path')[0]
        pool_type = xpath_get_text(xml, '/pool/@type')[0]
        source = self._get_storage_source(pool_type, xml)
        # FIXME: nfs workaround - prevent any libvirt operation
        # for a nfs if the corresponding NFS server is down.
        if pool_type == 'netfs' and not self._nfs_status_online(pool):
            wok_log.debug(
                'NFS pool %s is offline, reason: NFS ' 'server %s is unreachable.',
                name,
                source['addr'],
            )
            # Mark state as '4' => inaccessible.
            info[0] = 4
            # skip calculating volumes
            nr_volumes = 0
        else:
            nr_volumes = self._get_storagepool_vols_num(pool)

        res = {
            'state': POOL_STATE_MAP[info[0]],
            'path': path,
            'source': source,
            'type': pool_type,
            'autostart': autostart,
            'capacity': info[1],
            'allocated': info[2],
            'available': info[3],
            'nr_volumes': nr_volumes,
            'persistent': persistent,
            'in_use': self._pool_used_by_template(name),
        }

        if not pool.isPersistent():
            # Deal with deep scan generated pool
            try:
                with self.objstore as session:
                    task_id = session.get('scanning', name)
                res['task_id'] = str(task_id)
                res['type'] = 'kimchi-iso'
            except NotFoundError:
                # User created normal pool
                pass
        return res

    def _get_vms_attach_to_storagepool(self, storagepool):
        conn = self.conn.get()

        # get storage pool path
        pool = self.get_storagepool(storagepool, self.conn)
        path = "".join(xpath_get_text(pool.XMLDesc(), "/pool/target/path"))

        # activate and deactive quickly to get volumes
        vms = []
        for dom in conn.listAllDomains(0):
            xml = dom.XMLDesc(0)
            files = "/domain/devices/disk[@device='disk']/source/@file"
            for file in xpath_get_text(xml, files):
                if file not in vms and file.startswith(path):
                    vms.append(dom.name())
        return vms

    def test_forward_xml(self):
        """
        Test network forward xml
        """
        params = {'mode': None}

        forward = nxml._get_forward_elem(**params)
        self.assertEqual(None, forward)

        params['mode'] = 'nat'
        params['dev'] = 'eth0'
        xml = ET.tostring(nxml._get_forward_elem(**params))
        mode = xpath_get_text(xml, '/forward/@mode')[0]
        dev = xpath_get_text(xml, '/forward/@dev')[0]
        self.assertEqual(params['mode'], mode)
        self.assertEqual(params['dev'], dev)

    def deactivate(self, name):
        if self._pool_used_by_template(name):
            raise InvalidOperation('KCHPOOL0034E', {'name': name})

        pool = self.get_storagepool(name, self.conn)
        # FIXME: nfs workaround - do not try to deactivate a NFS pool
        # if the NFS server is not reachable.
        xml = pool.XMLDesc(0)
        pool_type = xpath_get_text(xml, "/pool/@type")[0]
        if pool_type == 'netfs' and not self._nfs_status_online(pool):
            # block the user from dactivating the pool.
            source = self._get_storage_source(pool_type, xml)
            raise OperationFailed("KCHPOOL0033E",
                                  {'name': name, 'server': source['addr']})
            return
        try:
            persistent = pool.isPersistent()
            pool.destroy()
        except libvirt.libvirtError as e:
            raise OperationFailed("KCHPOOL0010E",
                                  {'name': name, 'err': e.get_error_message()})
        # If pool was not persistent, then it was erased by destroy() and
        # must return nothing here, to trigger _redirect() and avoid errors
        if not persistent:
            return ""

    def _get_storage_type(self, pool_uri=None):
        try:
            pool = self._get_storage_pool(pool_uri)

        except:
            return ''
        xml = pool.XMLDesc(0)
        return xpath_get_text(xml, "/pool/@type")[0]

 def test_mem_dev_slots(self):
     vm_uuid = str(uuid.uuid4()).replace('-', '')
     t = VMTemplate({'name': 'test-template', 'cdrom': self.iso,
                     'memory':  {'current': 2048, 'maxmemory': 3072}})
     xml = t.to_vm_xml('test-vm', vm_uuid)
     expr = "/domain/maxMemory/@slots"
     slots = str(MEM_DEV_SLOTS[os.uname()[4]])
     self.assertEquals(slots, xpath_get_text(xml, expr)[0])

        def _get_ipaddr_info(libvirt_interface_xml):
            search_ip = \
                xpath_get_text(libvirt_interface_xml,
                               "/interface/protocol[@family='ipv4']"
                               "/ip/@address")

            if not len(search_ip):
                return '', ''

            search_prefix = \
                xpath_get_text(libvirt_interface_xml,
                               "/interface/protocol[@family='ipv4']"
                               "/ip/@prefix")

            ip_obj = ipaddr.IPv4Network('%s/%s' % (search_ip[0],
                                                   search_prefix[0]))
            return str(ip_obj.ip), str(ip_obj.netmask)

 def test_to_xml(self):
     graphics = {'type': 'spice', 'listen': '127.0.0.1'}
     vm_uuid = str(uuid.uuid4()).replace('-', '')
     if os.uname()[4] in ['ppc', 'ppc64', 'ppc64le']:
         maxmem = 3328
     else:
         maxmem = 3072
     t = VMTemplate({'name': 'test-template', 'cdrom': self.iso,
                    'max_memory': maxmem << 10})
     xml = t.to_vm_xml('test-vm', vm_uuid, graphics=graphics)
     self.assertEquals(vm_uuid, xpath_get_text(xml, "/domain/uuid")[0])
     self.assertEquals('test-vm', xpath_get_text(xml, "/domain/name")[0])
     expr = "/domain/devices/graphics/@type"
     self.assertEquals(graphics['type'], xpath_get_text(xml, expr)[0])
     expr = "/domain/devices/graphics/@listen"
     self.assertEquals(graphics['listen'], xpath_get_text(xml, expr)[0])
     expr = "/domain/maxMemory/@slots"
     self.assertEquals('2', xpath_get_text(xml, expr)[0])