implement proper progress report with OpProgress

diff --git a/apt-pkg/algorithms.cc b/apt-pkg/algorithms.cc
index 5d9fefaa670f3fbe937c9227c0101665192358d3..31c3e9c28633316d7835f7e4743229e4e99a0bf6 100644 (file)
--- a/apt-pkg/algorithms.cc
+++ b/apt-pkg/algorithms.cc
@@ -333,8 +333,10 @@ bool pkgFixBroken(pkgDepCache &Cache)
 bool pkgDistUpgrade(pkgDepCache &Cache)
 {
    std::string const solver = _config->Find("APT::Solver::Name", "internal");
 bool pkgDistUpgrade(pkgDepCache &Cache)
 {
    std::string const solver = _config->Find("APT::Solver::Name", "internal");

-   if (solver != "internal")
-      return EDSP::ResolveExternal(solver.c_str(), Cache, false, true, false);
+   if (solver != "internal") {
+      OpTextProgress Prog(*_config);
+      return EDSP::ResolveExternal(solver.c_str(), Cache, false, true, false, &Prog);
+   }

 
    pkgDepCache::ActionGroup group(Cache);
 
 
    pkgDepCache::ActionGroup group(Cache);
 


@@ -389,8 +391,10 @@ bool pkgDistUpgrade(pkgDepCache &Cache)
 bool pkgAllUpgrade(pkgDepCache &Cache)
 {
    std::string const solver = _config->Find("APT::Solver::Name", "internal");
 bool pkgAllUpgrade(pkgDepCache &Cache)
 {
    std::string const solver = _config->Find("APT::Solver::Name", "internal");

-   if (solver != "internal")
-      return EDSP::ResolveExternal(solver.c_str(), Cache, true, false, false);
+   if (solver != "internal") {
+      OpTextProgress Prog(*_config);
+      return EDSP::ResolveExternal(solver.c_str(), Cache, true, false, false, &Prog);
+   }

 
    pkgDepCache::ActionGroup group(Cache);
 
 
    pkgDepCache::ActionGroup group(Cache);
 


@@ -748,8 +752,10 @@ bool pkgProblemResolver::DoUpgrade(pkgCache::PkgIterator Pkg)
 bool pkgProblemResolver::Resolve(bool BrokenFix)
 {
    std::string const solver = _config->Find("APT::Solver::Name", "internal");
 bool pkgProblemResolver::Resolve(bool BrokenFix)
 {
    std::string const solver = _config->Find("APT::Solver::Name", "internal");

-   if (solver != "internal")
-      return EDSP::ResolveExternal(solver.c_str(), Cache, false, false, false);
+   if (solver != "internal") {
+      OpTextProgress Prog(*_config);
+      return EDSP::ResolveExternal(solver.c_str(), Cache, false, false, false, &Prog);
+   }

    return ResolveInternal(BrokenFix);
 }
                                                                        /*}}}*/
    return ResolveInternal(BrokenFix);
 }
                                                                        /*}}}*/


@@ -1223,8 +1229,10 @@ bool pkgProblemResolver::ResolveInternal(bool const BrokenFix)
 bool pkgProblemResolver::ResolveByKeep()
 {
    std::string const solver = _config->Find("APT::Solver::Name", "internal");
 bool pkgProblemResolver::ResolveByKeep()
 {
    std::string const solver = _config->Find("APT::Solver::Name", "internal");

-   if (solver != "internal")
-      return EDSP::ResolveExternal(solver.c_str(), Cache, true, false, false);
+   if (solver != "internal") {
+      OpTextProgress Prog(*_config);
+      return EDSP::ResolveExternal(solver.c_str(), Cache, true, false, false, &Prog);
+   }

    return ResolveByKeepInternal();
 }
                                                                        /*}}}*/
    return ResolveByKeepInternal();
 }
                                                                        /*}}}*/

diff --git a/apt-pkg/edsp.cc b/apt-pkg/edsp.cc
index 7ece92d2e4ef433096fbc3c0dccac9b97869501d..489dd293336a3c4a47b17b6a787bfb69e4644e4a 100644 (file)
--- a/apt-pkg/edsp.cc
+++ b/apt-pkg/edsp.cc
@@ -26,29 +26,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;
 }
                                                                        /*}}}*/


@@ -184,11 +197,17 @@ 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;
       if (Cache[Pkg].Delete() == true)
         req = &del;
       string* req;
       if (Cache[Pkg].Delete() == true)
         req = &del;


@@ -221,7 +240,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,14 +266,14 @@ 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 const msg = section.FindS("Message");
+                               if (msg.empty() == true)
+                                       Progress->SubProgress(100, _("Prepare for receiving solution"));
+                               else
+                                       Progress->SubProgress(100, msg);
+                               Progress->Progress(section.FindI("Percentage", 0));
+                       }

                        continue;
                } else if (section.Exists("Error") == true) {
                        std::cerr << "The solver encountered an error of type: " << section.FindS("Error") << std::endl;
                        continue;
                } else if (section.Exists("Error") == true) {
                        std::cerr << "The solver encountered an error of type: " << section.FindS("Error") << std::endl;


@@ -512,7 +531,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;


@@ -520,11 +539,18 @@ 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)
+       if (Progress != NULL)
+               Progress->OverallProgress(25, 100, 75, _("Execute external solver"));
+       if (EDSP::ReadResponse(solver_out, Cache, Progress) == false)

                return _error->Error("Reading solver response failed");
 
        return true;
                return _error->Error("Reading solver response failed");
 
        return true;

diff --git a/apt-pkg/edsp.h b/apt-pkg/edsp.h
index 210188d038dd75ad11a2e81c5da5059c9f3d0b85..743c3f5d1dc52404ed35379a3b91bd7f5985be64 100644 (file)
--- a/apt-pkg/edsp.h
+++ b/apt-pkg/edsp.h
@@ -11,6 +11,7 @@
 
 #include <apt-pkg/depcache.h>
 #include <apt-pkg/cacheset.h>
 
 #include <apt-pkg/depcache.h>
 #include <apt-pkg/cacheset.h>

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

 
 #include <string>
 
 
 #include <string>
 


@@ -46,13 +47,15 @@ public:
         *  \param upgrade is true if it is an request like apt-get upgrade
         *  \param distUpgrade is true if it is a request like apt-get dist-upgrade
         *  \param autoRemove is true if removal of unneeded packages should be performed
         *  \param upgrade is true if it is an request like apt-get upgrade
         *  \param distUpgrade is true if it is a request like apt-get dist-upgrade
         *  \param autoRemove is true if removal of unneeded packages should be performed

+        *  \param Progress is an instance to report progress to

         *
         *  \return true if request was composed successfully, otherwise false
         */
        bool static WriteRequest(pkgDepCache &Cache, FILE* output,
                                 bool const upgrade = false,
                                 bool const distUpgrade = false,
         *
         *  \return true if request was composed successfully, otherwise false
         */
        bool static WriteRequest(pkgDepCache &Cache, FILE* output,
                                 bool const upgrade = false,
                                 bool const distUpgrade = false,

-                                bool const autoRemove = false);
+                                bool const autoRemove = false,
+                               OpProgress *Progress = NULL);

 
        /** \brief creates the scenario representing the package universe
         *
 
        /** \brief creates the scenario representing the package universe
         *


@@ -67,10 +70,11 @@ public:
         *
         *  \param Cache is the known package universe
         *  \param output is written to this "file"
         *
         *  \param Cache is the known package universe
         *  \param output is written to this "file"

+        *  \param Progress is an instance to report progress to

         *
         *  \return true if universe was composed successfully, otherwise false
         */
         *
         *  \return true if universe was composed successfully, otherwise false
         */

-       bool static WriteScenario(pkgDepCache &Cache, FILE* output);
+       bool static WriteScenario(pkgDepCache &Cache, FILE* output, OpProgress *Progress = NULL);

 
        /** \brief creates a limited scenario representing the package universe
         *
 
        /** \brief creates a limited scenario representing the package universe
         *


@@ -83,11 +87,13 @@ public:
         *  \param Cache is the known package universe
         *  \param output is written to this "file"
         *  \param pkgset is a set of packages the universe should be limited to
         *  \param Cache is the known package universe
         *  \param output is written to this "file"
         *  \param pkgset is a set of packages the universe should be limited to

+        *  \param Progress is an instance to report progress to

         *
         *  \return true if universe was composed successfully, otherwise false
         */
        bool static WriteLimitedScenario(pkgDepCache &Cache, FILE* output,
         *
         *  \return true if universe was composed successfully, otherwise false
         */
        bool static WriteLimitedScenario(pkgDepCache &Cache, FILE* output,

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

 
        /** \brief waits and acts on the information returned from the solver
         *
 
        /** \brief waits and acts on the information returned from the solver
         *


@@ -98,10 +104,11 @@ public:
         *
         *  \param input file descriptor with the response from the solver
         *  \param Cache the solution should be applied on if any
         *
         *  \param input file descriptor with the response from the solver
         *  \param Cache the solution should be applied on if any

+        *  \param Progress is an instance to report progress to

         *
         *  \return true if a solution is found and applied correctly, otherwise false
         */
         *
         *  \return true if a solution is found and applied correctly, otherwise false
         */

-       bool static ReadResponse(int const input, pkgDepCache &Cache);
+       bool static ReadResponse(int const input, pkgDepCache &Cache, OpProgress *Progress = NULL);

 
        /** \brief search and read the request stanza for action later
         *
 
        /** \brief search and read the request stanza for action later
         *


@@ -202,13 +209,14 @@ public:
         *  \param upgrade is true if it is a request like apt-get upgrade
         *  \param distUpgrade is true if it is a request like apt-get dist-upgrade
         *  \param autoRemove is true if unneeded packages should be removed
         *  \param upgrade is true if it is a request like apt-get upgrade
         *  \param distUpgrade is true if it is a request like apt-get dist-upgrade
         *  \param autoRemove is true if unneeded packages should be removed

+        *  \param Progress is an instance to report progress to

         *
         *  \return true if the solver has successfully solved the problem,
         *  otherwise false
         */
        bool static ResolveExternal(const char* const solver, pkgDepCache &Cache,
                                    bool const upgrade, bool const distUpgrade,
         *
         *  \return true if the solver has successfully solved the problem,
         *  otherwise false
         */
        bool static ResolveExternal(const char* const solver, pkgDepCache &Cache,
                                    bool const upgrade, bool const distUpgrade,

-                                   bool const autoRemove);
+                                   bool const autoRemove, OpProgress *Progress = NULL);

 };
                                                                        /*}}}*/
 #endif
 };
                                                                        /*}}}*/
 #endif