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:
            subprocess.call([constants.EXT_UMOUNT, '-n', filename])
        utils.rmFile(filename)

 def _removeFile(filename):
     """Remove file (directly or using oVirt node's library)"""
     if utils.isOvirtNode():
         node_fs.Config().delete(filename)  # unpersists and shreds the file
     else:
         utils.rmFile(filename)
     logging.debug("Removed file %s", filename)

    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 _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:
            utils.execCmd([constants.EXT_UMOUNT, '-n', filename])
        utils.rmFile(filename)
        logging.debug("Removed file %s", filename)

 def restoreAtomicBackup(self):
     logging.info("Rolling back configuration (restoring atomic backup)")
     for confFile, content in self._backups.iteritems():
         if content is None:
             utils.rmFile(confFile)
             logging.debug("Removing empty configuration backup %s", confFile)
         else:
             open(confFile, "w").write(content)
         logging.info("Restored %s", confFile)

    def testInit(self):
        filePath = os.path.join(self.tempdir, "nets", NETWORK)
        try:
            with open(filePath, "w") as networkFile:
                json.dump(NETWORK_ATTRIBUTES, networkFile)

            persistence = Config(self.tempdir)
            self.assertEqual(persistence.networks[NETWORK], NETWORK_ATTRIBUTES)
        finally:
            rmFile(filePath)

def _kill_and_rm_pid(pid, pid_file):
    try:
        os.kill(pid, signal.SIGTERM)
    except OSError as e:
        if e.errno == os.errno.ESRCH:  # Already exited
            pass
        else:
            raise
    if pid_file is not None:
        rmFile(pid_file)

def clean_vm_files(cif):
    for f in os.listdir(constants.P_VDSM_RUN):
        try:
            vmId, fileType = f.split(".", 1)
        except ValueError:
            # If file is missing type extention - ignore it
            pass
        else:
            if fileType == "recovery" and vmId not in cif.vmContainer:
                cif.log.debug("cleaning old file " + f)
                utils.rmFile(constants.P_VDSM_RUN + f)

def rmAppropriateSCSIDevice(device_name, udev_path):
    rule_file = _UDEV_RULE_FILE_NAME % ('scsi', device_name)
    _log.debug("Removing rule %s", rule_file)
    utils.rmFile(rule_file)

    _log.debug('Changing ownership (to root:disk) of device %s', udev_path)
    cmd = [EXT_CHOWN, 'root:disk', udev_path]
    rc, out, err = commands.execCmd(cmd)
    if err:
        raise OSError(errno.EINVAL, 'Could not change ownership'
                      'out %s\nerr %s' % (out, err))

 def restoreAtomicBackup(self):
     logging.info("Rolling back configuration (restoring atomic backup)")
     for confFilePath, content in self._backups.iteritems():
         if content is None:
             utils.rmFile(confFilePath)
             logging.debug('Removing empty configuration backup %s',
                           confFilePath)
         else:
             with open(confFilePath, 'w') as confFile:
                 confFile.write(content)
         logging.info('Restored %s', confFilePath)

 def _cleanOldFiles(self):
     for f in os.listdir(constants.P_VDSM_RUN):
         try:
             vmId, fileType = f.split(".", 1)
             exts = ["guest.socket", "monitor.socket",
                     "stdio.dump", "recovery"]
             if fileType in exts and vmId not in self.vmContainer:
                 self.log.debug("removing old file " + f)
                 utils.rmFile(constants.P_VDSM_RUN + f)
         except:
             pass

    def _create(cls, dom, imgUUID, volUUID, size, volFormat, preallocate,
                volParent, srcImgUUID, srcVolUUID, imgPath, volPath):
        """
        Class specific implementation of volumeCreate. All the exceptions are
        properly handled and logged in volume.create()
        """

        if preallocate == volume.SPARSE_VOL:
            volSize = "%s" % config.get("irs", "volume_utilization_chunk_mb")
        else:
            volSize = "%s" % ((size + SECTORS_TO_MB - 1) / SECTORS_TO_MB)

        lvm.createLV(dom.sdUUID, volUUID, volSize, activate=True,
                     initialTag=TAG_VOL_UNINIT)

        utils.rmFile(volPath)
        os.symlink(lvm.lvPath(dom.sdUUID, volUUID), volPath)

        if not volParent:
            cls.log.info("Request to create %s volume %s with size = %s "
                         "sectors", volume.type2name(volFormat), volPath,
                         size)

            if volFormat == volume.COW_FORMAT:
                volume.createVolume(None, None, volPath, size, volFormat,
                                    preallocate)
        else:
            # Create hardlink to template and its meta file
            cls.log.info("Request to create snapshot %s/%s of volume %s/%s",
                         imgUUID, volUUID, srcImgUUID, srcVolUUID)
            volParent.clone(imgPath, volUUID, volFormat, preallocate)

        with cls._tagCreateLock:
            mdSlot = dom.mapMetaOffset(volUUID, VOLUME_MDNUMBLKS)
            mdTags = ["%s%s" % (TAG_PREFIX_MD, mdSlot),
                      "%s%s" % (TAG_PREFIX_PARENT, srcVolUUID),
                      "%s%s" % (TAG_PREFIX_IMAGE, imgUUID)]
            lvm.changeLVTags(dom.sdUUID, volUUID, delTags=[TAG_VOL_UNINIT],
                             addTags=mdTags)

        try:
            lvm.deactivateLVs(dom.sdUUID, volUUID)
        except se.CannotDeactivateLogicalVolume:
            cls.log.warn("Cannot deactivate new created volume %s/%s",
                         dom.sdUUID, volUUID, exc_info=True)

        return (dom.sdUUID, mdSlot)

 def _cleanOldFiles(self):
     for f in os.listdir(constants.P_VDSM_RUN):
         try:
             vmId, fileType = f.split(".", 1)
             if fileType in ["guest.socket", "monitor.socket", "pid",
                                 "stdio.dump", "recovery"]:
                 if vmId in self.vmContainer: continue
                 if f == 'vdsmd.pid': continue
                 if f == 'respawn.pid': continue
                 if f == 'svdsm.pid': continue
                 if f == 'svdsm.sock': continue
             else:
                 continue
             self.log.debug("removing old file " + f)
             utils.rmFile(constants.P_VDSM_RUN + f)
         except:
             pass

 def shutdown(self):
     try:
         pid = int(open(self.pidFile).readline().strip())
     except IOError as e:
         if e.errno == os.errno.ENOENT:
             pass
         else:
             raise
     else:
         try:
             os.kill(pid, signal.SIGTERM)
         except OSError as e:
             if e.errno == os.errno.ESRCH:
                 pass
             else:
                 raise
         rmFile(self.pidFile)

