Пример #1
0
def chown(vendorid, productid):
    # remove the 0x from the vendor and product id
    devid = vendorid[2:] + ':' + productid[2:]
    command = ['lsusb', '-d', devid]
    retcode, out, err = utils.execCmd(command, sudo=False, raw=True)
    if retcode != 0:
        sys.stderr.write('hostusb: cannot find usb device: %s\n' % devid)
        sys.exit(2)

    # find the device path:
    # /dev/bus/usb/xxx/xxx
    devpath = '/dev/bus/usb/' + out[4:7] + '/' + out[15:18]
    stat = os.stat(devpath)

    group = grp.getgrnam('qemu')
    gid = group.gr_gid
    user = pwd.getpwnam('qemu')
    uid = user.pw_uid

    # we don't use os.chown because we need sudo
    owner = str(uid) + ':' + str(gid)
    command = ['/bin/chown', owner, devpath]
    retcode, out, err = utils.execCmd(command, sudo=True, raw=True)
    if retcode != 0:
        sys.stderr.write('hostusb: error chown %s to %s, err = %s\n' %
                         (devpath, owner, err))
        sys.exit(2)

    log_dev_owner(devpath, stat.st_uid, stat.st_gid)
Пример #2
0
def chown(vendorid, productid):
    # remove the 0x from the vendor and product id
    devid = vendorid[2:] + ':' + productid[2:]
    command = ['lsusb', '-d', devid]
    retcode, out, err = utils.execCmd(command, sudo=False, raw=True)
    if retcode != 0:
        sys.stderr.write('hostusb: cannot find usb device: %s\n' % devid)
        sys.exit(2)

    devpath = '/dev/bus/usb/' + out[4:7] + '/' + out[15:18]

    uid, gid = get_owner(devpath)
    if uid == -1:
        sys.stderr.write(
            'hostusb after_vm_destroy: cannot find devpath: %s in file: %s\n' %
            (devpath, HOOK_HOSTUSB_PATH))
        return

    # we don't use os.chown because we need sudo
    owner = str(uid) + ':' + str(gid)
    command = ['/bin/chown', owner, devpath]
    retcode, out, err = utils.execCmd(command, sudo=True, raw=True)
    if retcode != 0:
        sys.stderr.write(
            'hostusb after_vm_destroy: error chown %s to %s, err = %s\n' %
            (devpath, owner, err))
        sys.exit(2)
Пример #3
0
def chown(vendorid, productid):
    # remove the 0x from the vendor and product id
    devid = vendorid[2:] + ':' + productid[2:]
    command = ['lsusb', '-d', devid]
    retcode, out, err = utils.execCmd(command, sudo=False, raw=True)
    if retcode != 0:
        sys.stderr.write('hostusb: cannot find usb device: %s\n' % devid)
        sys.exit(2)

    # find the device path:
    # /dev/bus/usb/xxx/xxx
    devpath = '/dev/bus/usb/' + out[4:7] + '/' + out[15:18]
    stat = os.stat(devpath)

    group = grp.getgrnam('qemu')
    gid = group.gr_gid
    user = pwd.getpwnam('qemu')
    uid = user.pw_uid

    # we don't use os.chown because we need sudo
    owner = str(uid) + ':' + str(gid)
    command = ['/bin/chown', owner, devpath]
    retcode, out, err = utils.execCmd(command, sudo=True, raw=True)
    if retcode != 0:
        sys.stderr.write('hostusb: error chown %s to %s, err = %s\n' % (devpath, owner, err))
        sys.exit(2)

    log_dev_owner(devpath, stat.st_uid, stat.st_gid)
Пример #4
0
def chown(vendorid, productid):
    # remove the 0x from the vendor and product id
    devid = vendorid[2:] + ":" + productid[2:]
    command = ["lsusb", "-d", devid]
    retcode, out, err = utils.execCmd(command, sudo=False, raw=True)
    if retcode != 0:
        sys.stderr.write("hostusb: cannot find usb device: %s\n" % devid)
        sys.exit(2)

    devpath = "/dev/bus/usb/" + out[4:7] + "/" + out[15:18]

    uid, gid = get_owner(devpath)
    if uid == -1:
        sys.stderr.write(
            "hostusb after_vm_destroy: cannot find devpath: %s in file: %s\n" % (devpath, HOOK_HOSTUSB_PATH)
        )
        return

    # we don't use os.chown because we need sudo
    owner = str(uid) + ":" + str(gid)
    command = ["/bin/chown", owner, devpath]
    retcode, out, err = utils.execCmd(command, sudo=True, raw=True)
    if retcode != 0:
        sys.stderr.write("hostusb after_vm_destroy: error chown %s to %s, err = %s\n" % (devpath, owner, err))
        sys.exit(2)
Пример #5
0
    def adjust(self):
        """adjust ksm state according to configuration and current memory stress
        return whether ksm is running"""

        self._lock.acquire()
        try:
            utils.execCmd([constants.EXT_SERVICE, 'ksmtuned', 'retune'], sudo=True)
            self.state, self.pages = self.readState()
        finally:
            self._lock.release()
        return self.state
