releasing package apt version 1.0.5

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

diff --git a/apt-pkg/edsp.cc b/apt-pkg/edsp.cc
index 88ad27681180a2c9e07cd9a75fe6a021731596af..0d0418e0633c52c191dde8d4b4a6f38448db2465 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 <time.h>
 #include <unistd.h>
 #include <stdio.h>

+#include <algorithm>

 #include <iostream>
 #include <vector>
 #include <limits>
 #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;
    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)
    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);
       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);
       }
         if (Progress != NULL && p % 100 == 0)
            Progress->Progress(p);
       }

+   }

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


@@ -438,6 +445,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);
            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());
 
         else
            _error->Warning("Unknown line in EDSP Request stanza: %s", line.c_str());
 


@@ -535,7 +549,7 @@ bool EDSP::WriteError(char const * const uuid, std::string const &message, FILE*
 }
                                                                        /*}}}*/
 // EDSP::ExecuteSolver - fork requested solver and setup ipc pipes     {{{*/
 }
                                                                        /*}}}*/
 // 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();
        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 +561,16 @@ bool EDSP::ExecuteSolver(const char* const solver, int *solver_in, int *solver_o
        }
 
        if (file.empty() == true)
        }
 
        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)
        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);
 
        for (int i = 0; i < 4; ++i)
                SetCloseExec(external[i], true);
 


@@ -567,11 +587,19 @@ bool EDSP::ExecuteSolver(const char* const solver, int *solver_in, int *solver_o
        close(external[3]);
 
        if (WaitFd(external[1], true, 5) == false)
        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];
 
        *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        {{{*/
 }
                                                                        /*}}}*/
 // EDSP::ResolveExternal - resolve problems by asking external for help        {{{*/


@@ -579,7 +607,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;
                         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");
                return false;
 
        FILE* output = fdopen(solver_in, "w");


@@ -599,6 +628,6 @@ bool EDSP::ResolveExternal(const char* const solver, pkgDepCache &Cache,
        if (EDSP::ReadResponse(solver_out, Cache, Progress) == false)
                return false;
 
        if (EDSP::ReadResponse(solver_out, Cache, Progress) == false)
                return false;
 

-       return true;
+       return ExecWait(solver_pid, solver);

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