create directory for extended_states if needed

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

diff --git a/apt-pkg/edsp.cc b/apt-pkg/edsp.cc
index 88ad27681180a2c9e07cd9a75fe6a021731596af..3c6a7e30f903131412a414ff6449096a99ec3cc4 100644 (file)
--- a/apt-pkg/edsp.cc
+++ b/apt-pkg/edsp.cc
@@ -26,6 +26,7 @@
 #include <time.h>
 #include <unistd.h>
 #include <stdio.h>
+#include <algorithm>
 #include <iostream>
 #include <vector>
 #include <limits>
@@ -50,7 +51,12 @@ 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;
+   std::vector<std::string> archs = APT::Configuration::getArchitectures();
    for (pkgCache::PkgIterator Pkg = Cache.PkgBegin(); Pkg.end() == false; ++Pkg)
+   {
+      std::string const arch = Pkg.Arch();
+      if (std::find(archs.begin(), archs.end(), arch) == archs.end())
+        continue;
       for (pkgCache::VerIterator Ver = Pkg.VersionList(); Ver.end() == false; ++Ver, ++p)
       {
         WriteScenarioVersion(Cache, output, Pkg, Ver);
@@ -59,6 +65,7 @@ bool EDSP::WriteScenario(pkgDepCache &Cache, FILE* output, OpProgress *Progress)
         if (Progress != NULL && p % 100 == 0)
            Progress->Progress(p);
       }
+   }
    return true;
 }
                                                                        /*}}}*/
@@ -88,12 +95,15 @@ bool EDSP::WriteLimitedScenario(pkgDepCache &Cache, FILE* output,
 void EDSP::WriteScenarioVersion(pkgDepCache &Cache, FILE* output, pkgCache::PkgIterator const &Pkg,
                                pkgCache::VerIterator const &Ver)
 {
+   fprintf(output, "Package: %s\n", Pkg.Name());
+#if APT_PKG_ABI >= 413
+   fprintf(output, "Source: %s\n", Ver.SourcePkgName());
+#else
    pkgRecords Recs(Cache);
    pkgRecords::Parser &rec = Recs.Lookup(Ver.FileList());
    string srcpkg = rec.SourcePkg().empty() ? Pkg.Name() : rec.SourcePkg();
-
-   fprintf(output, "Package: %s\n", Pkg.Name());
    fprintf(output, "Source: %s\n", srcpkg.c_str());
+#endif
    fprintf(output, "Architecture: %s\n", Ver.Arch());
    fprintf(output, "Version: %s\n", Ver.VerStr());
    if (Pkg.CurrentVer() == Ver)
@@ -438,6 +448,13 @@ bool EDSP::ReadRequest(int const input, std::list<std::string> &install,
            distUpgrade = EDSP::StringToBool(line.c_str() + 14, false);
         else if (line.compare(0, 11, "Autoremove:") == 0)
            autoRemove = EDSP::StringToBool(line.c_str() + 12, false);
+        else if (line.compare(0, 13, "Architecture:") == 0)
+           _config->Set("APT::Architecture", line.c_str() + 14);
+        else if (line.compare(0, 14, "Architectures:") == 0)
+        {
+           std::string const archs = line.c_str() + 15;
+           _config->Set("APT::Architectures", SubstVar(archs, " ", ","));
+        }
         else
            _error->Warning("Unknown line in EDSP Request stanza: %s", line.c_str());
 
@@ -535,7 +552,7 @@ bool EDSP::WriteError(char const * const uuid, std::string const &message, FILE*
 }
                                                                        /*}}}*/
 // EDSP::ExecuteSolver - fork requested solver and setup ipc pipes     {{{*/
-bool EDSP::ExecuteSolver(const char* const solver, int *solver_in, int *solver_out) {
+pid_t EDSP::ExecuteSolver(const char* const solver, int * const solver_in, int * const solver_out, bool) {
        std::vector<std::string> const solverDirs = _config->FindVector("Dir::Bin::Solvers");
        std::string file;
        for (std::vector<std::string>::const_iterator dir = solverDirs.begin();
@@ -547,10 +564,16 @@ bool EDSP::ExecuteSolver(const char* const solver, int *solver_in, int *solver_o
        }
 
        if (file.empty() == true)
-               return _error->Error("Can't call external solver '%s' as it is not in a configured directory!", solver);
+       {
+               _error->Error("Can't call external solver '%s' as it is not in a configured directory!", solver);
+               return 0;
+       }
        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");
+       {
+               _error->Errno("Resolve", "Can't create needed IPC pipes for EDSP");
+               return 0;
+       }
        for (int i = 0; i < 4; ++i)
                SetCloseExec(external[i], true);
 
@@ -567,11 +590,19 @@ bool EDSP::ExecuteSolver(const char* const solver, int *solver_in, int *solver_o
        close(external[3]);
 
        if (WaitFd(external[1], true, 5) == false)
-               return _error->Errno("Resolve", "Timed out while Waiting on availability of solver stdin");
+       {
+               _error->Errno("Resolve", "Timed out while Waiting on availability of solver stdin");
+               return 0;
+       }
 
        *solver_in = external[1];
        *solver_out = external[2];
-       return true;
+       return Solver;
+}
+bool EDSP::ExecuteSolver(const char* const solver, int *solver_in, int *solver_out) {
+   if (ExecuteSolver(solver, solver_in, solver_out, true) == 0)
+      return false;
+   return true;
 }
                                                                        /*}}}*/
 // EDSP::ResolveExternal - resolve problems by asking external for help        {{{*/
@@ -579,7 +610,8 @@ bool EDSP::ResolveExternal(const char* const solver, pkgDepCache &Cache,
                         bool const upgrade, bool const distUpgrade,
                         bool const autoRemove, OpProgress *Progress) {
        int solver_in, solver_out;
-       if (EDSP::ExecuteSolver(solver, &solver_in, &solver_out) == false)
+       pid_t const solver_pid = EDSP::ExecuteSolver(solver, &solver_in, &solver_out, true);
+       if (solver_pid == 0)
                return false;
 
        FILE* output = fdopen(solver_in, "w");
@@ -599,6 +631,6 @@ bool EDSP::ResolveExternal(const char* const solver, pkgDepCache &Cache,
        if (EDSP::ReadResponse(solver_out, Cache, Progress) == false)
                return false;
 
-       return true;
+       return ExecWait(solver_pid, solver);
 }
                                                                        /*}}}*/