unfuzzy various strings in manpage po's

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

diff --git a/apt-pkg/edsp.cc b/apt-pkg/edsp.cc
index 49873f2438ddcbd8652567ebade9fae35df58d65..b80b9a45679963899b26e12458a07e6e213bfc4f 100644 (file)
--- a/apt-pkg/edsp.cc
+++ b/apt-pkg/edsp.cc
@@ -7,6 +7,7 @@
 // Include Files                                                       /*{{{*/
 #include <config.h>
 
 // Include Files                                                       /*{{{*/
 #include <config.h>
 

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

 #include <apt-pkg/error.h>
 #include <apt-pkg/cacheset.h>
 #include <apt-pkg/depcache.h>
 #include <apt-pkg/error.h>
 #include <apt-pkg/cacheset.h>
 #include <apt-pkg/depcache.h>


@@ -339,7 +340,7 @@ static bool WriteScenarioLimitedDependency(FileFd &output,
 static bool SkipUnavailableVersions(pkgDepCache &Cache, pkgCache::PkgIterator const &Pkg, pkgCache::VerIterator const &Ver)/*{{{*/
 {
    /* versions which aren't current and aren't available in
 static bool SkipUnavailableVersions(pkgDepCache &Cache, pkgCache::PkgIterator const &Pkg, pkgCache::VerIterator const &Ver)/*{{{*/
 {
    /* versions which aren't current and aren't available in

-      any "online" source file are bad, expect if they are the choosen
+      any "online" source file are bad, expect if they are the chosen

       candidate: The exception is for build-dep implementation as it creates
       such pseudo (package) versions and removes them later on again.
       We filter out versions at all so packages in 'rc' state only available
       candidate: The exception is for build-dep implementation as it creates
       such pseudo (package) versions and removes them later on again.
       We filter out versions at all so packages in 'rc' state only available


@@ -439,7 +440,7 @@ bool EDSP::WriteScenario(pkgDepCache &Cache, FileFd &output, OpProgress *Progres
            Progress->Progress(p);
       }
    }
            Progress->Progress(p);
       }
    }

-   return true;
+   return Okay;

 }
                                                                        /*}}}*/
 // EDSP::WriteLimitedScenario - to the given file descriptor           /*{{{*/
 }
                                                                        /*}}}*/
 // EDSP::WriteLimitedScenario - to the given file descriptor           /*{{{*/


@@ -647,13 +648,19 @@ bool EDSP::ReadResponse(int const input, pkgDepCache &Cache, OpProgress *Progres
                        }
                        continue;
                } else if (section.Exists("Error") == true) {
                        }
                        continue;
                } else if (section.Exists("Error") == true) {

+                       if (_error->PendingError()) {
+                               if (Progress != nullptr)
+                                       Progress->Done();
+                               Progress = nullptr;
+                               _error->DumpErrors(std::cerr, GlobalError::DEBUG, false);
+                       }

                        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());
                        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)
+                       if (Progress != nullptr)

                                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;
                                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;


@@ -911,14 +918,14 @@ bool EDSP::WriteSolutionStanza(FileFd &output, char const * const Type, pkgCache
                                                                        /*}}}*/
 // EDSP::WriteProgess - pulse to the given file descriptor             /*{{{*/
 bool EDSP::WriteProgress(unsigned short const percent, const char* const message, FILE* output) {
                                                                        /*}}}*/
 // EDSP::WriteProgess - pulse to the given file descriptor             /*{{{*/
 bool EDSP::WriteProgress(unsigned short const percent, const char* const message, FILE* output) {

-       fprintf(output, "Progress: %s\n", TimeRFC1123(time(NULL)).c_str());
+       fprintf(output, "Progress: %s\n", TimeRFC1123(time(NULL), true).c_str());

        fprintf(output, "Percentage: %d\n", percent);
        fprintf(output, "Message: %s\n\n", message);
        fflush(output);
        return true;
 }
 bool EDSP::WriteProgress(unsigned short const percent, const char* const message, FileFd &output) {
        fprintf(output, "Percentage: %d\n", percent);
        fprintf(output, "Message: %s\n\n", message);
        fflush(output);
        return true;
 }
 bool EDSP::WriteProgress(unsigned short const percent, const char* const message, FileFd &output) {

-       return WriteOkay(output, "Progress: ", TimeRFC1123(time(NULL)), "\n",
+       return WriteOkay(output, "Progress: ", TimeRFC1123(time(NULL), true), "\n",

              "Percentage: ", percent, "\n",
              "Message: ", message, "\n\n") && output.Flush();
 }
              "Percentage: ", percent, "\n",
              "Message: ", message, "\n\n") && output.Flush();
 }


@@ -1016,24 +1023,43 @@ bool EDSP::ExecuteSolver(const char* const solver, int *solver_in, int *solver_o
    return true;
 }
                                                                        /*}}}*/
    return true;
 }
                                                                        /*}}}*/

