- load the supported compressors from configuration

  - support adding new compressors by configuration

apt-pkg/aptconfiguration.cc

@@ -42,10 +42,7 @@ const Configuration::getCompressionTypes(bool const &Cached) {
 	_config->CndSet("Acquire::CompressionTypes::lzma","lzma");
 	_config->CndSet("Acquire::CompressionTypes::gz","gzip");
 
-	// Set default application paths to check for optional compression types
-	_config->CndSet("Dir::Bin::lzma", "/usr/bin/lzma");
-	_config->CndSet("Dir::Bin::xz", "/usr/bin/xz");
-	_config->CndSet("Dir::Bin::bzip2", "/bin/bzip2");
+	setDefaultConfigurationForCompressors();
 
 	// accept non-list order as override setting for config settings on commandline
 	std::string const overrideOrder = _config->Find("Acquire::CompressionTypes::Order","");
@@ -346,4 +343,73 @@ bool const Configuration::checkArchitecture(std::string const &Arch) {
 	return (std::find(archs.begin(), archs.end(), Arch) != archs.end());
 }
 									/*}}}*/
+// setDefaultConfigurationForCompressors				/*{{{*/
+void Configuration::setDefaultConfigurationForCompressors() {
+	// Set default application paths to check for optional compression types
+	_config->CndSet("Dir::Bin::lzma", "/usr/bin/lzma");
+	_config->CndSet("Dir::Bin::xz", "/usr/bin/xz");
+	_config->CndSet("Dir::Bin::bzip2", "/bin/bzip2");
+}
+									/*}}}*/
+// getCompressors - Return Vector of usbale compressors			/*{{{*/
+// ---------------------------------------------------------------------
+/* return a vector of compressors used by apt-ftparchive in the
+   multicompress functionality or to detect data.tar files */
+std::vector<APT::Configuration::Compressor>
+const Configuration::getCompressors(bool const Cached) {
+	static std::vector<APT::Configuration::Compressor> compressors;
+	if (compressors.empty() == false) {
+		if (Cached == true)
+			return compressors;
+		else
+			compressors.clear();
+	}
+
+	setDefaultConfigurationForCompressors();
+
+	compressors.push_back(Compressor(".", "", "", "", "", 1));
+	if (_config->Exists("Dir::Bin::gzip") == false || FileExists(_config->FindFile("Dir::Bin::gzip")) == true)
+		compressors.push_back(Compressor("gzip",".gz","gzip","-9n","-d",2));
+	if (_config->Exists("Dir::Bin::bzip2") == false || FileExists(_config->FindFile("Dir::Bin::bzip2")) == true)
+		compressors.push_back(Compressor("bzip2",".bz2","bzip2","-9","-d",3));
+	if (_config->Exists("Dir::Bin::lzma") == false || FileExists(_config->FindFile("Dir::Bin::lzma")) == true)
+		compressors.push_back(Compressor("lzma",".lzma","lzma","-9","-d",4));
+	if (_config->Exists("Dir::Bin::xz") == false || FileExists(_config->FindFile("Dir::Bin::xz")) == true)
+		compressors.push_back(Compressor("xz",".xz","xz","-6","-d",5));
+
+	std::vector<std::string> const comp = _config->FindVector("APT::Compressor");
+	for (std::vector<std::string>::const_iterator c = comp.begin();
+	     c != comp.end(); ++c) {
+		if (*c == "." || *c == "gzip" || *c == "bzip2" || *c == "lzma" || *c == "xz")
+			continue;
+		compressors.push_back(Compressor(c->c_str(), std::string(".").append(*c).c_str(), c->c_str(), "-9", "-d", 100));
+	}
+
+	return compressors;
+}
+									/*}}}*/
+// Compressor constructor						/*{{{*/
+// ---------------------------------------------------------------------
+/* */
+Configuration::Compressor::Compressor(char const *name, char const *extension,
+				      char const *binary,
+				      char const *compressArg, char const *uncompressArg,
+				      unsigned short const cost) {
+	std::string const config = string("APT:Compressor::").append(name).append("::");
+	Name = _config->Find(std::string(config).append("Name"), name);
+	Extension = _config->Find(std::string(config).append("Extension"), extension);
+	Binary = _config->Find(std::string(config).append("Binary"), binary);
+	Cost = _config->FindI(std::string(config).append("Cost"), cost);
+	std::string const compConf = std::string(config).append("CompressArg");
+	if (_config->Exists(compConf) == true)
+		CompressArgs = _config->FindVector(compConf);
+	else if (compressArg != NULL)
+		CompressArgs.push_back(compressArg);
+	std::string const uncompConf = std::string(config).append("UncompressArg");
+	if (_config->Exists(uncompConf) == true)
+		UncompressArgs = _config->FindVector(uncompConf);
+	else if (uncompressArg != NULL)
+		UncompressArgs.push_back(uncompressArg);
+}
+									/*}}}*/
 }

apt-pkg/aptconfiguration.h

