apt-pkg/install-progress.cc

   1 #include <config.h>
   2
   3 #include <apt-pkg/configuration.h>
   4 #include <apt-pkg/fileutl.h>
   5 #include <apt-pkg/strutl.h>
   6 #include <apt-pkg/install-progress.h>
   7
   8 #include <signal.h>
   9 #include <unistd.h>
  10 #include <iostream>
  11 #include <vector>
  12 #include <sys/ioctl.h>
  13 #include <fcntl.h>
  14 #include <algorithm>
  15 #include <stdio.h>
  16 #include <sstream>
  17
  18 #include <apti18n.h>
  19
  20 namespace APT {
  21 namespace Progress {
  22
  23 PackageManager::PackageManager() : d(NULL), percentage(0.0), last_reported_progress(-1) {}
  24 PackageManager::~PackageManager() {}
  25
  26 /* Return a APT::Progress::PackageManager based on the global
  27  * apt configuration (i.e. APT::Status-Fd and APT::Status-deb822-Fd)
  28  */
  29 PackageManager* PackageManagerProgressFactory()
  30 {
  31    // select the right progress
  32    int status_fd = _config->FindI("APT::Status-Fd", -1);
  33    int status_deb822_fd = _config->FindI("APT::Status-deb822-Fd", -1);
  34
  35    APT::Progress::PackageManager *progress = NULL;
  36    if (status_deb822_fd > 0)
  37       progress = new APT::Progress::PackageManagerProgressDeb822Fd(
  38          status_deb822_fd);
  39    else if (status_fd > 0)
  40       progress = new APT::Progress::PackageManagerProgressFd(status_fd);
  41    else if(_config->FindB("Dpkg::Progress-Fancy", false) == true)
  42       progress = new APT::Progress::PackageManagerFancy();
  43    else if (_config->FindB("Dpkg::Progress",
  44                            _config->FindB("DpkgPM::Progress", false)) == true)
  45       progress = new APT::Progress::PackageManagerText();
  46    else
  47       progress = new APT::Progress::PackageManager();
  48    return progress;
  49 }
  50
  51 bool PackageManager::StatusChanged(std::string /*PackageName*/,
  52                                    unsigned int StepsDone,
  53                                    unsigned int TotalSteps,
  54                                    std::string /*HumanReadableAction*/)
  55 {
  56    int reporting_steps = _config->FindI("DpkgPM::Reporting-Steps", 1);
  57    percentage = StepsDone/(float)TotalSteps * 100.0;
  58    strprintf(progress_str, _("Progress: [%3i%%]"), (int)percentage);
  59
  60    if(percentage < (last_reported_progress + reporting_steps))
  61       return false;
  62
  63    return true;
  64 }
  65
  66 PackageManagerProgressFd::PackageManagerProgressFd(int progress_fd)
  67    : d(NULL), StepsDone(0), StepsTotal(1)
  68 {
  69    OutStatusFd = progress_fd;
  70 }
  71 PackageManagerProgressFd::~PackageManagerProgressFd() {}
  72
  73 void PackageManagerProgressFd::WriteToStatusFd(std::string s)
  74 {
  75    if(OutStatusFd <= 0)
  76       return;
  77    FileFd::Write(OutStatusFd, s.c_str(), s.size());
  78 }
  79
  80 void PackageManagerProgressFd::StartDpkg()
  81 {
  82    if(OutStatusFd <= 0)
  83       return;
  84
  85    // FIXME: use SetCloseExec here once it taught about throwing
  86    //        exceptions instead of doing _exit(100) on failure
  87    fcntl(OutStatusFd,F_SETFD,FD_CLOEXEC);
  88
  89    // send status information that we are about to fork dpkg
  90    std::ostringstream status;
  91    status << "pmstatus:dpkg-exec:"
  92           << (StepsDone/float(StepsTotal)*100.0)
  93           << ":" << _("Running dpkg")
  94           << std::endl;
  95    WriteToStatusFd(status.str());
  96 }
  97
  98 APT_CONST void PackageManagerProgressFd::Stop()
  99 {
 100 }
 101
 102 void PackageManagerProgressFd::Error(std::string PackageName,
 103                                      unsigned int StepsDone,
 104                                      unsigned int TotalSteps,
 105                                      std::string ErrorMessage)
 106 {
 107    std::ostringstream status;
 108    status << "pmerror:" << PackageName
 109           << ":"  << (StepsDone/float(TotalSteps)*100.0)
 110           << ":" << ErrorMessage
 111           << std::endl;
 112    WriteToStatusFd(status.str());
 113 }
 114
 115 void PackageManagerProgressFd::ConffilePrompt(std::string PackageName,
 116                                               unsigned int StepsDone,
 117                                               unsigned int TotalSteps,
 118                                               std::string ConfMessage)
 119 {
 120    std::ostringstream status;
 121    status << "pmconffile:" << PackageName
 122           << ":"  << (StepsDone/float(TotalSteps)*100.0)
 123           << ":" << ConfMessage
 124           << std::endl;
 125    WriteToStatusFd(status.str());
 126 }
 127
 128
 129 bool PackageManagerProgressFd::StatusChanged(std::string PackageName,
 130                                              unsigned int xStepsDone,
 131                                              unsigned int xTotalSteps,
 132                                              std::string pkg_action)
 133 {
 134    StepsDone = xStepsDone;
 135    StepsTotal = xTotalSteps;
 136
 137    // build the status str
 138    std::ostringstream status;
 139    status << "pmstatus:" << StringSplit(PackageName, ":")[0]
 140           << ":"  << (StepsDone/float(StepsTotal)*100.0)
 141           << ":" << pkg_action
 142           << std::endl;
 143    WriteToStatusFd(status.str());
 144
 145    if(_config->FindB("Debug::APT::Progress::PackageManagerFd", false) == true)
 146       std::cerr << "progress: " << PackageName << " " << xStepsDone
 147                 << " " << xTotalSteps << " " << pkg_action
 148                 << std::endl;
 149
 150
 151    return true;
 152 }
 153
 154
 155 PackageManagerProgressDeb822Fd::PackageManagerProgressDeb822Fd(int progress_fd)
 156    : d(NULL), StepsDone(0), StepsTotal(1)
 157 {
 158    OutStatusFd = progress_fd;
 159 }
 160 PackageManagerProgressDeb822Fd::~PackageManagerProgressDeb822Fd() {}
 161
 162 void PackageManagerProgressDeb822Fd::WriteToStatusFd(std::string s)
 163 {
 164    FileFd::Write(OutStatusFd, s.c_str(), s.size());
 165 }
 166
 167 void PackageManagerProgressDeb822Fd::StartDpkg()
 168 {
 169    // FIXME: use SetCloseExec here once it taught about throwing
 170    //        exceptions instead of doing _exit(100) on failure
 171    fcntl(OutStatusFd,F_SETFD,FD_CLOEXEC);
 172
 173    // send status information that we are about to fork dpkg
 174    std::ostringstream status;
 175    status << "Status: " << "progress" << std::endl
 176           << "Percent: " << (StepsDone/float(StepsTotal)*100.0) << std::endl
 177           << "Message: " << _("Running dpkg") << std::endl
 178           << std::endl;
 179    WriteToStatusFd(status.str());
 180 }
 181
 182 APT_CONST void PackageManagerProgressDeb822Fd::Stop()
 183 {
 184 }
 185
 186 void PackageManagerProgressDeb822Fd::Error(std::string PackageName,
 187                                      unsigned int StepsDone,
 188                                      unsigned int TotalSteps,
 189                                      std::string ErrorMessage)
 190 {
 191    std::ostringstream status;
 192    status << "Status: " << "Error" << std::endl
 193           << "Package:" << PackageName << std::endl
 194           << "Percent: "  << (StepsDone/float(TotalSteps)*100.0) << std::endl
 195           << "Message: " << ErrorMessage << std::endl
 196           << std::endl;
 197    WriteToStatusFd(status.str());
 198 }
 199
 200 void PackageManagerProgressDeb822Fd::ConffilePrompt(std::string PackageName,
 201                                               unsigned int StepsDone,
 202                                               unsigned int TotalSteps,
 203                                               std::string ConfMessage)
 204 {
 205    std::ostringstream status;
 206    status << "Status: " << "ConfFile" << std::endl
 207           << "Package:" << PackageName << std::endl
 208           << "Percent: "  << (StepsDone/float(TotalSteps)*100.0) << std::endl
 209           << "Message: " << ConfMessage << std::endl
 210           << std::endl;
 211    WriteToStatusFd(status.str());
 212 }
 213
 214
 215 bool PackageManagerProgressDeb822Fd::StatusChanged(std::string PackageName,
 216                                              unsigned int xStepsDone,
 217                                              unsigned int xTotalSteps,
 218                                              std::string message)
 219 {
 220    StepsDone = xStepsDone;
 221    StepsTotal = xTotalSteps;
 222
 223    // build the status str
 224    std::ostringstream status;
 225    status << "Status: " << "progress" << std::endl
 226           << "Package: " << PackageName << std::endl
 227           << "Percent: "  << (StepsDone/float(StepsTotal)*100.0) << std::endl
 228           << "Message: " << message << std::endl
 229           << std::endl;
 230    WriteToStatusFd(status.str());
 231
 232    return true;
 233 }
 234
 235
 236 PackageManagerFancy::PackageManagerFancy()
 237    : d(NULL), child_pty(-1)
 238 {
 239    // setup terminal size
 240    old_SIGWINCH = signal(SIGWINCH, PackageManagerFancy::staticSIGWINCH);
 241    instances.push_back(this);
 242 }
 243 std::vector<PackageManagerFancy*> PackageManagerFancy::instances;
 244
 245 PackageManagerFancy::~PackageManagerFancy()
 246 {
 247    instances.erase(find(instances.begin(), instances.end(), this));
 248    signal(SIGWINCH, old_SIGWINCH);
 249 }
 250
 251 void PackageManagerFancy::staticSIGWINCH(int signum)
 252 {
 253    std::vector<PackageManagerFancy *>::const_iterator I;
 254    for(I = instances.begin(); I != instances.end(); ++I)
 255       (*I)->HandleSIGWINCH(signum);
 256 }
 257
 258 PackageManagerFancy::TermSize
 259 PackageManagerFancy::GetTerminalSize()
 260 {
 261    struct winsize win;
 262    PackageManagerFancy::TermSize s = { 0, 0 };
 263
 264    // FIXME: get from "child_pty" instead?
 265    if(ioctl(STDOUT_FILENO, TIOCGWINSZ, (char *)&win) != 0)
 266       return s;
 267
 268    if(_config->FindB("Debug::InstallProgress::Fancy", false) == true)
 269       std::cerr << "GetTerminalSize: " << win.ws_row << " x " << win.ws_col << std::endl;
 270
 271    s.rows = win.ws_row;
 272    s.columns = win.ws_col;
 273    return s;
 274 }
 275
 276 void PackageManagerFancy::SetupTerminalScrollArea(int nr_rows)
 277 {
 278      if(_config->FindB("Debug::InstallProgress::Fancy", false) == true)
 279         std::cerr << "SetupTerminalScrollArea: " << nr_rows << std::endl;
 280
 281      if (unlikely(nr_rows <= 1))
 282         return;
 283
 284      // scroll down a bit to avoid visual glitch when the screen
 285      // area shrinks by one row
 286      std::cout << "\n";
 287
 288      // save cursor
 289      std::cout << "\0337";
 290
 291      // set scroll region (this will place the cursor in the top left)
 292      std::cout << "\033[0;" << nr_rows - 1 << "r";
 293
 294      // restore cursor but ensure its inside the scrolling area
 295      std::cout << "\0338";
 296      static const char *move_cursor_up = "\033[1A";
 297      std::cout << move_cursor_up;
 298
 299      // ensure its flushed
 300      std::flush(std::cout);
 301
 302      // setup tty size to ensure xterm/linux console are working properly too
 303      // see bug #731738
 304      struct winsize win;
 305      if (ioctl(child_pty, TIOCGWINSZ, (char *)&win) != -1)
 306      {
 307         win.ws_row = nr_rows - 1;
 308         ioctl(child_pty, TIOCSWINSZ, (char *)&win);
 309      }
 310 }
 311
 312 void PackageManagerFancy::HandleSIGWINCH(int)
 313 {
 314    int const nr_terminal_rows = GetTerminalSize().rows;
 315    SetupTerminalScrollArea(nr_terminal_rows);
 316    DrawStatusLine();
 317 }
 318
 319 void PackageManagerFancy::Start(int a_child_pty)
 320 {
 321    child_pty = a_child_pty;
 322    int const nr_terminal_rows = GetTerminalSize().rows;
 323    SetupTerminalScrollArea(nr_terminal_rows);
 324 }
 325
 326 void PackageManagerFancy::Stop()
 327 {
 328    int const nr_terminal_rows = GetTerminalSize().rows;
 329    if (nr_terminal_rows > 0)
 330    {
 331       SetupTerminalScrollArea(nr_terminal_rows + 1);
 332
 333       // override the progress line (sledgehammer)
 334       static const char* clear_screen_below_cursor = "\033[J";
 335       std::cout << clear_screen_below_cursor;
 336       std::flush(std::cout);
 337    }
 338    child_pty = -1;
 339 }
 340
 341 std::string
 342 PackageManagerFancy::GetTextProgressStr(float Percent, int OutputSize)
 343 {
 344    std::string output;
 345    int i;
 346
 347    // should we raise a exception here instead?
 348    if (Percent < 0.0 || Percent > 1.0 || OutputSize < 3)
 349       return output;
 350
 351    int BarSize = OutputSize - 2; // bar without the leading "[" and trailing "]"
 352    output += "[";
 353    for(i=0; i < BarSize*Percent; i++)
 354       output += "#";
 355    for (/*nothing*/; i < BarSize; i++)
 356       output += ".";
 357    output += "]";
 358    return output;
 359 }
 360
 361 bool PackageManagerFancy::StatusChanged(std::string PackageName,
 362                                         unsigned int StepsDone,
 363                                         unsigned int TotalSteps,
 364                                         std::string HumanReadableAction)
 365 {
 366    if (!PackageManager::StatusChanged(PackageName, StepsDone, TotalSteps,
 367           HumanReadableAction))
 368       return false;
 369
 370    return DrawStatusLine();
 371 }
 372 bool PackageManagerFancy::DrawStatusLine()
 373 {
 374    PackageManagerFancy::TermSize const size = GetTerminalSize();
 375    if (unlikely(size.rows < 1 || size.columns < 1))
 376       return false;
 377
 378    static std::string save_cursor = "\0337";
 379    static std::string restore_cursor = "\0338";
 380
 381    // green
 382    static std::string set_bg_color = DeQuoteString(
 383       _config->Find("Dpkg::Progress-Fancy::Progress-fg", "%1b[42m"));
 384    // black
 385    static std::string set_fg_color = DeQuoteString(
 386       _config->Find("Dpkg::Progress-Fancy::Progress-bg", "%1b[30m"));
 387
 388    static std::string restore_bg =  "\033[49m";
 389    static std::string restore_fg = "\033[39m";
 390
 391    std::cout << save_cursor
 392       // move cursor position to last row
 393              << "\033[" << size.rows << ";0f"
 394              << set_bg_color
 395              << set_fg_color
 396              << progress_str
 397              << restore_bg
 398              << restore_fg;
 399    std::flush(std::cout);
 400
 401    // draw text progress bar
 402    if (_config->FindB("Dpkg::Progress-Fancy::Progress-Bar", true))
 403    {
 404       int padding = 4;
 405       float progressbar_size = size.columns - padding - progress_str.size();
 406       float current_percent = percentage / 100.0;
 407       std::cout << " "
 408                 << GetTextProgressStr(current_percent, progressbar_size)
 409                 << " ";
 410       std::flush(std::cout);
 411    }
 412
 413    // restore
 414    std::cout << restore_cursor;
 415    std::flush(std::cout);
 416
 417    last_reported_progress = percentage;
 418
 419    return true;
 420 }
 421
 422 bool PackageManagerText::StatusChanged(std::string PackageName,
 423                                        unsigned int StepsDone,
 424                                        unsigned int TotalSteps,
 425                                        std::string HumanReadableAction)
 426 {
 427    if (!PackageManager::StatusChanged(PackageName, StepsDone, TotalSteps, HumanReadableAction))
 428       return false;
 429
 430    std::cout << progress_str << "\r\n";
 431    std::flush(std::cout);
 432
 433    last_reported_progress = percentage;
 434
 435    return true;
 436 }
 437
 438 PackageManagerText::PackageManagerText() : PackageManager(), d(NULL) {}
 439 PackageManagerText::~PackageManagerText() {}
 440
 441
 442
 443
 444 } // namespace progress
 445 } // namespace apt