fix some more ABI issues, abicheck is happy now

[apt.git] / apt-pkg / edsp.cc

diff --git a/apt-pkg/edsp.cc b/apt-pkg/edsp.cc
index ce9ad250cf7eb7f0b6b2f6c4fc30f53f2f13d68a..e90598392abbcaaf677e711747c2947eaa3769b7 100644 (file)
--- a/apt-pkg/edsp.cc
+++ b/apt-pkg/edsp.cc
@@ -5,19 +5,28 @@
    ##################################################################### */
                                                                        /*}}}*/
 // Include Files                                                       /*{{{*/
    ##################################################################### */
                                                                        /*}}}*/
 // Include Files                                                       /*{{{*/

+#include <config.h>
+

 #include <apt-pkg/edsp.h>
 #include <apt-pkg/error.h>
 #include <apt-pkg/edsp.h>
 #include <apt-pkg/error.h>

+#include <apt-pkg/cacheset.h>

 #include <apt-pkg/configuration.h>
 #include <apt-pkg/version.h>
 #include <apt-pkg/policy.h>
 #include <apt-pkg/tagfile.h>
 #include <apt-pkg/configuration.h>
 #include <apt-pkg/version.h>
 #include <apt-pkg/policy.h>
 #include <apt-pkg/tagfile.h>

+#include <apt-pkg/fileutl.h>
+#include <apt-pkg/progress.h>

 
 

-#include <apti18n.h>

 #include <limits>
 #include <limits>

-

 #include <stdio.h>
 #include <stdio.h>

+
+#include <string>
+
+#include <apti18n.h>

                                                                        /*}}}*/
 
                                                                        /*}}}*/
 

+using std::string;
+

 // we could use pkgCache::DepType and ::Priority, but these would be localized strings…
 const char * const EDSP::PrioMap[] = {0, "important", "required", "standard",
                                      "optional", "extra"};
 // we could use pkgCache::DepType and ::Priority, but these would be localized strings…
 const char * const EDSP::PrioMap[] = {0, "important", "required", "standard",
                                      "optional", "extra"};


@@ -26,29 +35,42 @@ const char * const EDSP::DepMap[] = {"", "Depends", "Pre-Depends", "Suggests",
                                     "Obsoletes", "Breaks", "Enhances"};
 
 // EDSP::WriteScenario - to the given file descriptor                  /*{{{*/
                                     "Obsoletes", "Breaks", "Enhances"};
 
 // EDSP::WriteScenario - to the given file descriptor                  /*{{{*/