Пример #6
0
    def adjust(self):
        """adjust ksm state according to configuration and current memory stress
        return whether ksm is running"""

        self._lock.acquire()
        try:
            utils.execCmd([constants.EXT_SERVICE, 'ksmtuned', 'retune'],
                          sudo=True)
            self.state, self.pages = self.readState()
        finally:
            self._lock.release()
        return self.state
Пример #7
0
 def _connect(self):
     logging.debug("Attempting connection to %s", self._socketName)
     utils.execCmd([constants.EXT_PREPARE_VMCHANNEL, self._socketName])
     self._sock.settimeout(5)
     while not self._stopped:
         try:
             self._sock.connect(self._socketName)
             logging.debug("connected to %s", self._socketName)
             self._sock.settimeout(config.getint('vars', 'guest_agent_timeout'))
             return True
         except:
             time.sleep(1)
     return False
Пример #8
0
def _gen_keys(cluster_name, fsid, monitors, cluster_dir):
    '''
    :: monitors = {ID: {'name': SHORT_HOSTNAME, 'address': IP_ADDR,
                        'port': INT}, ...}
    '''
    mon_key_path = cluster_dir + '/mon.key'
    admin_key_path = cluster_dir + '/client.admin.keyring'
    mon_map_path = cluster_dir + '/mon.map'

    utils.execCmd([_ceph_authtool.cmd, '--create-keyring', mon_key_path,
                   '--gen-key', '-n', 'mon.', '--cap', 'mon', 'allow *'])

    utils.execCmd([_ceph_authtool.cmd, '--create-keyring', admin_key_path,
                   '--gen-key', '-n', 'client.admin', '--set-uid=0', '--cap',
                   'mon', 'allow *', '--cap', 'osd', 'allow *', '--cap',
                   'mds', 'allow'])

    utils.execCmd([_ceph_authtool.cmd, mon_key_path, '--import-keyring',
                   admin_key_path])

    cmd = [_monmaptool.cmd, '--create', '--clobber']
    for m, v in monitors.iteritems():
        cmd += ['--add', 'mon.' + m, v['address']]
    cmd += ['--fsid', fsid, mon_map_path]
    utils.execCmd(cmd)

    return True
Пример #9
0
def _gen_keys(cluster_name, fsid, monitors, cluster_dir):
    '''
    :: monitors = {ID: {'name': SHORT_HOSTNAME, 'address': IP_ADDR,
                        'port': INT}, ...}
    '''
    mon_key_path = cluster_dir + '/mon.key'
    admin_key_path = cluster_dir + '/client.admin.keyring'
    mon_map_path = cluster_dir + '/mon.map'

    utils.execCmd([
        _ceph_authtool.cmd, '--create-keyring', mon_key_path, '--gen-key',
        '-n', 'mon.', '--cap', 'mon', 'allow *'
    ])

    utils.execCmd([
        _ceph_authtool.cmd, '--create-keyring', admin_key_path, '--gen-key',
        '-n', 'client.admin', '--set-uid=0', '--cap', 'mon', 'allow *',
        '--cap', 'osd', 'allow *', '--cap', 'mds', 'allow'
    ])

    utils.execCmd(
        [_ceph_authtool.cmd, mon_key_path, '--import-keyring', admin_key_path])

    cmd = [_monmaptool.cmd, '--create', '--clobber']
    for m, v in monitors.iteritems():
        cmd += ['--add', 'mon.' + m, v['address']]
    cmd += ['--fsid', fsid, mon_map_path]
    utils.execCmd(cmd)

    return True
Пример #10
0
def getRBDStats(pool_name, cluster_name):
    cmd = ["rbd", "du", "--cluster", cluster_name, "-p", pool_name, "--format=json"]
    rc, out, err = utils.execCmd(cmd)
    if not rc:
        return out
    else:
        return err
Пример #11
0
def getPoolList(clusterName):
    cmd = ["ceph", "--cluster", clusterName, "-f", "json", "osd", "lspools"]
    rc, out, err = utils.execCmd(cmd)
    if not rc:
        return out
    else:
        return err
Пример #12
0
def _execCmd(command):
    returnCode, output, error = execCmd(command)

    if returnCode:
        raise IPRoute2Error(error)

    return output
Пример #13
0
def info(image, format=None):
    cmd = [_qemuimg.cmd, "info"]

    if format:
        cmd.extend(("-f", format))

    cmd.append(image)
    rc, out, err = utils.execCmd(cmd)

    if rc != 0:
        raise QImgError(rc, out, err)

    try:
        info = {
            'format': __iregexSearch("format", out[1]),
            'virtualsize': int(__iregexSearch("virtualsize", out[2])),
        }

        if len(out) > 4:
            info['clustersize'] = int(__iregexSearch("clustersize", out[4]))

        if len(out) > 5:
            info['backingfile'] = __iregexSearch("backingfile", out[5])
    except:
        raise QImgError(rc, out, err, "unable to parse qemu-img info output")

    return info
Пример #14
0
def info(image, format=None):
    cmd = [_qemuimg.cmd, "info"]

    if format:
        cmd.extend(("-f", format))

    cmd.append(image)
    rc, out, err = utils.execCmd(cmd)

    if rc != 0:
        raise QImgError(rc, out, err)

    try:
        info = {
            'format': __iregexSearch("format", out[1]),
            'virtualsize': int(__iregexSearch("virtualsize", out[2])),
        }

        if len(out) > 4:
            info['clustersize'] = int(__iregexSearch("clustersize", out[4]))

        if len(out) > 5:
            info['backingfile'] = __iregexSearch("backingfile", out[5])
    except:
        raise QImgError(rc, out, err, "unable to parse qemu-img info output")

    return info
