Merge topic 'CPackArchiveGenerator-ComponentSupport'
a986daf
CPack fix broken compilation for CygwinSource generator873e99a
CPackArchiveGenerator improve usability and robustness654683a
CPackArchiveGenerator add component supports36a550a
CPackArchiveGenerator use cmArchiveWrite wrapper
This commit is contained in:
commit
65fa0f0235
|
@ -22,11 +22,12 @@
|
|||
#include <errno.h>
|
||||
|
||||
#include <cmsys/SystemTools.hxx>
|
||||
#include <cmsys/Directory.hxx>
|
||||
#include <cm_libarchive.h>
|
||||
|
||||
//----------------------------------------------------------------------
|
||||
cmCPackArchiveGenerator::cmCPackArchiveGenerator(CompressType t,
|
||||
ArchiveType at)
|
||||
cmCPackArchiveGenerator::cmCPackArchiveGenerator(cmArchiveWrite::Compress t,
|
||||
cmArchiveWrite::Type at)
|
||||
{
|
||||
this->Compress = t;
|
||||
this->Archive = at;
|
||||
|
@ -37,222 +38,269 @@ cmCPackArchiveGenerator::~cmCPackArchiveGenerator()
|
|||
{
|
||||
}
|
||||
|
||||
static const size_t cmCPackTGZ_Data_BlockSize = 16384;
|
||||
|
||||
// make this an anonymous namespace so that archive.h does not
|
||||
// have to be included in the .h file for this class
|
||||
namespace
|
||||
{
|
||||
bool SetArchiveType(struct archive* a,
|
||||
cmCPackArchiveGenerator::CompressType ct,
|
||||
cmCPackArchiveGenerator::ArchiveType at)
|
||||
{
|
||||
int res = 0;
|
||||
// pick the archive type
|
||||
switch(at)
|
||||
{
|
||||
case cmCPackArchiveGenerator::TAR:
|
||||
// maybe this:
|
||||
res = archive_write_set_format_pax_restricted(a);
|
||||
break;
|
||||
case cmCPackArchiveGenerator::ZIP:
|
||||
res = archive_write_set_format_zip(a);
|
||||
break;
|
||||
}
|
||||
if(res != ARCHIVE_OK)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
// pick a compression type
|
||||
switch(ct)
|
||||
{
|
||||
case cmCPackArchiveGenerator::GZIP:
|
||||
res = archive_write_set_compression_gzip(a);
|
||||
break;
|
||||
case cmCPackArchiveGenerator::BZIP2:
|
||||
res = archive_write_set_compression_bzip2(a);
|
||||
break;
|
||||
case cmCPackArchiveGenerator::COMPRESS:
|
||||
res = archive_write_set_compression_compress(a);
|
||||
break;
|
||||
case cmCPackArchiveGenerator::LZMA:
|
||||
res = archive_write_set_compression_lzma(a);
|
||||
break;
|
||||
case cmCPackArchiveGenerator::NONE:
|
||||
default:
|
||||
res = archive_write_set_compression_none(a);
|
||||
}
|
||||
if(res != ARCHIVE_OK)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
// do not pad the last block!!
|
||||
res = archive_write_set_bytes_in_last_block(a, 1);
|
||||
if(res != ARCHIVE_OK)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
struct StreamData
|
||||
{
|
||||
StreamData(cmGeneratedFileStream* gfs,
|
||||
cmCPackArchiveGenerator* ag)
|
||||
{
|
||||
this->GeneratedFileStream = gfs;
|
||||
this->Generator = ag;
|
||||
}
|
||||
cmGeneratedFileStream* GeneratedFileStream;
|
||||
cmCPackArchiveGenerator* Generator;
|
||||
};
|
||||
|
||||
|
||||
extern "C"
|
||||
{
|
||||
int OpenArchive(struct archive *, void *client_data)
|
||||
{
|
||||
struct StreamData *data = (StreamData*)client_data;
|
||||
if(data->GeneratedFileStream &&
|
||||
*data->GeneratedFileStream)
|
||||
{
|
||||
if(data->Generator->
|
||||
GenerateHeader(data->GeneratedFileStream))
|
||||
{
|
||||
return ARCHIVE_OK;
|
||||
}
|
||||
}
|
||||
return (ARCHIVE_FATAL);
|
||||
}
|
||||
|
||||
__LA_SSIZE_T WriteArchive(struct archive *,
|
||||
void *client_data,
|
||||
const void *buff,
|
||||
size_t n)
|
||||
{
|
||||
struct StreamData *data = (StreamData*)client_data;
|
||||
data->GeneratedFileStream->
|
||||
write(reinterpret_cast<const char*>(buff),n);
|
||||
if(!data->GeneratedFileStream->bad())
|
||||
{
|
||||
return n;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
int CloseArchive(struct archive *, void *client_data)
|
||||
{
|
||||
struct StreamData *data = (StreamData*)client_data;
|
||||
if(data->GeneratedFileStream->Close())
|
||||
{
|
||||
delete data->GeneratedFileStream;
|
||||
return ARCHIVE_OK;
|
||||
}
|
||||
return ARCHIVE_FATAL;
|
||||
}
|
||||
} //extern C
|
||||
} // anon name space
|
||||
|
||||
|
||||
//----------------------------------------------------------------------
|
||||
int cmCPackArchiveGenerator::InitializeInternal()
|
||||
{
|
||||
this->SetOptionIfNotSet("CPACK_INCLUDE_TOPLEVEL_DIRECTORY", "1");
|
||||
return this->Superclass::InitializeInternal();
|
||||
}
|
||||
//----------------------------------------------------------------------
|
||||
int cmCPackArchiveGenerator::addOneComponentToArchive(cmArchiveWrite& archive,
|
||||
cmCPackComponent* component)
|
||||
{
|
||||
cmCPackLogger(cmCPackLog::LOG_VERBOSE, " - packaging component: "
|
||||
<< component->Name
|
||||
<< std::endl);
|
||||
// Add the files of this component to the archive
|
||||
std::string localToplevel(this->GetOption("CPACK_TEMPORARY_DIRECTORY"));
|
||||
localToplevel += "/"+ component->Name;
|
||||
std::string dir = cmSystemTools::GetCurrentWorkingDirectory();
|
||||
// Change to local toplevel
|
||||
cmSystemTools::ChangeDirectory(localToplevel.c_str());
|
||||
std::vector<std::string>::const_iterator fileIt;
|
||||
for (fileIt = component->Files.begin(); fileIt != component->Files.end(); ++fileIt )
|
||||
{
|
||||
cmCPackLogger(cmCPackLog::LOG_DEBUG,"Adding file: " << (*fileIt) << std::endl);
|
||||
archive.Add(*fileIt);
|
||||
if (!archive)
|
||||
{
|
||||
cmCPackLogger(cmCPackLog::LOG_ERROR, "ERROR while packaging files: "
|
||||
<< archive.GetError()
|
||||
<< std::endl);
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
// Go back to previous dir
|
||||
cmSystemTools::ChangeDirectory(dir.c_str());
|
||||
return 1;
|
||||
}
|
||||
|
||||
/*
|
||||
* The macro will open/create a file 'filename'
|
||||
* an declare and open the associated
|
||||
* cmArchiveWrite 'archive' object.
|
||||
*/
|
||||
#define DECLARE_AND_OPEN_ARCHIVE(filename,archive) \
|
||||
cmGeneratedFileStream gf; \
|
||||
gf.Open(filename.c_str(), false, true); \
|
||||
if (!GenerateHeader(&gf)) \
|
||||
{ \
|
||||
cmCPackLogger(cmCPackLog::LOG_ERROR, "Problem to generate Header for archive < " \
|
||||
<< filename \
|
||||
<< ">." << std::endl); \
|
||||
return 0; \
|
||||
} \
|
||||
cmArchiveWrite archive(gf,this->Compress, this->Archive); \
|
||||
if (!archive) \
|
||||
{ \
|
||||
cmCPackLogger(cmCPackLog::LOG_ERROR, "Problem to create archive < " \
|
||||
<< filename \
|
||||
<< ">. ERROR =" \
|
||||
<< archive.GetError() \
|
||||
<< std::endl); \
|
||||
return 0; \
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------
|
||||
int cmCPackArchiveGenerator::PackageComponents(bool ignoreComponentGroup)
|
||||
{
|
||||
packageFileNames.clear();
|
||||
// The default behavior is to have one package by component group
|
||||
// unless CPACK_COMPONENTS_IGNORE_GROUP is specified.
|
||||
if (!ignoreComponentGroup)
|
||||
{
|
||||
std::map<std::string, cmCPackComponentGroup>::iterator compGIt;
|
||||
for (compGIt=this->ComponentGroups.begin();
|
||||
compGIt!=this->ComponentGroups.end(); ++compGIt)
|
||||
{
|
||||
cmCPackLogger(cmCPackLog::LOG_VERBOSE, "Packaging component group: "
|
||||
<< compGIt->first
|
||||
<< std::endl);
|
||||
// Begin the archive for this group
|
||||
std::string packageFileName= std::string(toplevel);
|
||||
packageFileName += "/"+std::string(this->GetOption("CPACK_PACKAGE_FILE_NAME"))+"-"+compGIt->first + this->GetOutputExtension();
|
||||
// open a block in order to automatically close archive
|
||||
// at the end of the block
|
||||
{
|
||||
DECLARE_AND_OPEN_ARCHIVE(packageFileName,archive);
|
||||
// now iterate over the component of this group
|
||||
std::vector<cmCPackComponent*>::iterator compIt;
|
||||
for (compIt=(compGIt->second).Components.begin();
|
||||
compIt!=(compGIt->second).Components.end();
|
||||
++compIt)
|
||||
{
|
||||
// Add the files of this component to the archive
|
||||
addOneComponentToArchive(archive,*compIt);
|
||||
}
|
||||
}
|
||||
// add the generated package to package file names list
|
||||
packageFileNames.push_back(packageFileName);
|
||||
}
|
||||
}
|
||||
// CPACK_COMPONENTS_IGNORE_GROUPS is set
|
||||
// We build 1 package per component
|
||||
else
|
||||
{
|
||||
std::map<std::string, cmCPackComponent>::iterator compIt;
|
||||
for (compIt=this->Components.begin();compIt!=this->Components.end(); ++compIt )
|
||||
{
|
||||
std::string localToplevel(this->GetOption("CPACK_TEMPORARY_DIRECTORY"));
|
||||
std::string packageFileName = std::string(toplevel);
|
||||
|
||||
localToplevel += "/"+ compIt->first;
|
||||
packageFileName += "/"+std::string(this->GetOption("CPACK_PACKAGE_FILE_NAME"))+"-"+compIt->first + this->GetOutputExtension();
|
||||
{
|
||||
DECLARE_AND_OPEN_ARCHIVE(packageFileName,archive);
|
||||
// Add the files of this component to the archive
|
||||
addOneComponentToArchive(archive,&(compIt->second));
|
||||
}
|
||||
// add the generated package to package file names list
|
||||
packageFileNames.push_back(packageFileName);
|
||||
}
|
||||
}
|
||||
return 1;
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------
|
||||
int cmCPackArchiveGenerator::PackageComponentsAllInOne(bool allComponentInOne)
|
||||
{
|
||||
// reset the package file names
|
||||
packageFileNames.clear();
|
||||
packageFileNames.push_back(std::string(toplevel));
|
||||
packageFileNames[0] += "/"+std::string(this->GetOption("CPACK_PACKAGE_FILE_NAME"))+"-ALL" + this->GetOutputExtension();
|
||||
cmCPackLogger(cmCPackLog::LOG_VERBOSE, "Packaging all groups in one package...(CPACK_COMPONENTS_ALL_GROUPS_IN_ONE_PACKAGE is set)"
|
||||
<< std::endl);
|
||||
DECLARE_AND_OPEN_ARCHIVE(packageFileNames[0],archive);
|
||||
|
||||
// The ALL GROUP in ONE package case
|
||||
if (! allComponentInOne) {
|
||||
// iterate over the component groups
|
||||
std::map<std::string, cmCPackComponentGroup>::iterator compGIt;
|
||||
for (compGIt=this->ComponentGroups.begin();
|
||||
compGIt!=this->ComponentGroups.end(); ++compGIt)
|
||||
{
|
||||
cmCPackLogger(cmCPackLog::LOG_VERBOSE, "Packaging component group: "
|
||||
<< compGIt->first
|
||||
<< std::endl);
|
||||
// now iterate over the component of this group
|
||||
std::vector<cmCPackComponent*>::iterator compIt;
|
||||
for (compIt=(compGIt->second).Components.begin();
|
||||
compIt!=(compGIt->second).Components.end();
|
||||
++compIt)
|
||||
{
|
||||
// Add the files of this component to the archive
|
||||
addOneComponentToArchive(archive,*compIt);
|
||||
}
|
||||
}
|
||||
}
|
||||
// The ALL COMPONENT in ONE package case
|
||||
else
|
||||
{
|
||||
std::map<std::string, cmCPackComponent>::iterator compIt;
|
||||
for (compIt=this->Components.begin();compIt!=this->Components.end(); ++compIt )
|
||||
{
|
||||
// Add the files of this component to the archive
|
||||
addOneComponentToArchive(archive,&(compIt->second));
|
||||
}
|
||||
}
|
||||
// archive goes out of scope so it will finalized and closed.
|
||||
return 1;
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------
|
||||
int cmCPackArchiveGenerator::PackageFiles()
|
||||
{
|
||||
int res = ARCHIVE_OK;
|
||||
#define CHECK_ARCHIVE_ERROR(res, msg) \
|
||||
if(res != ARCHIVE_OK) \
|
||||
{\
|
||||
cmCPackLogger(cmCPackLog::LOG_ERROR, msg \
|
||||
<< archive_error_string(a) \
|
||||
<< cmSystemTools::GetLastSystemError() \
|
||||
<< " " << res \
|
||||
<< "\n"); \
|
||||
}
|
||||
cmCPackLogger(cmCPackLog::LOG_DEBUG, "Toplevel: "
|
||||
<< toplevel << std::endl);
|
||||
|
||||
// create a new archive
|
||||
struct archive* a = archive_write_new();
|
||||
// Set the compress and archive types for the archive
|
||||
SetArchiveType(a, this->Compress, this->Archive);
|
||||
// Open binary stream
|
||||
cmGeneratedFileStream* gf = new cmGeneratedFileStream;
|
||||
gf->Open(packageFileNames[0].c_str(), false, true);
|
||||
StreamData data(gf, this);
|
||||
// pass callbacks to archive_write_open to handle stream
|
||||
res = archive_write_open(a,
|
||||
&data,
|
||||
OpenArchive,
|
||||
WriteArchive,
|
||||
CloseArchive);
|
||||
CHECK_ARCHIVE_ERROR(res, "archive_write_open:");
|
||||
// create a new disk struct
|
||||
struct archive* disk = archive_read_disk_new();
|
||||
#if !defined(_WIN32) || defined(__CYGWIN__)
|
||||
res = archive_read_disk_set_standard_lookup(disk);
|
||||
#endif
|
||||
CHECK_ARCHIVE_ERROR(res, "archive_read_disk_set_standard_lookup:");
|
||||
// The default behavior is to create 1 package by component group
|
||||
// unless the user asked to put all COMPONENTS in a single package
|
||||
bool allGroupInOne = (NULL != (this->GetOption("CPACK_COMPONENTS_ALL_GROUPS_IN_ONE_PACKAGE")));
|
||||
bool allComponentInOne = (NULL != (this->GetOption("CPACK_COMPONENTS_ALL_IN_ONE_PACKAGE")));
|
||||
bool ignoreComponentGroup = ( NULL != (this->GetOption("CPACK_COMPONENTS_IGNORE_GROUPS")));
|
||||
|
||||
std::string groupingType;
|
||||
|
||||
// Second way to specify grouping
|
||||
if (NULL != this->GetOption("CPACK_COMPONENTS_GROUPING")) {
|
||||
groupingType = this->GetOption("CPACK_COMPONENTS_GROUPING");
|
||||
}
|
||||
|
||||
if (groupingType.length()>0)
|
||||
{
|
||||
cmCPackLogger(cmCPackLog::LOG_VERBOSE, "["
|
||||
<< this->Name << "]"
|
||||
<< " requested component grouping = "<< groupingType <<std::endl);
|
||||
if (groupingType == "ALL_GROUP_IN_ONE")
|
||||
{
|
||||
allGroupInOne = true;
|
||||
}
|
||||
else if (groupingType == "ALL_COMPONENT_IN_ONE")
|
||||
{
|
||||
allComponentInOne = true;
|
||||
}
|
||||
else if (groupingType == "IGNORE")
|
||||
{
|
||||
ignoreComponentGroup = true;
|
||||
}
|
||||
else
|
||||
{
|
||||
cmCPackLogger(cmCPackLog::LOG_WARNING, "["
|
||||
<< this->Name << "]"
|
||||
<< " requested component grouping type <"<< groupingType
|
||||
<< "> UNKNOWN not in (ALL_GROUP_IN_ONE,ALL_COMPONENT_IN_ONE,IGNORE)" <<std::endl);
|
||||
}
|
||||
}
|
||||
|
||||
// Some components were defined but NO group
|
||||
// force ignoreGroups
|
||||
if (this->ComponentGroups.empty() && (!this->Components.empty()) && (!ignoreComponentGroup)) {
|
||||
cmCPackLogger(cmCPackLog::LOG_WARNING, "["
|
||||
<< this->Name << "]"
|
||||
<< " Some Components defined but NO component group:"
|
||||
<< " Ignoring component group."
|
||||
<< std::endl);
|
||||
ignoreComponentGroup = true;
|
||||
}
|
||||
// CASE 1 : COMPONENT ALL-IN-ONE package
|
||||
// If ALL GROUPS or ALL COMPONENTS in ONE package has been requested
|
||||
// then the package file is unique and should be open here.
|
||||
if (allComponentInOne || (allGroupInOne && (!this->ComponentGroups.empty())))
|
||||
{
|
||||
return PackageComponentsAllInOne(allComponentInOne);
|
||||
}
|
||||
// CASE 2 : COMPONENT CLASSICAL package(s) (i.e. not all-in-one)
|
||||
// There will be 1 package for each component group
|
||||
// however one may require to ignore component group and
|
||||
// in this case you'll get 1 package for each component.
|
||||
else if ((!this->ComponentGroups.empty()) || (ignoreComponentGroup))
|
||||
{
|
||||
return PackageComponents(ignoreComponentGroup);
|
||||
}
|
||||
|
||||
// CASE 3 : NON COMPONENT package.
|
||||
DECLARE_AND_OPEN_ARCHIVE(packageFileNames[0],archive);
|
||||
std::vector<std::string>::const_iterator fileIt;
|
||||
std::string dir = cmSystemTools::GetCurrentWorkingDirectory();
|
||||
cmSystemTools::ChangeDirectory(toplevel.c_str());
|
||||
for ( fileIt = files.begin(); fileIt != files.end(); ++ fileIt )
|
||||
{
|
||||
// create a new entry for each file
|
||||
struct archive_entry *entry = archive_entry_new();
|
||||
// Get the relative path to the file
|
||||
std::string rp = cmSystemTools::RelativePath(toplevel.c_str(), fileIt->c_str());
|
||||
// Set the name of the entry to the file name
|
||||
archive_entry_set_pathname(entry, rp.c_str());
|
||||
res = archive_read_disk_entry_from_file(disk, entry, -1, 0);
|
||||
CHECK_ARCHIVE_ERROR(res, "archive_read_disk_entry_from_file:");
|
||||
// write entry header
|
||||
res = archive_write_header(a, entry);
|
||||
CHECK_ARCHIVE_ERROR(res, "archive_write_header:");
|
||||
// the entry size can be 0 if it is a symlink
|
||||
if(archive_entry_size(entry) > 0)
|
||||
archive.Add(rp);
|
||||
if(!archive)
|
||||
{
|
||||
// now copy contents of file into archive a
|
||||
FILE* file = fopen(fileIt->c_str(), "rb");
|
||||
if(!file)
|
||||
{
|
||||
cmCPackLogger(cmCPackLog::LOG_ERROR, "Problem with fopen(): "
|
||||
<< fileIt->c_str()
|
||||
<< strerror(errno)
|
||||
<< std::endl);
|
||||
return 0;
|
||||
}
|
||||
char buff[cmCPackTGZ_Data_BlockSize];
|
||||
size_t len = fread(buff, 1, sizeof(buff), file);
|
||||
while (len > 0)
|
||||
{
|
||||
size_t wlen = archive_write_data(a, buff, len);
|
||||
if(wlen != len)
|
||||
{
|
||||
cmCPackLogger(cmCPackLog::LOG_ERROR, "archive_write_data(): "
|
||||
<< "tried to write " << len << "\n"
|
||||
<< "write " << wlen << "\n");
|
||||
return 0;
|
||||
}
|
||||
len = fread(buff, 1, sizeof(buff), file);
|
||||
}
|
||||
// close the file and free the entry
|
||||
fclose(file);
|
||||
cmCPackLogger(cmCPackLog::LOG_ERROR, "Problem while adding file< "
|
||||
<< *fileIt
|
||||
<< "> to archive <"
|
||||
<< packageFileNames[0] << "> .ERROR ="
|
||||
<< archive.GetError()
|
||||
<< std::endl);
|
||||
return 0;
|
||||
}
|
||||
archive_entry_free(entry);
|
||||
}
|
||||
cmSystemTools::ChangeDirectory(dir.c_str());
|
||||
// close the archive and finish the write
|
||||
archive_write_close(a);
|
||||
archive_write_finish(a);
|
||||
archive_read_finish(disk);
|
||||
// The destructor of cmArchiveWrite will close and finish the write
|
||||
return 1;
|
||||
}
|
||||
|
||||
|
@ -261,3 +309,7 @@ int cmCPackArchiveGenerator::GenerateHeader(std::ostream*)
|
|||
{
|
||||
return 1;
|
||||
}
|
||||
|
||||
bool cmCPackArchiveGenerator::SupportsComponentInstallation() const {
|
||||
return true;
|
||||
}
|
||||
|
|
|
@ -13,34 +13,61 @@
|
|||
#ifndef cmCPackArchiveGenerator_h
|
||||
#define cmCPackArchiveGenerator_h
|
||||
|
||||
#include "cmArchiveWrite.h"
|
||||
#include "cmCPackGenerator.h"
|
||||
|
||||
|
||||
/** \class cmCPackArchiveGenerator
|
||||
* \brief A generator base for libarchive generation
|
||||
* \brief A generator base for libarchive generation.
|
||||
* The generator itself uses the libarchive wrapper
|
||||
* \ref cmArchiveWrite.
|
||||
*
|
||||
*/
|
||||
class cmCPackArchiveGenerator : public cmCPackGenerator
|
||||
{
|
||||
{
|
||||
public:
|
||||
enum CompressType{ GZIP, BZIP2, COMPRESS, LZMA, NONE};
|
||||
enum ArchiveType{ TAR, ZIP};
|
||||
cmTypeMacro(cmCPackArchiveGenerator, cmCPackGenerator);
|
||||
|
||||
/**
|
||||
* Construct generator
|
||||
*/
|
||||
cmCPackArchiveGenerator(CompressType, ArchiveType);
|
||||
cmCPackArchiveGenerator(cmArchiveWrite::Compress, cmArchiveWrite::Type);
|
||||
virtual ~cmCPackArchiveGenerator();
|
||||
// Used to add a header to the archive
|
||||
virtual int GenerateHeader(std::ostream* os);
|
||||
|
||||
// component support
|
||||
virtual bool SupportsComponentInstallation() const;
|
||||
protected:
|
||||
virtual int InitializeInternal();
|
||||
/**
|
||||
* Add the files belonging to the specified component
|
||||
* to the provided (already opened) archive.
|
||||
* @param[in,out] archive the archive object
|
||||
* @param[in] component the component whose file will be added to archive
|
||||
*/
|
||||
int addOneComponentToArchive(cmArchiveWrite& archive, cmCPackComponent* component);
|
||||
|
||||
/**
|
||||
* The main package file method.
|
||||
* If component install was required this
|
||||
* method will call either PackageComponents or
|
||||
* PackageComponentsAllInOne.
|
||||
*/
|
||||
int PackageFiles();
|
||||
/**
|
||||
* The method used to package files when component
|
||||
* install is used. This will create one
|
||||
* archive for each component group.
|
||||
*/
|
||||
int PackageComponents(bool ignoreComponentGroup);
|
||||
/**
|
||||
* Special case of component install where all
|
||||
* components will be put in a single installer.
|
||||
*/
|
||||
int PackageComponentsAllInOne(bool allComponentInOne);
|
||||
virtual const char* GetOutputExtension() = 0;
|
||||
CompressType Compress;
|
||||
ArchiveType Archive;
|
||||
};
|
||||
cmArchiveWrite::Compress Compress;
|
||||
cmArchiveWrite::Type Archive;
|
||||
};
|
||||
|
||||
#endif
|
||||
|
|
|
@ -59,7 +59,7 @@ int cmCPackCygwinSourceGenerator::PackageFiles()
|
|||
// skip one parent up to the cmCPackTarBZip2Generator
|
||||
// to create tar.bz2 file with the list of source
|
||||
// files
|
||||
this->Compress = BZIP2;
|
||||
this->Compress = cmArchiveWrite::CompressBZip2;
|
||||
if ( !this->cmCPackTarBZip2Generator::PackageFiles() )
|
||||
{
|
||||
return 0;
|
||||
|
|
|
@ -851,8 +851,8 @@ int cmCPackGenerator::DoPackage()
|
|||
return 0;
|
||||
}
|
||||
|
||||
cmCPackLogger(cmCPackLog::LOG_OUTPUT, "Compress package" << std::endl);
|
||||
cmCPackLogger(cmCPackLog::LOG_VERBOSE, "Compress files to: "
|
||||
cmCPackLogger(cmCPackLog::LOG_OUTPUT, "Create package" << std::endl);
|
||||
cmCPackLogger(cmCPackLog::LOG_VERBOSE, "Package files to: "
|
||||
<< (tempPackageFileName ? tempPackageFileName : "(NULL)") << std::endl);
|
||||
if ( cmSystemTools::FileExists(tempPackageFileName) )
|
||||
{
|
||||
|
@ -876,7 +876,10 @@ int cmCPackGenerator::DoPackage()
|
|||
std::vector<std::string>::const_iterator it;
|
||||
for ( it = files.begin(); it != files.end(); ++ it )
|
||||
{
|
||||
std::string fileN = cmSystemTools::RelativePath(tempDirectory,
|
||||
// beware we cannot just use tempDirectory as before
|
||||
// because some generator will "CPACK_INCLUDE_TOPLEVEL_DIRECTORY"
|
||||
// we really want "CPACK_TEMPORARY_DIRECTORY"
|
||||
std::string fileN = cmSystemTools::RelativePath(this->GetOption("CPACK_TEMPORARY_DIRECTORY"),
|
||||
it->c_str());
|
||||
|
||||
// Determine which component we are in.
|
||||
|
@ -887,6 +890,7 @@ int cmCPackGenerator::DoPackage()
|
|||
|
||||
// Add this file to the list of files for the component.
|
||||
this->Components[componentName].Files.push_back(fileN);
|
||||
cmCPackLogger(cmCPackLog::LOG_DEBUG, "Adding file <" <<fileN<<"> to component <"<<componentName<<">"<<std::endl);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
@ -14,8 +14,8 @@
|
|||
|
||||
//----------------------------------------------------------------------
|
||||
cmCPackTGZGenerator::cmCPackTGZGenerator()
|
||||
:cmCPackArchiveGenerator(cmCPackArchiveGenerator::GZIP,
|
||||
cmCPackArchiveGenerator::TAR)
|
||||
:cmCPackArchiveGenerator(cmArchiveWrite::CompressGZip,
|
||||
cmArchiveWrite::TypeTAR)
|
||||
{
|
||||
}
|
||||
|
||||
|
|
|
@ -13,8 +13,8 @@
|
|||
#include "cmCPackTarBZip2Generator.h"
|
||||
//----------------------------------------------------------------------
|
||||
cmCPackTarBZip2Generator::cmCPackTarBZip2Generator()
|
||||
:cmCPackArchiveGenerator(cmCPackArchiveGenerator::BZIP2,
|
||||
cmCPackArchiveGenerator::TAR)
|
||||
:cmCPackArchiveGenerator(cmArchiveWrite::CompressBZip2,
|
||||
cmArchiveWrite::TypeTAR)
|
||||
{
|
||||
}
|
||||
|
||||
|
|
|
@ -14,8 +14,8 @@
|
|||
|
||||
//----------------------------------------------------------------------
|
||||
cmCPackTarCompressGenerator::cmCPackTarCompressGenerator()
|
||||
:cmCPackArchiveGenerator(cmCPackArchiveGenerator::COMPRESS,
|
||||
cmCPackArchiveGenerator::TAR)
|
||||
:cmCPackArchiveGenerator(cmArchiveWrite::CompressCompress,
|
||||
cmArchiveWrite::TypeTAR)
|
||||
{
|
||||
}
|
||||
|
||||
|
|
|
@ -14,8 +14,8 @@
|
|||
|
||||
//----------------------------------------------------------------------
|
||||
cmCPackZIPGenerator::cmCPackZIPGenerator()
|
||||
:cmCPackArchiveGenerator(cmCPackArchiveGenerator::NONE,
|
||||
cmCPackArchiveGenerator::ZIP)
|
||||
:cmCPackArchiveGenerator(cmArchiveWrite::CompressNone,
|
||||
cmArchiveWrite::TypeZIP)
|
||||
{
|
||||
}
|
||||
|
||||
|
|
Loading…
Reference in New Issue