Merge branch 'cmake'

[apt.git] / apt-pkg / install-progress.cc

diff --git a/apt-pkg/install-progress.cc b/apt-pkg/install-progress.cc
index b341fe6860302fc1a40fab341bf0c2d19c484952..c77c240c33800c91cc52d4739b76e8fe48ea0d4d 100644 (file)
--- a/apt-pkg/install-progress.cc
+++ b/apt-pkg/install-progress.cc
@@ -1,18 +1,31 @@
+#include <config.h>
+

 #include <apt-pkg/configuration.h>
 #include <apt-pkg/fileutl.h>
 #include <apt-pkg/strutl.h>
 #include <apt-pkg/install-progress.h>
 
 #include <apt-pkg/configuration.h>
 #include <apt-pkg/fileutl.h>
 #include <apt-pkg/strutl.h>
 #include <apt-pkg/install-progress.h>
 

-#include <apti18n.h>
-
-#include <termios.h>
+#include <signal.h>
+#include <unistd.h>
+#include <iostream>
+#include <vector>

 #include <sys/ioctl.h>
 #include <sys/ioctl.h>

-#include <sstream>

 #include <fcntl.h>
 #include <fcntl.h>

+#include <algorithm>
+#include <stdio.h>
+#include <sstream>
+
+#include <apti18n.h>

 
 namespace APT {
 namespace Progress {
 
 
 namespace APT {
 namespace Progress {
 

+PackageManager::PackageManager() : d(NULL), percentage(0.0), last_reported_progress(-1) {}
+PackageManager::~PackageManager() {}
+
+/* Return a APT::Progress::PackageManager based on the global
+ * apt configuration (i.e. APT::Status-Fd and APT::Status-deb822-Fd)
+ */

 PackageManager* PackageManagerProgressFactory()
 {
    // select the right progress
 PackageManager* PackageManagerProgressFactory()
 {
    // select the right progress


@@ -35,10 +48,10 @@ PackageManager* PackageManagerProgressFactory()
    return progress;
 }
 
    return progress;
 }
 

-bool PackageManager::StatusChanged(std::string PackageName, 
+bool PackageManager::StatusChanged(std::string /*PackageName*/,

                                    unsigned int StepsDone,
                                    unsigned int TotalSteps,
                                    unsigned int StepsDone,
                                    unsigned int TotalSteps,

-                                   std::string HumanReadableAction)
+                                   std::string /*HumanReadableAction*/)

 {
    int reporting_steps = _config->FindI("DpkgPM::Reporting-Steps", 1);
    percentage = StepsDone/(float)TotalSteps * 100.0;
 {
    int reporting_steps = _config->FindI("DpkgPM::Reporting-Steps", 1);
    percentage = StepsDone/(float)TotalSteps * 100.0;


@@ -51,10 +64,11 @@ bool PackageManager::StatusChanged(std::string PackageName,
 }
 
 PackageManagerProgressFd::PackageManagerProgressFd(int progress_fd)
 }
 
 PackageManagerProgressFd::PackageManagerProgressFd(int progress_fd)

-   : StepsDone(0), StepsTotal(1)
+   : d(NULL), StepsDone(0), StepsTotal(1)

 {
    OutStatusFd = progress_fd;
 }
 {
    OutStatusFd = progress_fd;
 }

+PackageManagerProgressFd::~PackageManagerProgressFd() {}

 
 void PackageManagerProgressFd::WriteToStatusFd(std::string s)
 {
 
 void PackageManagerProgressFd::WriteToStatusFd(std::string s)
 {


@@ -73,15 +87,13 @@ void PackageManagerProgressFd::StartDpkg()
    fcntl(OutStatusFd,F_SETFD,FD_CLOEXEC); 
 
    // send status information that we are about to fork dpkg
    fcntl(OutStatusFd,F_SETFD,FD_CLOEXEC); 
 
    // send status information that we are about to fork dpkg

-   std::ostringstream status;
-   status << "pmstatus:dpkg-exec:" 
-          << (StepsDone/float(StepsTotal)*100.0) 
-          << ":" << _("Running dpkg")
-          << std::endl;
-   WriteToStatusFd(status.str());
+   std::string status;
+   strprintf(status, "pmstatus:dpkg-exec:%.4f:%s\n",
+        (StepsDone/float(StepsTotal)*100.0), _("Running dpkg"));
+   WriteToStatusFd(std::move(status));

 }
 
 }
 

-void PackageManagerProgressFd::Stop()
+APT_CONST void PackageManagerProgressFd::Stop()

 {
 }
 
 {
 }
 


@@ -90,12 +102,10 @@ void PackageManagerProgressFd::Error(std::string PackageName,
                                      unsigned int TotalSteps,
                                      std::string ErrorMessage)
 {
                                      unsigned int TotalSteps,
                                      std::string ErrorMessage)
 {

-   std::ostringstream status;
-   status << "pmerror:" << PackageName
-          << ":"  << (StepsDone/float(TotalSteps)*100.0) 
-          << ":" << ErrorMessage
-          << std::endl;
-   WriteToStatusFd(status.str());
+   std::string status;
+   strprintf(status, "pmerror:%s:%.4f:%s\n", PackageName.c_str(),
+        (StepsDone/float(TotalSteps)*100.0), ErrorMessage.c_str());
+   WriteToStatusFd(std::move(status));

 }
 
 void PackageManagerProgressFd::ConffilePrompt(std::string PackageName,
 }
 
 void PackageManagerProgressFd::ConffilePrompt(std::string PackageName,


@@ -103,12 +113,10 @@ void PackageManagerProgressFd::ConffilePrompt(std::string PackageName,
                                               unsigned int TotalSteps,
                                               std::string ConfMessage)
 {
                                               unsigned int TotalSteps,
                                               std::string ConfMessage)
 {

-   std::ostringstream status;
-   status << "pmconffile:" << PackageName
-          << ":"  << (StepsDone/float(TotalSteps)*100.0) 
-          << ":" << ConfMessage
-          << std::endl;
-   WriteToStatusFd(status.str());
+   std::string status;
+   strprintf(status, "pmconffile:%s:%.4f:%s\n", PackageName.c_str(),
+        (StepsDone/float(TotalSteps)*100.0), ConfMessage.c_str());
+   WriteToStatusFd(std::move(status));

 }
 
 
 }
 
 


@@ -121,12 +129,10 @@ bool PackageManagerProgressFd::StatusChanged(std::string PackageName,
    StepsTotal = xTotalSteps;
 
    // build the status str
    StepsTotal = xTotalSteps;
 
    // build the status str

-   std::ostringstream status;
-   status << "pmstatus:" << StringSplit(PackageName, ":")[0]
-          << ":"  << (StepsDone/float(StepsTotal)*100.0) 
-          << ":" << pkg_action
-          << std::endl;
-   WriteToStatusFd(status.str());
+   std::string status;
+   strprintf(status, "pmstatus:%s:%.4f:%s\n", StringSplit(PackageName, ":")[0].c_str(),
+        (StepsDone/float(StepsTotal)*100.0), pkg_action.c_str());
+   WriteToStatusFd(std::move(status));

 
    if(_config->FindB("Debug::APT::Progress::PackageManagerFd", false) == true)
       std::cerr << "progress: " << PackageName << " " << xStepsDone
 
    if(_config->FindB("Debug::APT::Progress::PackageManagerFd", false) == true)
       std::cerr << "progress: " << PackageName << " " << xStepsDone


@@ -139,10 +145,11 @@ bool PackageManagerProgressFd::StatusChanged(std::string PackageName,
 
 
 PackageManagerProgressDeb822Fd::PackageManagerProgressDeb822Fd(int progress_fd)
 
 
 PackageManagerProgressDeb822Fd::PackageManagerProgressDeb822Fd(int progress_fd)

-   : StepsDone(0), StepsTotal(1)
+   : d(NULL), StepsDone(0), StepsTotal(1)

 {
    OutStatusFd = progress_fd;
 }
 {
    OutStatusFd = progress_fd;
 }

+PackageManagerProgressDeb822Fd::~PackageManagerProgressDeb822Fd() {}

 
 void PackageManagerProgressDeb822Fd::WriteToStatusFd(std::string s)
 {
 
 void PackageManagerProgressDeb822Fd::WriteToStatusFd(std::string s)
 {


@@ -156,15 +163,13 @@ void PackageManagerProgressDeb822Fd::StartDpkg()
    fcntl(OutStatusFd,F_SETFD,FD_CLOEXEC); 
 
    // send status information that we are about to fork dpkg
    fcntl(OutStatusFd,F_SETFD,FD_CLOEXEC); 
 
    // send status information that we are about to fork dpkg

-   std::ostringstream status;
-   status << "Status: " << "progress" << std::endl
-          << "Percent: " << (StepsDone/float(StepsTotal)*100.0) << std::endl
-          << "Message: " << _("Running dpkg") << std::endl
-          << std::endl;
-   WriteToStatusFd(status.str());
+   std::string status;
+   strprintf(status, "Status: %s\nPercent: %.4f\nMessage: %s\n\n", "progress",
+        (StepsDone/float(StepsTotal)*100.0), _("Running dpkg"));
+   WriteToStatusFd(std::move(status));

 }
 
 }
 

-void PackageManagerProgressDeb822Fd::Stop()
+APT_CONST void PackageManagerProgressDeb822Fd::Stop()

 {
 }
 
 {
 }
 


@@ -173,13 +178,10 @@ void PackageManagerProgressDeb822Fd::Error(std::string PackageName,
                                      unsigned int TotalSteps,
                                      std::string ErrorMessage)
 {
                                      unsigned int TotalSteps,
                                      std::string ErrorMessage)
 {

-   std::ostringstream status;
-   status << "Status: " << "Error" << std::endl
-          << "Package:" << PackageName << std::endl
-          << "Percent: "  << (StepsDone/float(TotalSteps)*100.0) << std::endl
-          << "Message: " << ErrorMessage << std::endl
-          << std::endl;
-   WriteToStatusFd(status.str());
+   std::string status;
+   strprintf(status, "Status: %s\nPackage: %s\nPercent: %.4f\nMessage: %s\n\n", "Error",
+        PackageName.c_str(), (StepsDone/float(TotalSteps)*100.0), ErrorMessage.c_str());
+   WriteToStatusFd(std::move(status));

 }
 
 void PackageManagerProgressDeb822Fd::ConffilePrompt(std::string PackageName,
 }
 
 void PackageManagerProgressDeb822Fd::ConffilePrompt(std::string PackageName,


@@ -187,13 +189,10 @@ void PackageManagerProgressDeb822Fd::ConffilePrompt(std::string PackageName,
                                               unsigned int TotalSteps,
                                               std::string ConfMessage)
 {
                                               unsigned int TotalSteps,
                                               std::string ConfMessage)
 {

-   std::ostringstream status;
-   status << "Status: " << "ConfFile" << std::endl
-          << "Package:" << PackageName << std::endl
-          << "Percent: "  << (StepsDone/float(TotalSteps)*100.0) << std::endl
-          << "Message: " << ConfMessage << std::endl
-          << std::endl;
-   WriteToStatusFd(status.str());
+   std::string status;
+   strprintf(status, "Status: %s\nPackage: %s\nPercent: %.4f\nMessage: %s\n\n", "ConfFile",
+        PackageName.c_str(), (StepsDone/float(TotalSteps)*100.0), ConfMessage.c_str());
+   WriteToStatusFd(std::move(status));

 }
 
 
 }
 
 


@@ -205,62 +204,107 @@ bool PackageManagerProgressDeb822Fd::StatusChanged(std::string PackageName,
    StepsDone = xStepsDone;
    StepsTotal = xTotalSteps;
 
    StepsDone = xStepsDone;
    StepsTotal = xTotalSteps;
 

-   // build the status str
-   std::ostringstream status;
-   status << "Status: " << "progress" << std::endl
-          << "Package: " << PackageName << std::endl
-          << "Percent: "  << (StepsDone/float(StepsTotal)*100.0) << std::endl
-          << "Message: " << message << std::endl
-          << std::endl;
-   WriteToStatusFd(status.str());
-
+   std::string status;
+   strprintf(status, "Status: %s\nPackage: %s\nPercent: %.4f\nMessage: %s\n\n", "progress",
+        PackageName.c_str(), (StepsDone/float(StepsTotal)*100.0), message.c_str());
+   WriteToStatusFd(std::move(status));

    return true;
 }
 
 
    return true;
 }
 
 

+PackageManagerFancy::PackageManagerFancy()
+   : d(NULL), child_pty(-1)
+{
+   // setup terminal size
+   old_SIGWINCH = signal(SIGWINCH, PackageManagerFancy::staticSIGWINCH);
+   instances.push_back(this);
+}
+std::vector<PackageManagerFancy*> PackageManagerFancy::instances;
+
+PackageManagerFancy::~PackageManagerFancy()
+{
+   instances.erase(find(instances.begin(), instances.end(), this));
+   signal(SIGWINCH, old_SIGWINCH);
+}
+
+void PackageManagerFancy::staticSIGWINCH(int signum)
+{
+   std::vector<PackageManagerFancy *>::const_iterator I;
+   for(I = instances.begin(); I != instances.end(); ++I)
+      (*I)->HandleSIGWINCH(signum);
+}
+
+PackageManagerFancy::TermSize
+PackageManagerFancy::GetTerminalSize()
+{
+   struct winsize win;
+   PackageManagerFancy::TermSize s = { 0, 0 };
+
+   // FIXME: get from "child_pty" instead?
+   if(ioctl(STDOUT_FILENO, TIOCGWINSZ, (char *)&win) != 0)
+      return s;
+
+   if(_config->FindB("Debug::InstallProgress::Fancy", false) == true)
+      std::cerr << "GetTerminalSize: " << win.ws_row << " x " << win.ws_col << std::endl;
+
+   s.rows = win.ws_row;
+   s.columns = win.ws_col;
+   return s;
+}
+

 void PackageManagerFancy::SetupTerminalScrollArea(int nr_rows)
 {
 void PackageManagerFancy::SetupTerminalScrollArea(int nr_rows)
 {

+     if(_config->FindB("Debug::InstallProgress::Fancy", false) == true)
+        std::cerr << "SetupTerminalScrollArea: " << nr_rows << std::endl;
+
+     if (unlikely(nr_rows <= 1))
+       return;
+

      // scroll down a bit to avoid visual glitch when the screen
      // area shrinks by one row
      std::cout << "\n";
          
      // save cursor
      // scroll down a bit to avoid visual glitch when the screen
      // area shrinks by one row
      std::cout << "\n";
          
      // save cursor

-     std::cout << "\033[s";
+     std::cout << "\0337";

          
      // set scroll region (this will place the cursor in the top left)
          
      // set scroll region (this will place the cursor in the top left)

-     std::cout << "\033[1;" << nr_rows - 1 << "r";
+     std::cout << "\033[0;" << std::to_string(nr_rows - 1) << "r";

             
      // restore cursor but ensure its inside the scrolling area
             
      // restore cursor but ensure its inside the scrolling area

-     std::cout << "\033[u";
+     std::cout << "\0338";

      static const char *move_cursor_up = "\033[1A";
      std::cout << move_cursor_up;
 
      static const char *move_cursor_up = "\033[1A";
      std::cout << move_cursor_up;
 

-     // setup env for (hopefully!) ncurses
-     string s;
-     strprintf(s, "%i", nr_rows);
-     setenv("LINES", s.c_str(), 1);
-
+     // ensure its flushed

      std::flush(std::cout);
      std::flush(std::cout);

+
+     // setup tty size to ensure xterm/linux console are working properly too
+     // see bug #731738
+     struct winsize win;
+     if (ioctl(child_pty, TIOCGWINSZ, (char *)&win) != -1)
+     {
+       win.ws_row = nr_rows - 1;
+       ioctl(child_pty, TIOCSWINSZ, (char *)&win);
+     }

 }
 
 }
 

-PackageManagerFancy::PackageManagerFancy()
-   : nr_terminal_rows(-1)
+void PackageManagerFancy::HandleSIGWINCH(int)

 {
 {

-   struct winsize win;
-   if(ioctl(STDOUT_FILENO, TIOCGWINSZ, (char *)&win) == 0)
-   {
-      nr_terminal_rows = win.ws_row;
-   }
+   int const nr_terminal_rows = GetTerminalSize().rows;
+   SetupTerminalScrollArea(nr_terminal_rows);
+   DrawStatusLine();

 }
 
 }
 

-void PackageManagerFancy::Start()
+void PackageManagerFancy::Start(int a_child_pty)

 {
 {

-   if (nr_terminal_rows > 0)
-      SetupTerminalScrollArea(nr_terminal_rows);
+   child_pty = a_child_pty;
+   int const nr_terminal_rows = GetTerminalSize().rows;
+   SetupTerminalScrollArea(nr_terminal_rows);

 }
 
 void PackageManagerFancy::Stop()
 {
 }
 
 void PackageManagerFancy::Stop()
 {

+   int const nr_terminal_rows = GetTerminalSize().rows;

    if (nr_terminal_rows > 0)
    {
       SetupTerminalScrollArea(nr_terminal_rows + 1);
    if (nr_terminal_rows > 0)
    {
       SetupTerminalScrollArea(nr_terminal_rows + 1);


@@ -268,7 +312,29 @@ void PackageManagerFancy::Stop()
       // override the progress line (sledgehammer)
       static const char* clear_screen_below_cursor = "\033[J";
       std::cout << clear_screen_below_cursor;
       // override the progress line (sledgehammer)
       static const char* clear_screen_below_cursor = "\033[J";
       std::cout << clear_screen_below_cursor;

+      std::flush(std::cout);

    }
    }

+   child_pty = -1;
+}
+
+std::string 
+PackageManagerFancy::GetTextProgressStr(float Percent, int OutputSize)
+{
+   std::string output;
+   int i;
+   
+   // should we raise a exception here instead?
+   if (Percent < 0.0 || Percent > 1.0 || OutputSize < 3)
+      return output;
+   
+   int BarSize = OutputSize - 2; // bar without the leading "[" and trailing "]"
+   output += "[";
+   for(i=0; i < BarSize*Percent; i++)
+      output += "#";
+   for (/*nothing*/; i < BarSize; i++)
+      output += ".";
+   output += "]";
+   return output;

 }
 
 bool PackageManagerFancy::StatusChanged(std::string PackageName, 
 }
 
 bool PackageManagerFancy::StatusChanged(std::string PackageName, 


@@ -280,27 +346,53 @@ bool PackageManagerFancy::StatusChanged(std::string PackageName,
           HumanReadableAction))
       return false;
 
           HumanReadableAction))
       return false;
 

-   int row = nr_terminal_rows;
+   return DrawStatusLine();
+}
+bool PackageManagerFancy::DrawStatusLine()
+{
+   PackageManagerFancy::TermSize const size = GetTerminalSize();
+   if (unlikely(size.rows < 1 || size.columns < 1))
+      return false;
+
+   static std::string save_cursor = "\0337";
+   static std::string restore_cursor = "\0338";
+
+   // green
+   static std::string set_bg_color = DeQuoteString(
+      _config->Find("Dpkg::Progress-Fancy::Progress-fg", "%1b[42m"));
+   // black
+   static std::string set_fg_color = DeQuoteString(
+      _config->Find("Dpkg::Progress-Fancy::Progress-bg", "%1b[30m"));
+
+   static std::string restore_bg =  "\033[49m";
+   static std::string restore_fg = "\033[39m";

 
 

-   static string save_cursor = "\033[s";
-   static string restore_cursor = "\033[u";
-   
-   static string set_bg_color = "\033[42m"; // green
-   static string set_fg_color = "\033[30m"; // black
-   
-   static string restore_bg =  "\033[49m";
-   static string restore_fg = "\033[39m";
-   

    std::cout << save_cursor
       // move cursor position to last row
    std::cout << save_cursor
       // move cursor position to last row

-             << "\033[" << row << ";0f" 
+             << "\033[" << std::to_string(size.rows) << ";0f"

              << set_bg_color
              << set_fg_color
              << progress_str
              << set_bg_color
              << set_fg_color
              << progress_str

-             << restore_cursor

              << restore_bg
              << restore_fg;
    std::flush(std::cout);
              << restore_bg
              << restore_fg;
    std::flush(std::cout);

+
+   // draw text progress bar
+   if (_config->FindB("Dpkg::Progress-Fancy::Progress-Bar", true))
+   {
+      int padding = 4;
+      float progressbar_size = size.columns - padding - progress_str.size();
+      float current_percent = percentage / 100.0;
+      std::cout << " " 
+                << GetTextProgressStr(current_percent, progressbar_size)
+                << " ";
+      std::flush(std::cout);
+   }
+
+   // restore
+   std::cout << restore_cursor;
+   std::flush(std::cout);
+

    last_reported_progress = percentage;
 
    return true;
    last_reported_progress = percentage;
 
    return true;


@@ -322,7 +414,11 @@ bool PackageManagerText::StatusChanged(std::string PackageName,
    return true;
 }
 
    return true;
 }
 

+PackageManagerText::PackageManagerText() : PackageManager(), d(NULL) {}
+PackageManagerText::~PackageManagerText() {}
+
+

 
 
 
 

-}; // namespace progress
-}; // namespace apt
+} // namespace progress
+} // namespace apt