add volatile sources support in libapt-pkg

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

diff --git a/apt-pkg/install-progress.cc b/apt-pkg/install-progress.cc
index a9146f27d600ac1f1748a172fa193fc1a7de136a..ff3f652e5613c19262a507db341042ab9ea2be11 100644 (file)
--- a/apt-pkg/install-progress.cc
+++ b/apt-pkg/install-progress.cc
@@ -1,18 +1,32 @@
+#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 <string>
+#include <vector>

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

+#include <algorithm>
+#include <stdio.h>
+
+#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 +49,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 +65,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)
 {


@@ -63,7 +78,7 @@ void PackageManagerProgressFd::WriteToStatusFd(std::string s)
    FileFd::Write(OutStatusFd, s.c_str(), s.size());   
 }
 
    FileFd::Write(OutStatusFd, s.c_str(), s.size());   
 }
 

-void PackageManagerProgressFd::Start()
+void PackageManagerProgressFd::StartDpkg()

 {
    if(OutStatusFd <= 0)
       return;
 {
    if(OutStatusFd <= 0)
       return;


@@ -81,10 +96,8 @@ void PackageManagerProgressFd::Start()
    WriteToStatusFd(status.str());
 }
 
    WriteToStatusFd(status.str());
 }
 

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

 {
 {

-   // clear the Keep-Fd again
-   _config->Clear("APT::Keep-Fds", OutStatusFd);

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


@@ -141,17 +154,18 @@ 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)
 {
    FileFd::Write(OutStatusFd, s.c_str(), s.size());   
 }
 
 
 void PackageManagerProgressDeb822Fd::WriteToStatusFd(std::string s)
 {
    FileFd::Write(OutStatusFd, s.c_str(), s.size());   
 }
 

-void PackageManagerProgressDeb822Fd::Start()
+void PackageManagerProgressDeb822Fd::StartDpkg()

 {
    // FIXME: use SetCloseExec here once it taught about throwing
    //        exceptions instead of doing _exit(100) on failure
 {
    // FIXME: use SetCloseExec here once it taught about throwing
    //        exceptions instead of doing _exit(100) on failure


@@ -166,10 +180,8 @@ void PackageManagerProgressDeb822Fd::Start()
    WriteToStatusFd(status.str());
 }
 
    WriteToStatusFd(status.str());
 }
 

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

 {
 {

-   // clear the Keep-Fd again
-   _config->Clear("APT::Keep-Fds", OutStatusFd);

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


@@ -222,8 +234,54 @@ bool PackageManagerProgressDeb822Fd::StatusChanged(std::string PackageName,
 }
 
 
 }
 
 

+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";
      // scroll down a bit to avoid visual glitch when the screen
      // area shrinks by one row
      std::cout << "\n";


@@ -232,34 +290,43 @@ void PackageManagerFancy::SetupTerminalScrollArea(int nr_rows)
      std::cout << "\033[s";
          
      // set scroll region (this will place the cursor in the top left)
      std::cout << "\033[s";
          
      // set scroll region (this will place the cursor in the top left)

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

             
      // restore cursor but ensure its inside the scrolling area
      std::cout << "\033[u";
      static const char *move_cursor_up = "\033[1A";
      std::cout << move_cursor_up;
 
             
      // restore cursor but ensure its inside the scrolling area
      std::cout << "\033[u";
      static const char *move_cursor_up = "\033[1A";
      std::cout << move_cursor_up;
 

+     // 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,6 +335,27 @@ void PackageManagerFancy::Stop()
       static const char* clear_screen_below_cursor = "\033[J";
       std::cout << clear_screen_below_cursor;
    }
       static const char* clear_screen_below_cursor = "\033[J";
       std::cout << clear_screen_below_cursor;
    }

+   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, 


@@ -279,27 +367,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 = "\033[s";
+   static std::string restore_cursor = "\033[u";
+
+   // 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[" << 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;


@@ -321,7 +435,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