PHP PharData::buildFromIterator方法代码示例

 public static function copyDirToArchive($dir, $archive, $basename = null, $excludeDirs = null)
 {
     $dir = rtrim($dir, '/\\');
     $basename = $basename ?: basename($dir);
     rex_dir::create(dirname($archive));
     $files = array();
     $iterator = rex_finder::factory($dir)->recursive()->filesOnly();
     if ($excludeDirs) {
         $iterator->ignoreDirs($excludeDirs, false);
     }
     foreach ($iterator as $path => $file) {
         $subpath = str_replace($dir, $basename, $path);
         $subpath = str_replace('\\', '/', $subpath);
         $files[$subpath] = $path;
     }
     if (class_exists('ZipArchive')) {
         $zip = new ZipArchive();
         $zip->open($archive, ZipArchive::CREATE);
         foreach ($files as $path => $realpath) {
             $zip->addFile($realpath, $path);
         }
         $zip->close();
     } else {
         $phar = new PharData($archive, 0, null, Phar::ZIP);
         $phar->buildFromIterator(new ArrayIterator($files));
         $phar->compressFiles(Phar::GZ);
         foreach ($files as $path => $realpath) {
             if (filesize($realpath) == 0) {
                 $phar[$path]->decompress();
             }
         }
     }
 }

 /**
  * @param  string $project
  * @return array  $return
  */
 public function backupArchive($project)
 {
     // Exception if not defined
     if (!isset($this->config[$project]['archive'])) {
         throw new \Exception('No "Archive config" for this project', 1);
     }
     // Get backup settings
     $settings = $this->getArchiveSettings($project);
     // Get backup file prefix
     $backupFilePrefix = '';
     if (!empty($settings['backup_file_prefix'])) {
         $backupFilePrefix = $settings['backup_file_prefix'];
     }
     // Set filename
     $filename = $backupFilePrefix . date('Ymd_His') . '.tar';
     // Data required to backup Database
     $path = $this->getBackupPath($project, 'archive');
     // Create Archive
     $phar = new \PharData($path . '/' . $filename);
     $phar->buildFromIterator(new \ArrayIterator($this->getArchiveFilesList($project)));
     // Compress and unlink none compress archive
     $phar->compress(\Phar::GZ);
     unlink($path . '/' . $filename);
     return $this->getBackupInfo($path, $filename);
 }

 /**
  * {@inheritdoc}
  */
 public function archive($sources, $target, $format, array $excludes = array())
 {
     $sources = realpath($sources);
     // Phar would otherwise load the file which we don't want
     if (file_exists($target)) {
         unlink($target);
     }
     try {
         $filename = substr($target, 0, strrpos($target, $format) - 1);
         // Check if compress format
         if (isset(static::$compressFormats[$format])) {
             // Current compress format supported base on tar
             $target = $filename . '.tar';
         }
         $phar = new \PharData($target, null, null, static::$formats[$format]);
         $files = new ArchivableFilesFinder($sources, $excludes);
         $phar->buildFromIterator($files, $sources);
         if (isset(static::$compressFormats[$format])) {
             // Check can be compressed?
             if (!$phar->canCompress(static::$compressFormats[$format])) {
                 throw new \RuntimeException(sprintf('Can not compress to %s format', $format));
             }
             // Delete old tar
             unlink($target);
             // Compress the new tar
             $phar->compress(static::$compressFormats[$format]);
             // Make the correct filename
             $target = $filename . '.' . $format;
         }
         return $target;
     } catch (\UnexpectedValueException $e) {
         $message = sprintf("Could not create archive '%s' from '%s': %s", $target, $sources, $e->getMessage());
         throw new \RuntimeException($message, $e->getCode(), $e);
     }
 }

function run_with_iterator(Iterator $it, $root = '')
{
    $tmpnam = tempnam('/tmp', 'testzip');
    unlink($tmpnam);
    $tmpnam .= '.zip';
    $pd = new PharData($tmpnam);
    var_dump($pd->buildFromIterator($it, $root));
    $z = zip_open($tmpnam);
    while ($entry = zip_read($z)) {
        var_dump([zip_entry_name($entry), zip_entry_filesize($entry)]);
    }
}

 public function archive($sources, $target, $format, array $excludes = array())
 {
     $sources = realpath($sources);
     if (file_exists($target)) {
         unlink($target);
     }
     try {
         $phar = new \PharData($target, null, null, static::$formats[$format]);
         $files = new ArchivableFilesFinder($sources, $excludes);
         $phar->buildFromIterator($files, $sources);
         return $target;
     } catch (\UnexpectedValueException $e) {
         $message = sprintf("Could not create archive '%s' from '%s': %s", $target, $sources, $e->getMessage());
         throw new \RuntimeException($message, $e->getCode(), $e);
     }
 }

