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

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

#include <apt-private/private-progress.h>

#include <apti18n.h>

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

namespace APT {
namespace Progress {

bool PackageManager::StatusChanged(std::string PackageName, 
                                   unsigned int StepsDone,
                                   unsigned int TotalSteps,
                                   std::string HumanReadableAction)
{
   int reporting_steps = _config->FindI("DpkgPM::Reporting-Steps", 1);
   percentage = StepsDone/(float)TotalSteps * 100.0;
   strprintf(progress_str, _("Progress: [%3i%%]"), (int)percentage);

   if(percentage < (last_reported_progress + reporting_steps))
      return false;

   return true;
}

PackageManagerProgressFd::PackageManagerProgressFd(int progress_fd)
   : StepsDone(0), StepsTotal(1)
{
   OutStatusFd = progress_fd;
}

void PackageManagerProgressFd::WriteToStatusFd(std::string s)
{
   if(OutStatusFd <= 0)
      return;
   FileFd::Write(OutStatusFd, s.c_str(), s.size());   
}

void PackageManagerProgressFd::Start()
{
   if(OutStatusFd <= 0)
      return;

   // FIXME: use SetCloseExec here once it taught about throwing
   //        exceptions instead of doing _exit(100) on failure
   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());
}

void PackageManagerProgressFd::Stop()
{
   // clear the Keep-Fd again
   _config->Clear("APT::Keep-Fds", OutStatusFd);
}

void PackageManagerProgressFd::Error(std::string PackageName,
                                     unsigned int StepsDone,
                                     unsigned int TotalSteps,
                                     std::string ErrorMessage)
{
   std::ostringstream status;
   status << "pmerror:" << PackageName
          << ":"  << (StepsDone/float(TotalSteps)*100.0) 
          << ":" << ErrorMessage
          << std::endl;
   WriteToStatusFd(status.str());
}

void PackageManagerProgressFd::ConffilePrompt(std::string PackageName,
                                              unsigned int StepsDone,
                                              unsigned int TotalSteps,
                                              std::string ConfMessage)
{
   std::ostringstream status;
   status << "pmconffile:" << PackageName
          << ":"  << (StepsDone/float(TotalSteps)*100.0) 
          << ":" << ConfMessage
          << std::endl;
   WriteToStatusFd(status.str());
}


bool PackageManagerProgressFd::StatusChanged(std::string PackageName, 
                                             unsigned int xStepsDone,
                                             unsigned int xTotalSteps,
                                             std::string pkg_action)
{
   StepsDone = xStepsDone;
   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());

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


   return true;
}


PackageManagerProgressDeb822Fd::PackageManagerProgressDeb822Fd(int progress_fd)
   : StepsDone(0), StepsTotal(1)
{
   OutStatusFd = progress_fd;
}

void PackageManagerProgressDeb822Fd::WriteToStatusFd(std::string s)
{
   FileFd::Write(OutStatusFd, s.c_str(), s.size());   
}

void PackageManagerProgressDeb822Fd::Start()
{
   // FIXME: use SetCloseExec here once it taught about throwing
   //        exceptions instead of doing _exit(100) on failure
   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());
}

void PackageManagerProgressDeb822Fd::Stop()
{
   // clear the Keep-Fd again
   _config->Clear("APT::Keep-Fds", OutStatusFd);
}

void PackageManagerProgressDeb822Fd::Error(std::string PackageName,
                                     unsigned int StepsDone,
                                     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());
}

void PackageManagerProgressDeb822Fd::ConffilePrompt(std::string PackageName,
                                              unsigned int StepsDone,
                                              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());
}


bool PackageManagerProgressDeb822Fd::StatusChanged(std::string PackageName, 
                                             unsigned int xStepsDone,
                                             unsigned int xTotalSteps,
                                             std::string message)
{
   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());

   return true;
}