-bool EDSP::WriteScenario(pkgDepCache &Cache, FILE* output)
+bool EDSP::WriteScenario(pkgDepCache &Cache, FILE* output, OpProgress *Progress)

 {
 {

+   if (Progress != NULL)
+      Progress->SubProgress(Cache.Head().VersionCount, _("Send scenario to solver"));
+   unsigned long p = 0;

    for (pkgCache::PkgIterator Pkg = Cache.PkgBegin(); Pkg.end() == false; ++Pkg)
    for (pkgCache::PkgIterator Pkg = Cache.PkgBegin(); Pkg.end() == false; ++Pkg)

-      for (pkgCache::VerIterator Ver = Pkg.VersionList(); Ver.end() == false; ++Ver)
+      for (pkgCache::VerIterator Ver = Pkg.VersionList(); Ver.end() == false; ++Ver, ++p)

       {
         WriteScenarioVersion(Cache, output, Pkg, Ver);
         WriteScenarioDependency(Cache, output, Pkg, Ver);
         fprintf(output, "\n");
       {
         WriteScenarioVersion(Cache, output, Pkg, Ver);
         WriteScenarioDependency(Cache, output, Pkg, Ver);
         fprintf(output, "\n");

+        if (Progress != NULL && p % 100 == 0)
+           Progress->Progress(p);

       }
    return true;
 }
                                                                        /*}}}*/
 // EDSP::WriteLimitedScenario - to the given file descriptor           /*{{{*/
 bool EDSP::WriteLimitedScenario(pkgDepCache &Cache, FILE* output,
       }
    return true;
 }
                                                                        /*}}}*/
 // EDSP::WriteLimitedScenario - to the given file descriptor           /*{{{*/
 bool EDSP::WriteLimitedScenario(pkgDepCache &Cache, FILE* output,

-                               APT::PackageSet const &pkgset)
+                               APT::PackageSet const &pkgset,
+                               OpProgress *Progress)

 {
 {

-   for (APT::PackageSet::const_iterator Pkg = pkgset.begin(); Pkg != pkgset.end(); ++Pkg)
+   if (Progress != NULL)
+      Progress->SubProgress(Cache.Head().VersionCount, _("Send scenario to solver"));
+   unsigned long p  = 0;
+   for (APT::PackageSet::const_iterator Pkg = pkgset.begin(); Pkg != pkgset.end(); ++Pkg, ++p)

       for (pkgCache::VerIterator Ver = Pkg.VersionList(); Ver.end() == false; ++Ver)
       {
         WriteScenarioVersion(Cache, output, Pkg, Ver);
         WriteScenarioLimitedDependency(Cache, output, Pkg, Ver, pkgset);
         fprintf(output, "\n");
       for (pkgCache::VerIterator Ver = Pkg.VersionList(); Ver.end() == false; ++Ver)
       {
         WriteScenarioVersion(Cache, output, Pkg, Ver);
         WriteScenarioLimitedDependency(Cache, output, Pkg, Ver, pkgset);
         fprintf(output, "\n");

+        if (Progress != NULL && p % 100 == 0)
+           Progress->Progress(p);

       }
       }

+   if (Progress != NULL)
+      Progress->Done();

    return true;
 }
                                                                        /*}}}*/
    return true;
 }
                                                                        /*}}}*/


@@ -69,11 +91,11 @@ void EDSP::WriteScenarioVersion(pkgDepCache &Cache, FILE* output, pkgCache::PkgI
    if ((Pkg->Flags & pkgCache::Flag::Essential) == pkgCache::Flag::Essential)
       fprintf(output, "Essential: yes\n");
    fprintf(output, "Section: %s\n", Ver.Section());
    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)
+   if ((Ver->MultiArch & pkgCache::Version::Allowed) == pkgCache::Version::Allowed)

       fprintf(output, "Multi-Arch: allowed\n");
       fprintf(output, "Multi-Arch: allowed\n");

-   else if (Ver->MultiArch == pkgCache::Version::Foreign || Ver->MultiArch == pkgCache::Version::AllForeign)
+   else if ((Ver->MultiArch & pkgCache::Version::Foreign) == pkgCache::Version::Foreign)

       fprintf(output, "Multi-Arch: foreign\n");
       fprintf(output, "Multi-Arch: foreign\n");

