Python FeatureTests.is_nm_running方法代码示例

# 需要导入模块: from wok.plugins.kimchi.model.featuretests import FeatureTests [as 别名]
# 或者: from wok.plugins.kimchi.model.featuretests.FeatureTests import is_nm_running [as 别名]
    def lookup(self, *ident):
        if not is_libvirtd_up():
            return {
                'libvirt_stream_protocols': [],
                'qemu_spice': False,
                'qemu_stream': False,
                'screenshot': None,
                'kernel_vfio': self.kernel_vfio,
                'nm_running': FeatureTests.is_nm_running(),
                'mem_hotplug_support': False,
                'libvirtd_running': False,
            }
        elif not self.libvirtd_running:
            # Libvirt returned, run tests again
            self._set_capabilities()
            self._set_depend_capabilities()

        return {
            'libvirt_stream_protocols': self.libvirt_stream_protocols,
            'qemu_spice': self._qemu_support_spice(),
            'qemu_stream': self.qemu_stream,
            'screenshot': VMScreenshot.get_stream_test_result(),
            'kernel_vfio': self.kernel_vfio,
            'nm_running': FeatureTests.is_nm_running(),
            'mem_hotplug_support': self.mem_hotplug_support,
            'libvirtd_running': True,
        }

# 需要导入模块: from wok.plugins.kimchi.model.featuretests import FeatureTests [as 别名]
# 或者: from wok.plugins.kimchi.model.featuretests.FeatureTests import is_nm_running [as 别名]
    def lookup(self, *ident):
        if not is_libvirtd_up():
            return {
                "libvirt_stream_protocols": [],
                "qemu_spice": False,
                "qemu_stream": False,
                "screenshot": None,
                "kernel_vfio": self.kernel_vfio,
                "nm_running": FeatureTests.is_nm_running(),
                "mem_hotplug_support": False,
                "libvirtd_running": False,
            }
        elif self.libvirtd_running == False:
            # Libvirt returned, run tests again
            self._set_capabilities()
            self._set_depend_capabilities()

        return {
            "libvirt_stream_protocols": self.libvirt_stream_protocols,
            "qemu_spice": self._qemu_support_spice(),
            "qemu_stream": self.qemu_stream,
            "screenshot": VMScreenshot.get_stream_test_result(),
            "kernel_vfio": self.kernel_vfio,
            "nm_running": FeatureTests.is_nm_running(),
            "mem_hotplug_support": self.mem_hotplug_support,
            "libvirtd_running": True,
        }

# 需要导入模块: from wok.plugins.kimchi.model.featuretests import FeatureTests [as 别名]
# 或者: from wok.plugins.kimchi.model.featuretests.FeatureTests import is_nm_running [as 别名]
    def test_customized_network(self):
        # Create a template
        t = {'name': 'test', 'cdrom': '/tmp/mock.iso'}
        req = json.dumps(t)
        resp = self.request('/plugins/kimchi/templates', req, 'POST')
        self.assertEquals(201, resp.status)

        # Create networks to be used for testing
        networks = [{'name': u'kīмсhī-пet', 'connection': 'isolated'},
                    {'name': u'nat-network', 'connection': 'nat'},
                    {'name': u'subnet-network', 'connection': 'nat',
                     'subnet': '127.0.100.0/24'}]

        # Verify the current system has at least one interface to create a
        # bridged network
        interfaces = json.loads(
            self.request('/plugins/kimchi/interfaces?type=nic').read()
        )
        if len(interfaces) > 0:
            iface = interfaces[0]['name']
            networks.append({'name': u'bridge-network',
                             'connection': 'macvtap',
                             'interfaces': [iface]})
            if not FeatureTests.is_nm_running():
                networks.append({'name': u'bridge-network-with-vlan',
                                 'connection': 'bridge',
                                 'interfaces': [iface], 'vlan_id': 987})

        tmpl_nets = []
        for net in networks:
            self.request('/plugins/kimchi/networks', json.dumps(net), 'POST')
            tmpl_nets.append(net['name'])
            req = json.dumps({'networks': tmpl_nets})
            resp = self.request('/plugins/kimchi/templates/test', req, 'PUT')
            self.assertEquals(200, resp.status)

# 需要导入模块: from wok.plugins.kimchi.model.featuretests import FeatureTests [as 别名]
# 或者: from wok.plugins.kimchi.model.featuretests.FeatureTests import is_nm_running [as 别名]
 def _set_capabilities(self):
     wok_log.info("\n*** Kimchi: Running feature tests ***")
     self.libvirtd_running = is_libvirtd_up()
     msg = "Service Libvirtd running ...: %s"
     wok_log.info(msg % str(self.libvirtd_running))
     if self.libvirtd_running == False:
         wok_log.info("*** Kimchi: Feature tests not completed ***\n")
         return
     conn = self.conn.get()
     self.nfs_target_probe = FeatureTests.libvirt_support_nfs_probe(conn)
     msg = "NFS Target Probe support ...: %s"
     wok_log.info(msg % str(self.nfs_target_probe))
     self.fc_host_support = FeatureTests.libvirt_support_fc_host(conn)
     msg = "Fibre Channel Host support .: %s"
     wok_log.info(msg % str(self.fc_host_support))
     self.kernel_vfio = FeatureTests.kernel_support_vfio()
     msg = "Kernel VFIO support ........: %s"
     wok_log.info(msg % str(self.kernel_vfio))
     self.nm_running = FeatureTests.is_nm_running()
     msg = "Network Manager running ....: %s"
     wok_log.info(msg % str(self.nm_running))
     self.mem_hotplug_support = FeatureTests.has_mem_hotplug_support(conn)
     msg = "Memory Hotplug support .....: %s"
     wok_log.info(msg % str(self.mem_hotplug_support))
     wok_log.info("*** Kimchi: Feature tests completed ***\n")

