def _launchSupervdsm(self):
     self._authkey = str(uuid.uuid4())
     self._log.debug("Launching Super Vdsm")
     superVdsmCmd = [constants.EXT_PYTHON, SUPERVDSM,
                     self._authkey, str(os.getpid())]
     misc.execCmd(superVdsmCmd, sync=False)
     sleep(2)

 def removeBridge(self, bridge):
     ifdown(bridge.name)
     self._removeSourceRoute(bridge)
     execCmd([constants.EXT_BRCTL, 'delbr', bridge.name])
     self.configApplier.removeBridge(bridge.name)
     if bridge.port:
         bridge.port.remove()

 def _killSupervdsm(self):
     try:
         with open(PIDFILE, "r") as f:
             pid = int(f.read().strip())
         misc.execCmd([constants.EXT_KILL, "-9", str(pid)])
     except Exception, ex:
         self._log.debug("Could not kill old Super Vdsm %s", ex)

    def _removeFile(filename):
        """Remove file, umounting ovirt config files if needed."""

        mounts = open('/proc/mounts').read()
        if ' /config ext3' in mounts and ' %s ext3' % filename in mounts:
            execCmd([constants.EXT_UMOUNT, '-n', filename])
        utils.rmFile(filename)
        logging.debug("Removed file %s", filename)

 def removeBridge(self, bridge):
     DynamicSourceRoute.addInterfaceTracking(bridge)
     ifdown(bridge.name)
     self._removeSourceRoute(bridge)
     execCmd([constants.EXT_BRCTL, "delbr", bridge.name])
     self.configApplier.removeBridge(bridge.name)
     if bridge.port:
         bridge.port.remove()

    def _persistentBackup(cls, filename):
        """ Persistently backup ifcfg-* config files """
        if os.path.exists("/usr/libexec/ovirt-functions"):
            execCmd([constants.EXT_SH, "/usr/libexec/ovirt-functions", "unmount_config", filename])
            logging.debug("unmounted %s using ovirt", filename)

        (dummy, basename) = os.path.split(filename)
        if os.path.exists(filename):
            content = open(filename).read()
        else:
            # For non-exists ifcfg-* file use predefined header
            content = cls.DELETED_HEADER + "\n"
        logging.debug("backing up %s: %s", basename, content)

        cls.writeBackupFile(netinfo.NET_CONF_BACK_DIR, basename, content)

    def testExec(self):
        """
        Tests that execCmd execs and returns the correct ret code
        """
        ret, out, err = misc.execCmd([EXT_ECHO], sudo=False)

        self.assertEquals(ret, 0)

def _genInitramfs():
    logging.warning('Generating a temporary initramfs image')
    fd, path = tempfile.mkstemp()
    cmd = [_mkinitrd.cmd, "-f", path, _kernelVer]
    rc, out, err = execCmd(cmd)
    os.chmod(path, 0o644)
    return path

