Python archive_util.unpack_archive函数代码示例

    def download_src(self, url, source=None, archive=True):
        """ Download source and return path to it.

        :param url: url to source distribution
        :type url: string

        :param source_dir: source directory after unpacking (optional)
        :type source_dir: string

        :param archive: is source archive file or not
        :type archive: boolean

        :return: path to source directory
        """

        tmp_dir = tempfile.gettempdir()
        source_file = os.path.join(tmp_dir, url.split('/')[-1])
        urllib.request.urlretrieve(url, source_file)

        if source is None:
            source = source_file

        if archive:
            unpack_archive(source_file, tmp_dir)
            source = os.path.splitext(source)[0]
            if 'tar' in source:
                source = os.path.splitext(source)[0]

        return os.path.join(tmp_dir, source)

 def local_distribution(self):
     if self._local_dist is None:
         ensure_directory(os.path.join(self.tmpdir, "dummy"))
         info("Fetching %s from %s..." % (str(self.distribution),
             self.location))
         dist = self.repository.environment.fetch_distribution(self.requirement,
             self.tmpdir, source=self.source, develop_ok=self.develop)
         location = dist.location
         distros = list(find_distributions(location))
         if distros:
             self._local_dist = distros[0]
         elif os.path.isfile(location) and os.path.splitext(location) != \
                 ".py":
             # try to unpack the file
             unpack_dir = os.path.join(self.tmpdir, "unpack")
             info("Unpacking to %s..." % unpack_dir)
             unpack_archive(location, unpack_dir)
             distros = list(find_distributions(unpack_dir))
             if distros:
                 self._local_dist = distros[0]
             else:
                 for path in glob(os.path.join(unpack_dir, "*")):
                     distros = list(find_distributions(path))
                     if distros:
                         self._local_dist = distros[0]
                         break
                 else:
                     self._local_dist = Distribution.from_filename(location)
     return self._local_dist

 def _get_new(self, allow_redirects=True, chunk_size=512):
     """Retrieves the new archive and extracts it to self.updatedir."""
     self.log.info("Retrieving new version")
     newurl = self.url+self.newfiles
     # Get new files
     http_get = requests.get(newurl, stream=True,
                             allow_redirects=allow_redirects)
     http_get.raise_for_status()
     with open(self.newfiles, 'wb') as filehandle:
         for chunk in http_get.iter_content(chunk_size=chunk_size):
             if chunk:
                 filehandle.write(chunk)
     # Unpack archive and remove it after extraction
     try:
         self.log.info("Unpacking downloaded archive")
         unpack_archive(self.newfiles, self.updatedir)
     except UnrecognizedFormat:
         self.log.error("Retrieved version archive is invalid!\n"
                        "Please contact the software authors.\n"
                        "Please include the invalid archive "
                        "in a bug report.")
         os.rename(self.newfiles,self.newfiles+".dump")
     else:
         # Remove archive only if unpack operation succeeded
         self.log.info("Removing archive after extraction")
         os.remove(self.newfiles)
         # Signal that update is ready
         self.log.debug("Creating downloaded file marker")
         open(self.queue_replace,"w").close()

    def extract_gz(self, archive_path,
                   archivedir_write_path,
                   file_name=None,
                   open_archive_file=None,
                   archive=None):
        """Extract gz files.

        Extracts a given file name or all the files in the gz.
        """
        if file_name:
            open_archive_file = gzip.open(archive_path, 'r')
            file_obj = open_archive_file
            open_object = False
            self.write_fileobject(archivedir_write_path,
                                  file_name,
                                  file_obj=open_archive_file,
                                  open_object=False)
            if 'archive' in locals() and archive:
                archive.close()
            return [file_name]
        files_before = set(walk_relative_path(archivedir_write_path))
        archive_util.unpack_archive(archive_path, archivedir_write_path)
        files_after = set(walk_relative_path(archivedir_write_path))
        unpacked_files = files_after - files_before
        return list(unpacked_files)

 def get_filelist(self):
     '''
     Unpack the archive if it is an archive, and return a list of 
     file names that should be examined by OGR to determine if they are
     OGR supported file types.
     
     Cache the result to speed up subsequent calls.
     '''
     if not hasattr(self, '_files'):
         name, extension=os.path.splitext(self.filename)
         # only handle a few types, since some of the others might mess 
         # up some processing...like xlsx (which this will unpack.)
         logger.debug('Extension is %s', extension)
         if extension.lower() in ('.zip','.gz','.tgz'):
             try:
                 # Ensure that the files are output in the working dir, and 
                 # subdirectories are omitted (so it's a flat dir structure)
                 archive_util.unpack_archive(self.filename, self.working_dir,
                                             progress_filter=self._progress_filter)
                 logger.debug('Unpacked archive %s to %s', self.filename, 
                              self.working_dir)
                 files=[fn for fn in map(lambda dir: os.path.join(self.working_dir, 
                                                                  dir),
                                         os.listdir(self.working_dir)) 
                                         if not os.path.isdir(fn)]
                 self._files=files
             except archive_util.UnrecognizedFormat, e:
                 logger.debug('Specified file (%s) is not a recognized archive',
                              self.filename)
                 self._files=[self.filename,]
         else:
             self._files=[self.filename,]

 def _extract_file_to_file_server(cls, file_server_root, archive_target_path):
     # extract application to file server
     tempdir = tempfile.mkdtemp("-blueprint-submit")
     try:
         try:
             archive_util.unpack_archive(archive_target_path, tempdir)
         except archive_util.UnrecognizedFormat:
             raise manager_exceptions.BadParametersError(
                 "Blueprint archive is of an unrecognized format. "
                 "Supported formats are: {0}".format(SUPPORTED_ARCHIVE_TYPES)
             )
         archive_file_list = os.listdir(tempdir)
         if len(archive_file_list) != 1 or not path.isdir(path.join(tempdir, archive_file_list[0])):
             raise manager_exceptions.BadParametersError("archive must contain exactly 1 directory")
         application_dir_base_name = archive_file_list[0]
         # generating temporary unique name for app dir, to allow multiple
         # uploads of apps with the same name (as it appears in the file
         # system, not the app name field inside the blueprint.
         # the latter is guaranteed to be unique).
         generated_app_dir_name = "{0}-{1}".format(application_dir_base_name, uuid.uuid4())
         temp_application_dir = path.join(tempdir, application_dir_base_name)
         temp_application_target_dir = path.join(tempdir, generated_app_dir_name)
         shutil.move(temp_application_dir, temp_application_target_dir)
         shutil.move(temp_application_target_dir, file_server_root)
         return generated_app_dir_name
     finally:
         shutil.rmtree(tempdir)