# 需要导入模块: from wok.plugins.kimchi.model.featuretests import FeatureTests [as 别名]
# 或者: from wok.plugins.kimchi.model.featuretests.FeatureTests import is_nm_running [as 别名]
    def lookup(self, *ident):
        report_tool = DebugReportsModel.get_system_report_tool()
        try:
            SoftwareUpdate()
        except Exception:
            update_tool = False
        else:
            update_tool = True

        try:
            repo = Repositories()
        except Exception:
            repo_mngt_tool = None
        else:
            repo_mngt_tool = repo._pkg_mnger.TYPE

        return {'libvirt_stream_protocols': self.libvirt_stream_protocols,
                'qemu_spice': self._qemu_support_spice(),
                'qemu_stream': self.qemu_stream,
                'screenshot': VMScreenshot.get_stream_test_result(),
                'system_report_tool': bool(report_tool),
                'update_tool': update_tool,
                'repo_mngt_tool': repo_mngt_tool,
                'federation': kconfig.get("server", "federation"),
                'auth': kconfig.get("authentication", "method"),
                'kernel_vfio': self.kernel_vfio,
                'nm_running': FeatureTests.is_nm_running(),
                'mem_hotplug_support': self.mem_hotplug_support
                }

# 需要导入模块: from wok.plugins.kimchi.model.featuretests import FeatureTests [as 别名]
# 或者: from wok.plugins.kimchi.model.featuretests.FeatureTests import is_nm_running [as 别名]
    def _set_network_bridge(self, params):
        params['forward'] = {'mode': 'bridge'}

        # Bridges cannot be the trunk device of a VLAN
        iface = params['interfaces'][0]
        if 'vlan_id' in params and netinfo.is_bridge(iface):
            raise InvalidParameter('KCHNET0019E', {'name': iface})

        # User specified bridge interface, simply use it
        self._ensure_iface_up(iface)
        params['ovs'] = False
        if netinfo.is_bridge(iface):
            params['bridge'] = iface

            if netinfo.is_ovs_bridge(iface):
                params['ovs'] = True

        # connection == macvtap and iface is not bridge
        elif netinfo.is_bare_nic(iface) or netinfo.is_bonding(iface):
            # libvirt bridge creation will fail with NetworkManager enabled
            if FeatureTests.is_nm_running():
                raise InvalidParameter('KCHNET0027E')

            if 'vlan_id' in params:
                params['bridge'] = \
                    self._create_vlan_tagged_bridge(str(iface),
                                                    str(params['vlan_id']))
            else:
                # create Linux bridge interface and use it as actual iface
                iface = self._create_linux_bridge(iface)
                params['bridge'] = iface

        # unrecognized interface type: fail
        else:
            raise InvalidParameter("KCHNET0007E")

# 需要导入模块: from wok.plugins.kimchi.model.featuretests import FeatureTests [as 别名]
# 或者: from wok.plugins.kimchi.model.featuretests.FeatureTests import is_nm_running [as 别名]
 def lookup(self, *ident):
     return {'libvirt_stream_protocols': self.libvirt_stream_protocols,
             'qemu_spice': self._qemu_support_spice(),
             'qemu_stream': self.qemu_stream,
             'screenshot': VMScreenshot.get_stream_test_result(),
             'kernel_vfio': self.kernel_vfio,
             'nm_running': FeatureTests.is_nm_running(),
             'mem_hotplug_support': self.mem_hotplug_support}

# 需要导入模块: from wok.plugins.kimchi.model.featuretests import FeatureTests [as 别名]
# 或者: from wok.plugins.kimchi.model.featuretests.FeatureTests import is_nm_running [as 别名]
 def _set_capabilities(self):
     wok_log.info("*** Running feature tests ***")
     conn = self.conn.get()
     self.nfs_target_probe = FeatureTests.libvirt_support_nfs_probe(conn)
     self.fc_host_support = FeatureTests.libvirt_support_fc_host(conn)
     self.kernel_vfio = FeatureTests.kernel_support_vfio()
     self.nm_running = FeatureTests.is_nm_running()
     self.mem_hotplug_support = FeatureTests.has_mem_hotplug_support(conn)
     wok_log.info("*** Feature tests completed ***")