@@ -82,6 +82,32 @@ public:									/*{{{*/
 	 */
 	bool static const checkArchitecture(std::string const &Arch);
 
+	/** \brief Representation of supported compressors */
+	struct Compressor {
+		std::string Name;
+		std::string Extension;
+		std::string Binary;
+		std::vector<std::string> CompressArgs;
+		std::vector<std::string> UncompressArgs;
+		unsigned short Cost;
+
+		Compressor(char const *name, char const *extension, char const *binary,
+			   char const *compressArg, char const *uncompressArg,
+			   unsigned short const cost);
+		Compressor() {};
+	};
+
+	/** \brief Return a vector of Compressors supported for data.tar's
+	 *
+	 *  \param Cached saves the result so we need to calculated it only once
+	 *                this parameter should ony be used for testing purposes.
+	 *
+	 *  \return a vector of Compressors
+	 */
+	std::vector<Compressor> static const getCompressors(bool const Cached = true);
+									/*}}}*/
+	private:							/*{{{*/
+	void static setDefaultConfigurationForCompressors();
 									/*}}}*/
 };
 									/*}}}*/

debian/changelog

@@ -9,18 +9,20 @@ apt (0.8.11.6) UNRELEASED; urgency=low
   * ftparchive/multicompress.cc, apt-inst/deb/debfile.cc:
     - support xz compressor to create xz-compressed Indexes and be able
       to open data.tar.xz files
+    - load the supported compressors from configuration
   * ftparchive/writer.cc:
     - ensure that Date and Valid-Until time strings are not localised
     - add options to disable specific checksums for Indexes
     - include xz-compressed Packages and Sources files in Release file
   * apt-pkg/aptconfiguration.cc:
     - support download of xz-compressed indexes files
+    - support adding new compressors by configuration
   * apt-pkg/deb/debsrcrecords.cc:
     - support xz-compressed source v3 debian.tar files
   * ftparchive/contents.cc:
     - remove ExtractArchive codecopy from apt-inst/deb/debfile.cc
 
- -- David Kalnischkies <kalnischkies@gmail.com>  Wed, 23 Feb 2011 09:00:51 +0100
+ -- David Kalnischkies <kalnischkies@gmail.com>  Sun, 27 Feb 2011 23:00:07 +0100
 
 apt (0.8.11.5) unstable; urgency=low
 

ftparchive/multicompress.cc

@@ -30,13 +30,6 @@
 
 using namespace std;
 
-const MultiCompress::CompType MultiCompress::Compressors[] =
-      {{".","",0,0,0,1},
-       {"gzip",".gz","gzip","-9n","-d",2},
-       {"bzip2",".bz2","bzip2","-9","-d",3},
-       {"lzma",".lzma","lzma","-9","-d",4},
-       {"xz",".xz","xz","-6","-d",5},
-       {}};
 
 // MultiCompress::MultiCompress - Constructor				/*{{{*/
 // ---------------------------------------------------------------------