def mkIsoFs(vmId, files, volumeName=None):
    dirname = isopath = None
    try:
        dirname = tempfile.mkdtemp()
        _decodeFilesIntoDir(files, dirname)
        isopath = _getFileName(vmId, files)

        command = [EXT_MKISOFS, '-R', '-J', '-o', isopath]
        if volumeName is not None:
            command.extend(['-V', volumeName])
        command.extend([dirname])

        mode = 0o640
        # pre-create the destination iso path with the right permissions;
        # mkisofs/genisoimage will truncate the content and keep the
        # permissions.

        if os.path.exists(isopath):
            logging.warning("iso file %r exists, removing", isopath)
            rmFile(isopath)

        fd = os.open(isopath, os.O_CREAT | os.O_RDONLY | os.O_EXCL, mode)
        os.close(fd)

        rc, out, err = execCmd(command, raw=True)
        if rc:
            # clean up after ourselves in case of error
            removeFs(isopath)
            # skip _commonCleanFs step for missing iso
            isopath = None

            raise OSError(errno.EIO, "could not create iso file: "
                          "code %s, out %s\nerr %s" % (rc, out, err))

        _check_attributes(isopath, mode)

    finally:
        _commonCleanFs(dirname, isopath)

    return isopath

        def wrapper(*args, **kwargs):

            directory_existed = False

            if not functional:
                old_vdsm_hooks = constants.P_VDSM_HOOKS
                constants.P_VDSM_HOOKS = tempfile.mkdtemp()

            hook_path = constants.P_VDSM_HOOKS + '/' + hook_dir

            try:
                os.mkdir(hook_path)
            except OSError as mkdir_error:
                if mkdir_error.errno == errno.EEXIST:
                    directory_existed = True
                else:
                    raise

            cookie_file = _createHookScript(hook_path, hook_name, hook_script)

            output = None

            try:
                kwargs['hook_cookiefile'] = cookie_file
                output = test_function(*args, **kwargs)
            finally:
                if directory_existed:
                    utils.rmFile(hook_path + '/' + hook_name)
                else:
                    utils.rmTree(hook_path)

                utils.rmFile(cookie_file)

                if not functional:
                    constants.P_VDSM_HOOKS = old_vdsm_hooks

            return output

    def _cleanup(self):
        with self._volPrepareLock:
            for drive in self._devices[DISK_DEVICES]:
                try:
                    self.cif.teardownVolumePath(drive)
                except:
                    self.log.error("Drive teardown failure for %s",
                                   drive, exc_info=True)

        if self.conf.get('volatileFloppy'):
            try:
                self.log.debug("Floppy %s cleanup" % self.conf['floppy'])
                utils.rmFile(self.conf['floppy'])
            except:
                pass

        try:
            self.guestAgent.stop()
        except:
            pass

        utils.rmFile(self._guestSocektFile)
        utils.rmFile(self._recoveryFile)

 def removeInterfaceTracking(device):
     rmFile(DynamicSourceRoute.getTrackingFilePath(device))

 def cleanup(self):
     with self._lock:
         utils.rmFile(self._path)
         self._path = None

 def _removeFile(filename):
     utils.rmFile(filename)
     logging.debug("Removed file %s", filename)