-   else if (Ver->MultiArch == pkgCache::Version::Same)
+   else if ((Ver->MultiArch & pkgCache::Version::Same) == pkgCache::Version::Same)

       fprintf(output, "Multi-Arch: same\n");
    signed short Pin = std::numeric_limits<signed short>::min();
    for (pkgCache::VerFileIterator File = Ver.FileList(); File.end() == false; ++File) {
       fprintf(output, "Multi-Arch: same\n");
    signed short Pin = std::numeric_limits<signed short>::min();
    for (pkgCache::VerFileIterator File = Ver.FileList(); File.end() == false; ++File) {


@@ -96,8 +118,7 @@ void EDSP::WriteScenarioDependency(pkgDepCache &Cache, FILE* output, pkgCache::P
    bool orGroup = false;
    for (pkgCache::DepIterator Dep = Ver.DependsList(); Dep.end() == false; ++Dep)
    {
    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)
+      if (Dep.IsMultiArchImplicit() == true)

         continue;
       if (orGroup == false)
         dependencies[Dep->Type].append(", ");
         continue;
       if (orGroup == false)
         dependencies[Dep->Type].append(", ");


@@ -118,8 +139,7 @@ void EDSP::WriteScenarioDependency(pkgDepCache &Cache, FILE* output, pkgCache::P
    string provides;
    for (pkgCache::PrvIterator Prv = Ver.ProvidesList(); Prv.end() == false; ++Prv)
    {
    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)
+      if (Prv.IsMultiArchImplicit() == true)

         continue;
       provides.append(", ").append(Prv.Name());
    }
         continue;
       provides.append(", ").append(Prv.Name());
    }


@@ -137,8 +157,7 @@ void EDSP::WriteScenarioLimitedDependency(pkgDepCache &Cache, FILE* output,
    bool orGroup = false;
    for (pkgCache::DepIterator Dep = Ver.DependsList(); Dep.end() == false; ++Dep)
    {
    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)
+      if (Dep.IsMultiArchImplicit() == true)

         continue;
       if (orGroup == false)
       {
         continue;
       if (orGroup == false)
       {


@@ -171,8 +190,7 @@ void EDSP::WriteScenarioLimitedDependency(pkgDepCache &Cache, FILE* output,
    string provides;
    for (pkgCache::PrvIterator Prv = Ver.ProvidesList(); Prv.end() == false; ++Prv)
    {
    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)
+      if (Prv.IsMultiArchImplicit() == true)

         continue;
       if (pkgset.find(Prv.ParentPkg()) == pkgset.end())
         continue;
         continue;
       if (pkgset.find(Prv.ParentPkg()) == pkgset.end())
         continue;


@@ -184,15 +202,23 @@ void EDSP::WriteScenarioLimitedDependency(pkgDepCache &Cache, FILE* output,
                                                                        /*}}}*/
 // EDSP::WriteRequest - to the given file descriptor                   /*{{{*/
 bool EDSP::WriteRequest(pkgDepCache &Cache, FILE* output, bool const Upgrade,
                                                                        /*}}}*/
 // EDSP::WriteRequest - to the given file descriptor                   /*{{{*/
 bool EDSP::WriteRequest(pkgDepCache &Cache, FILE* output, bool const Upgrade,

-                       bool const DistUpgrade, bool const AutoRemove)
+                       bool const DistUpgrade, bool const AutoRemove,
+                       OpProgress *Progress)

 {
 {

+   if (Progress != NULL)
+      Progress->SubProgress(Cache.Head().PackageCount, _("Send request to solver"));
+   unsigned long p = 0;

    string del, inst;
    string del, inst;

-   for (pkgCache::PkgIterator Pkg = Cache.PkgBegin(); Pkg.end() == false; ++Pkg)
+   for (pkgCache::PkgIterator Pkg = Cache.PkgBegin(); Pkg.end() == false; ++Pkg, ++p)

    {
    {

+      if (Progress != NULL && p % 100 == 0)
+         Progress->Progress(p);

       string* req;
       string* req;

-      if (Cache[Pkg].Delete() == true)
+      pkgDepCache::StateCache &P = Cache[Pkg];
+      if (P.Delete() == true)

         req = &del;
         req = &del;

-      else if (Cache[Pkg].NewInstall() == true || Cache[Pkg].Upgrade() == true)
+      else if (P.NewInstall() == true || P.Upgrade() == true || P.ReInstall() == true ||
+              (P.Mode == pkgDepCache::ModeKeep && (P.iFlags & pkgDepCache::Protected) == pkgDepCache::Protected))

         req = &inst;
       else
         continue;
         req = &inst;
       else
         continue;


@@ -212,7 +238,7 @@ bool EDSP::WriteRequest(pkgDepCache &Cache, FILE* output, bool const Upgrade,
    if (_config->FindB("APT::Solver::Strict-Pinning", true) == false)
       fprintf(output, "Strict-Pinning: no\n");
    string solverpref("APT::Solver::");
    if (_config->FindB("APT::Solver::Strict-Pinning", true) == false)
       fprintf(output, "Strict-Pinning: no\n");
    string solverpref("APT::Solver::");

-   solverpref.append(_config->Find("APT::Solver::Name", "internal")).append("::Preferences");
+   solverpref.append(_config->Find("APT::Solver", "internal")).append("::Preferences");

    if (_config->Exists(solverpref) == true)
       fprintf(output, "Preferences: %s\n", _config->Find(solverpref,"").c_str());
    fprintf(output, "\n");
    if (_config->Exists(solverpref) == true)
       fprintf(output, "Preferences: %s\n", _config->Find(solverpref,"").c_str());
    fprintf(output, "\n");


@@ -221,7 +247,7 @@ bool EDSP::WriteRequest(pkgDepCache &Cache, FILE* output, bool const Upgrade,
 }
                                                                        /*}}}*/
 // EDSP::ReadResponse - from the given file descriptor                 /*{{{*/
 }
                                                                        /*}}}*/
 // EDSP::ReadResponse - from the given file descriptor                 /*{{{*/

-bool EDSP::ReadResponse(int const input, pkgDepCache &Cache) {
+bool EDSP::ReadResponse(int const input, pkgDepCache &Cache, OpProgress *Progress) {

        /* We build an map id to mmap offset here
           In theory we could use the offset as ID, but then VersionCount
           couldn't be used to create other versionmappings anymore and it
        /* We build an map id to mmap offset here
           In theory we could use the offset as ID, but then VersionCount
           couldn't be used to create other versionmappings anymore and it


@@ -247,15 +273,26 @@ bool EDSP::ReadResponse(int const input, pkgDepCache &Cache) {
                else if (section.Exists("Remove") == true)
                        type = "Remove";
                else if (section.Exists("Progress") == true) {
                else if (section.Exists("Remove") == true)
                        type = "Remove";
                else if (section.Exists("Progress") == true) {

-                       std::clog << TimeRFC1123(time(NULL)) << " ";
-                       ioprintf(std::clog, "[ %3d%% ] ", section.FindI("Percentage", 0));
-                       std::clog << section.FindS("Progress") << " - ";
-                       string const msg = section.FindS("Message");
-                       if (msg.empty() == true)
-                               std::clog << "Solver is still working on the solution" << std::endl;
-                       else
-                               std::clog << msg << std::endl;
+                       if (Progress != NULL) {
+                               string msg = section.FindS("Message");
+                               if (msg.empty() == true)
+                                       msg = _("Prepare for receiving solution");
+                               Progress->SubProgress(100, msg, section.FindI("Percentage", 0));
+                       }

                        continue;
                        continue;

+               } else if (section.Exists("Error") == true) {
+                       std::string msg = SubstVar(SubstVar(section.FindS("Message"), "\n .\n", "\n\n"), "\n ", "\n");
+                       if (msg.empty() == true) {
+                               msg = _("External solver failed without a proper error message");
+                               _error->Error("%s", msg.c_str());
+                       } else
+                               _error->Error("External solver failed with: %s", msg.substr(0,msg.find('\n')).c_str());
+                       if (Progress != NULL)
+                               Progress->Done();
+                       std::cerr << "The solver encountered an error of type: " << section.FindS("Error") << std::endl;
+                       std::cerr << "The following information might help you to understand what is wrong:" << std::endl;
+                       std::cerr << msg << std::endl << std::endl;
+                       return false;

                } else if (section.Exists("Autoremove") == true)
                        type = "Autoremove";
                else
                } else if (section.Exists("Autoremove") == true)
                        type = "Autoremove";
                else


@@ -273,7 +310,7 @@ bool EDSP::ReadResponse(int const input, pkgDepCache &Cache) {
                pkgCache::VerIterator Ver(Cache.GetCache(), Cache.GetCache().VerP + VerIdx[id]);
                Cache.SetCandidateVersion(Ver);
                if (type == "Install")
                pkgCache::VerIterator Ver(Cache.GetCache(), Cache.GetCache().VerP + VerIdx[id]);
                Cache.SetCandidateVersion(Ver);
                if (type == "Install")

-                       Cache.MarkInstall(Ver.ParentPkg(), false, false);
+                       Cache.MarkInstall(Ver.ParentPkg(), false, 0, false);

                else if (type == "Remove")
                        Cache.MarkDelete(Ver.ParentPkg(), false);
                else if (type == "Autoremove") {
                else if (type == "Remove")
                        Cache.MarkDelete(Ver.ParentPkg(), false);
                else if (type == "Autoremove") {


@@ -438,7 +475,6 @@ bool EDSP::WriteSolution(pkgDepCache &Cache, FILE* output)
         fprintf(output, "Autoremove: %d\n", Pkg.CurrentVer()->ID);
         if (Debug == true)
            fprintf(output, "Package: %s\nVersion: %s\n", Pkg.FullName().c_str(), Pkg.CurrentVer().VerStr());
         fprintf(output, "Autoremove: %d\n", Pkg.CurrentVer()->ID);
         if (Debug == true)
            fprintf(output, "Package: %s\nVersion: %s\n", Pkg.FullName().c_str(), Pkg.CurrentVer().VerStr());

-           fprintf(stderr, "Autoremove: %s\nVersion: %s\n", Pkg.FullName().c_str(), Pkg.CurrentVer().VerStr());

       }
       else
         continue;
       }
       else
         continue;


@@ -457,8 +493,13 @@ bool EDSP::WriteProgress(unsigned short const percent, const char* const message
        return true;
 }
                                                                        /*}}}*/
        return true;
 }
                                                                        /*}}}*/

-bool EDSP::WriteError(std::string const &message, FILE* output) { return false; }
-
+// EDSP::WriteError - format an error message to be send to file descriptor /*{{{*/
+bool EDSP::WriteError(char const * const uuid, std::string const &message, FILE* output) {
+       fprintf(output, "Error: %s\n", uuid);
+       fprintf(output, "Message: %s\n\n", SubstVar(SubstVar(message, "\n\n", "\n.\n"), "\n", "\n ").c_str());
+       return true;
+}
+                                                                       /*}}}*/

 // EDSP::ExecuteSolver - fork requested solver and setup ipc pipes     {{{*/
 bool EDSP::ExecuteSolver(const char* const solver, int *solver_in, int *solver_out) {
        std::vector<std::string> const solverDirs = _config->FindVector("Dir::Bin::Solvers");
 // EDSP::ExecuteSolver - fork requested solver and setup ipc pipes     {{{*/
 bool EDSP::ExecuteSolver(const char* const solver, int *solver_in, int *solver_out) {
        std::vector<std::string> const solverDirs = _config->FindVector("Dir::Bin::Solvers");


@@ -502,7 +543,7 @@ bool EDSP::ExecuteSolver(const char* const solver, int *solver_in, int *solver_o
 // EDSP::ResolveExternal - resolve problems by asking external for help        {{{*/
 bool EDSP::ResolveExternal(const char* const solver, pkgDepCache &Cache,
                         bool const upgrade, bool const distUpgrade,
 // 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) {
+                        bool const autoRemove, OpProgress *Progress) {

        int solver_in, solver_out;
        if (EDSP::ExecuteSolver(solver, &solver_in, &solver_out) == false)
                return false;
        int solver_in, solver_out;
        if (EDSP::ExecuteSolver(solver, &solver_in, &solver_out) == false)
                return false;


@@ -510,12 +551,19 @@ bool EDSP::ResolveExternal(const char* const solver, pkgDepCache &Cache,
        FILE* output = fdopen(solver_in, "w");
        if (output == NULL)
                return _error->Errno("Resolve", "fdopen on solver stdin failed");
        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);
+
+       if (Progress != NULL)
+               Progress->OverallProgress(0, 100, 5, _("Execute external solver"));
+       EDSP::WriteRequest(Cache, output, upgrade, distUpgrade, autoRemove, Progress);
+       if (Progress != NULL)
+               Progress->OverallProgress(5, 100, 20, _("Execute external solver"));
+       EDSP::WriteScenario(Cache, output, Progress);

        fclose(output);
 
        fclose(output);
 

-       if (EDSP::ReadResponse(solver_out, Cache) == false)
-               return _error->Error("Reading solver response failed");
+       if (Progress != NULL)
+               Progress->OverallProgress(25, 100, 75, _("Execute external solver"));
+       if (EDSP::ReadResponse(solver_out, Cache, Progress) == false)
+               return false;

 
        return true;
 }
 
        return true;
 }