void PackageManagerFancy::SetupTerminalScrollArea(int nr_rows)
{
     // 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";
         
     // set scroll region (this will place the cursor in the top left)
     std::cout << "\033[1;" << 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;

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

PackageManagerFancy::PackageManagerFancy()
   : nr_terminal_rows(-1)
{
   struct winsize win;
   if(ioctl(STDOUT_FILENO, TIOCGWINSZ, (char *)&win) == 0)
   {
      nr_terminal_rows = win.ws_row;
   }
}

void PackageManagerFancy::Start()
{
   if (nr_terminal_rows > 0)
      SetupTerminalScrollArea(nr_terminal_rows);
}

void PackageManagerFancy::Stop()
{
   if (nr_terminal_rows > 0)
   {
      SetupTerminalScrollArea(nr_terminal_rows + 1);

      // override the progress line (sledgehammer)
      static const char* clear_screen_below_cursor = "\033[J";
      std::cout << clear_screen_below_cursor;
   }
}

bool PackageManagerFancy::StatusChanged(std::string PackageName, 
                                        unsigned int StepsDone,
                                        unsigned int TotalSteps,
                                        std::string HumanReadableAction)
{
   if (!PackageManager::StatusChanged(PackageName, StepsDone, TotalSteps,
          HumanReadableAction))
      return false;

   int row = nr_terminal_rows;

   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
             << "\033[" << row << ";0f" 
             << set_bg_color
             << set_fg_color
             << progress_str
             << restore_cursor
             << restore_bg
             << restore_fg;
   std::flush(std::cout);
   last_reported_progress = percentage;

   return true;
}

bool PackageManagerText::StatusChanged(std::string PackageName, 
                                       unsigned int StepsDone,
                                       unsigned int TotalSteps,
                                       std::string HumanReadableAction)
{
   if (!PackageManager::StatusChanged(PackageName, StepsDone, TotalSteps, HumanReadableAction))
      return false;

   std::cout << progress_str << "\r\n";
   std::flush(std::cout);
                   
   last_reported_progress = percentage;

   return true;
}


}; // namespace progress
}; // namespace apt
Commit	Line	Data
e6ad8031 MV	1	#include <apt-pkg/configuration.h>
e6ad8031 MV	2	#include <apt-pkg/fileutl.h>
31f97d7b	3	#include <apt-pkg/strutl.h>
e6ad8031	4
c7ea1eba MV	5	#include <apt-private/private-progress.h>
c7ea1eba MV	6
6c5ae8ed	7	#include <apti18n.h>
31f97d7b MV	8
	9	#include <termios.h>
	10	#include <sys/ioctl.h>