Пример #15
0
def _getKeyPackages():
    def kernelDict():
        try:
            ver, rel = file('/proc/sys/kernel/osrelease').read(). \
                                strip().split('-', 1)
        except:
            logging.error('kernel release not found', exc_info=True)
            ver, rel = '0', '0'
        try:
            t = file('/proc/sys/kernel/version').read().split()[2:]
            del t[4]  # Delete timezone
            t = time.mktime(time.strptime(' '.join(t)))
        except:
            logging.error('kernel build time not found', exc_info=True)
            t = '0'
        return dict(version=ver, release=rel, buildtime=t)

    KEY_PACKAGES = ['qemu-kvm', 'qemu-img', 'vdsm', 'spice-server', 'libvirt']

    pkgs = {'kernel': kernelDict()}
    try:
        for pkg in KEY_PACKAGES:
            rc, out, err = utils.execCmd([
                constants.EXT_RPM, '-q', '--qf',
                '%{NAME}\t%{VERSION}\t%{RELEASE}\t%{BUILDTIME}\n', pkg
            ],
                                         sudo=False)
            if rc: continue
            line = out[-1]
            n, v, r, t = line.split()
            pkgs[pkg] = dict(version=v, release=r, buildtime=t)
    except:
        logging.error('', exc_info=True)

    return pkgs
Пример #16
0
def getOSDDetails(clusterName):
    cmd = ["ceph", "osd", "df", "--cluster", clusterName, "-f", "json"]
    rc, out, err = utils.execCmd(cmd)
    if not rc:
        return out
    else:
        return err
Пример #17
0
def removeDeviceNode(devpath):
    # we don't use os.unlink because we need sudo
    command = ['/bin/rm', '-f', devpath]
    retcode, out, err = utils.execCmd(command, sudo=True, raw=True)
    if retcode != 0:
        sys.stderr.write('directlun after_vm_destroy: error rm -f %s, err = %s\n' % (devpath, err))
        sys.exit(2)
Пример #18
0
def _getKeyPackages():
    def kernelDict():
        try:
            ver, rel = file('/proc/sys/kernel/osrelease').read(). \
                                strip().split('-', 1)
        except:
            logging.error('kernel release not found', exc_info=True)
            ver, rel = '0', '0'
        try:
            t = file('/proc/sys/kernel/version').read().split()[2:]
            del t[4] # Delete timezone
            t = time.mktime(time.strptime(' '.join(t)))
        except:
            logging.error('kernel build time not found', exc_info=True)
            t = '0'
        return dict(version=ver, release=rel, buildtime=t)

    KEY_PACKAGES = ['qemu-kvm', 'qemu-img',
                    'vdsm', 'spice-server', 'libvirt']

    pkgs = {'kernel': kernelDict()}
    try:
        for pkg in KEY_PACKAGES:
            rc, out, err = utils.execCmd([constants.EXT_RPM, '-q', '--qf',
                  '%{NAME}\t%{VERSION}\t%{RELEASE}\t%{BUILDTIME}\n', pkg],
                  sudo=False)
            if rc: continue
            line = out[-1]
            n, v, r, t = line.split()
            pkgs[pkg] = dict(version=v, release=r, buildtime=t)
    except:
        logging.error('', exc_info=True)

    return pkgs
Пример #19
0
def getPoolList(clusterName):
    cmd = ["ceph", "--cluster", clusterName, "-f", "json", "osd", "lspools"]
    rc, out, err = utils.execCmd(cmd)
    if not rc:
        return out
    else:
        return err
Пример #20
0
def _execCmd(command):
    returnCode, output, error = execCmd(command)

    if returnCode:
        raise IPRoute2Error(error)

    return output
Пример #21
0
def getOSDDetails(clusterName):
    cmd = ["ceph", "osd", "df", "--cluster", clusterName, "-f", "json"]
    rc, out, err = utils.execCmd(cmd)
    if not rc:
        return out
    else:
        return err
Пример #22
0
def _execGluster(cmd):
    rc, out, err = utils.execCmd(cmd)
    if rc != 0:
        if (err is not None and any(_TRANS_IN_PROGRESS in e.lower() for e in err)) or (
            out is not None and any("connection failed" in o.lower() for o in out)
        ):
            raise GlusterLockedException(rc, out, err)
    return rc, out, err
Пример #23
0
def addOsdToCrush(clusterName, osdName, weight, host):
    hostStr = 'host='+host
    cmd = ["ceph", "--cluster", clusterName, "osd", "crush", "create-or-move", osdName, str(round(weight,9)), hostStr, "root=default"]
    try:
        rc, out, err = utils.execCmd(cmd)
        return rc
    except Exception as e:
        return 1
Пример #24
0
def getClusterStatus(clusterName):
    cmd = ["ceph", "-s", "--cluster", clusterName]
    rc, out, err = utils.execCmd(cmd)
    if not rc:
        for line in out.splitlines():
            if line.strip().startswith("health"):
                return line.strip().split(' ')[1]
    return ''