function run_with_iterator(Iterator $it, $root = '')
{
    $tmpnam = tempnam('/tmp', 'testtar');
    unlink($tmpnam);
    $tmpnam .= '.tar';
    $pd = new PharData($tmpnam);
    var_dump($pd->buildFromIterator($it, $root));
    // Re-create for read
    $pd = new PharData($tmpnam);
    $out = array();
    $it = new RecursiveIteratorIterator($pd);
    foreach ($it as $fname => $data) {
        $out[$fname] = array(get_class($data), $data->getFilename(), $data->getPathname(), (string) $data);
    }
    ksort($out);
    var_dump($out);
}

 public function cmd_artifact(array $params = array())
 {
     \System\Directory::check(BASE_DIR . static::DIR_PACKAGES);
     $target = BASE_DIR . static::DIR_PACKAGES . '/artifact.tar';
     $result = $target . '.gz';
     if (isset($params[0])) {
         $target = $params[0];
     }
     if (file_exists($target)) {
         unlink($target);
     }
     if (file_exists($result)) {
         unlink($result);
     }
     $iter = new \RecursiveDirectoryIterator(BASE_DIR);
     $iter->setFlags(\FileSystemIterator::SKIP_DOTS);
     $iter = new ProjectDirectoryRecursiveIterator($iter);
     $iter = new \RecursiveIteratorIterator($iter);
     $archive = new \PharData($target);
     $archive->buildFromIterator($iter, BASE_DIR);
     $archive->compress(\Phar::GZ);
     unlink($target);
 }

 /**
  * @inheritdoc
  */
 public function run(&$cmdParams, &$params)
 {
     $res = true;
     $taskRunner = $this->taskRunner;
     $toBeAdded = [];
     $srcList = !empty($cmdParams[0]) ? $cmdParams[0] : [];
     $destFile = !empty($cmdParams[1]) ? $taskRunner->parsePath($cmdParams[1]) : '';
     $srcBaseDir = !empty($cmdParams[2]) ? $taskRunner->parsePath($cmdParams[2]) : '';
     $format = !empty($cmdParams[3]) ? strtolower($cmdParams[3]) : self::CMP_GZ;
     $options = !empty($cmdParams[4]) ? $cmdParams[4] : [];
     if (!empty($srcBaseDir) && !is_dir($srcBaseDir)) {
         Log::throwException('compress: srcBaseDir has to be a directory');
     }
     if (empty($destFile) || file_exists($destFile) && is_dir($destFile)) {
         Log::throwException('compress: Destination has to be a file');
     }
     switch ($format) {
         case self::CMP_NONE:
             $extension = '.tar';
             $compression = \Phar::NONE;
             $doCompress = false;
             break;
         case self::CMP_GZ:
             $extension = '.tar.gz';
             $compression = \Phar::GZ;
             $doCompress = true;
             break;
         case self::CMP_BZ2:
             $extension = '.tar.bz2';
             $compression = \Phar::BZ2;
             $doCompress = true;
             break;
         default:
             $extension = '';
             $compression = false;
             $doCompress = false;
             Log::throwException('compress: Invalid format specified: ' . $format);
             break;
     }
     // if $srcList is specified but it is a string, we convert it to an array
     if (!empty($srcList) && is_string($srcList)) {
         $srcList = explode(',', $srcList);
     }
     foreach ($srcList as $srcPath) {
         $parsedPath = $taskRunner->parseStringAliases(trim($srcPath));
         if (!empty($srcBaseDir)) {
             $toBeAdded[$parsedPath] = $srcBaseDir . DIRECTORY_SEPARATOR . $parsedPath;
         } else {
             $toBeAdded[] = $parsedPath;
         }
     }
     $this->controller->stdout("Creating archive: ");
     $this->controller->stdout($destFile, Console::FG_BLUE);
     $archive = null;
     $destDir = dirname($destFile);
     $destBaseFile = $destDir . DIRECTORY_SEPARATOR . basename($destFile, '.tar');
     if (!$this->controller->dryRun) {
         if (!is_dir($destDir)) {
             FileHelper::createDirectory($destDir);
         }
         @unlink($destFile);
         @unlink($destBaseFile);
         try {
             $archive = new \PharData($destFile);
         } catch (\Exception $e) {
             Log::throwException($e->getMessage());
         }
     } else {
         $this->controller->stdout(' [dry run]', Console::FG_YELLOW);
     }
     $this->controller->stdout("\n");
     $this->controller->stdout("Adding to archive: ");
     foreach ($toBeAdded as $srcRelPath => $srcFullPath) {
         if (file_exists($srcFullPath)) {
             $this->controller->stdout("\n - " . $srcFullPath);
             if (!$this->controller->dryRun) {
                 if (is_dir($srcFullPath)) {
                     $files = FileHelper::findFiles($srcFullPath, $options);
                     $archive->buildFromIterator(new ArrayIterator($files), !empty($srcBaseDir) ? $srcBaseDir : $srcFullPath);
                 } elseif (FileHelper::filterPath($srcFullPath, $options)) {
                     $archive->addFile($srcFullPath, !empty($srcBaseDir) ? $srcRelPath : basename($srcFullPath));
                 }
             } else {
                 $this->controller->stdout(' [dry run]', Console::FG_YELLOW);
             }
         } else {
             $this->controller->stderr("\n{$srcFullPath} does not exists!\n", Console::FG_RED);
         }
     }
     $this->controller->stdout("\n");
     if ($doCompress) {
         $this->controller->stdout("Compressing archive: ");
         $this->controller->stdout($destBaseFile . $extension, Console::FG_CYAN);
         if (!$this->controller->dryRun) {
             @unlink($destBaseFile . $extension);
             try {
                 $archive->compress($compression, $extension);
//.........这里部分代码省略.........

 /**
  * @throws BuildException
  */
 public function main()
 {
     $this->checkPreconditions();
     try {
         $this->log('Building archive: ' . $this->destinationFile->__toString(), Project::MSG_INFO);
         /**
          * Delete old archive, if exists.
          */
         if ($this->destinationFile->exists()) {
             $isDeleted = $this->destinationFile->delete();
             if (!$isDeleted) {
                 $this->log("Could not delete destination file {$this->destinationFile}", Project::MSG_WARN);
             }
         }
         $pharData = new PharData($this->baseDirectory->getPath() . '/' . $this->destinationFile->getName());
         foreach ($this->filesets as $fileset) {
             $this->log('Adding specified files in ' . $fileset->getDir($this->project) . ' to archive', Project::MSG_VERBOSE);
             $pharData->buildFromIterator($fileset->getIterator(), $fileset->getDir($this->project));
         }
         if ($this->compression !== PHAR::NONE && $pharData->canCompress($this->compression)) {
             try {
                 $pharData->compress($this->compression);
             } catch (UnexpectedValueException $uve) {
                 $pharData->compressFiles($this->compression);
             }
             unset($pharData);
         }
     } catch (Exception $e) {
         throw new BuildException('Problem creating archive: ' . $e->getMessage(), $e, $this->getLocation());
     }
 }

 /**
  * Create PHAR archive
  *
  * @param string    &$name    Pack name
  * @param \Iterator $iterator Directory iterator
  * @param array     $metadata Archive description OPTIONAL
  * @param boolean   $compress Flag OPTIONAL
  *
  * @return \Phar
  */
 protected static function pack(&$name, \Iterator $iterator, array $metadata = array(), $compress = true)
 {
     // To prevent existsing files usage
     \Includes\Utils\FileManager::deleteFile($name);
     $phar = new \PharData($name);
     // Files
     $phar->buildFromIterator($iterator, LC_DIR_ROOT);
     // Metadata
     $phar->setMetadata($metadata);
     // File hashes
     static::addPackHash($phar, $iterator);
     // GZ compression
     return $compress ? static::compress($phar, $name) : $phar;
 }

 /**
  * Will cleanup log files based on the value set for their maximal number
  *
  * @return void
  */
 protected function cleanupFiles()
 {
     // skip GC of old logs if files are unlimited
     if (0 === $this->maxFiles) {
         return;
     }
     $logFiles = glob($this->getGlobPattern());
     if ($this->maxFiles >= count($logFiles)) {
         // no files to remove
         return;
     }
     // Sorting the files by name to remove the older ones
     usort($logFiles, function ($a, $b) {
         return strcmp($b, $a);
     });
     // collect the files we have to archive and clean and prepare the archive's internal mapping
     $oldFiles = array();
     foreach (array_slice($logFiles, $this->maxFiles) as $oldFile) {
         $oldFiles[basename($oldFile)] = $oldFile;
     }
     // create an archive from the old files
     $dateTime = new \DateTime();
     $currentTime = $dateTime->format($this->getDateFormat());
     $phar = new \PharData($this->originalLogFile . $currentTime . '.tar');
     $phar->buildFromIterator(new \ArrayIterator($oldFiles));
     // finally delete them as we got them in the archive
     foreach ($oldFiles as $oldFile) {
         if (is_writable($oldFile)) {
             unlink($oldFile);
         }
     }
 }

/**
 * Rempli une archive déjà créée avec le contenu d'un dossier.
 * Si erreur, renvoie JSON_FILE_SYSTEM_ERROR et exit.
 *
 * @param PharData $phar L'archive à remplir
 * @param string $include Le dossier à inclure
 * @param string $basePath Le chemin à partir duquel l'arborescence doit être copiée
 */
function fillArchive($phar, $include, $basePath)
{
    try {
        $phar->buildFromIterator(new RecursiveIteratorIterator(new RecursiveDirectoryIterator($include, FilesystemIterator::SKIP_DOTS)), $basePath);
    } catch (UnexpectedValueException $e) {
        sendJson(JSON_FILE_SYSTEM_ERROR);
    }
}