e6ad8031	11	#include <sstream>
5e9458e2	12	#include <fcntl.h>
31f97d7b MV	13
	14	namespace APT {
	15	namespace Progress {
	16
6c5ae8ed	17	bool PackageManager::StatusChanged(std::string PackageName,
e6ad8031 MV	18	unsigned int StepsDone,
	19	unsigned int TotalSteps,
	20	std::string HumanReadableAction)
6c5ae8ed MV	21	{
	22	int reporting_steps = _config->FindI("DpkgPM::Reporting-Steps", 1);
	23	percentage = StepsDone/(float)TotalSteps * 100.0;
	24	strprintf(progress_str, _("Progress: [%3i%%]"), (int)percentage);
	25
	26	if(percentage < (last_reported_progress + reporting_steps))
	27	return false;
	28
	29	return true;
	30	}
	31
e6ad8031	32	PackageManagerProgressFd::PackageManagerProgressFd(int progress_fd)
65dbd5a1	33	: StepsDone(0), StepsTotal(1)
e6ad8031 MV	34	{
	35	OutStatusFd = progress_fd;
	36	}
	37
f9935b1c MV	38	void PackageManagerProgressFd::WriteToStatusFd(std::string s)
	39	{
	40	if(OutStatusFd <= 0)
	41	return;
	42	FileFd::Write(OutStatusFd, s.c_str(), s.size());
	43	}
	44
a22fdebf	45	void PackageManagerProgressFd::Start()
e6ad8031	46	{
5e9458e2 MV	47	if(OutStatusFd <= 0)
	48	return;
	49
	50	// FIXME: use SetCloseExec here once it taught about throwing
	51	// exceptions instead of doing _exit(100) on failure
	52	fcntl(OutStatusFd,F_SETFD,FD_CLOEXEC);
e6ad8031 MV	53
e6ad8031 MV	54	// send status information that we are about to fork dpkg
f9935b1c MV	55	std::ostringstream status;
	56	status << "pmstatus:dpkg-exec:"
	57	<< (StepsDone/float(StepsTotal)*100.0)
	58	<< ":" << _("Running dpkg")
	59	<< std::endl;
	60	WriteToStatusFd(status.str());
e6ad8031 MV	61	}
e6ad8031 MV	62
a22fdebf	63	void PackageManagerProgressFd::Stop()
e6ad8031 MV	64	{
	65	// clear the Keep-Fd again
	66	_config->Clear("APT::Keep-Fds", OutStatusFd);
	67	}
	68
	69	void PackageManagerProgressFd::Error(std::string PackageName,
	70	unsigned int StepsDone,
	71	unsigned int TotalSteps,
	72	std::string ErrorMessage)
	73	{
	74	std::ostringstream status;
	75	status << "pmerror:" << PackageName
	76	<< ":" << (StepsDone/float(TotalSteps)*100.0)
	77	<< ":" << ErrorMessage
	78	<< std::endl;
f9935b1c	79	WriteToStatusFd(status.str());
e6ad8031 MV	80	}
	81
	82	void PackageManagerProgressFd::ConffilePrompt(std::string PackageName,
	83	unsigned int StepsDone,
	84	unsigned int TotalSteps,
	85	std::string ConfMessage)
	86	{
	87	std::ostringstream status;
	88	status << "pmconffile:" << PackageName
	89	<< ":" << (StepsDone/float(TotalSteps)*100.0)
	90	<< ":" << ConfMessage
	91	<< std::endl;
f9935b1c	92	WriteToStatusFd(status.str());
e6ad8031 MV	93	}
	94
	95
	96	bool PackageManagerProgressFd::StatusChanged(std::string PackageName,
	97	unsigned int xStepsDone,
	98	unsigned int xTotalSteps,
	99	std::string pkg_action)
	100	{
	101	StepsDone = xStepsDone;
	102	StepsTotal = xTotalSteps;
	103
	104	// build the status str
	105	std::ostringstream status;
dd640f3c	106	status << "pmstatus:" << StringSplit(PackageName, ":")[0]
e6ad8031 MV	107	<< ":" << (StepsDone/float(StepsTotal)*100.0)
	108	<< ":" << pkg_action
	109	<< std::endl;
f9935b1c	110	WriteToStatusFd(status.str());
65dbd5a1 MV	111
	112	if(_config->FindB("Debug::APT::Progress::PackageManagerFd", false) == true)
	113	std::cerr << "progress: " << PackageName << " " << xStepsDone
	114	<< " " << xTotalSteps << " " << pkg_action
	115	<< std::endl;
	116
	117
e6ad8031 MV	118	return true;
	119	}
	120
c7ea1eba MV	121
	122	PackageManagerProgressDeb822Fd::PackageManagerProgressDeb822Fd(int progress_fd)
	123	: StepsDone(0), StepsTotal(1)
	124	{
	125	OutStatusFd = progress_fd;
	126	}
	127
	128	void PackageManagerProgressDeb822Fd::WriteToStatusFd(std::string s)
	129	{
	130	FileFd::Write(OutStatusFd, s.c_str(), s.size());
	131	}
	132
	133	void PackageManagerProgressDeb822Fd::Start()
	134	{
	135	// FIXME: use SetCloseExec here once it taught about throwing
	136	// exceptions instead of doing _exit(100) on failure
	137	fcntl(OutStatusFd,F_SETFD,FD_CLOEXEC);
	138
	139	// send status information that we are about to fork dpkg
	140	std::ostringstream status;
	141	status << "Status: " << "progress" << std::endl
	142	<< "Percent: " << (StepsDone/float(StepsTotal)*100.0) << std::endl
	143	<< "Message: " << _("Running dpkg") << std::endl
	144	<< std::endl;
	145	WriteToStatusFd(status.str());
	146	}
	147
	148	void PackageManagerProgressDeb822Fd::Stop()
	149	{
	150	// clear the Keep-Fd again
	151	_config->Clear("APT::Keep-Fds", OutStatusFd);
	152	}
	153
	154	void PackageManagerProgressDeb822Fd::Error(std::string PackageName,
	155	unsigned int StepsDone,
	156	unsigned int TotalSteps,
	157	std::string ErrorMessage)
	158	{
	159	std::ostringstream status;
	160	status << "Status: " << "Error" << std::endl
	161	<< "Package:" << PackageName << std::endl
	162	<< "Percent: " << (StepsDone/float(TotalSteps)*100.0) << std::endl
	163	<< "Message: " << ErrorMessage << std::endl
	164	<< std::endl;
	165	WriteToStatusFd(status.str());
	166	}
	167
	168	void PackageManagerProgressDeb822Fd::ConffilePrompt(std::string PackageName,
	169	unsigned int StepsDone,
	170	unsigned int TotalSteps,
	171	std::string ConfMessage)
	172	{
	173	std::ostringstream status;
	174	status << "Status: " << "ConfFile" << std::endl
	175	<< "Package:" << PackageName << std::endl
	176	<< "Percent: " << (StepsDone/float(TotalSteps)*100.0) << std::endl
	177	<< "Message: " << ConfMessage << std::endl
	178	<< std::endl;
	179	WriteToStatusFd(status.str());
	180	}
	181
	182
	183	bool PackageManagerProgressDeb822Fd::StatusChanged(std::string PackageName,
	184	unsigned int xStepsDone,
185	unsigned int xTotalSteps,
186	std::string message)
187	{
188	StepsDone = xStepsDone;
189	StepsTotal = xTotalSteps;
190
191	// build the status str
192	std::ostringstream status;
193	status << "Status: " << "progress" << std::endl
194	<< "Package: " << PackageName << std::endl
195	<< "Percent: " << (StepsDone/float(StepsTotal)*100.0) << std::endl
196	<< "Message: " << message << std::endl
197	<< std::endl;
198	WriteToStatusFd(status.str());
199
200	return true;
201	}
202
203
db78c60c	204	void PackageManagerFancy::SetupTerminalScrollArea(int nr_rows)
31f97d7b MV	205	{
	206	// scroll down a bit to avoid visual glitch when the screen
	207	// area shrinks by one row
	208	std::cout << "\n";
	209
	210	// save cursor
	211	std::cout << "\033[s";
	212
	213	// set scroll region (this will place the cursor in the top left)
	214	std::cout << "\033[1;" << nr_rows - 1 << "r";
	215
	216	// restore cursor but ensure its inside the scrolling area
	217	std::cout << "\033[u";
	218	static const char *move_cursor_up = "\033[1A";
	219	std::cout << move_cursor_up;
db78c60c	220
31f97d7b MV	221	std::flush(std::cout);
	222	}
	223
	224	PackageManagerFancy::PackageManagerFancy()
	225	: nr_terminal_rows(-1)
	226	{
	227	struct winsize win;
	228	if(ioctl(STDOUT_FILENO, TIOCGWINSZ, (char *)&win) == 0)
	229	{
	230	nr_terminal_rows = win.ws_row;
	231	}
	232	}
	233
a22fdebf	234	void PackageManagerFancy::Start()
31f97d7b	235	{
db78c60c MV	236	if (nr_terminal_rows > 0)
db78c60c MV	237	SetupTerminalScrollArea(nr_terminal_rows);
31f97d7b MV	238	}
31f97d7b MV	239
a22fdebf	240	void PackageManagerFancy::Stop()
31f97d7b	241	{
db78c60c MV	242	if (nr_terminal_rows > 0)
	243	{
	244	SetupTerminalScrollArea(nr_terminal_rows + 1);
31f97d7b	245
db78c60c MV	246	// override the progress line (sledgehammer)
	247	static const char* clear_screen_below_cursor = "\033[J";
	248	std::cout << clear_screen_below_cursor;
	249	}
31f97d7b MV	250	}
31f97d7b MV	251
6c5ae8ed	252	bool PackageManagerFancy::StatusChanged(std::string PackageName,
31f97d7b	253	unsigned int StepsDone,
e6ad8031 MV	254	unsigned int TotalSteps,
e6ad8031 MV	255	std::string HumanReadableAction)
31f97d7b	256	{
e6ad8031 MV	257	if (!PackageManager::StatusChanged(PackageName, StepsDone, TotalSteps,
e6ad8031 MV	258	HumanReadableAction))
6c5ae8ed	259	return false;
31f97d7b MV	260
	261	int row = nr_terminal_rows;
	262
	263	static string save_cursor = "\033[s";
	264	static string restore_cursor = "\033[u";
	265
	266	static string set_bg_color = "\033[42m"; // green
	267	static string set_fg_color = "\033[30m"; // black
	268
	269	static string restore_bg = "\033[49m";
	270	static string restore_fg = "\033[39m";
	271
	272	std::cout << save_cursor
	273	// move cursor position to last row
	274	<< "\033[" << row << ";0f"
	275	<< set_bg_color
	276	<< set_fg_color
	277	<< progress_str
	278	<< restore_cursor
	279	<< restore_bg
	280	<< restore_fg;
	281	std::flush(std::cout);
	282	last_reported_progress = percentage;
6c5ae8ed MV	283
6c5ae8ed MV	284	return true;
31f97d7b MV	285	}
31f97d7b MV	286
6c5ae8ed	287	bool PackageManagerText::StatusChanged(std::string PackageName,
31f97d7b	288	unsigned int StepsDone,
e6ad8031 MV	289	unsigned int TotalSteps,
e6ad8031 MV	290	std::string HumanReadableAction)
31f97d7b	291	{
e6ad8031	292	if (!PackageManager::StatusChanged(PackageName, StepsDone, TotalSteps, HumanReadableAction))
6c5ae8ed	293	return false;
31f97d7b MV	294
	295	std::cout << progress_str << "\r\n";
	296	std::flush(std::cout);
	297
	298	last_reported_progress = percentage;
6c5ae8ed MV	299
6c5ae8ed MV	300	return true;
31f97d7b MV	301	}
	302
	303
c7ea1eba	304
31f97d7b MV	305	}; // namespace progress
31f97d7b MV	306	}; // namespace apt