VersionHash: Do not skip too long dependency lines

[apt.git] / cmdline / apt-internal-solver.cc

diff --git a/cmdline/apt-internal-solver.cc b/cmdline/apt-internal-solver.cc
index 2df1d3bef32efa9632490fec979a96999b42600f..aecb0eaba224ec6d511c81978c1b5759850b280f 100644 (file)
--- a/cmdline/apt-internal-solver.cc
+++ b/cmdline/apt-internal-solver.cc
@@ -63,10 +63,24 @@ static std::vector<aptDispatchWithHelp> GetCommands()                       /*{{{*/
    return {};
 }
                                                                        /*}}}*/
+static bool WriteSolution(pkgDepCache &Cache, FileFd &output)          /*{{{*/
+{
+   bool Okay = output.Failed() == false;
+   for (pkgCache::PkgIterator Pkg = Cache.PkgBegin(); Pkg.end() == false && likely(Okay); ++Pkg)
+   {
+      std::string action;
+      if (Cache[Pkg].Delete() == true)
+        Okay &= EDSP::WriteSolutionStanza(output, "Remove", Pkg.CurrentVer());
+      else if (Cache[Pkg].NewInstall() == true || Cache[Pkg].Upgrade() == true)
+        Okay &= EDSP::WriteSolutionStanza(output, "Install", Cache.GetCandidateVersion(Pkg));
+      else if (Cache[Pkg].Garbage == true)
+        Okay &= EDSP::WriteSolutionStanza(output, "Autoremove", Pkg.CurrentVer());
+   }
+   return Okay;
+}
+                                                                       /*}}}*/
 int main(int argc,const char *argv[])                                  /*{{{*/
 {
-       InitLocale();
-
        // we really don't need anything
        DropPrivileges();
 
@@ -88,7 +102,12 @@ int main(int argc,const char *argv[])                                       /*{{{*/
                if (pkgset.empty() == true)
                        EDSP::WriteScenario(CacheFile, output);
                else
-                       EDSP::WriteLimitedScenario(CacheFile, output, pkgset);
+               {
+                       std::vector<bool> pkgvec(CacheFile->Head().PackageCount, false);
+                       for (auto const &p: pkgset)
+                          pkgvec[p->ID] = true;
+                       EDSP::WriteLimitedScenario(CacheFile, output, pkgvec);
+               }
                output.Close();
                _error->DumpErrors(std::cerr);
                return 0;
@@ -104,6 +123,7 @@ int main(int argc,const char *argv[])                                       /*{{{*/
        _config->Set("APT::System", "Debian APT solver interface");
        _config->Set("APT::Solver", "internal");
        _config->Set("edsp::scenario", "/nonexistent/stdin");
+       _config->Clear("Dir::Log");
        FileFd output;
        if (output.OpenDescriptor(STDOUT_FILENO, FileFd::WriteOnly | FileFd::BufferedWrite, true) == false)
           DIE("stdout couldn't be opened");
@@ -121,8 +141,8 @@ int main(int argc,const char *argv[])                                       /*{{{*/
                DIE("WAIT timed out in the resolver");
 
        std::list<std::string> install, remove;
-       bool upgrade, distUpgrade, autoRemove;
-       if (EDSP::ReadRequest(input, install, remove, upgrade, distUpgrade, autoRemove) == false)
+       unsigned int flags;
+       if (EDSP::ReadRequest(input, install, remove, flags) == false)
                DIE("Parsing the request failed!");
 
        EDSP::WriteProgress(5, "Read scenario…", output);
@@ -159,12 +179,19 @@ int main(int argc,const char *argv[])                                     /*{{{*/
        EDSP::WriteProgress(60, "Call problemresolver on current scenario…", output);
 
        std::string failure;
-       if (upgrade == true) {
-               if (APT::Upgrade::Upgrade(CacheFile, APT::Upgrade::FORBID_REMOVE_PACKAGES | APT::Upgrade::FORBID_INSTALL_NEW_PACKAGES) == false)
+       if (flags & EDSP::Request::UPGRADE_ALL) {
+               int upgrade_flags = APT::Upgrade::ALLOW_EVERYTHING;
+               if (flags & EDSP::Request::FORBID_NEW_INSTALL)
+                  upgrade_flags |= APT::Upgrade::FORBID_INSTALL_NEW_PACKAGES;
+               if (flags & EDSP::Request::FORBID_REMOVE)
+                  upgrade_flags |= APT::Upgrade::FORBID_REMOVE_PACKAGES;
+
+               if (APT::Upgrade::Upgrade(CacheFile, upgrade_flags))
+                       ;
+               else if (upgrade_flags == APT::Upgrade::ALLOW_EVERYTHING)
+                       failure = "ERR_UNSOLVABLE_FULL_UPGRADE";
+               else
                        failure = "ERR_UNSOLVABLE_UPGRADE";
-       } else if (distUpgrade == true) {
-               if (APT::Upgrade::Upgrade(CacheFile, APT::Upgrade::ALLOW_EVERYTHING) == false)
-                       failure = "ERR_UNSOLVABLE_DIST_UPGRADE";
        } else if (Fix.Resolve() == false)
                failure = "ERR_UNSOLVABLE";
 
@@ -177,7 +204,7 @@ int main(int argc,const char *argv[])                                       /*{{{*/
 
        EDSP::WriteProgress(95, "Write solution…", output);
 
-       if (EDSP::WriteSolution(CacheFile, output) == false)
+       if (WriteSolution(CacheFile, output) == false)
                DIE("Failed to output the solution!");
 
        EDSP::WriteProgress(100, "Done", output);