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