Ejemplo n.º 1
0
def get_sels(server):
    sels = []
    serverData = get_config(server)
    if serverData:
        password = serverData['password']
        ipaddr = serverData['ipaddr']
        salt = serverData['salt']
        if serverData.get('username'):
            out, err, rc = run_command(
                ['ipmitool', '-H', ipaddr, '-I', 'lanplus', '-U',
                 serverData['username'], '-P', decrypt(password, salt),
                 'sel', 'list'])
        else:
            out, err, rc = run_command(
                ['ipmitool', '-H', ipaddr, '-I', 'lanplus', '-P',
                 decrypt(password, salt), 'sel', 'list'])
        if rc == 0:
            output = out.rstrip().split('\n')
            for each in output:
                sels.append(get_each_sel(each))
        else:
            raise OperationFailed(
                'GINSEL00001E',
                {'name': server,
                 'err': err,
                 'rc': rc})
    else:
        raise OperationFailed('GINSEL00002E', {'name': server})
    return sels
Ejemplo n.º 2
0
 def activate(self, ifacename):
     wok_log.info('Bring up an interface ' + ifacename)
     iface_type = netinfo.get_interface_type(ifacename)
     if iface_type == "Ethernet":
         cmd_ipup = ['ip', 'link', 'set', '%s' % ifacename, 'up']
         out, error, returncode = run_command(cmd_ipup)
         if returncode != 0:
             wok_log.error(
                 'Unable to bring up the interface on ' + ifacename +
                 ', ' + error)
             raise OperationFailed('GINNET0059E', {'name': ifacename,
                                                   'error': error})
         # Some times based on system load, it takes few seconds to
         # reflect the  /sys/class/net files upon execution of 'ip link
         # set' command.  Following snippet is to wait util files get
         # reflect.
         timeout = self.wait_time(ifacename)
         if timeout == 5:
             wok_log.warn("Time-out has happened upon execution of 'ip "
                          "link set <interface> up', hence behavior of "
                          "activating an interface may not as expected.")
         else:
             wok_log.info(
                 'Successfully brought up the interface ' + ifacename)
     wok_log.info('Activating an interface ' + ifacename)
     cmd_ifup = ['ifup', '%s' % ifacename]
     out, error, returncode = run_command(cmd_ifup)
     if returncode != 0:
         wok_log.error(
             'Unable to activate the interface on ' + ifacename +
             ', ' + error)
         raise OperationFailed('GINNET0016E',
                               {'name': ifacename, 'error': error})
     wok_log.info(
         'Connection successfully activated for the interface ' + ifacename)
Ejemplo n.º 3
0
def change_dasdpart_type(part, type):
    """
    Change the type of the dasd partition
    :param part: name of the dasd partition e.g. dasd1
    :param type: partition type to be changed to e.g 4 (Linux LVM type)
    :return:
    """
    part_details = re.search(r'(dasd[a-zA-Z]+)(\d+)', part)
    if not part_details:
        raise OperationFailed('GINDASDPAR0011E', {'name': part})
    devname, partnum = part_details.groups()
    devname = '/dev/' + devname

    typ_str = '\nt\n' + partnum + '\n' + type + '\n' + 'w\n'
    p1_out = subprocess.Popen(["echo", "-e", "\'", typ_str, "\'"],
                              stdout=subprocess.PIPE)
    p2_out = subprocess.Popen(["fdasd", devname], stdin=p1_out.stdout,
                              stderr=subprocess.PIPE, stdout=subprocess.PIPE)
    p1_out.stdout.close()
    out, err = p2_out.communicate()
    if p2_out.returncode != 0:
        if 'error while rereading partition table' in err.lower():
            run_command(["partprobe", devname, "-s"])
        else:
            raise OperationFailed("GINDASDPAR0014E", {'err': err})
    return
Ejemplo n.º 4
0
def delete_sel(server, sel_id):
    serverData = get_config(server)
    sel_id_int = int(sel_id, 16)
    if serverData:
        password = serverData['password']
        ipaddr = serverData['ipaddr']
        salt = serverData['salt']
        if serverData.get('username'):
            out, err, rc = run_command(
                ['ipmitool', '-H', ipaddr, '-I', 'lanplus', '-U',
                 serverData['username'], '-P', decrypt(password, salt),
                 'sel', 'delete', str(sel_id_int)])
        else:
            out, err, rc = run_command(
                ['ipmitool', '-H', ipaddr, '-I', 'lanplus', '-P',
                 decrypt(password, salt), 'sel', 'delete', str(sel_id_int)])
        if rc != 0:
            raise OperationFailed(
                'GINSEL00004E',
                {'name': server,
                 'sel_id': sel_id,
                 'err': err,
                 'rc': rc})
    else:
        raise OperationFailed('GINSEL00002E', {'name': server})
Ejemplo n.º 5
0
    def _has_sudo(self, result):
        result.value = False

        _master, slave = pty.openpty()
        os.setsid()
        fcntl.ioctl(slave, termios.TIOCSCTTY, 0)

        out, err, exit = run_command(['sudo', '-l', '-U', self.user[USER_NAME],
                                      'sudo'])
        if exit == 0:
            debug("User %s is allowed to run sudo" % self.user[USER_NAME])
            # sudo allows a wide range of configurations, such as controlling
            # which binaries the user can execute with sudo.
            # For now, we will just check whether the user is allowed to run
            # any command with sudo.
            out, err, exit = run_command(['sudo', '-l', '-U',
                                          self.user[USER_NAME]])
            for line in out.split('\n'):
                if line and re.search("(ALL)", line):
                    result.value = True
                    debug("User %s can run any command with sudo" %
                          result.value)
                    return
            debug("User %s can only run some commands with sudo" %
                  self.user[USER_NAME])
        else:
            debug("User %s is not allowed to run sudo" % self.user[USER_NAME])