Пример #25
0
def getClusterStatus(clusterName):
    cmd = ["ceph", "-s", "--cluster", clusterName]
    rc, out, err = utils.execCmd(cmd)
    if not rc:
        for line in out.splitlines():
            if line.strip().startswith("health"):
                return line.strip().split(' ')[1]
    return ''
Пример #26
0
def removeDeviceNode(devpath):
    # we don't use os.unlink because we need sudo
    command = ['/bin/rm', '-f', devpath]
    retcode, out, err = utils.execCmd(command, sudo=True, raw=True)
    if retcode != 0:
        sys.stderr.write(
            'directlun after_vm_destroy: error rm -f %s, err = %s\n' %
            (devpath, err))
        sys.exit(2)
Пример #27
0
def _execGluster(cmd):
    rc, out, err = utils.execCmd(cmd)
    if rc != 0:
        if ((err is not None and
             any(_TRANS_IN_PROGRESS in e.lower() for e in err)) or
            (out is not None and
             any("connection failed" in o.lower() for o in out))):
            raise GlusterLockedException(rc, out, err)
    return rc, out, err
Пример #28
0
def getRBDStats(pool_name, cluster_name):
    cmd = [
        "rbd", "du", "--cluster", cluster_name, "-p", pool_name,
        "--format=json"
    ]
    rc, out, err = utils.execCmd(cmd)
    if not rc:
        return out
    else:
        return err
Пример #29
0
def removePool(clusterName, poolName):
    cmd = [
        "ceph", "osd", "pool", "delete", poolName, poolName,
        "--yes-i-really-really-mean-it", "--cluster", clusterName
    ]
    rc, out, err = utils.execCmd(cmd)
    if not rc:
        return out
    else:
        return err
Пример #30
0
def resize(image, newSize, format=None):
    cmd = [_qemuimg.cmd, "resize"]

    if format:
        cmd.extend(("-f", format))

    cmd.extend((image, str(newSize)))
    rc, out, err = utils.execCmd(cmd)

    if rc != 0:
        raise QImgError(rc, out, err)
Пример #31
0
def createPool(clusterName, poolName, pgNum=0):
    cmd = ["ceph", "--cluster", clusterName, "osd", "pool", "create", poolName]
    if pgNum:
        cmd += [pgNum]
    else:
        cmd += [DEFAULT_PG_NUM]
    rc, out, err = utils.execCmd(cmd)
    if not rc:
        return out
    else:
        return err
Пример #32
0
def createPool(clusterName, poolName, pgNum=0):
    cmd = ["ceph", "--cluster", clusterName, "osd", "pool", "create", poolName]
    if pgNum:
        cmd += [pgNum]
    else:
        cmd += [DEFAULT_PG_NUM]
    rc, out, err = utils.execCmd(cmd)
    if not rc:
        return out
    else:
        return err
Пример #33
0
def check(image, format=None):
    cmd = [_qemuimg.cmd, "check"]

    if format:
        cmd.extend(("-f", format))

    cmd.append(image)
    rc, out, err = utils.execCmd(cmd)

    if rc != 0:
        raise QImgError(rc, out, err)
Пример #34
0
def resize(image, newSize, format=None):
    cmd = [_qemuimg.cmd, "resize"]

    if format:
        cmd.extend(("-f", format))

    cmd.extend((image, str(newSize)))
    rc, out, err = utils.execCmd(cmd)

    if rc != 0:
        raise QImgError(rc, out, err)
Пример #35
0
def addOsdToCrush(clusterName, osdName, weight, host):
    hostStr = 'host=' + host
    cmd = [
        "ceph", "--cluster", clusterName, "osd", "crush", "create-or-move",
        osdName,
        str(round(weight, 9)), hostStr, "root=default"
    ]
    try:
        rc, out, err = utils.execCmd(cmd)
        return rc
    except Exception as e:
        return 1
Пример #36
0
def cloneDeviceNode(srcpath, devpath):
    '''Clone a device node into a temporary private location.'''

    # we don't use os.remove/mknod/chmod/chown because we need sudo
    command = ['/bin/rm', '-f', devpath]
    retcode, out, err = utils.execCmd(command, sudo=True, raw=True)
    if retcode != 0:
        sys.stderr.write('directlun: error rm -f %s, err = %s\n' %
                         (devpath, err))
        sys.exit(2)

    stat = os.stat(srcpath)
    major = os.major(stat.st_rdev)
    minor = os.minor(stat.st_rdev)
    command = ['/bin/mknod', devpath, 'b', str(major), str(minor)]
    retcode, out, err = utils.execCmd(command, sudo=True, raw=True)
    if retcode != 0:
        sys.stderr.write('directlun: error mknod %s, err = %s\n' %
                         (devpath, err))
        sys.exit(2)

    mode = '660'
    command = ['/bin/chmod', mode, devpath]
    retcode, out, err = utils.execCmd(command, sudo=True, raw=True)
    if retcode != 0:
        sys.stderr.write('directlun: error chmod %s to %s, err = %s\n' %
                         (devpath, mode, err))
        sys.exit(2)

    group = grp.getgrnam('qemu')
    gid = group.gr_gid
    user = pwd.getpwnam('qemu')
    uid = user.pw_uid
    owner = str(uid) + ':' + str(gid)
    command = ['/bin/chown', owner, devpath]
    retcode, out, err = utils.execCmd(command, sudo=True, raw=True)
    if retcode != 0:
        sys.stderr.write('directlun: error chown %s to %s, err = %s\n' %
                         (devpath, owner, err))
        sys.exit(2)
