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