Ejemplo n.º 6
0
def server_power_cycle(serverData, cmd):
    count = 0
    if 'username' in serverData.keys() and serverData['username']:
        out, err, rc = run_command(
            ['ipmitool', '-H', serverData['ipaddr'], '-I', 'lanplus', '-U',
             serverData['username'], '-P',
             decrypt(serverData['password'], serverData['salt']),
             'chassis', 'power', cmd])
    else:
        out, err, rc = run_command(
            ['ipmitool', '-H', serverData['ipaddr'], '-I', 'lanplus', '-P',
             decrypt(serverData['password'], serverData['salt']),
             'chassis', 'power', cmd])
    if rc == 0:
        while True:
            serverData = get_server_status(serverData)
            if 'on' in cmd and 'on' in serverData['status']:
                return True
            elif 'off' in cmd and 'off' in serverData['status']:
                return True
            else:
                if count == 15:
                    return False
                count += 1
                time.sleep(20)
    else:
        return False  # raising exception is handled by the caller
Ejemplo n.º 7
0
    def prepare(self, conn):
        mnt_point = tempfile.mkdtemp(dir='/tmp')
        export_path = "%s:%s" % (
            self.poolArgs['source']['host'], self.poolArgs['source']['path'])
        mount_cmd = ["mount", "-o", 'soft,timeo=100,retrans=3,retry=0',
                     export_path, mnt_point]
        umount_cmd = ["umount", "-f", export_path]
        mounted = False
        # Due to an NFS bug (See Red Hat BZ 1023059), NFSv4 exports may take
        # 10-15 seconds to mount the first time.
        cmd_timeout = 15

        with RollbackContext() as rollback:
            rollback.prependDefer(os.rmdir, mnt_point)
            try:
                run_command(mount_cmd, cmd_timeout)
                rollback.prependDefer(run_command, umount_cmd, cmd_timeout)
            except TimeoutExpired:
                raise InvalidParameter("KCHPOOL0012E", {'path': export_path})
            with open("/proc/mounts", "rb") as f:
                rawMounts = f.read()
            output_items = ['dev_path', 'mnt_point', 'type']
            mounts = parse_cmd_output(rawMounts, output_items)
            for item in mounts:
                if 'dev_path' in item and item['dev_path'] == export_path:
                    mounted = True

            if not mounted:
                raise InvalidParameter("KCHPOOL0013E", {'path': export_path})
Ejemplo n.º 8
0
 def _update_lvm_disks(self, pool_name, disks):
     # check if all the disks/partitions exists in the host
     for disk in disks:
         lsblk_cmd = ['lsblk', disk]
         output, error, returncode = run_command(lsblk_cmd)
         if returncode != 0:
             wok_log.error(
                 '%s is not a valid disk/partition. Could not '
                 'add it to the pool %s.',
                 disk,
                 pool_name,
             )
             raise OperationFailed(
                 'KCHPOOL0027E', {'disk': disk, 'pool': pool_name})
     # add disks to the lvm pool using vgextend + virsh refresh
     vgextend_cmd = ['vgextend', pool_name]
     vgextend_cmd += disks
     output, error, returncode = run_command(vgextend_cmd)
     if returncode != 0:
         msg = 'Could not add disks to pool %s, error: %s'
         wok_log.error(msg, pool_name, error)
         raise OperationFailed(
             'KCHPOOL0028E', {'pool': pool_name, 'err': error})
     # refreshing pool state
     pool = self.get_storagepool(pool_name, self.conn)
     if pool.isActive():
         pool.refresh(0)
Ejemplo n.º 9
0
def add_lun(adapter, port, lun_id):
    """
    Add a LUN to system
    :param adapter: HBA adapter id
    :param port: Remote port wwpn
    :param lun_id: Id of the given LUN
    """

    port_dir = '/sys/bus/ccw/drivers/zfcp/' + adapter + '/' + port + '/'
    lun_dir = port_dir + lun_id

    wok_log.info("Adding LUN, %s", lun_dir)

    if os.path.exists(lun_dir):
        # LUN already present on the system, nothing to add.
        return
    else:
        try:
            with open(port_dir + 'unit_add', "w") as txt_file:
                txt_file.write(lun_id)

            for _ in range(4):
                # Don't wait for udev queue to completely flush.
                # Wait for the relavant entry for this LUN is created in sysfs
                run_command([udevadm, "settle", "--exit-if-exists=" + lun_dir])
                if os.path.exists(lun_dir):
                    break
        except Exception as e:
            wok_log.error("Unable to add LUN, %s", lun_dir)
            raise OperationFailed("GS390XSTG00003", {'err': e.message})
Ejemplo n.º 10
0
def _create_dasd_part(dev, size):
    """
    This method creates a DASD partition
    :param dev: name of DASD device for creation of partition
    :param size: block size
    :return:
    """
    devname = '/dev/' + dev
    device = PDevice(devname)
    disk = PDisk(device)
    num_parts = len(disk.partitions)
    if num_parts == 3:
        raise OperationFailed("GINDASDPAR0016E")

    def kill_proc(proc, timeout_flag):
        try:
            parent = psutil.Process(proc.pid)
            for child in parent.get_children(recursive=True):
                child.kill()
            # kill the process after no children is left
            proc.kill()
        except OSError:
            pass
        else:
            timeout_flag[0] = True

    dasd_devs = _get_dasd_names()
    if dev not in dasd_devs:
        raise NotFoundError("GINDASDPAR0012E", {'name': dev})
    p_str = _form_part_str(size)
    try:
        p1_out = subprocess.Popen(["echo", "-e", "\'", p_str, "\'"],
                                  stdout=subprocess.PIPE)
        p2_out = subprocess.Popen(["fdasd", devname], stdin=p1_out.stdout,
                                  stderr=subprocess.PIPE,
                                  stdout=subprocess.PIPE)
        p1_out.stdout.close()
        timeout = 2.0
        timeout_flag = [False]
        timer = Timer(timeout, kill_proc, [p2_out, timeout_flag])
        timer.setDaemon(True)
        timer.start()
        out, err = p2_out.communicate()
        if timeout_flag[0]:
            msg_args = {'cmd': "fdasd " + devname, 'seconds': str(timeout)}
            raise TimeoutExpired("WOKUTILS0002E", msg_args)
        if p2_out.returncode != 0:
            if 'error while rereading partition table' in err.lower():
                run_command(["partprobe", devname, "-s"])
            else:
                raise OperationFailed("GINDASDPAR0007E",
                                      {'name': devname, 'err': err})
    except TimeoutExpired:
        raise
    finally:
        if timer and not timeout_flag[0]:
            timer.cancel()
