Python wok_log.debug函数代码示例

 def get_ipv4_info(self, info, cfgmap):
     wok_log.debug('Begin get_ipv4_info')
     if info.__len__() != 0 and cfgmap.__len__() != 0:
         info[IPV4_ID] = {}
         ipv4_info_keys = [BOOTPROTO, DEFROUTE, PEERROUTES, PEERDNS,
                           IPV4_FAILURE_FATAL]
         for key in ipv4_info_keys:
             if key in cfgmap:
                 info[IPV4_ID][key] = cfgmap[key]
         if BOOTPROTO in cfgmap and (info[IPV4_ID][BOOTPROTO] == MANUAL or
                                     info[IPV4_ID][BOOTPROTO] == STATIC):
             info[IPV4_ID][IPV4Addresses] = \
                 cfgInterfacesHelper.get_ipv4_addresses(cfgmap)
         dnsaddresses = cfgInterfacesHelper.get_dnsv4_info(cfgmap)
         if len(dnsaddresses) > 0:
             info[IPV4_ID][DNSAddresses] = dnsaddresses
         # construct routeinfo.
         if DEVICE in cfgmap:
             routes = self.get_routes_map(cfgmap[DEVICE], 4)
         elif NAME in cfgmap:
             routes = self.get_routes_map(cfgmap[NAME], 4)
         if len(routes) > 0:
             info[IPV4_ID][ROUTES] = routes
         # Fix ginger issue #110
         if len(info[IPV4_ID]) > 0:
             info[IPV4_ID][IPV4INIT] = CONST_YES
         else:
             info[IPV4_ID][IPV4INIT] = CONST_NO
     wok_log.debug('End get_ipv4_info')
     return info

 def get_ipv6_info(self, info, cfgmap):
     wok_log.debug('Begin get_ipv6_info')
     if info.__len__() != 0 and cfgmap.__len__() != 0:
         info[IPV6_ID] = {}
         ipv6_info_keys = [IPV6INIT, IPV6_AUTOCONF, IPV6_DEFROUTE,
                           IPV6_PEERDNS, IPV6_PEERROUTES,
                           IPV6_FAILURE_FATAL, DHCPV6C,
                           IPV6_DEFAULTGW, IPV6_PRIVACY]
         for key in ipv6_info_keys:
             if key in cfgmap:
                 info[IPV6_ID][key] = cfgmap[key]
         ipv6_addresses = cfgInterfacesHelper.get_ipv6_address(cfgmap)
         if len(ipv6_addresses):
             info[IPV6_ID][IPV6Addresses] = ipv6_addresses
     dnsaddresses = cfgInterfacesHelper.get_dnsv6_info(cfgmap)
     if len(dnsaddresses) > 0:
         info[IPV6_ID][DNSAddresses] = dnsaddresses
     # construct routeinfo.
     if DEVICE in cfgmap:
         routes = self.get_routes_map(cfgmap[DEVICE], 6)
     elif NAME in cfgmap:
         routes = self.get_routes_map(cfgmap[NAME], 6)
     if len(routes) > 0:
         info[IPV6_ID][ROUTES] = routes
     wok_log.debug('End get_ipv6_info')
     return info

    def _do_deep_scan(self, params):
        scan_params = dict(ignore_list=[])
        scan_params['scan_path'] = params['path']
        params['type'] = 'dir'

        for pool in self.get_list():
            try:
                res = StoragePoolModel(conn=self.conn, objstore=self.objstore).lookup(
                    pool
                )
                if res['state'] == 'active':
                    scan_params['ignore_list'].append(res['path'])
            except Exception as e:
                wok_log.debug(f'Exception {e} occured when get ignore path')

        params['path'] = self.scanner.scan_dir_prepare(params['name'])
        scan_params['pool_path'] = params['path']
        task_id = AsyncTask(
            f'/plugins/kimchi/storagepools/{ISO_POOL_NAME}',
            self.scanner.start_scan,
            scan_params,
        ).id
        # Record scanning-task/storagepool mapping for future querying
        try:
            with self.objstore as session:
                session.store(
                    'scanning', params['name'], task_id, get_kimchi_version())
            return task_id
        except Exception as e:
            raise OperationFailed('KCHPOOL0037E', {'err': e.message})

    def get_basic_info(self, cfgmap):
        wok_log.debug('Begin get_basic_info')
        info = {}
        info[BASIC_INFO] = {}
        basic_info_keys = [NAME, DEVICE, ONBOOT, MACADDR,
                           HWADDR, UUID, MTU, ZONE, TYPE]
        for key in basic_info_keys:
            if key in cfgmap:
                info[BASIC_INFO][key] = cfgmap[key]

        if SLAVE in cfgmap and CONST_YES == cfgmap[SLAVE]:
            info[BASIC_INFO][SLAVE] = cfgmap[SLAVE]
            info[BASIC_INFO][MASTER] = cfgInterfacesHelper.get_master(cfgmap)
        interface_type = None
        if TYPE in cfgmap:
            interface_type = cfgmap[TYPE]
        elif VLAN in cfgmap and CONST_YES == cfgmap[VLAN]:
            interface_type = IFACE_VLAN
            # Fix ginger issue #131
        cfgInterfacesHelper.get_architecture_specific_info(info, cfgmap)
        if interface_type is not None:
            info[BASIC_INFO][TYPE] = interface_type
            if interface_type == IFACE_VLAN:
                cfgInterfacesHelper.get_vlan_info(info, cfgmap)
            elif interface_type == IFACE_BOND:
                cfgInterfacesHelper.get_bond_info(info, cfgmap)
        wok_log.debug('end get_basic_info')
        if MTU not in cfgmap:
            info[BASIC_INFO][MTU] = "1500"
        return info

