1 files changed, 259 insertions, 187 deletions

diff --git a/Source/CPack/cmCPackArchiveGenerator.cxx b/Source/CPack/cmCPackArchiveGenerator.cxx
index a52d05e..c86434e 100644
--- a/Source/CPack/cmCPackArchiveGenerator.cxx
+++ b/Source/CPack/cmCPackArchiveGenerator.cxx
@@ -22,13 +22,12 @@
 #include <errno.h>
 
 #include <cmsys/SystemTools.hxx>
-#include <cmlibarchive/libarchive/archive.h>
-#include <cmlibarchive/libarchive/archive_entry.h>
-
+#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;
@@ -39,222 +38,291 @@ 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
+//----------------------------------------------------------------------
+int cmCPackArchiveGenerator::InitializeInternal()
 {
-bool SetArchiveType(struct archive* a,
-                     cmCPackArchiveGenerator::CompressType ct,
-                     cmCPackArchiveGenerator::ArchiveType at)
+  this->SetOptionIfNotSet("CPACK_INCLUDE_TOPLEVEL_DIRECTORY", "1");
+  return this->Superclass::InitializeInternal();
+}
+//----------------------------------------------------------------------
+int cmCPackArchiveGenerator::addOneComponentToArchive(cmArchiveWrite& archive,
+                             cmCPackComponent* component)
 {
-  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)
+  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 )
     {
-    return false;
+    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;
+      }
     }
-  
-  return true;
+  // Go back to previous dir
+  cmSystemTools::ChangeDirectory(dir.c_str());
+  return 1;
 }
-  
-struct StreamData
-{
-  StreamData(cmGeneratedFileStream* gfs,
-    cmCPackArchiveGenerator* ag) 
-    { 
-      this->GeneratedFileStream = gfs;
-      this->Generator = ag;
-    }
-  cmGeneratedFileStream* GeneratedFileStream;
-  cmCPackArchiveGenerator* Generator;
-};
 
+/*
+ * 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; \
+  }
 
-extern "C"
-{
-int OpenArchive(struct archive *, void *client_data)
+//----------------------------------------------------------------------
+int cmCPackArchiveGenerator::PackageComponents(bool ignoreComponentGroup)
 {
-  struct StreamData *data = (StreamData*)client_data;
-  if(data->GeneratedFileStream && 
-     *data->GeneratedFileStream)
+  packageFileNames.clear();
+  // The default behavior is to have one package by component group
+  // unless CPACK_COMPONENTS_IGNORE_GROUP is specified.
+  if (!ignoreComponentGroup)
     {
-    if(data->Generator->
-       GenerateHeader(data->GeneratedFileStream))
+    std::map<std::string, cmCPackComponentGroup>::iterator compGIt;
+    for (compGIt=this->ComponentGroups.begin();
+        compGIt!=this->ComponentGroups.end(); ++compGIt)
       {
-      return ARCHIVE_OK;
+      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);
       }
     }
-  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())
+  // CPACK_COMPONENTS_IGNORE_GROUPS is set
+  // We build 1 package per component
+  else
     {
-    return n;
+    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 0;
+  return 1;
 }
 
-
-int CloseArchive(struct archive *, void *client_data)
+//----------------------------------------------------------------------
+int cmCPackArchiveGenerator::PackageComponentsAllInOne(bool allComponentInOne)
 {
-  struct StreamData *data = (StreamData*)client_data;
-  if(data->GeneratedFileStream->Close())
+  // 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
     {
-    delete data->GeneratedFileStream;
-    return ARCHIVE_OK;
+    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));
+      }
     }
-  return ARCHIVE_FATAL;
+  // archive goes out of scope so it will finalized and closed.
+  return 1;
 }
-} //extern C
-} // anon name space
-
 
 //----------------------------------------------------------------------
-int cmCPackArchiveGenerator::InitializeInternal()
+int cmCPackArchiveGenerator::PackageFiles()
 {
-  this->SetOptionIfNotSet("CPACK_INCLUDE_TOPLEVEL_DIRECTORY", "1");
-  return this->Superclass::InitializeInternal();
-}
+  cmCPackLogger(cmCPackLog::LOG_DEBUG, "Toplevel: "
+                << toplevel << std::endl);
 
-int cmCPackArchiveGenerator::CompressFiles(const char* outFileName,
-  const char* toplevel, const std::vector<std::string>& files)
-{
-  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");                       \
+  // 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);
+      }
     }
-  cmCPackLogger(cmCPackLog::LOG_DEBUG, "Toplevel: "
-                << (toplevel ? toplevel : "(NULL)") << 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(outFileName, 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:");
+
+  // 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);
+  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, 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)
+    std::string rp = cmSystemTools::RelativePath(toplevel.c_str(),
+                                                 fileIt->c_str());
+    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;
 }
 
@@ -263,3 +331,7 @@ int cmCPackArchiveGenerator::GenerateHeader(std::ostream*)
 {
   return 1;
 }
+
+bool cmCPackArchiveGenerator::SupportsComponentInstallation() const {
+  return true;
+}