def createFloppy(filename, path, content):

    if os.path.exists(path):
        os.remove(path)

    # create floppy file system
    command = ['/sbin/mkfs.msdos', '-C', path, '1440']
    retcode, out, err = utils.execCmd(command, sudo=True, raw=True)
    if retcode != 0:
        sys.stderr.write('floppyinject-before-dest-migration: error /sbin/mkfs.msdos fs: %s\n' % err)
        sys.exit(2)

    owner = '36:36'
    command = ['/bin/chown', owner, path]
    retcode, out, err = utils.execCmd(command, sudo=True, raw=True)
    if retcode != 0:
        sys.stderr.write('floppyinject-before-dest-migration: error /bin/chown: %s' % err)
        sys.exit(2)


    # create floppy file system
    command = ['/bin/chmod', '0770', path]
    retcode, out, err = utils.execCmd(command, sudo=True, raw=True)
    if retcode != 0:
        sys.stderr.write('floppyinject-before-dest-migration: error /bin/chmod: %s' % err)
        sys.exit(2)

    
    # mount the floppy file
    mntpoint = tempfile.mkdtemp()
    command = ['/bin/mount', '-o', 'loop,uid=36,gid=36' , path, mntpoint]
    sys.stderr.write('shahar: %s\n' % ' '.join(command))
    retcode, out, err = utils.execCmd(command, sudo=True, raw=True)
    if retcode != 0:
        sys.stderr.write('floppyinject-before-dest-migration: error /bin/mount: %s' % err)
        sys.exit(2)


    # write the file content
    contentpath = os.path.join(mntpoint, filename)
    f = open(contentpath, 'w')
    f.write(content)
    f.close()


    # unmounting
    command = ['/bin/umount', mntpoint]
    retcode, out, err = utils.execCmd(command, sudo=True, raw=True)
    if retcode != 0:
        sys.stderr.write('floppyinject-before-dest-migration: error /bin/umount: %s' % err)
        sys.exit(2)


    # remove tempdir
    command = ['/bin/rmdir',  mntpoint]
    retcode, out, err = utils.execCmd(command, sudo=True, raw=True)
    if retcode != 0:
        sys.stderr.write('floppyinject-before-dest-migration: error /bin/rmdir: %s' % err)
        sys.exit(2)
Пример #38
0
def getIp():
    ipRe = re.compile(
        r"(?:25[0-5]\.|2[0-4]\d\.|[01]?\d\d?\.){3}(?:25[0-5]|2[0-4]\d|[01]?\d\d?)"
    )
    wlanList = ['wlp2s0', 'wlan0']
    wlanip = ""
    for wlan in wlanList:
        ip = utils.execCmd("ifconfig " + wlan)
        ipList = ipRe.findall(ip)
        if len(ipList) != 0:
            wlanip = ipList[0]
            break
    return wlanip
Пример #39
0
def createDirectory(dirpath):
    # we don't use os.mkdir/chown because we need sudo
    command = ['/bin/mkdir', '-p', dirpath]
    retcode, out, err = utils.execCmd(command, sudo=True, raw=True)
    if retcode != 0:
        sys.stderr.write('directlun: error mkdir %s, err = %s\n' % (dirpath, err))
        sys.exit(2)

    mode = '755'
    command = ['/bin/chmod', mode, dirpath]
    if retcode != 0:
        sys.stderr.write('directlun: error chmod %s %s, err = %s\n' % (dirpath, mode, err))
        sys.exit(2)
Пример #40
0
def main():
    cmd = ["dbus-send", "--system", "--type=method_call", "--dest=org.storaged.Storaged",
           "/org/storaged/Storaged/Manager", "org.storaged.Storaged.Manager.EnableModules", "boolean:true"]
    rc, out, err = utils.execCmd(cmd)
    if rc != 0 :
        logger.error("Could not enable Storaged module")

    try:
        Skynetd().run()
        exit(0)
    except Exception as e:
        logger.error("Skynet Initialization failed: %s", str(e))
        pass
def createDirectory(dirpath):

    # we don't use os.mkdir/chown because we need sudo
    command = ['/bin/mkdir', '-p', dirpath]
    retcode, out, err = utils.execCmd(command, sudo=True, raw=True)
    if retcode != 0:
        sys.stderr.write('directlun: error mkdir %s, err = %s\n' % (dirpath, err))
        sys.exit(2)

    mode = '755'
    command = ['/bin/chmod', mode, dirpath]
    if retcode != 0:
        sys.stderr.write('directlun: error chmod %s %s, err = %s\n' % (dirpath, mode, err))
        sys.exit(2)