def get_storagedevice(device):
    """
    get the device info dict for the device passed as parameter.
    Raises exception on failure of lscss execution or device is None/blank
    :param device: device id for which we need info to be returned
    :return: device info dict
    """
    device = _validate_device(device)
    if dasd_utils._is_dasdeckd_device(device) or _is_zfcp_device(device):
        command = [lscss, '-d', device]
        msg = 'The command is "%s" ' % command
        wok_log.debug(msg)
        out, err, rc = run_command(command)
        messge = 'The output of command "%s" is %s' % (command, out)
        wok_log.debug(messge)
        if rc:
            err = err.strip().replace("lscss:", '').strip()
            wok_log.error(err)
            raise OperationFailed("GS390XCMD0001E",
                                  {'command': command,
                                   'rc': rc, 'reason': err})
        if out.strip():
            device_info = _get_deviceinfo(out, device)
            return device_info
        wok_log.error("lscss output is either blank or None")
        raise OperationFailed("GS390XCMD0001E",
                              {'command': command,
                               'rc': rc, 'reason': out})
    else:
        wok_log.error("Given device id is of type dasd-eckd or zfcp. "
                      "Device: %s" % device)
        raise InvalidParameter("GS390XINVINPUT",
                               {'reason': 'given device is not of type '
                                          'dasd-eckd or zfcp. '
                                          'Device : %s' % device})

def _get_deviceinfo(lscss_out, device):
    """
    :param lscss_out: out of lscss command
    :param device: device id for which we need info to be returned
    :return: device info dict for the device from lscss output
    """
    device_pattern = r'(' + re.escape(device) + r')\s+' \
        r'(\d\.\d\.[0-9a-fA-F]{4})\s+' \
        r'(\w+\/\w+)\s+' \
        r'(\w+\/\w+)\s' \
        r'(\s{3}|yes)\s+' \
        r'([0-9a-fA-F]{2})\s+' \
        r'([0-9a-fA-F]{2})\s+' \
        r'([0-9a-fA-F]{2})\s+' \
        r'(\w+\s\w+)'
    if device:
        device = utils.get_row_data(lscss_out, HEADER_PATTERN, device_pattern)
        msg = 'The device is %s' % device
        wok_log.debug(msg)
        try:
            device_info = _format_lscss(device)
            return device_info
        except KeyError as e:
            wok_log.error('lscss column key not found')
            raise e
    else:
        return device