+static bool CreateDumpFile(char const * const id, char const * const type, FileFd &output)/*{{{*/
+{
+       auto const dumpfile = _config->FindFile((std::string("Dir::Log::") + type).c_str());
+       if (dumpfile.empty())
+               return false;
+       auto const dumpdir = flNotFile(dumpfile);
+       _error->PushToStack();
+       bool errored_out = CreateAPTDirectoryIfNeeded(dumpdir, dumpdir) == false ||
+          output.Open(dumpfile, FileFd::WriteOnly | FileFd::Exclusive | FileFd::Create, FileFd::Extension, 0644) == false;
+       std::vector<std::string> downgrademsgs;
+       while (_error->empty() == false)
+       {
+               std::string msg;
+               _error->PopMessage(msg);
+               downgrademsgs.emplace_back(std::move(msg));
+       }
+       _error->RevertToStack();
+       for (auto && msg : downgrademsgs)
+          _error->Warning("%s", msg.c_str());
+       if (errored_out)
+               return _error->WarningE(id, _("Could not open file '%s'"), dumpfile.c_str());
+       return true;
+}
+                                                                       /*}}}*/

 // EDSP::ResolveExternal - resolve problems by asking external for help        {{{*/
 bool EDSP::ResolveExternal(const char* const solver, pkgDepCache &Cache,
                         unsigned int const flags, OpProgress *Progress) {
        if (strcmp(solver, "internal") == 0)
        {
 // EDSP::ResolveExternal - resolve problems by asking external for help        {{{*/
 bool EDSP::ResolveExternal(const char* const solver, pkgDepCache &Cache,
                         unsigned int const flags, OpProgress *Progress) {
        if (strcmp(solver, "internal") == 0)
        {

-               auto const dumpfile = _config->FindFile("Dir::Log::Solver");
-               if (dumpfile.empty())
-                       return false;
-               auto const dumpdir = flNotFile(dumpfile);

                FileFd output;
                FileFd output;

-               if (CreateAPTDirectoryIfNeeded(dumpdir, dumpdir) == false ||
-                     output.Open(dumpfile, FileFd::WriteOnly | FileFd::Exclusive | FileFd::Create, FileFd::Extension, 0644) == false)
-                       return _error->WarningE("EDSP::Resolve", _("Could not open file '%s'"), dumpfile.c_str());
-               bool Okay = EDSP::WriteRequest(Cache, output, flags, nullptr);
+               bool Okay = CreateDumpFile("EDSP::Resolve", "solver", output);
+               Okay &= EDSP::WriteRequest(Cache, output, flags, nullptr);

                return Okay && EDSP::WriteScenario(Cache, output, nullptr);
        }
                return Okay && EDSP::WriteScenario(Cache, output, nullptr);
        }

+       _error->PushToStack();

        int solver_in, solver_out;
        int solver_in, solver_out;

-       pid_t const solver_pid = EDSP::ExecuteSolver(solver, &solver_in, &solver_out, true);
+       pid_t const solver_pid = ExecuteSolver(solver, &solver_in, &solver_out, true);

        if (solver_pid == 0)
                return false;
 
        if (solver_pid == 0)
                return false;
 


@@ -1042,20 +1068,21 @@ bool EDSP::ResolveExternal(const char* const solver, pkgDepCache &Cache,
                return _error->Errno("ResolveExternal", "Opening solver %s stdin on fd %d for writing failed", solver, solver_in);
 
        bool Okay = output.Failed() == false;
                return _error->Errno("ResolveExternal", "Opening solver %s stdin on fd %d for writing failed", solver, solver_in);
 
        bool Okay = output.Failed() == false;

-       if (Progress != NULL)
+       if (Okay && Progress != NULL)

                Progress->OverallProgress(0, 100, 5, _("Execute external solver"));
        Okay &= EDSP::WriteRequest(Cache, output, flags, Progress);
                Progress->OverallProgress(0, 100, 5, _("Execute external solver"));
        Okay &= EDSP::WriteRequest(Cache, output, flags, Progress);

-       if (Progress != NULL)
+       if (Okay && Progress != NULL)

                Progress->OverallProgress(5, 100, 20, _("Execute external solver"));
        Okay &= EDSP::WriteScenario(Cache, output, Progress);
        output.Close();
 
                Progress->OverallProgress(5, 100, 20, _("Execute external solver"));
        Okay &= EDSP::WriteScenario(Cache, output, Progress);
        output.Close();
 

-       if (Progress != NULL)
+       if (Okay && Progress != NULL)

                Progress->OverallProgress(25, 100, 75, _("Execute external solver"));
                Progress->OverallProgress(25, 100, 75, _("Execute external solver"));

-       if (Okay && EDSP::ReadResponse(solver_out, Cache, Progress) == false)
-               return false;
-
-       return ExecWait(solver_pid, solver);
+       bool const ret = EDSP::ReadResponse(solver_out, Cache, Progress);
+       _error->MergeWithStack();
+       if (ExecWait(solver_pid, solver))
+               return ret;
+       return false;

 }
 bool EDSP::ResolveExternal(const char* const solver, pkgDepCache &Cache,
                         bool const upgrade, bool const distUpgrade,
 }
 bool EDSP::ResolveExternal(const char* const solver, pkgDepCache &Cache,
                         bool const upgrade, bool const distUpgrade,


@@ -1076,50 +1103,54 @@ bool EIPP::OrderInstall(char const * const solver, pkgPackageManager * const PM,
 {
    if (strcmp(solver, "internal") == 0)
    {
 {
    if (strcmp(solver, "internal") == 0)
    {

-      auto const dumpfile = _config->FindFile("Dir::Log::Planer");
-      if (dumpfile.empty())
-        return false;
-      auto const dumpdir = flNotFile(dumpfile);

       FileFd output;
       FileFd output;

-      if (CreateAPTDirectoryIfNeeded(dumpdir, dumpdir) == false ||
-           output.Open(dumpfile, FileFd::WriteOnly | FileFd::Exclusive | FileFd::Create, FileFd::Extension, 0644) == false)
-        return _error->WarningE("EIPP::OrderInstall", _("Could not open file '%s'"), dumpfile.c_str());
-      bool Okay = EIPP::WriteRequest(PM->Cache, output, flags, nullptr);
+      _error->PushToStack();
+      bool Okay = CreateDumpFile("EIPP::OrderInstall", "planner", output);
+      if (Okay == false && dynamic_cast<pkgSimulate*>(PM) != nullptr)
+      {
+        _error->RevertToStack();
+        return false;
+      }
+      _error->MergeWithStack();
+      Okay &= EIPP::WriteRequest(PM->Cache, output, flags, nullptr);

       return Okay && EIPP::WriteScenario(PM->Cache, output, nullptr);
    }
       return Okay && EIPP::WriteScenario(PM->Cache, output, nullptr);
    }

-
+   _error->PushToStack();

    int solver_in, solver_out;
    int solver_in, solver_out;

-   pid_t const solver_pid = ExecuteExternal("planer", solver, "Dir::Bin::Planers", &solver_in, &solver_out);
+   pid_t const solver_pid = ExecuteExternal("planner", solver, "Dir::Bin::Planners", &solver_in, &solver_out);

    if (solver_pid == 0)
       return false;
 
    FileFd output;
    if (output.OpenDescriptor(solver_in, FileFd::WriteOnly | FileFd::BufferedWrite, true) == false)
    if (solver_pid == 0)
       return false;
 
    FileFd output;
    if (output.OpenDescriptor(solver_in, FileFd::WriteOnly | FileFd::BufferedWrite, true) == false)

-      return _error->Errno("EIPP::OrderInstall", "Opening planer %s stdin on fd %d for writing failed", solver, solver_in);
+      return _error->Errno("EIPP::OrderInstall", "Opening planner %s stdin on fd %d for writing failed", solver, solver_in);

 
    bool Okay = output.Failed() == false;
 
    bool Okay = output.Failed() == false;

-   if (Progress != NULL)
-      Progress->OverallProgress(0, 100, 5, _("Execute external planer"));
+   if (Okay && Progress != NULL)
+      Progress->OverallProgress(0, 100, 5, _("Execute external planner"));

    Okay &= EIPP::WriteRequest(PM->Cache, output, flags, Progress);
    Okay &= EIPP::WriteRequest(PM->Cache, output, flags, Progress);

-   if (Progress != NULL)
-      Progress->OverallProgress(5, 100, 20, _("Execute external planer"));
+   if (Okay && Progress != NULL)
+      Progress->OverallProgress(5, 100, 20, _("Execute external planner"));

    Okay &= EIPP::WriteScenario(PM->Cache, output, Progress);
    output.Close();
 
    Okay &= EIPP::WriteScenario(PM->Cache, output, Progress);
    output.Close();
 

-   if (Progress != NULL)
-      Progress->OverallProgress(25, 100, 75, _("Execute external planer"));
-
-   // we don't tell the external planers about boring things
-   for (auto Pkg = PM->Cache.PkgBegin(); Pkg.end() == false; ++Pkg)
+   if (Okay)

    {
    {

-      if (Pkg->CurrentState == pkgCache::State::ConfigFiles && PM->Cache[Pkg].Purge() == true)
-        PM->Remove(Pkg, true);
-   }
-
-   if (Okay && EIPP::ReadResponse(solver_out, PM, Progress) == false)
-      return false;
+      if (Progress != nullptr)
+        Progress->OverallProgress(25, 100, 75, _("Execute external planner"));

 
 

-   return ExecWait(solver_pid, solver);
+      // we don't tell the external planners about boring things
+      for (auto Pkg = PM->Cache.PkgBegin(); Pkg.end() == false; ++Pkg)
+      {
+        if (Pkg->CurrentState == pkgCache::State::ConfigFiles && PM->Cache[Pkg].Purge() == true)
+           PM->Remove(Pkg, true);
+      }
+   }
+   bool const ret = EIPP::ReadResponse(solver_out, PM, Progress);
+   _error->MergeWithStack();
+   if (ExecWait(solver_pid, solver))
+      return ret;
+   return false;

 }
                                                                        /*}}}*/
 bool EIPP::WriteRequest(pkgDepCache &Cache, FileFd &output,            /*{{{*/
 }
                                                                        /*}}}*/
 bool EIPP::WriteRequest(pkgDepCache &Cache, FileFd &output,            /*{{{*/


@@ -1127,7 +1158,7 @@ bool EIPP::WriteRequest(pkgDepCache &Cache, FileFd &output,               /*{{{*/
                        OpProgress * const Progress)
 {
    if (Progress != NULL)
                        OpProgress * const Progress)
 {
    if (Progress != NULL)

-      Progress->SubProgress(Cache.Head().PackageCount, _("Send request to planer"));
+      Progress->SubProgress(Cache.Head().PackageCount, _("Send request to planner"));

    unsigned long p = 0;
    string del, inst, reinst;
    for (pkgCache::PkgIterator Pkg = Cache.PkgBegin(); Pkg.end() == false; ++Pkg, ++p)
    unsigned long p = 0;
    string del, inst, reinst;
    for (pkgCache::PkgIterator Pkg = Cache.PkgBegin(); Pkg.end() == false; ++Pkg, ++p)


@@ -1164,7 +1195,7 @@ bool EIPP::WriteRequest(pkgDepCache &Cache, FileFd &output,               /*{{{*/
       WriteOkay(Okay, output, "Install:", inst, "\n");
    if (reinst.empty() == false)
       WriteOkay(Okay, output, "ReInstall:", reinst, "\n");
       WriteOkay(Okay, output, "Install:", inst, "\n");
    if (reinst.empty() == false)
       WriteOkay(Okay, output, "ReInstall:", reinst, "\n");

-   WriteOkay(Okay, output, "Planer: ", _config->Find("APT::Planer", "internal"), "\n");
+   WriteOkay(Okay, output, "Planner: ", _config->Find("APT::Planner", "internal"), "\n");

    if ((flags & Request::IMMEDIATE_CONFIGURATION_ALL) != 0)
       WriteOkay(Okay, output, "Immediate-Configuration: yes\n");
    else if ((flags & Request::NO_IMMEDIATE_CONFIGURATION) != 0)
    if ((flags & Request::IMMEDIATE_CONFIGURATION_ALL) != 0)
       WriteOkay(Okay, output, "Immediate-Configuration: yes\n");
    else if ((flags & Request::NO_IMMEDIATE_CONFIGURATION) != 0)


@@ -1217,7 +1248,7 @@ template<typename forVersion> void forAllInterestingVersions(pkgDepCache &Cache,
 bool EIPP::WriteScenario(pkgDepCache &Cache, FileFd &output, OpProgress * const Progress)
 {
    if (Progress != NULL)
 bool EIPP::WriteScenario(pkgDepCache &Cache, FileFd &output, OpProgress * const Progress)
 {
    if (Progress != NULL)

-      Progress->SubProgress(Cache.Head().PackageCount, _("Send scenario to planer"));
+      Progress->SubProgress(Cache.Head().PackageCount, _("Send scenario to planner"));

    unsigned long p = 0;
    bool Okay = output.Failed() == false;
    std::vector<std::string> archs = APT::Configuration::getArchitectures();
    unsigned long p = 0;
    bool Okay = output.Failed() == false;
    std::vector<std::string> archs = APT::Configuration::getArchitectures();


@@ -1284,7 +1315,7 @@ bool EIPP::WriteScenario(pkgDepCache &Cache, FileFd &output, OpProgress * const
         continue;
       forAllInterestingVersions(Cache, Pkg, WriteVersion);
    }
         continue;
       forAllInterestingVersions(Cache, Pkg, WriteVersion);
    }

-   return true;
+   return Okay;

 }
                                                                        /*}}}*/
 // EIPP::ReadResponse - from the given file descriptor                 /*{{{*/
 }
                                                                        /*}}}*/
 // EIPP::ReadResponse - from the given file descriptor                 /*{{{*/


@@ -1316,15 +1347,21 @@ bool EIPP::ReadResponse(int const input, pkgPackageManager * const PM, OpProgres
         }
         continue;
       } else if (section.Exists("Error") == true) {
         }
         continue;
       } else if (section.Exists("Error") == true) {

+        if (_error->PendingError()) {
+           if (Progress != nullptr)
+              Progress->Done();
+           Progress = nullptr;
+           _error->DumpErrors(std::cerr, GlobalError::DEBUG, false);
+        }

         std::string msg = SubstVar(SubstVar(section.FindS("Message"), "\n .\n", "\n\n"), "\n ", "\n");
         if (msg.empty() == true) {
         std::string msg = SubstVar(SubstVar(section.FindS("Message"), "\n .\n", "\n\n"), "\n ", "\n");
         if (msg.empty() == true) {

-           msg = _("External planer failed without a proper error message");
+           msg = _("External planner failed without a proper error message");

            _error->Error("%s", msg.c_str());
         } else
            _error->Error("%s", msg.c_str());
         } else

-           _error->Error("External planer failed with: %s", msg.substr(0,msg.find('\n')).c_str());
-        if (Progress != NULL)
+           _error->Error("External planner failed with: %s", msg.substr(0,msg.find('\n')).c_str());
+        if (Progress != nullptr)

            Progress->Done();
            Progress->Done();

-        std::cerr << "The planer encountered an error of type: " << section.FindS("Error") << std::endl;
+        std::cerr << "The planner 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;
         std::cerr << "The following information might help you to understand what is wrong:" << std::endl;
         std::cerr << msg << std::endl << std::endl;
         return false;


@@ -1361,7 +1398,7 @@ bool EIPP::ReadResponse(int const input, pkgPackageManager * const PM, OpProgres
       else if (strcmp(type, "Remove") == 0)
         PM->Remove(Pkg, PM->Cache[Pkg].Purge());
    }
       else if (strcmp(type, "Remove") == 0)
         PM->Remove(Pkg, PM->Cache[Pkg].Purge());
    }

-   return true;
+   return in.Failed() == false;

 }
                                                                        /*}}}*/
 bool EIPP::ReadRequest(int const input, std::list<std::pair<std::string,PKG_ACTION>> &actions,/*{{{*/
 }
                                                                        /*}}}*/
 bool EIPP::ReadRequest(int const input, std::list<std::pair<std::string,PKG_ACTION>> &actions,/*{{{*/


@@ -1396,7 +1433,7 @@ bool EIPP::ReadRequest(int const input, std::list<std::pair<std::string,PKG_ACTI
            _config->Set("APT::Architecture", line);
         else if (LineStartsWithAndStrip(line, "Architectures:"))
            _config->Set("APT::Architectures", SubstVar(line, " ", ","));
            _config->Set("APT::Architecture", line);
         else if (LineStartsWithAndStrip(line, "Architectures:"))
            _config->Set("APT::Architectures", SubstVar(line, " ", ","));

-        else if (LineStartsWithAndStrip(line, "Planer:"))
+        else if (LineStartsWithAndStrip(line, "Planner:"))

            ; // purely informational line
         else if (LineStartsWithAndStrip(line, "Immediate-Configuration:"))
         {
            ; // purely informational line
         else if (LineStartsWithAndStrip(line, "Immediate-Configuration:"))
         {


@@ -1417,9 +1454,6 @@ bool EIPP::ReadRequest(int const input, std::list<std::pair<std::string,PKG_ACTI
       }
    }
    return false;
       }
    }
    return false;

-
-
-   return false;

 }
                                                                        /*}}}*/
 bool EIPP::ApplyRequest(std::list<std::pair<std::string,PKG_ACTION>> &actions,/*{{{*/
 }
                                                                        /*}}}*/
 bool EIPP::ApplyRequest(std::list<std::pair<std::string,PKG_ACTION>> &actions,/*{{{*/