445 lines
15 KiB
PHP
445 lines
15 KiB
PHP
<?php
|
|
/*
|
|
* $Id: TarTask.php 905 2010-10-05 16:28:03Z mrook $
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
|
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
|
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
|
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
|
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
|
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
|
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
|
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
|
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
|
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
*
|
|
* This software consists of voluntary contributions made by many individuals
|
|
* and is licensed under the LGPL. For more information please see
|
|
* <http://phing.info>.
|
|
*/
|
|
|
|
require_once 'phing/tasks/system/MatchingTask.php';
|
|
include_once 'phing/util/SourceFileScanner.php';
|
|
include_once 'phing/mappers/MergeMapper.php';
|
|
include_once 'phing/util/StringHelper.php';
|
|
|
|
/**
|
|
* Creates a tar archive using PEAR Archive_Tar.
|
|
*
|
|
* @author Hans Lellelid <hans@xmpl.org> (Phing)
|
|
* @author Stefano Mazzocchi <stefano@apache.org> (Ant)
|
|
* @author Stefan Bodewig <stefan.bodewig@epost.de> (Ant)
|
|
* @author Magesh Umasankar
|
|
* @version $Id: TarTask.php 905 2010-10-05 16:28:03Z mrook $
|
|
* @package phing.tasks.ext
|
|
*/
|
|
class TarTask extends MatchingTask {
|
|
|
|
const TAR_NAMELEN = 100;
|
|
|
|
const WARN = "warn";
|
|
const FAIL = "fail";
|
|
const OMIT = "omit";
|
|
|
|
private $tarFile;
|
|
private $baseDir;
|
|
private $includeEmpty = true; // Whether to include empty dirs in the TAR
|
|
|
|
private $longFileMode = "warn";
|
|
|
|
private $filesets = array();
|
|
private $fileSetFiles = array();
|
|
|
|
/**
|
|
* Indicates whether the user has been warned about long files already.
|
|
*/
|
|
private $longWarningGiven = false;
|
|
|
|
/**
|
|
* Compression mode. Available options "gzip", "bzip2", "none" (null).
|
|
*/
|
|
private $compression = null;
|
|
|
|
/**
|
|
* File path prefix in the tar archive
|
|
*
|
|
* @var string
|
|
*/
|
|
private $prefix = null;
|
|
|
|
/**
|
|
* Ensures that PEAR lib exists.
|
|
*/
|
|
public function init() {
|
|
include_once 'Archive/Tar.php';
|
|
if (!class_exists('Archive_Tar')) {
|
|
throw new BuildException("You must have installed the PEAR Archive_Tar class in order to use TarTask.");
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Add a new fileset
|
|
* @return FileSet
|
|
*/
|
|
public function createTarFileSet() {
|
|
$this->fileset = new TarFileSet();
|
|
$this->filesets[] = $this->fileset;
|
|
return $this->fileset;
|
|
}
|
|
|
|
/**
|
|
* Add a new fileset. Alias to createTarFileSet() for backwards compatibility.
|
|
* @return FileSet
|
|
* @see createTarFileSet()
|
|
*/
|
|
public function createFileSet() {
|
|
$this->fileset = new TarFileSet();
|
|
$this->filesets[] = $this->fileset;
|
|
return $this->fileset;
|
|
}
|
|
|
|
/**
|
|
* Set is the name/location of where to create the tar file.
|
|
* @param PhingFile $destFile The output of the tar
|
|
*/
|
|
public function setDestFile(PhingFile $destFile) {
|
|
$this->tarFile = $destFile;
|
|
}
|
|
|
|
/**
|
|
* This is the base directory to look in for things to tar.
|
|
* @param PhingFile $baseDir
|
|
*/
|
|
public function setBasedir(PhingFile $baseDir) {
|
|
$this->baseDir = $baseDir;
|
|
}
|
|
|
|
/**
|
|
* Set the include empty dirs flag.
|
|
* @param boolean Flag if empty dirs should be tarred too
|
|
* @return void
|
|
* @access public
|
|
*/
|
|
function setIncludeEmptyDirs($bool) {
|
|
$this->includeEmpty = (boolean) $bool;
|
|
}
|
|
|
|
/**
|
|
* Set how to handle long files, those with a path>100 chars.
|
|
* Optional, default=warn.
|
|
* <p>
|
|
* Allowable values are
|
|
* <ul>
|
|
* <li> truncate - paths are truncated to the maximum length
|
|
* <li> fail - paths greater than the maximim cause a build exception
|
|
* <li> warn - paths greater than the maximum cause a warning and GNU is used
|
|
* <li> gnu - GNU extensions are used for any paths greater than the maximum.
|
|
* <li> omit - paths greater than the maximum are omitted from the archive
|
|
* </ul>
|
|
*/
|
|
public function setLongfile($mode) {
|
|
$this->longFileMode = $mode;
|
|
}
|
|
|
|
/**
|
|
* Set compression method.
|
|
* Allowable values are
|
|
* <ul>
|
|
* <li> none - no compression
|
|
* <li> gzip - Gzip compression
|
|
* <li> bzip2 - Bzip2 compression
|
|
* </ul>
|
|
*/
|
|
public function setCompression($mode) {
|
|
switch($mode) {
|
|
case "gzip":
|
|
$this->compression = "gz";
|
|
break;
|
|
case "bzip2":
|
|
$this->compression = "bz2";
|
|
break;
|
|
case "none":
|
|
$this->compression = null;
|
|
break;
|
|
default:
|
|
$this->log("Ignoring unknown compression mode: ".$mode, Project::MSG_WARN);
|
|
$this->compression = null;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Sets the file path prefix for file in the tar file.
|
|
*
|
|
* @param string $prefix Prefix
|
|
*
|
|
* @return void
|
|
*/
|
|
public function setPrefix($prefix) {
|
|
$this->prefix = $prefix;
|
|
}
|
|
|
|
/**
|
|
* do the work
|
|
* @throws BuildException
|
|
*/
|
|
public function main() {
|
|
|
|
if ($this->tarFile === null) {
|
|
throw new BuildException("tarfile attribute must be set!", $this->getLocation());
|
|
}
|
|
|
|
if ($this->tarFile->exists() && $this->tarFile->isDirectory()) {
|
|
throw new BuildException("tarfile is a directory!", $this->getLocation());
|
|
}
|
|
|
|
if ($this->tarFile->exists() && !$this->tarFile->canWrite()) {
|
|
throw new BuildException("Can not write to the specified tarfile!", $this->getLocation());
|
|
}
|
|
|
|
// shouldn't need to clone, since the entries in filesets
|
|
// themselves won't be modified -- only elements will be added
|
|
$savedFileSets = $this->filesets;
|
|
|
|
try {
|
|
if ($this->baseDir !== null) {
|
|
if (!$this->baseDir->exists()) {
|
|
throw new BuildException("basedir does not exist!", $this->getLocation());
|
|
}
|
|
if (empty($this->filesets)) { // if there weren't any explicit filesets specivied, then
|
|
// create a default, all-inclusive fileset using the specified basedir.
|
|
$mainFileSet = new TarFileSet($this->fileset);
|
|
$mainFileSet->setDir($this->baseDir);
|
|
$this->filesets[] = $mainFileSet;
|
|
}
|
|
}
|
|
|
|
if (empty($this->filesets)) {
|
|
throw new BuildException("You must supply either a basedir "
|
|
. "attribute or some nested filesets.",
|
|
$this->getLocation());
|
|
}
|
|
|
|
// check if tar is out of date with respect to each fileset
|
|
if($this->tarFile->exists()) {
|
|
$upToDate = true;
|
|
foreach($this->filesets as $fs) {
|
|
$files = $fs->getFiles($this->project, $this->includeEmpty);
|
|
if (!$this->archiveIsUpToDate($files, $fs->getDir($this->project))) {
|
|
$upToDate = false;
|
|
}
|
|
for ($i=0, $fcount=count($files); $i < $fcount; $i++) {
|
|
if ($this->tarFile->equals(new PhingFile($fs->getDir($this->project), $files[$i]))) {
|
|
throw new BuildException("A tar file cannot include itself", $this->getLocation());
|
|
}
|
|
}
|
|
}
|
|
if ($upToDate) {
|
|
$this->log("Nothing to do: " . $this->tarFile->__toString() . " is up to date.", Project::MSG_INFO);
|
|
return;
|
|
}
|
|
}
|
|
|
|
$this->log("Building tar: " . $this->tarFile->__toString(), Project::MSG_INFO);
|
|
|
|
$tar = new Archive_Tar($this->tarFile->getAbsolutePath(), $this->compression);
|
|
|
|
// print errors
|
|
$tar->setErrorHandling(PEAR_ERROR_PRINT);
|
|
|
|
foreach($this->filesets as $fs) {
|
|
$files = $fs->getFiles($this->project, $this->includeEmpty);
|
|
if (count($files) > 1 && strlen($fs->getFullpath()) > 0) {
|
|
throw new BuildException("fullpath attribute may only "
|
|
. "be specified for "
|
|
. "filesets that specify a "
|
|
. "single file.");
|
|
}
|
|
$fsBasedir = $fs->getDir($this->project);
|
|
$filesToTar = array();
|
|
for ($i=0, $fcount=count($files); $i < $fcount; $i++) {
|
|
$f = new PhingFile($fsBasedir, $files[$i]);
|
|
$filesToTar[] = $f->getAbsolutePath();
|
|
$this->log("Adding file " . $f->getPath() . " to archive.", Project::MSG_VERBOSE);
|
|
}
|
|
$tar->addModify($filesToTar, $this->prefix, $fsBasedir->getAbsolutePath());
|
|
}
|
|
|
|
|
|
} catch (IOException $ioe) {
|
|
$msg = "Problem creating TAR: " . $ioe->getMessage();
|
|
$this->filesets = $savedFileSets;
|
|
throw new BuildException($msg, $ioe, $this->getLocation());
|
|
}
|
|
|
|
$this->filesets = $savedFileSets;
|
|
}
|
|
|
|
/**
|
|
* @param array $files array of filenames
|
|
* @param PhingFile $dir
|
|
* @return boolean
|
|
*/
|
|
protected function archiveIsUpToDate($files, $dir) {
|
|
$sfs = new SourceFileScanner($this);
|
|
$mm = new MergeMapper();
|
|
$mm->setTo($this->tarFile->getAbsolutePath());
|
|
return count($sfs->restrict($files, $dir, null, $mm)) == 0;
|
|
}
|
|
|
|
}
|
|
|
|
|
|
/**
|
|
* This is a FileSet with the option to specify permissions.
|
|
*
|
|
* Permissions are currently not implemented by PEAR Archive_Tar,
|
|
* but hopefully they will be in the future.
|
|
*
|
|
*/
|
|
class TarFileSet extends FileSet {
|
|
|
|
private $files = null;
|
|
|
|
private $mode = 0100644;
|
|
|
|
private $userName = "";
|
|
private $groupName = "";
|
|
private $prefix = "";
|
|
private $fullpath = "";
|
|
private $preserveLeadingSlashes = false;
|
|
|
|
/**
|
|
* Get a list of files and directories specified in the fileset.
|
|
* @return array a list of file and directory names, relative to
|
|
* the baseDir for the project.
|
|
*/
|
|
public function getFiles(Project $p, $includeEmpty = true) {
|
|
|
|
if ($this->files === null) {
|
|
|
|
$ds = $this->getDirectoryScanner($p);
|
|
$this->files = $ds->getIncludedFiles();
|
|
|
|
if ($includeEmpty) {
|
|
|
|
// first any empty directories that will not be implicitly added by any of the files
|
|
$implicitDirs = array();
|
|
foreach($this->files as $file) {
|
|
$implicitDirs[] = dirname($file);
|
|
}
|
|
|
|
$incDirs = $ds->getIncludedDirectories();
|
|
|
|
// we'll need to add to that list of implicit dirs any directories
|
|
// that contain other *directories* (and not files), since otherwise
|
|
// we get duplicate directories in the resulting tar
|
|
foreach($incDirs as $dir) {
|
|
foreach($incDirs as $dircheck) {
|
|
if (!empty($dir) && $dir == dirname($dircheck)) {
|
|
$implicitDirs[] = $dir;
|
|
}
|
|
}
|
|
}
|
|
|
|
$implicitDirs = array_unique($implicitDirs);
|
|
|
|
// Now add any empty dirs (dirs not covered by the implicit dirs)
|
|
// to the files array.
|
|
|
|
foreach($incDirs as $dir) { // we cannot simply use array_diff() since we want to disregard empty/. dirs
|
|
if ($dir != "" && $dir != "." && !in_array($dir, $implicitDirs)) {
|
|
// it's an empty dir, so we'll add it.
|
|
$this->files[] = $dir;
|
|
}
|
|
}
|
|
} // if $includeEmpty
|
|
|
|
} // if ($this->files===null)
|
|
|
|
return $this->files;
|
|
}
|
|
|
|
/**
|
|
* A 3 digit octal string, specify the user, group and
|
|
* other modes in the standard Unix fashion;
|
|
* optional, default=0644
|
|
* @param string $octalString
|
|
*/
|
|
public function setMode($octalString) {
|
|
$octal = (int) $octalString;
|
|
$this->mode = 0100000 | $octal;
|
|
}
|
|
|
|
public function getMode() {
|
|
return $this->mode;
|
|
}
|
|
|
|
/**
|
|
* The username for the tar entry
|
|
* This is not the same as the UID, which is
|
|
* not currently set by the task.
|
|
*/
|
|
public function setUserName($userName) {
|
|
$this->userName = $userName;
|
|
}
|
|
|
|
public function getUserName() {
|
|
return $this->userName;
|
|
}
|
|
|
|
/**
|
|
* The groupname for the tar entry; optional, default=""
|
|
* This is not the same as the GID, which is
|
|
* not currently set by the task.
|
|
*/
|
|
public function setGroup($groupName) {
|
|
$this->groupName = $groupName;
|
|
}
|
|
|
|
public function getGroup() {
|
|
return $this->groupName;
|
|
}
|
|
|
|
/**
|
|
* If the prefix attribute is set, all files in the fileset
|
|
* are prefixed with that path in the archive.
|
|
* optional.
|
|
*/
|
|
public function setPrefix($prefix) {
|
|
$this->prefix = $prefix;
|
|
}
|
|
|
|
public function getPrefix() {
|
|
return $this->prefix;
|
|
}
|
|
|
|
/**
|
|
* If the fullpath attribute is set, the file in the fileset
|
|
* is written with that path in the archive. The prefix attribute,
|
|
* if specified, is ignored. It is an error to have more than one file specified in
|
|
* such a fileset.
|
|
*/
|
|
public function setFullpath($fullpath) {
|
|
$this->fullpath = $fullpath;
|
|
}
|
|
|
|
public function getFullpath() {
|
|
return $this->fullpath;
|
|
}
|
|
|
|
/**
|
|
* Flag to indicates whether leading `/'s should
|
|
* be preserved in the file names.
|
|
* Optional, default is <code>false</code>.
|
|
* @return void
|
|
*/
|
|
public function setPreserveLeadingSlashes($b) {
|
|
$this->preserveLeadingSlashes = (boolean) $b;
|
|
}
|
|
|
|
public function getPreserveLeadingSlashes() {
|
|
return $this->preserveLeadingSlashes;
|
|
}
|
|
}
|