@@ -49,7 +42,7 @@ MultiCompress::MultiCompress(string const &Output,string const &Compress,
    Outputter = -1;
    Input = 0;
    UpdateMTime = 0;
-   
+
    /* Parse the compression string, a space separated lists of compresison
       types */
    string::const_iterator I = Compress.begin();
@@ -62,13 +55,14 @@ MultiCompress::MultiCompress(string const &Output,string const &Compress,
       for (; I != Compress.end() && !isspace(*I); I++);
 
       // Find the matching compressor
-      const CompType *Comp = Compressors;
-      for (; Comp->Name != 0; Comp++)
-	 if (stringcmp(Start,I,Comp->Name) == 0)
+      std::vector<APT::Configuration::Compressor> Compressors = APT::Configuration::getCompressors();
+      std::vector<APT::Configuration::Compressor>::const_iterator Comp = Compressors.begin();
+      for (; Comp != Compressors.end(); ++Comp)
+	 if (stringcmp(Start,I,Comp->Name.c_str()) == 0)
 	    break;
 
       // Hmm.. unknown.
-      if (Comp->Name == 0)
+      if (Comp == Compressors.end())
       {
 	 _error->Warning(_("Unknown compression algorithm '%s'"),string(Start,I).c_str());
 	 continue;
@@ -78,7 +72,7 @@ MultiCompress::MultiCompress(string const &Output,string const &Compress,
       Files *NewOut = new Files;
       NewOut->Next = Outputs;
       Outputs = NewOut;
-      NewOut->CompressProg = Comp;
+      NewOut->CompressProg = *Comp;
       NewOut->Output = Output+Comp->Extension;
       
       struct stat St;
@@ -142,13 +136,14 @@ bool MultiCompress::GetStat(string const &Output,string const &Compress,struct s
       for (; I != Compress.end() && !isspace(*I); I++);
 
       // Find the matching compressor
-      const CompType *Comp = Compressors;
-      for (; Comp->Name != 0; Comp++)
-	 if (stringcmp(Start,I,Comp->Name) == 0)
+      std::vector<APT::Configuration::Compressor> Compressors = APT::Configuration::getCompressors();
+      std::vector<APT::Configuration::Compressor>::const_iterator Comp = Compressors.begin();
+      for (; Comp != Compressors.end(); ++Comp)
+	 if (stringcmp(Start,I,Comp->Name.c_str()) == 0)
 	    break;
 
       // Hmm.. unknown.
-      if (Comp->Name == 0)
+      if (Comp == Compressors.end())
 	 continue;
 
       string Name = Output+Comp->Extension;
@@ -269,13 +264,13 @@ bool MultiCompress::Finalize(unsigned long &OutSize)
 /* This opens the compressor, either in compress mode or decompress 
    mode. FileFd is always the compressor input/output file, 
    OutFd is the created pipe, Input for Compress, Output for Decompress. */
-bool MultiCompress::OpenCompress(const CompType *Prog,pid_t &Pid,int const &FileFd,
-				 int &OutFd,bool const &Comp)
+bool MultiCompress::OpenCompress(APT::Configuration::Compressor const &Prog,
+				 pid_t &Pid,int const &FileFd,int &OutFd,bool const &Comp)
 {
    Pid = -1;
    
    // No compression
-   if (Prog->Binary == 0)
+   if (Prog.Binary.empty() == true)
    {
       OutFd = dup(FileFd);
       return true;
@@ -310,15 +305,17 @@ bool MultiCompress::OpenCompress(const CompType *Prog,pid_t &Pid,int const &File
       
       SetCloseExec(STDOUT_FILENO,false);
       SetCloseExec(STDIN_FILENO,false);
-      
-      const char *Args[3];
-      Args[0] = Prog->Binary;
-      if (Comp == true)
-	 Args[1] = Prog->CompArgs;
-      else
-	 Args[1] = Prog->UnCompArgs;
-      Args[2] = 0;
-      execvp(Args[0],(char **)Args);
+
+      std::vector<char const*> Args;
+      Args.push_back(Prog.Binary.c_str());
+      std::vector<std::string> const * const addArgs =
+		(Comp == true) ? &(Prog.CompressArgs) : &(Prog.UncompressArgs);
+      for (std::vector<std::string>::const_iterator a = addArgs->begin();
+	   a != addArgs->end(); ++a)
+	 Args.push_back(a->c_str());
+      Args.push_back(NULL);
+
+      execvp(Args[0],(char **)&Args[0]);
       cerr << _("Failed to exec compressor ") << Args[0] << endl;
       _exit(100);
    };      
@@ -336,7 +333,7 @@ bool MultiCompress::OpenOld(int &Fd,pid_t &Proc)
 {
    Files *Best = Outputs;
    for (Files *I = Outputs; I != 0; I = I->Next)
-      if (Best->CompressProg->Cost > I->CompressProg->Cost)
+      if (Best->CompressProg.Cost > I->CompressProg.Cost)
 	 Best = I;
 
    // Open the file
@@ -415,7 +412,7 @@ bool MultiCompress::Child(int const &FD)
    for (Files *I = Outputs; I != 0; I = I->Next)
    {
       if (I->CompressProc != -1)
-	 ExecWait(I->CompressProc,I->CompressProg->Binary,false);
+	 ExecWait(I->CompressProc, I->CompressProg.Binary.c_str(), false);
    }
    
    if (_error->PendingError() == true)

ftparchive/multicompress.h

@@ -20,28 +20,18 @@
 
 #include <string>
 #include <apt-pkg/fileutl.h>
+#include <apt-pkg/aptconfiguration.h>
 #include <stdio.h>
 #include <sys/types.h>
     
 class MultiCompress
 {
-   // Enumeration of all supported compressors
-   struct CompType
-   {
-      const char *Name;
-      const char *Extension;
-      const char *Binary;
-      const char *CompArgs;
-      const char *UnCompArgs;
-      unsigned char Cost;
-   };
-
    // An output file
    struct Files
    {
       string Output;
-      const CompType *CompressProg;
-      Files *Next;      
+      APT::Configuration::Compressor CompressProg;
+      Files *Next;
       FileFd TmpFile;
       pid_t CompressProc;
       time_t OldMTime;
@@ -51,10 +41,9 @@ class MultiCompress
    Files *Outputs;
    pid_t Outputter;
    mode_t Permissions;
-   static const CompType Compressors[];
 
-   bool OpenCompress(const CompType *Prog,pid_t &Pid,int const &FileFd,
-		     int &OutFd,bool const &Comp);
+   bool OpenCompress(APT::Configuration::Compressor const &Prog,
+		     pid_t &Pid,int const &FileFd, int &OutFd,bool const &Comp);
    bool Child(int const &Fd);
    bool Start();
    bool Die();

ftparchive/writer.cc

@@ -17,6 +17,7 @@
 #include <apt-pkg/strutl.h>
 #include <apt-pkg/error.h>
 #include <apt-pkg/configuration.h>
+#include <apt-pkg/aptconfiguration.h>
 #include <apt-pkg/md5.h>
 #include <apt-pkg/sha1.h>
 #include <apt-pkg/sha256.h>