Ejemplo n.º 11
0
    def __init__(self, **kargs):
        self.guest_threads_enabled = False
        self.sockets = 0
        self.cores_present = 0
        self.cores_available = 0
        self.cores_per_socket = 0
        self.threads_per_core = 0
        self.max_threads = 0

        self.conn = kargs['conn']
        libvirt_topology = None
        try:
            connect = self.conn.get()
            libvirt_topology = get_topo_capabilities(connect)
        except Exception as e:
            wok_log.info("Unable to get CPU topology capabilities: %s"
                         % e.message)
            return
        if libvirt_topology is None:
            wok_log.info("cpu_info topology not supported.")
            return

        if ARCH == 'power':
            # IBM PowerPC
            self.guest_threads_enabled = True
            out, error, rc = run_command(['ppc64_cpu', '--smt'])
            if rc or 'on' in out:
                # SMT has to be disabled for guest to use threads as CPUs.
                # rc is always zero, whether SMT is off or on.
                self.guest_threads_enabled = False
            out, error, rc = run_command(['ppc64_cpu', '--cores-present'])
            if not rc:
                self.cores_present = int(out.split()[-1])
            out, error, rc = run_command(['ppc64_cpu', '--cores-on'])
            if not rc:
                self.cores_available = int(out.split()[-1])
            out, error, rc = run_command(['ppc64_cpu', '--threads-per-core'])
            if not rc:
                self.threads_per_core = int(out.split()[-1])
            self.sockets = self.cores_present/self.threads_per_core
            if self.sockets == 0:
                self.sockets = 1
            self.cores_per_socket = self.cores_present/self.sockets
        else:
            # Intel or AMD
            self.guest_threads_enabled = True
            self.sockets = int(libvirt_topology.get('sockets'))
            self.cores_per_socket = int(libvirt_topology.get('cores'))
            self.cores_present = self.cores_per_socket * self.sockets
            self.cores_available = self.cores_present
            self.threads_per_core = int(libvirt_topology.get('threads'))
Ejemplo n.º 12
0
def create_file(self):
    fcmd = ["dd", "if=/dev/zero", "of=%s" % TESTFILE,
            "bs=10M", "count=1"]
    fout, err, rc = run_command(fcmd)
    if rc:
        self.assertRaises(OperationFailed)

    fscmd = ["mkfs.ext4", TESTFILE, "-F"]
    fsout, err, rc = run_command(fscmd)
    if rc:
        self.assertRaises(OperationFailed)

    if not os.path.exists(TESTDIR):
        os.makedirs(TESTDIR)
Ejemplo n.º 13
0
 def activate_iface(self, ifacename):
     wok_log.info('Bring up an interface ' + ifacename)
     iface_type = netinfo.get_interface_type(ifacename)
     if iface_type == "nic":
         cmd_ipup = ['ip', 'link', 'set', '%s' % ifacename, 'up']
         out, error, returncode = run_command(cmd_ipup)
         if returncode != 0:
             # non-ascii encoded value and unicode value
             # cannot be concatenated, so convert both variable
             # to one format.
             raise OperationFailed('GINNET0059E',
                                   {'name': encode_value(ifacename),
                                    'error': encode_value(error)})
         # Some times based on system load, it takes few seconds to
         # reflect the  /sys/class/net files upon execution of 'ip link
         # set' command.  Following snippet is to wait util files get
         # reflect.
         timeout = self.wait_time(ifacename)
         if timeout == 5:
             wok_log.warn("Time-out has happened upon execution of 'ip "
                          "link set <interface> up', hence behavior of "
                          "activating an interface may not as expected.")
         else:
             wok_log.info('Successfully brought up the interface ' +
                          ifacename)
     wok_log.info('Activating an interface ' + ifacename)
     cmd_ifup = ['ifup', ifacename]
     out, error, returncode = run_command(cmd_ifup)
     # Timeout is used for carrier file
     # since the carrier file needs few seconds approx 5 sec
     # to update the carrier value of an iface from 0 to 1.
     self.wait_time_carrier(ifacename)
     # Check for the carrier value after the device is activated
     if os.path.isfile(carrier_path % ifacename):
         with open(carrier_path % ifacename) as car_file:
             carrier_val = car_file.readline().strip()
         if (carrier_val == '0'):
             if iface_type != "nic":
                 raise OperationFailed('GINNET0094E', {'name': ifacename})
             else:
                 raise OperationFailed('GINNET0090E', {'name': ifacename})
     else:
         raise OperationFailed('GINNET0091E', {'name': ifacename})
     if returncode != 0:
         raise OperationFailed('GINNET0016E',
                               {'name': encode_value(ifacename),
                                'error': encode_value(error)})
     wok_log.info(
         'Connection successfully activated for the interface ' + ifacename)
Ejemplo n.º 14
0
 def activate_iface(self, ifacename):
     wok_log.info('Bring up an interface ' + ifacename)
     iface_type = netinfo.get_interface_type(ifacename)
     filename = ifcfg_filename_format % ifacename
     filepath = os.sep + network_configpath + filename
     if os.path.exists(filepath):
         if not (os.stat(filepath).st_size == 0):
             wok_log.info('Activating an interface ' + ifacename)
             cmd_ifup = ['ifup', ifacename]
             out, error, returncode = run_command(cmd_ifup)
             if (returncode == 4):
                 raise OperationFailed('GINNET0095E', {'name': ifacename})
             # Timeout is used for carrier file
             # since the carrier file needs few seconds approx 5 sec
             # to update the carrier value of an iface from 0 to 1.
             self.wait_time_carrier(ifacename)
             # Check for the carrier value after the device is activated
             if os.path.isfile(carrier_path % ifacename):
                 with open(carrier_path % ifacename) as car_file:
                     carrier_val = car_file.readline().strip()
                 if (carrier_val == '0'):
                     if iface_type != "nic":
                         raise OperationFailed('GINNET0094E',
                                               {'name': ifacename})
                     else:
                         raise OperationFailed('GINNET0090E',
                                               {'name': ifacename})
             else:
                 raise OperationFailed('GINNET0091E', {'name': ifacename})
             if returncode != 0:
                 raise OperationFailed('GINNET0016E',
                                       {'name': encode_value(ifacename),
                                        'error': encode_value(error)})
             wok_log.info('Connection successfully activated for the '
                          'interface ' + ifacename)
         else:
             cmd_ipup = ['ip', 'link', 'set', '%s' % ifacename, 'up']
             out, error, returncode = run_command(cmd_ipup)
             if returncode != 0:
                 raise OperationFailed('GINNET0059E', {'name': ifacename})
             wok_log.info('Connection successfully activated for the '
                          'interface ' + ifacename)
     else:
         cmd_ipup = ['ip', 'link', 'set', '%s' % ifacename, 'up']
         out, error, returncode = run_command(cmd_ipup)
         if returncode != 0:
             raise OperationFailed('GINNET0059E', {'name': ifacename})
         wok_log.info('Connection successfully activated for the '
                      'interface ' + ifacename)