def _unpack_eggs(egg_list):
    import os
    for pkg in egg_list:
        import pkg_resources
        eggs = pkg_resources.require(pkg)
        from setuptools.archive_util import unpack_archive
        for egg in eggs:
           if os.path.isdir(egg.location):
               sys.path.insert(0, egg.location)
               continue
           unpack_archive(egg.location, os.path.abspath(os.path.dirname(egg.location)))

 def copytree(self):
     # Copy the .egg-info tree to site-packages
     def skimmer(src,dst):
         # filter out source-control directories; note that 'src' is always
         # a '/'-separated path, regardless of platform.  'dst' is a
         # platform-specific path.
         for skip in '.svn/','CVS/':
             if src.startswith(skip) or '/'+skip in src:
                 return None
         self.outputs.append(dst)
         log.debug("Copying %s to %s", src, dst)
         return dst
     unpack_archive(self.source, self.target, skimmer)

def checkout_extension(name):
    log('Downloading extension %s to temporary folder', name)
    root = os.path.join(tdir, name)
    os.mkdir(root)
    checkout_path = PackageIndex().download(name, root)

    unpack_archive(checkout_path, root)
    path = None
    for fn in os.listdir(root):
        path = os.path.join(root, fn)
        if os.path.isdir(path):
            break
    log('Downloaded to %s', path)
    return path

def cache_package(spec, own_url):
    try:
        spec = Requirement.parse(spec)

    except ValueError:
        raise ArgumentError("Not a URL, existing file, or requirement spec: %r"
                                                                      % (spec,))

    try:
        # download and unpack source package
        path = tempfile.mkdtemp('.spynepi')
        logger.info("Downloading %r" % spec)
        dist = PackageIndex().fetch_distribution(spec, path, force_scan=True, source=True)
        archive_path = dist.location
        logger.info("Unpacking %r" % archive_path)
        unpack_archive(dist.location, path)

        # generate pypirc if possible
        if os.environ.has_key('HOME'):
            _generate_pypirc(own_url)
        else: # FIXME: ??? No idea. Hopefully setuptools knows better.
            pass # raise NotImplementedError("$HOME not defined, .pypirc not found.")

        # find setup.py in package. plagiarized from setuptools.
        setups = glob(os.path.join(path, '*', 'setup.py'))
        if not setups:
            raise ValidationError(
                "Couldn't find a setup script in %r editable distribution: %r" %
                                    (spec, os.path.join(path,'*', 'setup.py'))
            )

        if len(setups)>1:
            raise ValidationError(
                "Multiple setup scripts found in %r editable distribution: %r" %
                                    (spec, setups)
            )

        # self-register the package.
        lib_dir = os.path.dirname(setups[0])
        command = ["python", "setup.py", "register", "-r", REPO_NAME]
        logger.info('calling %r', command)
        subprocess.call(command, cwd=lib_dir, stdout=sys.stdout)

        # self-upload the package
        command = ["python", "-m", "spynepi.util.pypi.upload", archive_path]
        logger.info('calling %r', command)
        subprocess.call(command, cwd=lib_dir, stdin=sys.stdin, stdout=sys.stdout)

    finally:
        shutil.rmtree(path)