Пример #42
0
def createFloppy(filename, path, content):

    if os.path.exists(path):
        os.remove(path)

    # create floppy file system
    command = ['/sbin/mkfs.msdos', '-C', path, '1440']
    retcode, out, err = utils.execCmd(command, sudo=True, raw=True)
    if retcode != 0:
        sys.stderr.write('floppyinject: error /sbin/mkfs.msdos fs: %s\n' % err)
        sys.exit(2)

    owner = '36:36'
    command = ['/bin/chown', owner, path]
    retcode, out, err = utils.execCmd(command, sudo=True, raw=True)
    if retcode != 0:
        sys.stderr.write('floppyinject: error /bin/chown: %s' % err)
        sys.exit(2)

    # create floppy file system
    command = ['/bin/chmod', '0770', path]
    retcode, out, err = utils.execCmd(command, sudo=True, raw=True)
    if retcode != 0:
        sys.stderr.write('floppyinject: error /bin/chmod: %s' % err)
        sys.exit(2)

    # mount the floppy file
    mntpoint = tempfile.mkdtemp()
    command = ['/bin/mount', '-o', 'loop,uid=36,gid=36', path, mntpoint]
    sys.stderr.write('shahar: %s\n' % ' '.join(command))
    retcode, out, err = utils.execCmd(command, sudo=True, raw=True)
    if retcode != 0:
        sys.stderr.write('floppyinject: error /bin/mount: %s' % err)
        sys.exit(2)

    # base64 decode the content
    content = base64.decodestring(content)

    # write the file content
    contentpath = os.path.join(mntpoint, filename)
    f = open(contentpath, 'w')
    f.write(content)
    f.close()

    # unmounting
    command = ['/bin/umount', mntpoint]
    retcode, out, err = utils.execCmd(command, sudo=True, raw=True)
    if retcode != 0:
        sys.stderr.write('floppyinject: error /bin/umount: %s' % err)
        sys.exit(2)

    # remove tempdir
    command = ['/bin/rmdir', mntpoint]
    retcode, out, err = utils.execCmd(command, sudo=True, raw=True)
    if retcode != 0:
        sys.stderr.write('floppyinject: error /bin/rmdir: %s' % err)
        sys.exit(2)
Пример #43
0
 def __init__(self, cif):
     threading.Thread.__init__(self, name = 'KsmMonitor')
     self.setDaemon(True)
     self._cif = cif
     self.state, self.pages = False, 0
     self._lock = threading.Lock()
     if config.getboolean('ksm', 'ksm_monitor_thread'):
         pids = utils.execCmd([constants.EXT_PGREP, '-xf', 'ksmd'],
                              raw=False, sudo=False)[1]
         if pids:
             self._pid = pids[0].strip()
             self.start()
         else:
             self._cif.log.error('failed to find ksmd thread')
     self.cpuUsage = 0
Пример #44
0
def cloneDeviceNode(srcpath, devpath):
    """Clone a device node into a temporary private location."""

    # we don't use os.remove/mknod/chmod/chown because we need sudo
    command = ['/bin/rm', '-f', devpath]
    retcode, out, err = utils.execCmd(command, sudo=True, raw=True)
    if retcode != 0:
        sys.stderr.write('directlun: error rm -f %s, err = %s\n' % (devpath, err))
        sys.exit(2)

    stat = os.stat(srcpath)
    major = os.major(stat.st_rdev)
    minor = os.minor(stat.st_rdev)
    command = ['/bin/mknod', devpath, 'b', str(major), str(minor)]
    retcode, out, err = utils.execCmd(command, sudo=True, raw=True)
    if retcode != 0:
        sys.stderr.write('directlun: error mknod %s, err = %s\n' % (devpath, err))
        sys.exit(2)

    mode = '660'
    command = ['/bin/chmod', mode, devpath]
    retcode, out, err = utils.execCmd(command, sudo=True, raw=True)
    if retcode != 0:
        sys.stderr.write('directlun: error chmod %s to %s, err = %s\n' % (devpath, mode, err))
        sys.exit(2)

    group = grp.getgrnam('qemu')
    gid = group.gr_gid
    user = pwd.getpwnam('qemu')
    uid = user.pw_uid
    owner = str(uid) + ':' + str(gid)
    command = ['/bin/chown', owner, devpath]
    retcode, out, err = utils.execCmd(command, sudo=True, raw=True)
    if retcode != 0:
        sys.stderr.write('directlun: error chown %s to %s, err = %s\n' % (devpath, owner, err))
        sys.exit(2)
Пример #45
0
 def __init__(self, cif):
     threading.Thread.__init__(self, name='KsmMonitor')
     self.setDaemon(True)
     self._cif = cif
     self.state, self.pages = False, 0
     self._lock = threading.Lock()
     if config.getboolean('ksm', 'ksm_monitor_thread'):
         pids = utils.execCmd([constants.EXT_PGREP, '-xf', 'ksmd'],
                              raw=False,
                              sudo=False)[1]
         if pids:
             self._pid = pids[0].strip()
             self.start()
         else:
             self._cif.log.error('failed to find ksmd thread')
     self.cpuUsage = 0
Пример #46
0
def removePool(clusterName, poolName):
    cmd = [
            "ceph",
            "osd",
            "pool",
            "delete",
            poolName,
            poolName,
            "--yes-i-really-really-mean-it",
            "--cluster",
            clusterName
          ]
    rc, out, err = utils.execCmd(cmd)
    if not rc:
        return out
    else:
        return err