Ejemplo n.º 15
0
    def _validate_pci_passthrough_env():
        # Linux kernel < 3.5 doesn't provide /sys/kernel/iommu_groups
        if os.path.isdir('/sys/kernel/iommu_groups'):
            if not glob.glob('/sys/kernel/iommu_groups/*'):
                raise InvalidOperation("KCHVMHDEV0003E")

        # Enable virt_use_sysfs on RHEL6 and older distributions
        # In recent Fedora, there is no virt_use_sysfs.
        out, err, rc = run_command(['getsebool', 'virt_use_sysfs'],
                                   silent=True)
        if rc == 0 and out.rstrip('\n') != "virt_use_sysfs --> on":
            out, err, rc = run_command(['setsebool', '-P',
                                        'virt_use_sysfs=on'])
            if rc != 0:
                wok_log.warning("Unable to turn on sebool virt_use_sysfs")
Ejemplo n.º 16
0
def create_file(self):
    fcmd = ["dd", "if=/dev/zero", "of=/testfile",
            "bs=10M", "count=1"]
    fout, err, rc = run_command(fcmd)
    if rc:
        self.assertRaises(OperationFailed)

    fscmd = ["mkfs.ext4", "/testfile", "-F"]
    fsout, err, rc = run_command(fscmd)
    if rc:
        self.assertRaises(OperationFailed)

    mntpt = '/test'
    if not os.path.exists(mntpt):
        os.makedirs(mntpt)
Ejemplo n.º 17
0
    def deactivate_iface(self, ifacename):
        wok_log.info('Deactivating an interface ' + ifacename)
        cmd_ifdown = ['ifdown', '%s' % ifacename]
        out, error, returncode = run_command(cmd_ifdown)
        if returncode != 0:
            wok_log.error(
                'Unable to deactivate the interface on ' + ifacename +
                ', ' + error)
            raise OperationFailed('GINNET0017E',
                                  {'name': ifacename, 'error': error})
        wok_log.info(
            'Connection successfully deactivated for the interface ' +
            ifacename)

        wok_log.info('Bringing down an interface ' + ifacename)
        iface_type = netinfo.get_interface_type(ifacename)
        if iface_type == "Ethernet":
            cmd_ipdown = ['ip', 'link', 'set', '%s' % ifacename, 'down']
            out, error, returncode = run_command(cmd_ipdown)
            if returncode != 0:
                wok_log.error(
                    'Unable to bring down the interface on ' + ifacename +
                    ', ' + error)
                raise OperationFailed('GINNET0060E', {'name': ifacename,
                                                      'error': error})
            # Some times based on system load, it takes few seconds to
            # reflect the  /sys/class/net files upon execution of 'ip link
            # set' command. Following snippet is to wait util files get
            # reflect.
            timeout = self.wait_time(ifacename)
            if timeout == 5:
                wok_log.warn("Time-out has happened upon execution of 'ip "
                             "link set <interface> down', hence behavior of "
                             "activating an interface may not as expected.")
            else:
                wok_log.info('Successfully brought down the interface ' +
                             ifacename)
        vlan_or_bond = [nw_cfginterfaces_utils.IFACE_BOND,
                        nw_cfginterfaces_utils.IFACE_VLAN]
        if iface_type in vlan_or_bond:
            if ifacename in ethtool.get_devices():
                cmd_ip_link_del = ['ip', 'link', 'delete', '%s' % ifacename]
                out, error, returncode = run_command(cmd_ip_link_del)
                if returncode != 0 and ifacename in ethtool.get_devices():
                    wok_log.error('Unable to delete the interface ' +
                                  ifacename + ', ' + error)
                raise OperationFailed('GINNET0017E', {'name': ifacename,
                                                      'error': error})
Ejemplo n.º 18
0
    def __init__(self):
        # This stores all packages to be updated for Ginger Base perspective.
        # It's a dictionary of dictionaries, in the format
        # {'package_name': package},
        # where:
        # package = {'package_name': <string>, 'version': <string>,
        #           'arch': <string>, 'repository': <string>
        #           }
        self._packages = {}

        # This stores the number of packages to update
        self._num2update = 0

        # Get the distro of host machine and creates an object related to
        # correct package management system
        try:
            __import__('yum')
            wok_log.info("Loading YumUpdate features.")
            self._pkg_mnger = YumUpdate()
        except ImportError:
            try:
                __import__('apt')
                wok_log.info("Loading AptUpdate features.")
                self._pkg_mnger = AptUpdate()
            except ImportError:
                zypper_help = ["zypper", "--help"]
                (stdout, stderr, returncode) = run_command(zypper_help)
                if returncode == 0:
                    wok_log.info("Loading ZypperUpdate features.")
                    self._pkg_mnger = ZypperUpdate()
                else:
                    raise Exception("There is no compatible package manager "
                                    "for this system.")
Ejemplo n.º 19
0
def ovs_bridge_ports(ovsbr):
    """Get the ports of a OVS bridge.

    In some distributions, like Fedora, the files bridge and brif are
    not created under /sys/class/net/<ovsbridge> for OVS bridges.
    These specific functions allows one to differentiate OVS bridges
    from other types of bridges.

    Args:
        ovsbr (str): name of the OVS bridge

    Returns:
        List[str]: a list with the ports of this bridge.

    """
    if not is_openvswitch_running():
        return []

    ovs_cmd = find_executable("ovs-vsctl")

    # openvswitch not installed: there is no OVS bridge configured
    if ovs_cmd is None:
        return []

    out, _, r_code = run_command([ovs_cmd, 'list-ports', ovsbr], silent=True)
    if r_code != 0:
        return []

    return [x.strip() for x in out.rstrip('\n').split('\n') if x.strip()]