# 需要导入模块: from wok.plugins.kimchi.model.featuretests import FeatureTests [as 别名]
# 或者: from wok.plugins.kimchi.model.featuretests.FeatureTests import is_nm_running [as 别名]
 def lookup(self, *ident):
     return {
         "libvirt_stream_protocols": self.libvirt_stream_protocols,
         "qemu_spice": self._qemu_support_spice(),
         "qemu_stream": self.qemu_stream,
         "screenshot": VMScreenshot.get_stream_test_result(),
         "kernel_vfio": self.kernel_vfio,
         "nm_running": FeatureTests.is_nm_running(),
         "mem_hotplug_support": self.mem_hotplug_support,
     }

# 需要导入模块: from wok.plugins.kimchi.model.featuretests import FeatureTests [as 别名]
# 或者: from wok.plugins.kimchi.model.featuretests.FeatureTests import is_nm_running [as 别名]
 def lookup(self, *ident):
     return {'libvirt_stream_protocols': self.libvirt_stream_protocols,
             'qemu_spice': self._qemu_support_spice(),
             'qemu_stream': self.qemu_stream,
             'screenshot': VMScreenshot.get_stream_test_result(),
             'federation': kconfig.get("server", "federation"),
             'auth': kconfig.get("authentication", "method"),
             'kernel_vfio': self.kernel_vfio,
             'nm_running': FeatureTests.is_nm_running(),
             'mem_hotplug_support': self.mem_hotplug_support
             }

# 需要导入模块: from wok.plugins.kimchi.model.featuretests import FeatureTests [as 别名]
# 或者: from wok.plugins.kimchi.model.featuretests.FeatureTests import is_nm_running [as 别名]
    def _set_capabilities(self):
        wok_log.info("*** Running feature tests ***")
        conn = self.conn.get()
        self.qemu_stream = FeatureTests.qemu_supports_iso_stream()
        self.nfs_target_probe = FeatureTests.libvirt_support_nfs_probe(conn)
        self.fc_host_support = FeatureTests.libvirt_support_fc_host(conn)
        self.kernel_vfio = FeatureTests.kernel_support_vfio()
        self.nm_running = FeatureTests.is_nm_running()
        self.mem_hotplug_support = FeatureTests.has_mem_hotplug_support(conn)

        self.libvirt_stream_protocols = []
        for p in ['http', 'https', 'ftp', 'ftps', 'tftp']:
            if FeatureTests.libvirt_supports_iso_stream(conn, p):
                self.libvirt_stream_protocols.append(p)

        wok_log.info("*** Feature tests completed ***")

# 需要导入模块: from wok.plugins.kimchi.model.featuretests import FeatureTests [as 别名]
# 或者: from wok.plugins.kimchi.model.featuretests.FeatureTests import is_nm_running [as 别名]
def _set_capabilities(conn=False):
    debug("Running feature tests. This can take a while.", True)
    if not conn:
        return
    qemu_stream = FeatureTests.qemu_supports_iso_stream()
    nfs_target_probe = FeatureTests.libvirt_support_nfs_probe(conn)
    fc_host_support = FeatureTests.libvirt_support_fc_host(conn)
    kernel_vfio = FeatureTests.kernel_support_vfio()
    nm_running = FeatureTests.is_nm_running()
    mem_hotplug_support = FeatureTests.has_mem_hotplug_support(conn)

    libvirt_stream_protocols = []
    for p in ['http', 'https', 'ftp', 'ftps', 'tftp']:
        if FeatureTests.libvirt_supports_iso_stream(conn, p):
            libvirt_stream_protocols.append(p)
    debug("Feature tests completed.", True)

# 需要导入模块: from wok.plugins.kimchi.model.featuretests import FeatureTests [as 别名]
# 或者: from wok.plugins.kimchi.model.featuretests.FeatureTests import is_nm_running [as 别名]
 def _set_capabilities(self):
     wok_log.info('\n*** Kimchi: Running feature tests ***')
     self.libvirtd_running = is_libvirtd_up()
     wok_log.info(f'Service Libvirtd running ...: {self.libvirtd_running}')
     if not self.libvirtd_running:
         wok_log.info('*** Kimchi: Feature tests not completed ***\n')
         return
     conn = self.conn.get()
     self.nfs_target_probe = FeatureTests.libvirt_support_nfs_probe(conn)
     wok_log.info(f'NFS Target Probe support ...: {self.nfs_target_probe}')
     self.fc_host_support = FeatureTests.libvirt_support_fc_host(conn)
     wok_log.info(f'Fibre Channel Host support .: {self.fc_host_support}')
     self.kernel_vfio = FeatureTests.kernel_support_vfio()
     wok_log.info(f'Kernel VFIO support ........: {self.kernel_vfio}')
     self.nm_running = FeatureTests.is_nm_running()
     wok_log.info(f'Network Manager running ....: {self.nm_running}')
     self.mem_hotplug_support = FeatureTests.has_mem_hotplug_support(conn)
     wok_log.info(
         f'Memory Hotplug support .....: {self.mem_hotplug_support}')
     wok_log.info('*** Kimchi: Feature tests completed ***\n')