def runScanArgs(*args):
    cmd = [_virtAlignmentScan.cmd]
    cmd.extend(args)
    # TODO: remove the environment variable when the issue in
    # virt-alignment-scan/libvirt is resolved
    # http://bugzilla.redhat.com/1151838
    return execCmd(cmd, env={'LIBGUESTFS_BACKEND': 'direct'})

    def writeLargeData(self):
        data = """The Doctor: Davros, if you had created a virus in your
                              laboratory, something contagious and infectious
                              that killed on contact, a virus that would
                              destroy all other forms of life; would you allow
                              its use?
                  Davros: It is an interesting conjecture.
                  The Doctor: Would you do it?
                  Davros: The only living thing... The microscopic organism...
                          reigning supreme... A fascinating idea.
                  The Doctor: But would you do it?
                  Davros: Yes; yes. To hold in my hand, a capsule that
                          contained such power. To know that life and death on
                          such a scale was my choice. To know that the tiny
                          pressure on my thumb, enough to break the glass,
                          would end everything. Yes! I would do it! That power
                          would set me up above the gods! And through the
                          Daleks, I shall have that power! """
                  # (C) BBC - Doctor Who

        data = data * ((4096 / len(data)) * 2)
        self.assertTrue(data > 4096)
        p = misc.execCmd([EXT_CAT], sync=False)
        self.log.info("Writing data to std out")
        p.stdin.write(data)
        p.stdin.flush()
        self.log.info("Written data reading")
        self.assertEquals(p.stdout.read(len(data)), data)

 def __udevVersion(self):
     cmd = [EXT_UDEVADM, '--version']
     rc, out, err = misc.execCmd(cmd, sudo=False)
     if rc:
         self.log.error("Udevadm version command failed rc=%s, "
                        " out=\"%s\", err=\"%s\"", rc, out, err)
         raise RuntimeError("Could not get udev version number")
     return int(out[0])

 def test(self):
     args = [EXT_SLEEP, "4"]
     sproc = misc.execCmd(args, sync=False, sudo=False)
     try:
         self.assertEquals(misc.getCmdArgs(sproc.pid), tuple(args))
     finally:
         sproc.kill()
         sproc.wait()

    def _ifup(netIf):
        rc, out, err = execCmd([constants.EXT_IFUP, netIf], raw=False)

        if rc != 0:
            # In /etc/sysconfig/network-scripts/ifup* the last line usually
            # contains the error reason.
            raise ConfigNetworkError(ne.ERR_FAILED_IFUP, out[-1] if out else "")
        return rc, out, err

 def udevTrigger(self, guid):
     self.__udevReloadRules(guid)
     cmd = [EXT_UDEVADM, 'trigger', '--verbose', '--action', 'change',
            '--property-match=DM_NAME=%s' % guid]
     rc, out, err = misc.execCmd(cmd, sudo=False)
     if rc:
         raise OSError(errno.EINVAL, "Could not trigger change for device \
                       %s, out %s\nerr %s" % (guid, out, err))

 def testSudo(self):
     """
     Tests that when running with sudo the user really is root (or other
     desired user).
     """
     cmd = [EXT_WHOAMI]
     checkSudo(cmd)
     ret, stdout, stderr = misc.execCmd(cmd, sudo=True)
     self.assertEquals(stdout[0], SUDO_USER)

 def testWaitCond(self):
     ttl = 2
     p = misc.execCmd([EXT_SLEEP, str(ttl + 10)], sudo=False, sync=False)
     startTime = time.time()
     p.wait(cond=lambda: time.time() - startTime > ttl)
     duration = time.time() - startTime
     self.assertTrue(duration < (ttl + 2))
     self.assertTrue(duration > (ttl))
     p.kill()

 def testZombie(self):
     args = [EXT_SLEEP, "0"]
     sproc = misc.execCmd(args, sync=False, sudo=False)
     sproc.kill()
     try:
         test = lambda: self.assertEquals(misc.getCmdArgs(sproc.pid),
                                          tuple())
         utils.retry(AssertionError, test, tries=10, sleep=0.1)
     finally:
         sproc.wait()

 def testStdOut(self):
     """
     Tests that execCmd correctly returns the standard output of the prog it
     executes.
     """
     line = "All I wanted was to have some pizza, hang out with dad, " + \
            "and not let your weirdness mess up my day"
     # (C) Nickolodeon - Invader Zim
     ret, stdout, stderr = misc.execCmd((EXT_ECHO, line), sudo=False)
     self.assertEquals(stdout[0], line)

    def testValidInputFalse(self):
        """
        Test that is work when given valid but incorrect input.
        """
        count = 802
        with tempfile.NamedTemporaryFile() as f:
            cmd = [EXT_DD, "bs=1", "if=/dev/urandom", 'of=%s' % f.name,
                   'count=%d' % count]
            rc, out, err = misc.execCmd(cmd, sudo=False)

        self.assertFalse(misc.validateDDBytes(err, count + 1))

    def testNice(self):
        cmd = ["sleep", "10"]
        proc = misc.execCmd(cmd, sudo=False, nice=10, sync=False)

        def test():
            nice = utils.pidStat(proc.pid).nice
            self.assertEquals(nice, 10)

        utils.retry(AssertionError, test, tries=10, sleep=0.1)
        proc.kill()
        proc.wait()