Esempio n. 1
0
    def removeMatchDirectory(cls, search_dir_path, re_target_list):
        import shutil

        logger.debug("search-root=%s, target=%s" % (
            search_dir_path, str(re_target_list)))

        dict_result_pathlist = {}

        for dir_path, dir_name_list, _filename_list in os.walk(search_dir_path):
            for dir_name in dir_name_list:
                for re_text in re_target_list:
                    if re_text is None:
                        logger.debug("null regular expression")
                        continue
                    if re.search(re_text, dir_name):
                        break
                else:
                    continue

                remove_path = os.path.join(dir_path, dir_name)
                result = False
                logger.debug("remove directory: " + remove_path)
                if not cls.__dry_run:
                    try:
                        shutil.rmtree(remove_path, False)
                        result = True
                    except (OSError, os.error):
                        # for python 2.5 compatibility
                        _, e, _ = sys.exc_info()
                        logger.exception(e)

                dict_result_pathlist.setdefault(result, []).append(remove_path)

        return dict_result_pathlist
Esempio n. 2
0
    def clear(cls):
        cache_dir_path = cls.__get_command_cache_store_dir()

        try:
            import shutil

            if os.path.isdir(cache_dir_path):
                shutil.rmtree(cache_dir_path, False)
        except (OSError, os.error):
            _, e, _ = sys.exc_info()  # for python 2.5 compatibility
            logger.exception(e)
            return False

        return True
Esempio n. 3
0
    def remove_file(cls, path):
        try:
            file_type = check_file_existence(path)
        except (InvalidFilePathError, FileNotFoundError):
            return True

        if file_type not in [FileType.FILE, FileType.LINK]:
            logger.error("not a file: '%s'" % (path))
            return False

        if cls.__dry_run:
            return True

        try:
            os.remove(path)
        except Exception:
            _, e, _ = sys.exc_info()  # for python 2.5 compatibility
            logger.exception(e)
            return False

        return True
Esempio n. 4
0
    def rename(cls, src_path, dst_path):
        try:
            check_file_existence(src_path)
        except (InvalidFilePathError, FileNotFoundError):
            _, e, _ = sys.exc_info()  # for python 2.5 compatibility
            logger.exception(e)
            return False

        if dataproperty.is_empty_string(dst_path):
            logger.error("empty destination path")
            return False

        if os.path.lexists(dst_path):
            logger.error("'%s' already exists" % (dst_path))
            return False

        logger.info("rename: %s -> %s" % (src_path, dst_path))
        if not cls.__dry_run:
            os.rename(src_path, dst_path)

        return True
Esempio n. 5
0
    def __call__(self, *args):
        import thutils.gfile as gfile

        return_value = -1

        try:
            return_value = self.function()
            return return_value
        except (gfile.InvalidFilePathError, gfile.FileNotFoundError):
            _, e, _ = sys.exc_info()  # for python 2.5 compatibility
            logger.exception(e)
            return_value = EX_NOINPUT
            return return_value
        except IOError:
            _, e, _ = sys.exc_info()  # for python 2.5 compatibility
            logger.exception(e)
            return_value = EX_IOERR
            return return_value
        except ValueError:
            _, e, _ = sys.exc_info()  # for python 2.5 compatibility
            logger.exception(e)
            return_value = EX_SOFTWARE
            return return_value
        except ImportError:
            _, e, _ = sys.exc_info()  # for python 2.5 compatibility
            logger.exception(e)
            return_value = EX_OSFILE
            return return_value
        except KeyboardInterrupt:
            logger.info(
                self.KEYBOARD_INTERRUPT_FORMAT % (os.path.basename(__file__)))
            return_value = 1
            return return_value
        except Exception:
            _, e, _ = sys.exc_info()  # for python 2.5 compatibility
            logger.exception(e)
            return_value = 1
            return return_value
        finally:
            logger.debug("exit code: " + str(return_value))
Esempio n. 6
0
    def remove_directory(cls, path):
        try:
            file_type = check_file_existence(path)
        except (InvalidFilePathError, FileNotFoundError):
            return True

        if file_type not in [FileType.DIRECTORY]:
            logger.error("not a directory: '%s'" % (path))
            return False

        logger.debug("remove directory: " + path)
        if cls.__dry_run:
            return True

        try:
            import shutil
            shutil.rmtree(path, False)
        except (ImportError, IOError):
            _, e, _ = sys.exc_info()  # for python 2.5 compatibility
            logger.exception(e)
            return False

        return True
Esempio n. 7
0
 def test_smoke(self, message):
     try:
         raise ValueError("for logger test")
     except:
         _, e, _ = sys.exc_info()  # for python 2.5 compatibility
         logger.exception(e, message)