From be9b62f76406cf2546d21f3ca27587ee20e0fc37 Mon Sep 17 00:00:00 2001 From: Michael Vogt Date: Wed, 2 Feb 2011 22:30:45 +0100 Subject: add more dpointer placeholders --- apt-pkg/algorithms.h | 3 +++ 1 file changed, 3 insertions(+) (limited to 'apt-pkg/algorithms.h') diff --git a/apt-pkg/algorithms.h b/apt-pkg/algorithms.h index cf4a98c4f..42945a6f2 100644 --- a/apt-pkg/algorithms.h +++ b/apt-pkg/algorithms.h @@ -78,6 +78,9 @@ private: /*}}}*/ class pkgProblemResolver /*{{{*/ { + /** \brief dpointer placeholder (for later in case we need it) */ + void *d; + pkgDepCache &Cache; typedef pkgCache::PkgIterator PkgIterator; typedef pkgCache::VerIterator VerIterator; -- cgit v1.2.3-70-g09d2 From 6d38011bb93451dd9da3294614d821c77ac91687 Mon Sep 17 00:00:00 2001 From: David Kalnischkies Date: Wed, 30 Mar 2011 17:23:43 +0200 Subject: add a first round of stuff needed for talking between APT and solvers based on a very early draft for EDSP by Stefano APT can now write a scenario as well as load most stuff from it. --- apt-pkg/algorithms.cc | 33 +++++++++-- apt-pkg/algorithms.h | 2 + apt-pkg/deb/debindexfile.h | 4 +- apt-pkg/deb/deblistparser.h | 8 +-- apt-pkg/depcache.cc | 6 ++ apt-pkg/depcache.h | 4 +- apt-pkg/edsp/edspindexfile.cc | 74 +++++++++++++++++++++++ apt-pkg/edsp/edspindexfile.h | 25 ++++++++ apt-pkg/edsp/edsplistparser.cc | 109 ++++++++++++++++++++++++++++++++++ apt-pkg/edsp/edsplistparser.h | 38 ++++++++++++ apt-pkg/edsp/edspsystem.cc | 117 +++++++++++++++++++++++++++++++++++++ apt-pkg/edsp/edspsystem.h | 38 ++++++++++++ apt-pkg/edsp/edspwriter.cc | 130 +++++++++++++++++++++++++++++++++++++++++ apt-pkg/edsp/edspwriter.h | 19 ++++++ apt-pkg/makefile | 7 ++- apt-pkg/pkgcachegen.cc | 2 +- apt-pkg/policy.cc | 4 ++ apt-pkg/policy.h | 7 +-- 18 files changed, 609 insertions(+), 18 deletions(-) create mode 100644 apt-pkg/edsp/edspindexfile.cc create mode 100644 apt-pkg/edsp/edspindexfile.h create mode 100644 apt-pkg/edsp/edsplistparser.cc create mode 100644 apt-pkg/edsp/edsplistparser.h create mode 100644 apt-pkg/edsp/edspsystem.cc create mode 100644 apt-pkg/edsp/edspsystem.h create mode 100644 apt-pkg/edsp/edspwriter.cc create mode 100644 apt-pkg/edsp/edspwriter.h (limited to 'apt-pkg/algorithms.h') diff --git a/apt-pkg/algorithms.cc b/apt-pkg/algorithms.cc index 0b4366e5e..2ca3404a0 100644 --- a/apt-pkg/algorithms.cc +++ b/apt-pkg/algorithms.cc @@ -20,12 +20,15 @@ #include #include #include - +#include + #include #include #include #include #include + +#include /*}}}*/ using namespace std; @@ -731,7 +734,25 @@ bool pkgProblemResolver::DoUpgrade(pkgCache::PkgIterator Pkg) return true; } /*}}}*/ -// ProblemResolver::Resolve - Run the resolution pass /*{{{*/ +// ProblemResolver::Resolve - calls a resolver to fix the situation /*{{{*/ +// --------------------------------------------------------------------- +/* */ +bool pkgProblemResolver::Resolve(bool BrokenFix) +{ + std::string const solver = _config->Find("APT::Solver::Name", "internal"); + if (solver != "internal") + { + FILE* output = fopen("/tmp/universe.log", "w"); + edspWriter::WriteUniverse(Cache, output); + fclose(output); + output = fopen("/tmp/request.log", "w"); + edspWriter::WriteRequest(Cache, output); + fclose(output); + } + return ResolveInternal(BrokenFix); +} + /*}}}*/ +// ProblemResolver::ResolveInternal - Run the resolution pass /*{{{*/ // --------------------------------------------------------------------- /* This routines works by calculating a score for each package. The score is derived by considering the package's priority and all reverse @@ -745,12 +766,10 @@ bool pkgProblemResolver::DoUpgrade(pkgCache::PkgIterator Pkg) The BrokenFix flag enables a mode where the algorithm tries to upgrade packages to advoid problems. */ -bool pkgProblemResolver::Resolve(bool BrokenFix) +bool pkgProblemResolver::ResolveInternal(bool const BrokenFix) { pkgDepCache::ActionGroup group(Cache); - unsigned long Size = Cache.Head().PackageCount; - // Record which packages are marked for install bool Again = false; do @@ -780,7 +799,9 @@ bool pkgProblemResolver::Resolve(bool BrokenFix) clog << "Starting" << endl; MakeScores(); - + + unsigned long const Size = Cache.Head().PackageCount; + /* We have to order the packages so that the broken fixing pass operates from highest score to lowest. This prevents problems when high score packages cause the removal of lower score packages that diff --git a/apt-pkg/algorithms.h b/apt-pkg/algorithms.h index ebe31cc10..0778ec722 100644 --- a/apt-pkg/algorithms.h +++ b/apt-pkg/algorithms.h @@ -105,6 +105,8 @@ class pkgProblemResolver /*{{{*/ void MakeScores(); bool DoUpgrade(pkgCache::PkgIterator Pkg); + + bool ResolveInternal(bool const BrokenFix = false); public: diff --git a/apt-pkg/deb/debindexfile.h b/apt-pkg/deb/debindexfile.h index b5085992d..6697c5f26 100644 --- a/apt-pkg/deb/debindexfile.h +++ b/apt-pkg/deb/debindexfile.h @@ -22,8 +22,9 @@ class debStatusIndex : public pkgIndexFile { + protected: string File; - + public: virtual const Type *GetType() const; @@ -36,6 +37,7 @@ class debStatusIndex : public pkgIndexFile virtual bool HasPackages() const {return true;}; virtual unsigned long Size() const; virtual bool Merge(pkgCacheGenerator &Gen,OpProgress *Prog) const; + bool Merge(pkgCacheGenerator &Gen,OpProgress *Prog, unsigned long const Flag) const; virtual pkgCache::PkgFileIterator FindInCache(pkgCache &Cache) const; debStatusIndex(string File); diff --git a/apt-pkg/deb/deblistparser.h b/apt-pkg/deb/deblistparser.h index d62ce641c..8b8aff788 100644 --- a/apt-pkg/deb/deblistparser.h +++ b/apt-pkg/deb/deblistparser.h @@ -25,9 +25,9 @@ class debListParser : public pkgCacheGenerator::ListParser const char *Str; unsigned char Val; }; - - private: - + + protected: + pkgTagFile Tags; pkgTagSection Section; unsigned long iOffset; @@ -36,7 +36,7 @@ class debListParser : public pkgCacheGenerator::ListParser bool MultiArchEnabled; unsigned long UniqFindTagWrite(const char *Tag); - bool ParseStatus(pkgCache::PkgIterator &Pkg,pkgCache::VerIterator &Ver); + virtual bool ParseStatus(pkgCache::PkgIterator &Pkg,pkgCache::VerIterator &Ver); bool ParseDepends(pkgCache::VerIterator &Ver,const char *Tag, unsigned int Type); bool ParseProvides(pkgCache::VerIterator &Ver); diff --git a/apt-pkg/depcache.cc b/apt-pkg/depcache.cc index 07803d7bf..2790080a1 100644 --- a/apt-pkg/depcache.cc +++ b/apt-pkg/depcache.cc @@ -1578,6 +1578,12 @@ bool pkgDepCache::Policy::IsImportantDep(DepIterator const &Dep) return false; } /*}}}*/ +// Policy::GetPriority - Get the priority of the package pin /*{{{*/ +signed short pkgDepCache::Policy::GetPriority(pkgCache::PkgIterator const &Pkg) +{ return 0; }; +signed short pkgDepCache::Policy::GetPriority(pkgCache::PkgFileIterator const &File) +{ return 0; }; + /*}}}*/ pkgDepCache::InRootSetFunc *pkgDepCache::GetRootSetFunc() /*{{{*/ { DefaultRootSetFunc *f = new DefaultRootSetFunc; diff --git a/apt-pkg/depcache.h b/apt-pkg/depcache.h index 750da3d6f..b15cd527d 100644 --- a/apt-pkg/depcache.h +++ b/apt-pkg/depcache.h @@ -258,7 +258,9 @@ class pkgDepCache : protected pkgCache::Namespace virtual VerIterator GetCandidateVer(PkgIterator const &Pkg); virtual bool IsImportantDep(DepIterator const &Dep); - + virtual signed short GetPriority(PkgIterator const &Pkg); + virtual signed short GetPriority(PkgFileIterator const &File); + virtual ~Policy() {}; }; diff --git a/apt-pkg/edsp/edspindexfile.cc b/apt-pkg/edsp/edspindexfile.cc new file mode 100644 index 000000000..5a9d5aacd --- /dev/null +++ b/apt-pkg/edsp/edspindexfile.cc @@ -0,0 +1,74 @@ +// -*- mode: cpp; mode: fold -*- +// Description /*{{{*/ +/* ###################################################################### + The universe file is designed to work as an intermediate file between + APT and the resolver. Its on propose very similar to a dpkg status file + ##################################################################### */ + /*}}}*/ +// Include Files /*{{{*/ +#include +#include +#include +#include +#include +#include +#include +#include + +#include + /*}}}*/ + +// edspIndex::edspIndex - Constructor /*{{{*/ +// --------------------------------------------------------------------- +/* */ +edspIndex::edspIndex(string File) : debStatusIndex(File) +{ +} + /*}}}*/ +// StatusIndex::Merge - Load the index file into a cache /*{{{*/ +bool edspIndex::Merge(pkgCacheGenerator &Gen,OpProgress *Prog) const +{ + FileFd Pkg(File,FileFd::ReadOnlyGzip); + if (_error->PendingError() == true) + return false; + edspListParser Parser(&Pkg); + if (_error->PendingError() == true) + return false; + + if (Prog != NULL) + Prog->SubProgress(0,File); + if (Gen.SelectFile(File,string(),*this) == false) + return _error->Error("Problem with SelectFile %s",File.c_str()); + + // Store the IMS information + pkgCache::PkgFileIterator CFile = Gen.GetCurFile(); + struct stat St; + if (fstat(Pkg.Fd(),&St) != 0) + return _error->Errno("fstat","Failed to stat"); + CFile->Size = St.st_size; + CFile->mtime = St.st_mtime; + CFile->Archive = Gen.WriteUniqString("universe"); + + if (Gen.MergeList(Parser) == false) + return _error->Error("Problem with MergeList %s",File.c_str()); + return true; +} + /*}}}*/ +// Index File types for APT /*{{{*/ +class edspIFType: public pkgIndexFile::Type +{ + public: + virtual pkgRecords::Parser *CreatePkgParser(pkgCache::PkgFileIterator File) const + { + // we don't have a record parser for this type as the file is not presistent + return NULL; + }; + edspIFType() {Label = "APT universe file";}; +}; +static edspIFType _apt_Universe; + +const pkgIndexFile::Type *edspIndex::GetType() const +{ + return &_apt_Universe; +} + /*}}}*/ diff --git a/apt-pkg/edsp/edspindexfile.h b/apt-pkg/edsp/edspindexfile.h new file mode 100644 index 000000000..4ef7787e7 --- /dev/null +++ b/apt-pkg/edsp/edspindexfile.h @@ -0,0 +1,25 @@ +// -*- mode: cpp; mode: fold -*- +// Description /*{{{*/ +/* ###################################################################### + The universe file is designed to work as an intermediate file between + APT and the resolver. Its on propose very similar to a dpkg status file + ##################################################################### */ + /*}}}*/ +#ifndef PKGLIB_EDSPINDEXFILE_H +#define PKGLIB_EDSPINDEXFILE_H + +#include +#include + +class edspIndex : public debStatusIndex +{ + public: + + virtual const Type *GetType() const; + + virtual bool Merge(pkgCacheGenerator &Gen,OpProgress *Prog) const; + + edspIndex(string File); +}; + +#endif diff --git a/apt-pkg/edsp/edsplistparser.cc b/apt-pkg/edsp/edsplistparser.cc new file mode 100644 index 000000000..3e57ea822 --- /dev/null +++ b/apt-pkg/edsp/edsplistparser.cc @@ -0,0 +1,109 @@ +// -*- mode: cpp; mode: fold -*- +// Description /*{{{*/ +/* ###################################################################### + + Package Cache Generator - Generator for the cache structure. + + This builds the cache structure from the abstract package list parser. + + ##################################################################### */ + /*}}}*/ +// Include Files /*{{{*/ +#include +#include +#include +#include +#include +#include + /*}}}*/ + +// ListParser::edspListParser - Constructor /*{{{*/ +edspListParser::edspListParser(FileFd *File, string const &Arch) : debListParser(File, Arch) +{} + /*}}}*/ +// ListParser::NewVersion - Fill in the version structure /*{{{*/ +bool edspListParser::NewVersion(pkgCache::VerIterator &Ver) +{ + Ver->ID = Section.FindI("APT-ID", Ver->ID); + return debListParser::NewVersion(Ver); +} + /*}}}*/ +// ListParser::Description - Return the description string /*{{{*/ +// --------------------------------------------------------------------- +/* Sorry, no description for the resolvers… */ +string edspListParser::Description() +{ + return ""; +} +string edspListParser::DescriptionLanguage() +{ + return ""; +} +MD5SumValue edspListParser::Description_md5() +{ + return MD5SumValue(""); +} + /*}}}*/ +// ListParser::VersionHash - Compute a unique hash for this version /*{{{*/ +// --------------------------------------------------------------------- +/* */ +unsigned short edspListParser::VersionHash() +{ + if (Section.Exists("APT-Hash") == true) + return Section.FindI("APT-Hash"); + else if (Section.Exists("APT-ID") == true) + return Section.FindI("APT-ID"); + return 0; +} + /*}}}*/ +// ListParser::ParseStatus - Parse the status field /*{{{*/ +// --------------------------------------------------------------------- +/* The Status: line here is not a normal dpkg one but just one which tells + use if the package is installed or not, where missing means not. */ +bool edspListParser::ParseStatus(pkgCache::PkgIterator &Pkg, + pkgCache::VerIterator &Ver) +{ + const char *Start; + const char *Stop; + if (Section.Find("Status",Start,Stop) == false) + return true; + + // UsePackage() is responsible for setting the flag in the default case + bool const static essential = _config->Find("pkgCacheGen::Essential", "") == "installed"; + if (essential == true && + Section.FindFlag("Essential",Pkg->Flags,pkgCache::Flag::Essential) == false) + return false; + + // Isolate the first word + const char *I = Start; + for(; I < Stop && *I != ' '; I++); + + // Process the flag field + WordList StatusList[] = {{"installed",pkgCache::State::Installed}, + {}}; + if (GrabWord(string(Start,I-Start),StatusList,Pkg->CurrentState) == false) + return _error->Error("Malformed Status line"); + + /* A Status line marks the package as indicating the current + version as well. Only if it is actually installed.. Otherwise + the interesting dpkg handling of the status file creates bogus + entries. */ + if (!(Pkg->CurrentState == pkgCache::State::NotInstalled || + Pkg->CurrentState == pkgCache::State::ConfigFiles)) + { + if (Ver.end() == true) + _error->Warning("Encountered status field in a non-version description"); + else + Pkg->CurrentVer = Ver.Index(); + } + + return true; +} + /*}}}*/ +// ListParser::LoadReleaseInfo - Load the release information /*{{{*/ +bool edspListParser::LoadReleaseInfo(pkgCache::PkgFileIterator &FileI, + FileFd &File, string component) +{ + return true; +} + /*}}}*/ diff --git a/apt-pkg/edsp/edsplistparser.h b/apt-pkg/edsp/edsplistparser.h new file mode 100644 index 000000000..ec9f09905 --- /dev/null +++ b/apt-pkg/edsp/edsplistparser.h @@ -0,0 +1,38 @@ +// -*- mode: cpp; mode: fold -*- +// Description /*{{{*/ +/* ###################################################################### + + EDSP Package List Parser - This implements the abstract parser + interface for the APT specific intermediate format which is passed + to external resolvers + + ##################################################################### */ + /*}}}*/ +#ifndef PKGLIB_EDSPLISTPARSER_H +#define PKGLIB_EDSPLISTPARSER_H + +#include +#include +#include +#include + +class edspListParser : public debListParser +{ + public: + virtual bool NewVersion(pkgCache::VerIterator &Ver); + virtual string Description(); + virtual string DescriptionLanguage(); + virtual MD5SumValue Description_md5(); + virtual unsigned short VersionHash(); + + bool LoadReleaseInfo(pkgCache::PkgFileIterator &FileI,FileFd &File, + string section); + + edspListParser(FileFd *File, string const &Arch = ""); + + protected: + virtual bool ParseStatus(pkgCache::PkgIterator &Pkg,pkgCache::VerIterator &Ver); + +}; + +#endif diff --git a/apt-pkg/edsp/edspsystem.cc b/apt-pkg/edsp/edspsystem.cc new file mode 100644 index 000000000..579ffc656 --- /dev/null +++ b/apt-pkg/edsp/edspsystem.cc @@ -0,0 +1,117 @@ +// -*- mode: cpp; mode: fold -*- +// Description /*{{{*/ +/* ###################################################################### + + This system provides the abstraction to use the universe file as the + only source of package information to be able to feed the created file + back to APT for its own consumption (eat your own dogfood). + + ##################################################################### */ + /*}}}*/ +// Include Files /*{{{*/ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + /*}}}*/ + +edspSystem edspSys; + +// System::debSystem - Constructor /*{{{*/ +edspSystem::edspSystem() +{ + StatusFile = 0; + + Label = "Debian APT solver interface"; + VS = &debVS; +} + /*}}}*/ +// System::~debSystem - Destructor /*{{{*/ +edspSystem::~edspSystem() +{ + delete StatusFile; +} + /*}}}*/ +// System::Lock - Get the lock /*{{{*/ +bool edspSystem::Lock() +{ + return true; +} + /*}}}*/ +// System::UnLock - Drop a lock /*{{{*/ +bool edspSystem::UnLock(bool NoErrors) +{ + return true; +} + /*}}}*/ +// System::CreatePM - Create the underlying package manager /*{{{*/ +// --------------------------------------------------------------------- +/* we can't use edsp input as input for real installations - just a + simulation can work, but everything else will fail bigtime */ +pkgPackageManager *edspSystem::CreatePM(pkgDepCache *Cache) const +{ + return NULL; +} + /*}}}*/ +// System::Initialize - Setup the configuration space.. /*{{{*/ +bool edspSystem::Initialize(Configuration &Cnf) +{ + Cnf.Set("Dir::State::extended_states", "/dev/null"); + Cnf.Set("Dir::State::status","/dev/null"); + Cnf.Set("Dir::State::lists","/dev/null"); + + Cnf.Set("Debug::NoLocking", "true"); + Cnf.Set("APT::Get::Simulate", "true"); + + if (StatusFile) { + delete StatusFile; + StatusFile = 0; + } + return true; +} + /*}}}*/ +// System::ArchiveSupported - Is a file format supported /*{{{*/ +bool edspSystem::ArchiveSupported(const char *Type) +{ + return false; +} + /*}}}*/ +// System::Score - Determine if we should use the edsp system /*{{{*/ +signed edspSystem::Score(Configuration const &Cnf) +{ + if (FileExists(Cnf.FindFile("Dir::State::universe","")) == true) + return 1000; + return -1000; +} + /*}}}*/ +// System::AddStatusFiles - Register the status files /*{{{*/ +bool edspSystem::AddStatusFiles(vector &List) +{ + if (StatusFile == 0) + StatusFile = new edspIndex(_config->FindFile("Dir::State::universe")); + List.push_back(StatusFile); + return true; +} + /*}}}*/ +// System::FindIndex - Get an index file for status files /*{{{*/ +bool edspSystem::FindIndex(pkgCache::PkgFileIterator File, + pkgIndexFile *&Found) const +{ + if (StatusFile == 0) + return false; + if (StatusFile->FindInCache(*File.Cache()) == File) + { + Found = StatusFile; + return true; + } + + return false; +} + /*}}}*/ diff --git a/apt-pkg/edsp/edspsystem.h b/apt-pkg/edsp/edspsystem.h new file mode 100644 index 000000000..bc5be61d1 --- /dev/null +++ b/apt-pkg/edsp/edspsystem.h @@ -0,0 +1,38 @@ +// -*- mode: cpp; mode: fold -*- +// Description /*{{{*/ +// $Id: debsystem.h,v 1.4 2003/01/11 07:16:33 jgg Exp $ +/* ###################################################################### + + System - Debian version of the System Class + + ##################################################################### */ + /*}}}*/ +#ifndef PKGLIB_EDSPSYSTEM_H +#define PKGLIB_EDSPSYSTEM_H + +#include + +class edspIndex; +class edspSystem : public pkgSystem +{ + edspIndex *StatusFile; + + public: + + virtual bool Lock(); + virtual bool UnLock(bool NoErrors = false); + virtual pkgPackageManager *CreatePM(pkgDepCache *Cache) const; + virtual bool Initialize(Configuration &Cnf); + virtual bool ArchiveSupported(const char *Type); + virtual signed Score(Configuration const &Cnf); + virtual bool AddStatusFiles(std::vector &List); + virtual bool FindIndex(pkgCache::PkgFileIterator File, + pkgIndexFile *&Found) const; + + edspSystem(); + ~edspSystem(); +}; + +extern edspSystem edspSys; + +#endif diff --git a/apt-pkg/edsp/edspwriter.cc b/apt-pkg/edsp/edspwriter.cc new file mode 100644 index 000000000..38d0d82c5 --- /dev/null +++ b/apt-pkg/edsp/edspwriter.cc @@ -0,0 +1,130 @@ +// -*- mode: cpp; mode: fold -*- +// Description /*{{{*/ +/* ###################################################################### + Set of methods to help writing and reading everything needed for EDSP + ##################################################################### */ + /*}}}*/ +// Include Files /*{{{*/ +#include +#include +#include +#include +#include + +#include +#include + +#include + /*}}}*/ + +// edspWriter::WriteUniverse - to the given file descriptor /*{{{*/ +bool edspWriter::WriteUniverse(pkgDepCache &Cache, FILE* output) +{ + // we could use pkgCache::DepType and ::Priority, but these would be lokalized strings… + const char * const PrioMap[] = {0, "important", "required", "standard", + "optional", "extra"}; + const char * const DepMap[] = {"", "Depends", "PreDepends", "Suggests", + "Recommends" , "Conflicts", "Replaces", + "Obsoletes", "Breaks", "Enhances"}; + + for (pkgCache::PkgIterator Pkg = Cache.PkgBegin(); Pkg.end() == false; ++Pkg) + { + for (pkgCache::VerIterator Ver = Pkg.VersionList(); Ver.end() == false; ++Ver) + { + fprintf(output, "Package: %s\n", Pkg.Name()); + fprintf(output, "Architecture: %s\n", Ver.Arch()); + fprintf(output, "Version: %s\n", Ver.VerStr()); + if (Pkg.CurrentVer() == Ver) + fprintf(output, "Installed: yes\n"); + if (Pkg->SelectedState == pkgCache::State::Hold) + fprintf(output, "Hold: yes\n"); + fprintf(output, "APT-ID: %u\n", Ver->ID); + fprintf(output, "Priority: %s\n", PrioMap[Ver->Priority]); + if ((Pkg->Flags & pkgCache::Flag::Essential) == pkgCache::Flag::Essential) + fprintf(output, "Essential: yes\n"); + fprintf(output, "Section: %s\n", Ver.Section()); + if (Ver->MultiArch == pkgCache::Version::Allowed || Ver->MultiArch == pkgCache::Version::AllAllowed) + fprintf(output, "Multi-Arch: allowed\n"); + else if (Ver->MultiArch == pkgCache::Version::Foreign || Ver->MultiArch == pkgCache::Version::AllForeign) + fprintf(output, "Multi-Arch: foreign\n"); + else if (Ver->MultiArch == pkgCache::Version::Same) + fprintf(output, "Multi-Arch: same\n"); + signed short Pin = std::numeric_limits::min(); + for (pkgCache::VerFileIterator File = Ver.FileList(); File.end() == false; ++File) { + signed short const p = Cache.GetPolicy().GetPriority(File.File()); + if (Pin < p) + Pin = p; + } + fprintf(output, "APT-Pin: %d\n", Pin); + if (Cache.GetCandidateVer(Pkg) == Ver) + fprintf(output, "APT-Candidate: yes\n"); + if ((Cache[Pkg].Flags & pkgCache::Flag::Auto) == pkgCache::Flag::Auto) + fprintf(output, "APT-Automatic: yes\n"); + std::string dependencies[pkgCache::Dep::Enhances + 1]; + bool orGroup = false; + for (pkgCache::DepIterator Dep = Ver.DependsList(); Dep.end() == false; ++Dep) + { + // Ignore implicit dependencies for multiarch here + if (strcmp(Pkg.Arch(), Dep.TargetPkg().Arch()) != 0) + continue; + if (orGroup == false) + dependencies[Dep->Type].append(", "); + dependencies[Dep->Type].append(Dep.TargetPkg().Name()); + if (Dep->Version != 0) + dependencies[Dep->Type].append(" (").append(pkgCache::CompTypeDeb(Dep->CompareOp)).append(" ").append(Dep.TargetVer()).append(")"); + if ((Dep->CompareOp & pkgCache::Dep::Or) == pkgCache::Dep::Or) + { + dependencies[Dep->Type].append(" | "); + orGroup = true; + } + else + orGroup = false; + } + for (int i = 1; i < pkgCache::Dep::Enhances + 1; ++i) + if (dependencies[i].empty() == false) + fprintf(output, "%s: %s\n", DepMap[i], dependencies[i].c_str()+2); + string provides; + for (pkgCache::PrvIterator Prv = Ver.ProvidesList(); Prv.end() == false; ++Prv) + { + // Ignore implicit provides for multiarch here + if (strcmp(Pkg.Arch(), Prv.ParentPkg().Arch()) != 0 || strcmp(Pkg.Name(),Prv.Name()) == 0) + continue; + provides.append(", ").append(Prv.Name()); + } + if (provides.empty() == false) + fprintf(output, "Provides: %s\n", provides.c_str()+2); + + + fprintf(output, "\n"); + } + } + return true; +} + /*}}}*/ +// edspWriter::WriteRequest - to the given file descriptor /*{{{*/ +bool edspWriter::WriteRequest(pkgDepCache &Cache, FILE* output) +{ + string del, inst, upgrade; + for (pkgCache::PkgIterator Pkg = Cache.PkgBegin(); Pkg.end() == false; ++Pkg) + { + string* req; + if (Cache[Pkg].Delete() == true) + req = &del; + else if (Cache[Pkg].NewInstall() == true) + req = &inst; + else if (Cache[Pkg].Upgrade() == true) + req = &upgrade; + else + continue; + req->append(", ").append(Pkg.FullName()); + } + if (del.empty() == false) + fprintf(output, "Remove: %s\n", del.c_str()+2); + if (inst.empty() == false) + fprintf(output, "Install: %s\n", inst.c_str()+2); + if (upgrade.empty() == false) + fprintf(output, "Upgrade: %s\n", upgrade.c_str()+2); + + return true; +} + /*}}}*/ diff --git a/apt-pkg/edsp/edspwriter.h b/apt-pkg/edsp/edspwriter.h new file mode 100644 index 000000000..52923ff73 --- /dev/null +++ b/apt-pkg/edsp/edspwriter.h @@ -0,0 +1,19 @@ +// -*- mode: cpp; mode: fold -*- +// Description /*{{{*/ +/* ###################################################################### + Set of methods to help writing and reading everything needed for EDSP + ##################################################################### */ + /*}}}*/ +#ifndef PKGLIB_EDSPWRITER_H +#define PKGLIB_EDSPWRITER_H + +#include + +class edspWriter /*{{{*/ +{ +public: + bool static WriteUniverse(pkgDepCache &Cache, FILE* output); + bool static WriteRequest(pkgDepCache &Cache, FILE* output); +}; + /*}}}*/ +#endif diff --git a/apt-pkg/makefile b/apt-pkg/makefile index 4e5ec107f..a7880e81c 100644 --- a/apt-pkg/makefile +++ b/apt-pkg/makefile @@ -3,7 +3,7 @@ BASE=.. SUBDIR=apt-pkg # Header location -SUBDIRS = deb contrib +SUBDIRS = deb edsp contrib HEADER_TARGETDIRS = apt-pkg # Bring in the default rules @@ -53,6 +53,11 @@ SOURCE+= deb/deblistparser.cc deb/debrecords.cc deb/dpkgpm.cc \ HEADERS+= debversion.h debsrcrecords.h dpkgpm.h debrecords.h \ deblistparser.h debsystem.h debindexfile.h debmetaindex.h +# Source code for the APT resolver interface specific components +SOURCE+= edsp/edsplistparser.cc edsp/edspindexfile.cc edsp/edspsystem.cc \ + edsp/edspwriter.cc +HEADERS+= edsplistparser.h edspindexfile.h edspsystem.h edspwriter.h + HEADERS := $(addprefix apt-pkg/,$(HEADERS)) include $(LIBRARY_H) diff --git a/apt-pkg/pkgcachegen.cc b/apt-pkg/pkgcachegen.cc index b0ee04554..46dd22007 100644 --- a/apt-pkg/pkgcachegen.cc +++ b/apt-pkg/pkgcachegen.cc @@ -641,7 +641,7 @@ bool pkgCacheGenerator::FinishCache(OpProgress *Progress) bool const coInstall = ((V->MultiArch & pkgCache::Version::Same) == pkgCache::Version::Same); for (vector::const_iterator A = archs.begin(); A != archs.end(); ++A) { - if (*A == Arch) + if (Arch == 0 || *A == Arch) continue; /* We allow only one installed arch at the time per group, therefore each group member conflicts diff --git a/apt-pkg/policy.cc b/apt-pkg/policy.cc index 94c7fd4af..4e4077feb 100644 --- a/apt-pkg/policy.cc +++ b/apt-pkg/policy.cc @@ -269,6 +269,10 @@ signed short pkgPolicy::GetPriority(pkgCache::PkgIterator const &Pkg) } return 0; +} +signed short pkgPolicy::GetPriority(pkgCache::PkgFileIterator const &File) +{ + return PFPriority[File->ID]; } /*}}}*/ // PreferenceSection class - Overriding the default TrimRecord method /*{{{*/ diff --git a/apt-pkg/policy.h b/apt-pkg/policy.h index f8b2678de..e7f36d618 100644 --- a/apt-pkg/policy.h +++ b/apt-pkg/policy.h @@ -69,14 +69,13 @@ class pkgPolicy : public pkgDepCache::Policy // Things for manipulating pins void CreatePin(pkgVersionMatch::MatchType Type,string Pkg, string Data,signed short Priority); - inline signed short GetPriority(pkgCache::PkgFileIterator const &File) - {return PFPriority[File->ID];}; - signed short GetPriority(pkgCache::PkgIterator const &Pkg); pkgCache::VerIterator GetMatch(pkgCache::PkgIterator const &Pkg); // Things for the cache interface. virtual pkgCache::VerIterator GetCandidateVer(pkgCache::PkgIterator const &Pkg); - virtual bool IsImportantDep(pkgCache::DepIterator const &Dep) {return pkgDepCache::Policy::IsImportantDep(Dep);}; + virtual signed short GetPriority(pkgCache::PkgIterator const &Pkg); + virtual signed short GetPriority(pkgCache::PkgFileIterator const &File); + bool InitDefaults(); pkgPolicy(pkgCache *Owner); -- cgit v1.2.3-70-g09d2 From 741b7da9de1d2ab470728f1e7f38b25e0d6a556c Mon Sep 17 00:00:00 2001 From: David Kalnischkies Date: Tue, 3 May 2011 10:50:25 +0200 Subject: implement external solver calling for upgrade and dist-upgrade, too --- apt-pkg/algorithms.cc | 40 ++++++++++++----------- apt-pkg/algorithms.h | 1 + apt-pkg/edsp.cc | 88 +++++++++++++++++++++++++++++++-------------------- apt-pkg/edsp.h | 3 ++ 4 files changed, 80 insertions(+), 52 deletions(-) (limited to 'apt-pkg/algorithms.h') diff --git a/apt-pkg/algorithms.cc b/apt-pkg/algorithms.cc index fea9e92e1..5d9fefaa6 100644 --- a/apt-pkg/algorithms.cc +++ b/apt-pkg/algorithms.cc @@ -332,6 +332,10 @@ bool pkgFixBroken(pkgDepCache &Cache) */ bool pkgDistUpgrade(pkgDepCache &Cache) { + std::string const solver = _config->Find("APT::Solver::Name", "internal"); + if (solver != "internal") + return EDSP::ResolveExternal(solver.c_str(), Cache, false, true, false); + pkgDepCache::ActionGroup group(Cache); /* Upgrade all installed packages first without autoinst to help the resolver @@ -384,6 +388,10 @@ bool pkgDistUpgrade(pkgDepCache &Cache) to install packages not marked for install */ bool pkgAllUpgrade(pkgDepCache &Cache) { + std::string const solver = _config->Find("APT::Solver::Name", "internal"); + if (solver != "internal") + return EDSP::ResolveExternal(solver.c_str(), Cache, true, false, false); + pkgDepCache::ActionGroup group(Cache); pkgProblemResolver Fix(&Cache); @@ -740,25 +748,8 @@ bool pkgProblemResolver::DoUpgrade(pkgCache::PkgIterator Pkg) bool pkgProblemResolver::Resolve(bool BrokenFix) { std::string const solver = _config->Find("APT::Solver::Name", "internal"); - if (solver != "internal") - { - int solver_in, solver_out; - if (EDSP::ExecuteSolver(solver.c_str(), &solver_in, &solver_out) == false) - return false; - - FILE* output = fdopen(solver_in, "w"); - if (output == NULL) - return _error->Errno("Resolve", "fdopen on solver stdin failed"); - EDSP::WriteRequest(Cache, output); - EDSP::WriteScenario(Cache, output); - fclose(output); - - if (EDSP::ReadResponse(solver_out, Cache) == false) - return _error->Error("Reading solver response failed"); - - return true; - } + return EDSP::ResolveExternal(solver.c_str(), Cache, false, false, false); return ResolveInternal(BrokenFix); } /*}}}*/ @@ -1230,6 +1221,19 @@ bool pkgProblemResolver::ResolveInternal(bool const BrokenFix) in that it does not install or remove any packages. It is assumed that the system was non-broken previously. */ bool pkgProblemResolver::ResolveByKeep() +{ + std::string const solver = _config->Find("APT::Solver::Name", "internal"); + if (solver != "internal") + return EDSP::ResolveExternal(solver.c_str(), Cache, true, false, false); + return ResolveByKeepInternal(); +} + /*}}}*/ +// ProblemResolver::ResolveByKeepInternal - Resolve problems using keep /*{{{*/ +// --------------------------------------------------------------------- +/* This is the work horse of the soft upgrade routine. It is very gental + in that it does not install or remove any packages. It is assumed that the + system was non-broken previously. */ +bool pkgProblemResolver::ResolveByKeepInternal() { pkgDepCache::ActionGroup group(Cache); diff --git a/apt-pkg/algorithms.h b/apt-pkg/algorithms.h index 0778ec722..582cbc527 100644 --- a/apt-pkg/algorithms.h +++ b/apt-pkg/algorithms.h @@ -107,6 +107,7 @@ class pkgProblemResolver /*{{{*/ bool DoUpgrade(pkgCache::PkgIterator Pkg); bool ResolveInternal(bool const BrokenFix = false); + bool ResolveByKeepInternal(); public: diff --git a/apt-pkg/edsp.cc b/apt-pkg/edsp.cc index f35570c12..d72370358 100644 --- a/apt-pkg/edsp.cc +++ b/apt-pkg/edsp.cc @@ -197,7 +197,7 @@ bool EDSP::WriteRequest(pkgDepCache &Cache, FILE* output, bool const Upgrade, continue; req->append(" ").append(Pkg.FullName()); } - fprintf(output, "Request: EDSP 0.2\n"); + fprintf(output, "Request: EDSP 0.4\n"); if (del.empty() == false) fprintf(output, "Remove: %s\n", del.c_str()+1); if (inst.empty() == false) @@ -460,42 +460,62 @@ bool EDSP::WriteError(std::string const &message, FILE* output) { return false; // EDSP::ExecuteSolver - fork requested solver and setup ipc pipes {{{*/ bool EDSP::ExecuteSolver(const char* const solver, int *solver_in, int *solver_out) { - std::vector const solverDirs = _config->FindVector("Dir::Bin::Solvers"); - std::string file; - for (std::vector::const_iterator dir = solverDirs.begin(); - dir != solverDirs.end(); ++dir) { - file = flCombine(*dir, solver); - if (RealFileExists(file.c_str()) == true) - break; - file.clear(); - } + std::vector const solverDirs = _config->FindVector("Dir::Bin::Solvers"); + std::string file; + for (std::vector::const_iterator dir = solverDirs.begin(); + dir != solverDirs.end(); ++dir) { + file = flCombine(*dir, solver); + if (RealFileExists(file.c_str()) == true) + break; + file.clear(); + } - if (file.empty() == true) - return _error->Error("Can't call external solver '%s' as it is not in a configured directory!", solver); - int external[4] = {-1, -1, -1, -1}; - if (pipe(external) != 0 || pipe(external + 2) != 0) - return _error->Errno("Resolve", "Can't create needed IPC pipes for EDSP"); - for (int i = 0; i < 4; ++i) - SetCloseExec(external[i], true); + if (file.empty() == true) + return _error->Error("Can't call external solver '%s' as it is not in a configured directory!", solver); + int external[4] = {-1, -1, -1, -1}; + if (pipe(external) != 0 || pipe(external + 2) != 0) + return _error->Errno("Resolve", "Can't create needed IPC pipes for EDSP"); + for (int i = 0; i < 4; ++i) + SetCloseExec(external[i], true); - pid_t Solver = ExecFork(); - if (Solver == 0) - { - dup2(external[0], STDIN_FILENO); - dup2(external[3], STDOUT_FILENO); - const char* calling[2] = { file.c_str(), 0 }; - execv(calling[0], (char**) calling); - std::cerr << "Failed to execute solver '" << solver << "'!" << std::endl; - _exit(100); - } - close(external[0]); - close(external[3]); + pid_t Solver = ExecFork(); + if (Solver == 0) { + dup2(external[0], STDIN_FILENO); + dup2(external[3], STDOUT_FILENO); + const char* calling[2] = { file.c_str(), 0 }; + execv(calling[0], (char**) calling); + std::cerr << "Failed to execute solver '" << solver << "'!" << std::endl; + _exit(100); + } + close(external[0]); + close(external[3]); - if (WaitFd(external[1], true, 5) == false) - return _error->Errno("Resolve", "Timed out while Waiting on availability of solver stdin"); + if (WaitFd(external[1], true, 5) == false) + return _error->Errno("Resolve", "Timed out while Waiting on availability of solver stdin"); - *solver_in = external[1]; - *solver_out = external[2]; - return true; + *solver_in = external[1]; + *solver_out = external[2]; + return true; +} + /*}}}*/ +// EDSP::ResolveExternal - resolve problems by asking external for help {{{*/ +bool EDSP::ResolveExternal(const char* const solver, pkgDepCache &Cache, + bool const upgrade, bool const distUpgrade, + bool const autoRemove) { + int solver_in, solver_out; + if (EDSP::ExecuteSolver(solver, &solver_in, &solver_out) == false) + return false; + + FILE* output = fdopen(solver_in, "w"); + if (output == NULL) + return _error->Errno("Resolve", "fdopen on solver stdin failed"); + EDSP::WriteRequest(Cache, output, upgrade, distUpgrade, autoRemove); + EDSP::WriteScenario(Cache, output); + fclose(output); + + if (EDSP::ReadResponse(solver_out, Cache) == false) + return _error->Error("Reading solver response failed"); + + return true; } /*}}}*/ diff --git a/apt-pkg/edsp.h b/apt-pkg/edsp.h index df6e1d21c..95132ebd0 100644 --- a/apt-pkg/edsp.h +++ b/apt-pkg/edsp.h @@ -53,6 +53,9 @@ public: bool static WriteError(std::string const &message, FILE* output); bool static ExecuteSolver(const char* const solver, int *solver_in, int *solver_out); + bool static ResolveExternal(const char* const solver, pkgDepCache &Cache, + bool const upgrade, bool const distUpgrade, + bool const autoRemove); }; /*}}}*/ #endif -- cgit v1.2.3-70-g09d2