implement optional Progress report in EDSP

diff --git a/apt-pkg/edsp.cc b/apt-pkg/edsp.cc
index aec43c7e89be9c3177f26f1df2ecb7924f874f5b..6343b57cd2f4804ba9922c36befb049fa364fcfb 100644 (file)
--- a/apt-pkg/edsp.cc
+++ b/apt-pkg/edsp.cc
@@ -242,8 +242,16 @@ bool EDSP::ReadResponse(int const input, pkgDepCache &Cache) {
                        type = "Install";
                else if (section.Exists("Remove") == true)
                        type = "Remove";
                        type = "Install";
                else if (section.Exists("Remove") == true)
                        type = "Remove";

-               //FIXME: handle progress
-               else
+               else if (section.Exists("Progress") == true) {
+                       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;
+                       continue;
+               } else

                        continue;
 
                size_t const id = section.FindULL(type.c_str(), VersionCount);
                        continue;
 
                size_t const id = section.FindULL(type.c_str(), VersionCount);


@@ -422,4 +430,13 @@ bool EDSP::WriteSolution(pkgDepCache &Cache, FILE* output)
    return true;
 }
                                                                        /*}}}*/
    return true;
 }
                                                                        /*}}}*/

+// 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, "Percentage: %d\n", percent);
+       fprintf(output, "Message: %s\n\n", message);
+       fflush(output);
+       return true;
+}
+                                                                       /*}}}*/

 bool EDSP::WriteError(std::string const &message, FILE* output) { return false; }
 bool EDSP::WriteError(std::string const &message, FILE* output) { return false; }

diff --git a/apt-pkg/edsp.h b/apt-pkg/edsp.h
index db4f06a7c4b6cbd9c28a9113985ba1300e6c39a9..a05de94487e72bc76a4b475354ee8c5367a81c93 100644 (file)
--- a/apt-pkg/edsp.h
+++ b/apt-pkg/edsp.h
@@ -49,6 +49,7 @@ public:
                                 std::list<std::string> const &remove,
                                 pkgDepCache &Cache);
        bool static WriteSolution(pkgDepCache &Cache, FILE* output);
                                 std::list<std::string> const &remove,
                                 pkgDepCache &Cache);
        bool static WriteSolution(pkgDepCache &Cache, FILE* output);

+       bool static WriteProgress(unsigned short const percent, const char* const message, FILE* output);

        bool static WriteError(std::string const &message, FILE* output);
 
 };
        bool static WriteError(std::string const &message, FILE* output);
 
 };

diff --git a/cmdline/apt-internal-solver.cc b/cmdline/apt-internal-solver.cc
index 68489e21313894eda4f69709722cf9d4fbaaac58..0aa218d52b523edc89a6076f737d9cbb43ee0fd9 100644 (file)
--- a/cmdline/apt-internal-solver.cc
+++ b/cmdline/apt-internal-solver.cc
@@ -103,11 +103,15 @@ int main(int argc,const char *argv[])                                     /*{{{*/
        FILE* output = stdout;
        SetNonBlock(input, false);
 
        FILE* output = stdout;
        SetNonBlock(input, false);
 

+       EDSP::WriteProgress(0, "Start up solver…", output);
+

        if (pkgInitSystem(*_config,_system) == false) {
                std::cerr << "System could not be initialized!" << std::endl;
                return 1;
        }
 
        if (pkgInitSystem(*_config,_system) == false) {
                std::cerr << "System could not be initialized!" << std::endl;
                return 1;
        }
 

+       EDSP::WriteProgress(1, "Read request…", output);
+

        if (WaitFd(input, false, 5) == false)
                std::cerr << "WAIT timed out in the resolver" << std::endl;
 
        if (WaitFd(input, false, 5) == false)
                std::cerr << "WAIT timed out in the resolver" << std::endl;
 


@@ -118,9 +122,13 @@ int main(int argc,const char *argv[])                                      /*{{{*/
                return 2;
        }
 
                return 2;
        }
 

+       EDSP::WriteProgress(5, "Read scenario…", output);
+

        pkgCacheFile CacheFile;
        CacheFile.Open(NULL, false);
 
        pkgCacheFile CacheFile;
        CacheFile.Open(NULL, false);
 

+       EDSP::WriteProgress(50, "Apply request on scenario…", output);
+

        if (EDSP::ApplyRequest(install, remove, CacheFile) == false) {
                std::cerr << "Failed to apply request to depcache!" << std::endl;
                return 3;
        if (EDSP::ApplyRequest(install, remove, CacheFile) == false) {
                std::cerr << "Failed to apply request to depcache!" << std::endl;
                return 3;


@@ -146,17 +154,22 @@ int main(int argc,const char *argv[])                                     /*{{{*/
             i != install.end(); ++i)
                CacheFile->MarkInstall(CacheFile->FindPkg(*i), true);
 
             i != install.end(); ++i)
                CacheFile->MarkInstall(CacheFile->FindPkg(*i), true);
 

+       EDSP::WriteProgress(60, "Call problemresolver on current scenario…", output);

 
        if (Fix.Resolve() == false) {
                EDSP::WriteError("An error occured", output);
                return 0;
        }
 
 
        if (Fix.Resolve() == false) {
                EDSP::WriteError("An error occured", output);
                return 0;
        }
 

+       EDSP::WriteProgress(95, "Write solution…", output);
+

        if (EDSP::WriteSolution(CacheFile, output) == false) {
                std::cerr << "Failed to output the solution!" << std::endl;
                return 4;
        }
 
        if (EDSP::WriteSolution(CacheFile, output) == false) {
                std::cerr << "Failed to output the solution!" << std::endl;
                return 4;
        }
 

+       EDSP::WriteProgress(100, "Done", output);
+

        bool const Errors = _error->PendingError();
        if (_config->FindI("quiet",0) > 0)
                _error->DumpErrors(std::cerr);
        bool const Errors = _error->PendingError();
        if (_config->FindI("quiet",0) > 0)
                _error->DumpErrors(std::cerr);