Ejemplo n.º 20
0
def _pvdisplay_out(name):
    """
    This method fetches the details of particular PV
    :param name: path of the PV
    :return:
    """
    pv_version = get_lvm_version()
    # Disabled unsupported options to vgs command below
    # a threshold version
    if LooseVersion(pv_version) < LooseVersion(LVM_THR_VERSION):
        below_threshold_version = True
        cmd = ['pvs', '-o', 'pv_name,vg_name,'
               'pv_size,'
               'pv_pe_count,pv_pe_alloc_count,'
               'pv_uuid,vg_extent_size,'
               'vg_free_count', "--separator", ":", name,
               "--units", "K"]
    else:
        below_threshold_version = False
        cmd = ['pvs', '-o', 'pv_name,vg_name,'
               'pv_size,pv_allocatable,'
               'pv_pe_count,pv_pe_alloc_count,'
               'pv_uuid,vg_extent_size,'
               'vg_free_count', "--separator", ":", name,
               "--units", "K"]
    out, err, rc = run_command(cmd)

    if rc == 5 and 'Failed to find device' in err:
        raise NotFoundError("GINPV00011E", {'dev': name})

    elif rc != 0:
        raise OperationFailed("GINPV00007E",
                              {'dev': name, 'err': err})

    return parse_pvdisplay_output(out, below_threshold_version)
Ejemplo n.º 21
0
        def parse_hdds(temperature_unit):
            # hddtemp will strangely convert a non-number (see error case
            #   below) to 32 deg F. So just always ask for C and convert later.
            out, error, rc = run_command(['hddtemp'])
            if rc:
                wok_log.error("Error retrieving HD temperatures: rc %s."
                              "output: %s" % (rc, error))
                return None

            hdds = OrderedDict()

            for hdd in out.splitlines():
                hdd_name = ''
                hdd_temp = 0.0
                try:
                    hdd_items = hdd.split(':')
                    hdd_name, hdd_temp = hdd_items[0], hdd_items[2]
                    hdd_temp = re.sub('°[C|F]', '', hdd_temp).strip()
                except Exception as e:
                    wok_log.error('Sensors hdd parse error: %s' % e.message)
                    continue
                try:
                    # Try to convert the number to a float. If it fails,
                    # don't add this disk to the list.
                    hdd_temp = float(hdd_temp)
                    if(temperature_unit == 'F'):
                        hdd_temp = 9.0/5.0 * hdd_temp + 32
                    hdds[hdd_name] = hdd_temp
                except ValueError:
                    # If no sensor data, parse float will fail. For example:
                    # "/dev/sda: IBM IPR-10 5D831200: S.M.A.R.T. not available"
                    wok_log.warning("Sensors hdd: %s" % hdd)
            hdds['unit'] = temperature_unit
            return hdds
Ejemplo n.º 22
0
def get_mlx5_nic_type(mlx5_iface):
    """Checks lspci output to see if mlx5_iface is a physical or
    virtual nic interface.

    This is the lspci output this function is expecting for a mlx5 virtual
    nic interface:

    'Ethernet controller: Mellanox Technologies MT27700 Family
     [ConnectX-4 Virtual Function]'

    Verification will be done by checking for the 'Virtual Function'
    string in the output. Any other lspci output format or any other
    error will make this function return the default value 'physical'.

    Args:
        mlx5_iface (str): interface loaded by the mlx5_core driver.

    Returns:
        str: 'virtual' if mlx5_iface is a virtual function/nic,
            'physical' otherwise.

    """
    bus_id = get_mlx5_nic_bus_id(mlx5_iface)

    lspci_cmd = ['lspci', '-s', bus_id]
    out, err, r_code = run_command(lspci_cmd)

    if r_code == 0 and 'Virtual Function' in out:
        return 'virtual'

    if r_code != 0:
        wok_log.error('Error while getting nic type of '
                      'interface: %s' % err)

    return 'physical'
Ejemplo n.º 23
0
def vgs():
    """
    lists all volume groups in the system. All size units are in bytes.

    [{'vgname': 'vgtest', 'size': 999653638144L, 'free': 0}]
    """
    cmd = ['vgs',
           '--units',
           'b',
           '--nosuffix',
           '--noheading',
           '--unbuffered',
           '--options',
           'vg_name,vg_size,vg_free']

    out, err, rc = run_command(cmd)
    if rc != 0:
        raise OperationFailed("KCHLVM0001E", {'err': err})

    if not out:
        return []

    # remove blank spaces and create a list of VGs
    vgs = map(lambda v: v.strip(), out.strip('\n').split('\n'))

    # create a dict based on data retrieved from vgs
    return map(lambda l: {'vgname': l[0],
                          'size': long(l[1]),
                          'free': long(l[2])},
               [fields.split() for fields in vgs])
Ejemplo n.º 24
0
 def _erase_remote_file(self, path):
     username_host = "root@%s" % KIMCHI_LIVE_MIGRATION_TEST
     cmd = ['ssh', '-oStrictHostKeyChecking=no', username_host,
            'rm', '-f', path]
     _, _, returncode = run_command(cmd, silent=True)
     if returncode != 0:
         print 'cannot erase remote file ', path
Ejemplo n.º 25
0
 def disable_tcp_port(port):
     _, err, r_code = run_command(
         ['firewall-cmd', '--remove-port=%s/tcp' % port]
     )
     if r_code != 0:
         wok_log.error('Error when removing port from '
                       'firewall-cmd: %s' % err)