def unpackEgg(modulo):
    eggs = pkg_resources.require(modulo)
    for egg in eggs:
        if os.path.isdir(egg.location):
            sys.path.insert(0, egg.location)
            continue
        unpack_archive(egg.location, ".")
    eggpacks = set()
    eggspth = open("./eggs.pth", "w")
    for egg in eggs:
        eggspth.write(os.path.basename(egg.location))
        eggspth.write("\n")
        eggpacks.update(egg.get_metadata_lines("top_level.txt"))
    eggspth.close()

    eggpacks.clear()

    def copytree(self):
        # Copy the .egg-info tree to site-packages
        def skimmer(src, dst):
            # filter out source-control directories; note that 'src' is always
            # a '/'-separated path, regardless of platform.  'dst' is a
            # platform-specific path.
            for skip in ".svn/", "CVS/":
                if src.startswith(skip) or "/" + skip in src:
                    return None
            if self.install_layout and self.install_layout in ["deb"] and src.startswith("SOURCES.txt"):
                log.info("Skipping SOURCES.txt")
                return None
            self.outputs.append(dst)
            log.debug("Copying %s to %s", src, dst)
            return dst

        unpack_archive(self.source, self.target, skimmer)

def extract_blueprint_archive_to_mgr(archive_path, destination_root):
    """
    Extracting a package.

    :param destination_root: the root destination for the unzipped archive
    :param archive_path: the archive path
    :return: the full path for the extracted archive
    """
    # Importing this archives in the global scope causes import loop
    from manager_rest.resources import SUPPORTED_ARCHIVE_TYPES
    # extract application to file server
    tempdir = tempfile.mkdtemp('-blueprint-submit')
    try:
        try:
            archive_util.unpack_archive(archive_path, tempdir)
        except archive_util.UnrecognizedFormat:
            raise manager_exceptions.BadParametersError(
                    'Blueprint archive is of an unrecognized format. '
                    'Supported formats are: {0}'.format(
                            SUPPORTED_ARCHIVE_TYPES))
        archive_file_list = listdir(tempdir)
        if len(archive_file_list) != 1 or not path.isdir(
                path.join(tempdir, archive_file_list[0])):
            raise manager_exceptions.BadParametersError(
                    'archive must contain exactly 1 directory')
        application_dir_base_name = archive_file_list[0]
        # generating temporary unique name for app dir, to allow multiple
        # uploads of apps with the same name (as it appears in the file
        # system, not the app name field inside the blueprint.
        # the latter is guaranteed to be unique).
        generated_app_dir_name = '{0}-{1}'.format(
                application_dir_base_name, uuid.uuid4())
        temp_application_dir = path.join(tempdir,
                                         application_dir_base_name)
        temp_application_target_dir = path.join(tempdir,
                                                generated_app_dir_name)
        shutil.move(temp_application_dir, temp_application_target_dir)
        shutil.move(temp_application_target_dir, destination_root)
        return generated_app_dir_name
    finally:
        shutil.rmtree(tempdir)

def fixed_unpack_and_compile(self, egg_path, destination):
    from setuptools.archive_util import unpack_archive
    to_compile = []; to_chmod = []

    def pf(src,dst):
        if dst.endswith('.py') and not src.startswith('EGG-INFO/'):
            to_compile.append(dst)
            to_chmod.append(dst)
        elif dst.endswith('.dll') or dst.endswith('.so'):
            to_chmod.append(dst)
        self.unpack_progress(src,dst)
        return not self.dry_run and dst or None

    unpack_archive(egg_path, destination, pf)
    self.byte_compile(to_compile)
    if not self.dry_run:
        for f in to_chmod:
#           mode = ((os.stat(f)[stat.ST_MODE]) | 0555) & 07755
            mode = ((os.stat(f)[stat.ST_MODE]) | 0444) & 07755
            chmod(f, mode)

    to_compile = []; to_chmod = []
    return

def update_self():
	if len(sys.argv) > 1 and sys.argv[1] == '--updated':
		del sys.argv[1]
		return

	from setuptools.package_index import PackageIndex
	from setuptools.archive_util import unpack_archive

	tmpdir = tempfile.mkdtemp(prefix=TEMP_DIR_PREFIX)
	print('Downloading %s' % DEFAULT_URL)
	download = PackageIndex().download(DEFAULT_URL, tmpdir)
	print('Downloaded.')
	unpack_archive(download, tmpdir)
	unpack_dir = os.path.join(tmpdir, PACK_FILE_ROOT_DIR)
	move_files(unpack_dir, os.curdir,
		shutil.ignore_patterns('.*', '*.sln', '*.pyproj', '*.sample'))
	shutil.rmtree(tmpdir)
	print('Self updated.')

	if len(sys.argv) == 1:
		# only update self.
		sys.exit(0)
	else:
		restart(with_virtualenv=False)