Browse Source

- load the supported compressors from configuration

- support adding new compressors by configuration
tags/debian/0.8.12
David Kalnischkies 10 years ago
parent
commit
03bef78461
6 changed files with 133 additions and 52 deletions
  1. +70
    -4
      apt-pkg/aptconfiguration.cc
  2. +26
    -0
      apt-pkg/aptconfiguration.h
  3. +3
    -1
      debian/changelog
  4. +28
    -31
      ftparchive/multicompress.cc
  5. +5
    -16
      ftparchive/multicompress.h
  6. +1
    -0
      ftparchive/writer.cc

+ 70
- 4
apt-pkg/aptconfiguration.cc View File

@@ -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);
}
/*}}}*/
}

+ 26
- 0
apt-pkg/aptconfiguration.h View File

@@ -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();
/*}}}*/
};
/*}}}*/


+ 3
- 1
debian/changelog View File

@@ -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



+ 28
- 31
ftparchive/multicompress.cc View File

@@ -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)


+ 5
- 16
ftparchive/multicompress.h View File

@@ -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();


+ 1
- 0
ftparchive/writer.cc View File

@@ -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>


Loading…
Cancel
Save