Ejemplo n.º 26
0
def lvs(vgname=None):
    """
    lists all logical volumes found in the system. It can be filtered by
    the volume group. All size units are in bytes.

    [{'lvname': 'lva', 'path': '/dev/vgtest/lva', 'size': 12345L},
     {'lvname': 'lvb', 'path': '/dev/vgtest/lvb', 'size': 12345L}]
    """
    cmd = ['lvs',
           '--units',
           'b',
           '--nosuffix',
           '--noheading',
           '--unbuffered',
           '--options',
           'lv_name,lv_path,lv_size,vg_name']

    out, err, rc = run_command(cmd)
    if rc != 0:
        raise OperationFailed("KCHLVM0001E", {'err': err})

    if not out:
        return []

    # remove blank spaces and create a list of LVs filtered by vgname, if
    # provided
    lvs = filter(lambda f: vgname is None or vgname in f,
                 map(lambda v: v.strip(), out.strip('\n').split('\n')))

    # create a dict based on data retrieved from lvs
    return map(lambda l: {'lvname': l[0],
                          'path': l[1],
                          'size': long(l[2])},
               [fields.split() for fields in lvs])
Ejemplo n.º 27
0
def is_libvirtd_up():
    """
    Checks if libvirtd.service is up.
    """
    cmd = ['systemctl', 'is-active', 'libvirtd.service']
    output, error, rc = run_command(cmd, silent=True)
    return True if output == 'active\n' else False
Ejemplo n.º 28
0
def create_disk_image(format_type, path, capacity):
    """
    Create a disk image for the Guest
    Args:
        format: Format of the storage. e.g. qcow2
        path: Path where the virtual disk will be created
        capacity: Capacity of the virtual disk in GBs

    Returns:

    """
    out, err, rc = run_command(
        [
            '/usr/bin/qemu-img',
            'create',
            '-f',
            format_type,
            '-o',
            'preallocation=metadata',
            path,
            encode_value(capacity) + 'G',
        ]
    )

    if rc != 0:
        raise OperationFailed('KCHTMPL0041E', {'err': err})

    return
Ejemplo n.º 29
0
def _vgdisplay_out(name):
    """
    This method gets the details of particular volume group
    :param name: Name of the volume group
    :return:
    """
    vg_version = get_lvm_version()
    # Disabled unsupported options to vgs command below
    # a threshold version
    if LooseVersion(vg_version) < LooseVersion(LVM_THR_VERSION):
        below_threshold_version = True
        cmd = ["vgs", "-o", "vg_name,vg_sysid,"
               "vg_fmt,vg_mda_count,vg_seqno,"
               "max_lv,lv_count,max_pv,pv_count,"
               "vg_size,vg_extent_size,pv_pe_count,"
               "pv_pe_alloc_count,pv_used,vg_free_count,pv_free,"
               "vg_uuid,pv_name", "--separator", ":", name,
               "--units", "K"]
    else:
        below_threshold_version = False
        cmd = ["vgs", "-o", "vg_name,vg_sysid,"
               "vg_fmt,vg_mda_count,vg_seqno,vg_permissions,"
               "vg_extendable,max_lv,lv_count,max_pv,pv_count,"
               "vg_size,vg_extent_size,pv_pe_count,"
               "pv_pe_alloc_count,pv_used,vg_free_count,pv_free,"
               "vg_uuid,pv_name", "--separator", ":", name,
               "--units", "K"]
    out, err, rc = run_command(cmd)
    if rc != 0:
        raise OperationFailed("GINVG00008E")
    return parse_vgdisplay_output(out, below_threshold_version)
Ejemplo n.º 30
0
 def is_feature_available(self):
     _, _, returncode = run_command(['lsdasd', '-l'])
     ptfm = platform.machine()
     if ptfm != 's390x' or returncode != 0:
         return False
     else:
         return True
Ejemplo n.º 31
0
 def _erase_remote_file(self, path):
     username_host = "root@%s" % KIMCHI_LIVE_MIGRATION_TEST
     cmd = [
         'ssh', '-oStrictHostKeyChecking=no', username_host, 'rm', '-f',
         path
     ]
     _, _, returncode = run_command(cmd, silent=True)
     if returncode != 0:
         print 'cannot erase remote file ', path
Ejemplo n.º 32
0
 def reload_rules(self, name):
     rules_list = get_list_of_loaded_rules()
     unload_all_rules = ['auditctl', '-D']
     out, err, returncode = run_command(unload_all_rules)
     if returncode != 0:
         raise OperationFailed('GINAUD0002E', {'name': unload_all_rules})
     for each_rule in rules_list:
         if each_rule != str(name):
             self.load(each_rule)
Ejemplo n.º 33
0
    def lookup(self, params):
        cmd = ['systemctl', 'status', "sepctl"]
        output, error, rc = run_command(cmd)

        # workarround to get the correct output from this command
        if rc == 0:
            return {"status": "running"}

        return {"status": "not running"}
Ejemplo n.º 34
0
 def update(self, powerprofile, params):
     if params['active'] and self.active_powerprofile != powerprofile:
         self.active_powerprofile = powerprofile
         tuned_cmd = ["tuned-adm", "profile", powerprofile]
         output, error, returncode = run_command(tuned_cmd)
         if returncode != 0:
             raise OperationFailed("GINPOWER004E",
                                   {'profile': powerprofile, 'err': error})
     return powerprofile
Ejemplo n.º 35
0
def clear_multipath(dm_long_name):
    """
    Clear a multipath device entry
    @param dm_long_name : name of multipath device
    """
    out, err, rc = run_command(['multipath', '-f', dm_long_name])
    if rc != 0:
        wok_log.error("Unable to remove multipath device, %s", dm_long_name)
        raise OperationFailed("GS390XSTG0018E", {'err': err})