Пример #47
0
def _gen_keys(cluster_name, fsid, monitors, cluster_dir):
    """
    :: monitors = {ID: {'name': SHORT_HOSTNAME, 'address': IP_ADDR,
                        'port': INT}, ...}
    """
    mon_key_path = cluster_dir + "/mon.key"
    admin_key_path = cluster_dir + "/client.admin.keyring"
    mon_map_path = cluster_dir + "/mon.map"

    utils.execCmd(
        [_ceph_authtool.cmd, "--create-keyring", mon_key_path, "--gen-key", "-n", "mon.", "--cap", "mon", "allow *"]
    )

    utils.execCmd(
        [
            _ceph_authtool.cmd,
            "--create-keyring",
            admin_key_path,
            "--gen-key",
            "-n",
            "client.admin",
            "--set-uid=0",
            "--cap",
            "mon",
            "allow *",
            "--cap",
            "osd",
            "allow *",
            "--cap",
            "mds",
            "allow",
        ]
    )

    utils.execCmd([_ceph_authtool.cmd, mon_key_path, "--import-keyring", admin_key_path])

    cmd = [_monmaptool.cmd, "--create", "--clobber"]
    for m, v in monitors.iteritems():
        cmd += ["--add", "mon." + m, v["address"]]
    cmd += ["--fsid", fsid, mon_map_path]
    utils.execCmd(cmd)

    return True
Пример #48
0
def _runHooksDir(domxml, dir, vmconf={}, raiseError=True):
    scripts = _scriptsPerDir(dir)
    scripts.sort()

    if not scripts:
        return domxml

    xmlfd, xmlname = tempfile.mkstemp()
    try:
        os.write(xmlfd, domxml or '')
        os.close(xmlfd)

        scriptenv = os.environ.copy()
        scriptenv.update(vmconf.get('custom', {}))
        if vmconf.get('vmId'):
            scriptenv['vmId'] = vmconf.get('vmId')
        ppath = scriptenv.get('PYTHONPATH', '')
        scriptenv['PYTHONPATH'] = ':'.join(ppath.split(':') + [P_VDSM])
        scriptenv['_hook_domxml'] = xmlname
        for k, v in scriptenv.iteritems():
            scriptenv[k] = unicode(v).encode('utf-8')

        errorSeen = False
        for s in scripts:
            rc, out, err = utils.execCmd([s],
                                         sudo=False,
                                         raw=True,
                                         env=scriptenv)
            logging.info(err)
            if rc != 0:
                errorSeen = True

            if rc == 2:
                break
            elif rc > 2:
                logging.warn('hook returned unexpected return code %s', rc)

        if errorSeen and raiseError:
            raise HookError()

        finalxml = file(xmlname).read()
    finally:
        os.unlink(xmlname)
    return finalxml
Пример #49
0
def check(image, format=None):
    cmd = [_qemuimg.cmd, "check"]

    if format:
        cmd.extend(("-f", format))

    cmd.append(image)
    rc, out, err = utils.execCmd(cmd)

    #FIXME: handle different error codes and raise errors accordingly
    if rc != 0:
        raise QImgError(rc, out, err)
    try:
        check = {'offset': int(__iregexSearch("offset", out[1]))}
    #TODO: Add requires for qemu supporting offset and print exc_info
    except:
        raise QImgError(rc, out, err, "unable to parse qemu-img check output")

    return check
Пример #50
0
def _runHooksDir(domxml, dir, vmconf={}, raiseError=True):
    scripts = _scriptsPerDir(dir)
    scripts.sort()

    if not scripts:
        return domxml

    xmlfd, xmlname = tempfile.mkstemp()
    try:
        os.write(xmlfd, domxml or '')
        os.close(xmlfd)

        scriptenv = os.environ.copy()
        scriptenv.update(vmconf.get('custom', {}))
        if vmconf.get('vmId'):
            scriptenv['vmId'] = vmconf.get('vmId')
        ppath = scriptenv.get('PYTHONPATH', '')
        scriptenv['PYTHONPATH'] = ':'.join(ppath.split(':') + [P_VDSM])
        scriptenv['_hook_domxml'] = xmlname
        for k, v in scriptenv.iteritems():
            scriptenv[k] = unicode(v).encode('utf-8')

        errorSeen = False
        for s in scripts:
            rc, out, err = utils.execCmd([s], sudo=False, raw=True,
                                         env=scriptenv)
            logging.info(err)
            if rc != 0:
                errorSeen = True

            if rc == 2:
                break
            elif rc > 2:
                logging.warn('hook returned unexpected return code %s', rc)

        if errorSeen and raiseError:
            raise HookError()

        finalxml = file(xmlname).read()
    finally:
        os.unlink(xmlname)
    return finalxml
Пример #51
0
def _execGlusterXml(cmd):
    cmd.append('--xml')
    rc, out, err = utils.execCmd(cmd)
    _throwIfBusy(cmd, rc, out, err)

    try:
        tree = etree.fromstring(out)
        rv = int(tree.find('opRet').text)
        msg = tree.find('opErrstr').text
        errNo = int(tree.find('opErrno').text)
    except _etreeExceptions:
        raise GlusterXMLError(cmd, out)

    if rv == 0:
        return tree

    if errNo != 0:
        rv = errNo

    raise GlusterCmdFailed(cmd, rv, err=msg)