def get_disk_xml(params):
    """
    <disk type='file' device='cdrom'>
      <driver name='qemu' type='raw'/>

      [source XML according to src_type]

      <target dev='%(dev)s' bus='%(bus)s'/>
      <readonly/>
    </disk>
    """
    path = params['path']
    disk_type = params.get('disk', None)
    if disk_type is None:
        disk_type = _get_disk_type(path) if len(path) > 0 else 'file'
    disk = E.disk(type=disk_type, device=params['type'])
    driver = E.driver(name='qemu', type=params['format'])
    try:
        fd = os.open(path, os.O_RDONLY | os.O_DIRECT)
        os.close(fd)
        wok_log.debug("Disk '%s' supports direct I/O. Setting cache=none"
                      "to enable live migration" % path)
    except OSError, e:
        if e.errno == errno.EINVAL:
            wok_log.debug("Disk '%s' does not support direct I/O: "
                          "'%s'. Let libvirt sets the default cache mode." %
                          (path, e.message))

 def _clean_scan(self, pool_name):
     try:
         conn = self.conn.get()
         pool = conn.storagePoolLookupByName(pool_name)
         pool.destroy()
         with self.objstore as session:
             session.delete('scanning', pool_name)
     except Exception as e:
         wok_log.debug(f'Exception {e} occurred when cleaning scan result')

 def _clean_scan(self, pool_name):
     try:
         conn = self.conn.get()
         pool = conn.storagePoolLookupByName(pool_name.encode("utf-8"))
         pool.destroy()
         with self.objstore as session:
             session.delete('scanning', pool_name)
     except Exception, e:
         err = "Exception %s occured when cleaning scan result"
         wok_log.debug(err % e.message)

    def _do_deep_scan(self, params):
        scan_params = dict(ignore_list=[])
        scan_params["scan_path"] = params["path"]
        params["type"] = "dir"

        for pool in self.get_list():
            try:
                res = StoragePoolModel(conn=self.conn, objstore=self.objstore).lookup(pool)
                if res["state"] == "active":
                    scan_params["ignore_list"].append(res["path"])
            except Exception, e:
                err = "Exception %s occured when get ignore path"
                wok_log.debug(err % e.message)

    def swupdate(self, *name):
        try:
            swupdate = SoftwareUpdate()
        except:
            raise OperationFailed('KCHPKGUPD0004E')

        pkgs = swupdate.getNumOfUpdates()
        if pkgs == 0:
            raise OperationFailed('KCHPKGUPD0001E')

        wok_log.debug('Host is going to be updated.')
        taskid = add_task('/plugins/kimchi/host/swupdate', swupdate.doUpdate,
                          self.objstore, None)
        return self.task.lookup(taskid)

    def _do_deep_scan(self, params):
        scan_params = dict(ignore_list=[])
        scan_params['scan_path'] = params['path']
        params['type'] = 'dir'

        for pool in self.get_list():
            try:
                res = StoragePoolModel(conn=self.conn,
                                       objstore=self.objstore).lookup(pool)
                if res['state'] == 'active':
                    scan_params['ignore_list'].append(res['path'])
            except Exception, e:
                err = "Exception %s occured when get ignore path"
                wok_log.debug(err % e.message)

    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 swupdate(self, *name):
        try:
            swupdate = SoftwareUpdate()
        except:
            raise OperationFailed('GGBPKGUPD0004E')

        pkgs = swupdate.getNumOfUpdates()
        if pkgs == 0:
            wok_log.debug(messages['GGBPKGUPD0001E'])
            return {'message': messages['GGBPKGUPD0001E']}

        wok_log.debug('Host is going to be updated.')
        taskid = AsyncTask('/plugins/gingerbase/host/swupdate',
                           swupdate.doUpdate).id
        return self.task.lookup(taskid)

    def get_list(self, _type=None):
        """
        :param _type: supported types are dasd-eckd, zfcp.
        Based on this devices will be retrieved
        :return: device data list.
        """
        device_paths = []
        if _type is None:
            device_paths.extend(utils.get_directories(syspath_eckd))
            device_paths.extend(utils.get_directories(syspath_zfcp))
        elif _type == DEV_TYPES[0]:
            device_paths = utils.get_directories(syspath_eckd)
        elif _type == DEV_TYPES[1]:
            device_paths = utils.get_directories(syspath_zfcp)
        else:
            wok_log.error("Invalid _type given. _type: %s"
                          % _type)
            raise InvalidParameter("GS390XINVTYPE",
                                   {'supported_type': DEV_TYPES})
        if not device_paths:
            return []
        command = [lscss]
        msg = 'The command executed is "%s" ' % command
        wok_log.debug(msg)
        out, err, rc = run_command(command)
        if rc:
            err = err.strip().replace("lscss:", '').strip()
            wok_log.error(err)
            raise OperationFailed("GS390XCMD0001E",
                                  {'command': command,
                                   'rc': rc, 'reason': err})

        device_pattern = r'(\d\.\d\.[0-9a-fA-F]{4})\s+' \
                         r'(\d\.\d\.[0-9a-fA-F]{4})\s+' \
                         r'(\w+\/\w+)\s+' \
                         r'(\w+\/\w+)\s' \
                         r'(\s{3}|yes)\s+' \
                         r'([0-9a-fA-F]{2})\s+' \
                         r'([0-9a-fA-F]{2})\s+' \
                         r'([0-9a-fA-F]{2})\s+' \
                         r'(\w+\s\w+)'

        devices = utils.get_rows_info(out, HEADER_PATTERN, device_pattern,
                                      unique_col='device',
                                      format_data=_format_lscss)
        device_data_list = _list_devicesinfo(devices, device_paths)
        return device_data_list