Ejemplo n.º 36
0
def _remove_devices(cb, devices):
    """
    Remove one or more device IDs from blacklist.
    :param devices: List of devices IDs. It can have range of device IDs
                    Ex: ['0.0.0120', '0.0.1230-0.0.1300', '0.0.001']
                    device ID format:
                            "<CSSID>.<SSID>.<DEVNO>". Ex: "0.0.0190"
                            Devices for which CSSID and SSID are 0 can
                            alternatively be specified by using only the
                            device number, either with or without leading
                            "0x" and zeros. Ex: "190", "0x190" or "0190"
    """
    cb('')  # reset messages
    try:
        wok_log.info('Removing devices %s from ignore list' % devices)
        failed_devices = {}
        devices = [
            x.encode('utf-8') if isinstance(x, unicode) else str(x)
            for x in devices
        ]
        for device in devices:
            if device and not device.isspace():
                if '-' in device:
                    # if range, remove space if any before or after '-'
                    device = device.replace(' ', '')
                command = [CIO_IGNORE, '-r', device]
                out, err, rc = run_command(command)
                if rc:
                    wok_log.error('failed to remove device(s): %s, from'
                                  ' ignore list. Error: %s' %
                                  (device, err.strip()))
                    err = err.strip().split(':')[-1].strip()
                    failed_devices[device] = err
            else:
                failed_devices[device] = 'device ID is required'
                wok_log.error('failed to remove device since'
                              ' device id is empty')

        if failed_devices:
            # to handle unicode charater
            str_failed_devices = ', '.join('%s: %s' % (device, err)
                                           for (device,
                                                err) in failed_devices.items())
            wok_log.error(
                'failed to remove devices \"%s\" from'
                ' ignore list', str_failed_devices)
            raise OperationFailed('GS390XIOIG002E',
                                  {'failed_devices': str_failed_devices})
        str_devices = ', '.join(devices)
        wok_log.info('Successfully removed devices \"%s\" from'
                     ' ignore list' % str_devices)
        cb(
            'Successfully removed devices \"%s\" from ignore'
            ' list' % str_devices, True)
    except Exception as e:
        cb(e.message, False)
Ejemplo n.º 37
0
def _get_vg_list():
    """
    This method gets a list of volume group names
    :return:
    """
    cmd = ["vgs", "-o", "vg_name"]
    out, err, rc = run_command(cmd)
    if rc != 0:
        raise OperationFailed("GINVG00007E")
    return parse_pvlist_output(out)
Ejemplo n.º 38
0
def unload_kernel_module(module_name):
    out, err, returncode = run_command(['modprobe', '-r', module_name])
    if returncode != 0:
        if 'not found' in err:
            raise NotFoundError('GINSYSMOD00002E', {'module': module_name})
        else:
            raise OperationFailed('GINSYSMOD00005E', {
                'err': err,
                'module': module_name
            })
Ejemplo n.º 39
0
def get_disks_by_id_out():
    """
    Execute 'ls -l /dev/disk/by-id'
    :return: Output of 'ls -l /dev/disk/by-id'
    """
    cmd = ['ls', '-l', '/dev/disk/by-id']
    out, err, rc = run_command(cmd)
    if rc != 0:
        raise OperationFailed('GINSD00001E', {'err': err})
    return out
Ejemplo n.º 40
0
    def _rollback_on_failure(self, gateway):
        _, err, rc = run_command(['ip', 'route', 'del', 'default'])
        if rc and not ('No such process' in err):
            raise OperationFailed('GINNET0010E', {'reason': err})
        if gateway:
            _, err, rc = run_command(
                ['ip', 'route', 'add', 'default', 'via', gateway])
            if rc:
                raise OperationFailed('GINNET0011E', {'reason': err})

        conn = self._conn
        try:
            conn.changeRollback()
        except libvirt.libvirtError as e:
            # In case the timeout thread is preempted, and confirm_change() is
            # called before our changeRollback(), we can just ignore the
            # VIR_ERR_OPERATION_INVALID error.
            if e.get_error_code() != libvirt.VIR_ERR_OPERATION_INVALID:
                raise
Ejemplo n.º 41
0
def is_openvswitch_running():
    """Checks if the openvswitch service is running in the host.

    Returns:
        bool: True if openvswitch service is running, False otherwise.

    """
    cmd = ['systemctl', 'is-active', 'openvswitch', '--quiet']
    _, _, r_code = run_command(cmd, silent=True)
    return r_code == 0
Ejemplo n.º 42
0
def run_zipl_cmd():
    """
    Run zipl command to update the bootloader
    """

    wok_log.info('Running zipl command to update bootloader')
    out, err, rc = run_command(['zipl'])
    if rc:
        wok_log.error('failed to execute zipl,  %s', err)
        raise OperationFailed("GS390XSTG00015", {'err': err})
Ejemplo n.º 43
0
def create_local_sdr_cache(
    username, password, ipaddr, salt,
        localSdrCache, server):
    out, err, rc = run_command(
        ['ipmitool', '-H', ipaddr, '-I', 'lanplus', '-U', username, '-P',
         decrypt(password, salt), 'sdr', 'dump', localSdrCache])
    if rc == 0:
        return True
    else:
        return False
Ejemplo n.º 44
0
def _get_dasd_dev_details(bus_id):
    """
    Executes 'lsdasd -l bus_id' command and returns
    :return: details of device with given bus_id
    """
    command = ['lsdasd', '-l', bus_id]
    dasdout, err, rc = run_command(command)
    if rc:
        raise OperationFailed("GINDASD0002E", {'err': err})
    return _parse_lsdasd_output(dasdout)
Ejemplo n.º 45
0
def _get_lsdasd_devs():
    """
    Executes 'lsdasd -l' command and returns
    :return: output of 'lsdasd -l' command
    """
    command = ['lsdasd', '-l']
    dasdout, err, rc = run_command(command)
    if rc:
        raise OperationFailed('GINDASD0001E', {'err': err})
    return _parse_lsdasd_output(dasdout)
Ejemplo n.º 46
0
def get_active_tuned_profile():
    tuned_cmd = ["tuned-adm", "active"]
    output, error, returncode = run_command(tuned_cmd)
    # This is a possible scenario where tuned is running
    # but there is no active profile yet. No need to
    # report/issue an error.
    if returncode != 0:
        return None
    output = output.split()
    return output[-1].rstrip()
Ejemplo n.º 47
0
def _swapoff_device(device_name):
    """
    Remove a swap device
    :param device_name: file or device path
    :return:
    """
    out, err, rc = run_command(["swapoff", device_name])

    if rc != 0:
        raise OperationFailed("GINSP00016E", {'err': err})
Ejemplo n.º 48
0
def _activate_swap(file_loc):
    """
    Activate a swap device
    :param file_loc: file location or a device path
    :return:
    """
    out, err, rc = run_command(["swapon", file_loc])
    if rc != 0:
        raise OperationFailed("GINSP00013E", {'err': err})
    return