Пример #52
0
def _execGlusterXml(cmd):
    cmd.append('--xml')
    rc, out, err = utils.execCmd(cmd)
    _throwIfBusy(cmd, rc, out, err)

    try:
        tree = etree.fromstring(out)
        rv = int(tree.find('opRet').text)
        msg = tree.find('opErrstr').text
        errNo = int(tree.find('opErrno').text)
    except _etreeExceptions:
        raise GlusterXMLError(cmd, out)

    if rv == 0:
        return tree

    if errNo != 0:
        rv = errNo

    raise GlusterCmdFailed(cmd, rv, err=msg)
Пример #53
0
def create(image, size=None, format=None, backing=None, backingFormat=None):
    cmd = [_qemuimg.cmd, "create"]

    if format:
        cmd.extend(("-f", format))

    if backing:
        cmd.extend(("-b", backing))

    if backingFormat:
        cmd.extend(("-F", backingFormat))

    cmd.append(image)

    if size:
        cmd.append(int(size))

    rc, out, err = utils.execCmd(cmd)

    if rc != 0:
        raise QImgError(rc, out, err)
Пример #54
0
def check(image, format=None):
    cmd = [_qemuimg.cmd, "check"]

    if format:
        cmd.extend(("-f", format))

    cmd.append(image)
    rc, out, err = utils.execCmd(cmd)

    #FIXME: handle different error codes and raise errors accordingly
    if rc != 0:
        raise QImgError(rc, out, err)
    try:
        check = {
            'offset': int(__iregexSearch("offset", out[1]))
        }
    #TODO: Add requires for qemu supporting offset and print exc_info
    except:
        raise QImgError(rc, out, err, "unable to parse qemu-img check output")

    return check
Пример #55
0
def rbd_command(command_args, pool_name=None):
    """
    Run a rbd CLI operation directly.  This is a fallback to allow
    manual execution of arbitrary commands in case the user wants to
    do something that is absent or broken in Calamari proper.

    :param pool_name: Ceph pool name, or None to run without --pool argument
    :param command_args: Command line, excluding the leading 'rbd' part.
    """

    if pool_name:
        args = ["rbd", "--pool", pool_name] + command_args
    else:
        args = ["rbd"] + command_args

    log.info('rbd_command {0}'.format(str(args)))

    rc, out, err = utils.execCmd(args)

    log.info('rbd_command {0} {1} {2}'.format(str(rc), out, err))

    return {'out': out, 'err': err, 'status': rc}
Пример #56
0
def rbd_command(command_args, pool_name=None):
    """
    Run a rbd CLI operation directly.  This is a fallback to allow
    manual execution of arbitrary commands in case the user wants to
    do something that is absent or broken in Calamari proper.

    :param pool_name: Ceph pool name, or None to run without --pool argument
    :param command_args: Command line, excluding the leading 'rbd' part.
    """

    if pool_name:
        args = ["rbd", "--pool", pool_name] + command_args
    else:
        args = ["rbd"] + command_args

    log.info("rbd_command {0}".format(str(args)))

    rc, out, err = utils.execCmd(args)

    log.info("rbd_command {0} {1} {2}".format(str(rc), out, err))

    return {"out": out, "err": err, "status": rc}
Пример #57
0
def _execGlusterXml(cmd):
    cmd.append('--xml')
    rc, out, err = utils.execCmd(cmd)
    if rc != 0:
        if ((err is not None and
             any(_TRANS_IN_PROGRESS in e.lower() for e in err)) or
            (out is not None and
             any("connection failed" in o.lower() for o in out))):
            raise GlusterLockedException(rc, out, err)
        else:
            raise GlusterCmdFailedException(rc, out, err)
    try:
        tree = etree.fromstring('\n'.join(out))
        rv = int(tree.find('opRet').text)
        msg = tree.find('opErrstr').text
        errNo = int(tree.find('opErrno').text)
    except _etreeExceptions:
        raise GlusterCmdFailedException(err=out)
    if rv == 0:
        return tree
    else:
        if errNo != 0:
            rv = errNo
        raise GlusterCmdFailedException(rc=rv, err=[msg])
Пример #58
0
     
     if platform.system() == "Linux":
          import linuxTools as sEnv
     elif platform.system() == "Windows":
          import winTools as sEnv
     elif platform.system() == "Mac":
          import macTools as sEnv
     else:
          print("Unsupport os")
          
     if len(sys.argv) > 1:
          cf = ConfigParser.ConfigParser()
          cf.read("singleNet.conf")
          mUsername = cf.get("config", "username")
          mPassword = cf.get("config", "password")
          if sys.argv[1] == "1":
               mpin = utils.calc_pin(mUsername, mPassword)
               sEnv.connectWired(mUsername, mPassword, mpin)
          elif sys.argv[1] == "2":
	       wlanip = ""
               wlanip = sEnv.getIp()
	       if wlanip == "":
                    print("wlan device not found or error in found ip address")
	       else:
		    passRes = utils.execCmd("java EncryptPassword "+mPassword)
		    utils.connectWireless(mUsername, passRes, wlanip)
          else:
		print("Paramter error 1 for wired connect 2 for wireless connect")
     else:
          	print("Paramter error 1 for wired connect 2 for wireless connect")
Пример #59
0
def start():
    if not running():
        utils.execCmd([constants.EXT_SERVICE, 'ksmtuned', 'start'], sudo=True)
        utils.execCmd([constants.EXT_SERVICE, 'ksm', 'start'], sudo=True)