Ejemplo n.º 49
0
def _get_lv_list():
    """
    This method fetches the list of existing logical volumes
    :return:
    """
    cmd = ["lvs", "-o", "lv_path"]
    out, err, rc = run_command(cmd)
    if rc != 0:
        raise OperationFailed("GINLV00008E")
    return parse_pvlist_output(out)
Ejemplo n.º 50
0
def _get_pv_devices():
    """
    This method fetches the list of PV names
    :return:
    """
    cmd = ["pvs", "-o", "pv_name"]
    pvout, err, rc = run_command(cmd)
    if rc != 0:
        raise OperationFailed("GINPV00006E", {'err': err})
    return parse_pvlist_output(pvout)
Ejemplo n.º 51
0
def _create_pv(name):
    """
    This method creates the PV
    :param name: path of the partition to be used as PV
    :return:
    """
    out, err, rc = run_command(["pvcreate", "-f", name])
    if rc != 0:
        raise OperationFailed("GINPV00008E", {'err': err})
    return
Ejemplo n.º 52
0
 def _qemu_support_spice(self):
     qemu_path = find_qemu_binary(find_emulator=True)
     out, err, rc = run_command(['ldd', qemu_path])
     if rc != 0:
         wok_log.error('Failed to find qemu binary dependencies: %s', err)
         return False
     for line in out.split('\n'):
         if line.lstrip().startswith('libspice-server.so'):
             return True
     return False
Ejemplo n.º 53
0
def add_lun(adapter, port, lun_id):
    """
    Add a LUN to system
    :param adapter: HBA adapter id
    :param port: Remote port wwpn
    :param lun_id: Id of the given LUN
    """

    port_dir = '/sys/bus/ccw/drivers/zfcp/' + adapter + '/' + port + '/'
    lun_dir = port_dir + lun_id

    wok_log.info("Adding LUN, %s", lun_dir)

    if os.path.exists(lun_dir):
        # LUN already present on the system, nothing to add.
        return
    else:
        try:
            with open(port_dir + 'unit_add', "w") as txt_file:
                txt_file.write(lun_id)

            for _ in range(4):
                # Don't wait for udev queue to completely flush.
                # Wait for the relavant entry for this LUN is created in sysfs
                run_command([udevadm, "settle", "--exit-if-exists=" + lun_dir])
                if os.path.exists(lun_dir):
                    entry_exists = False
                    fo = open("/etc/zfcp.conf", "r")
                    lines = fo.readlines()
                    for line in lines:
                        if [adapter, port, lun_id] == line.split():
                            entry_exists = True
                    fo.close()
                    if not entry_exists:
                        with open("/etc/zfcp.conf", "a") as zfcp:
                            zfcp.write(adapter + " " + port + " " + lun_id +
                                       "\n")
                    break

        except Exception as e:
            wok_log.error("Unable to add LUN, %s", lun_dir)
            raise OperationFailed("GS390XSTG00003", {'err': e.message})
Ejemplo n.º 54
0
def _lvdisplay_out(path):
    """
    This method fetches the details of the logical volume
    :param path: Path of the particular logical volume
    :return:
    """
    cmd = ["lvdisplay", path]
    out, err, rc = run_command(cmd)
    if rc != 0:
        raise OperationFailed("GINLV00009E")
    return parse_lvdisplay_output(out)
Ejemplo n.º 55
0
 def load_smt_s390x(self, backup):
     """
     Method to execute the changes done in zipl file
      for s390x architecture.
     """
     command = ['zipl']
     output, error, retcode = run_command(command)
     if retcode != 0:
         self.recover_ziplfile(ZIPL, backup)
         raise OperationFailed('GINSMT0008E', {'error': error})
     wok_log.info('Successfully applied SMT settings.')
Ejemplo n.º 56
0
def _get_df_output():
    """
    Executes 'df -kT' command and returns
    :return: output of 'df -kT' command
    """
    command = ['df', '-kT']
    dfout, err, rc = run_command(command)
    if rc:
        wok_log.error("df -kT failed")
        raise OperationFailed("GINFS00006E", {'err': err})
    return _parse_df_output(dfout)
Ejemplo n.º 57
0
def _remove_lv(name):
    """
    This method removes the logical volume
    :param name: Path of the logical volume
    :return:
    """
    cmd = ["lvremove", "-f", name]
    out, err, rc = run_command(cmd)
    if rc != 0:
        raise OperationFailed("GINLV00010E")
    return
Ejemplo n.º 58
0
 def _restore_tar(self, archive_id):
     backup_dir = os.path.join(
         PluginPaths('ginger').state_dir, 'ginger_backups')
     backup_file = os.path.join(backup_dir, archive_id + '.tar.gz')
     cmd = ['tar', '-xzf', backup_file, '-C', '/']
     out, err, rc = run_command(cmd)
     if rc != 0:
         raise OperationFailed('GINHBK0001E', {
             'name': backup_file,
             'cmd': ' '.join(cmd)
         })
Ejemplo n.º 59
0
def nfsmount(server, share, mount_point, mnt_opts):
    """
    This method mounts the remote nfs share on local system
    :param server: ip address of the nfs server
    :param share: remote share location
    :param mount_point: mount point on local system
    :return:
    """
    if not os.path.exists(mount_point):
        d_cmd = ['mkdir', mount_point]
        d_out, err, rc = run_command(d_cmd)
        if rc:
            wok_log.error("mkdir failed")
    if mnt_opts:
        nfs_cmd = ['mount', server + ':' + share, mount_point, "-o", mnt_opts]
    else:
        nfs_cmd = ['mount', server + ':' + share, mount_point]
    nfs_out, err, rc = run_command(nfs_cmd)
    if rc:
        raise OperationFailed("GINFS00018E", err)
Ejemplo n.º 60
0
def get_list_of_loaded_rules():
    cmd_sc = ['auditctl', '-l']
    out, err, returncode = run_command(cmd_sc)
    if returncode == 0:
        audit_rules = out.split('\n')
        audit_rules.pop()
        if audit_rules[0] == "No rules":
            audit_rules.pop()
        return audit_rules + get_list_of_loaded_control_rules()
    else:
        raise OperationFailed('GINAUD0002E', {'name': ' '.join(cmd_sc)})