2005-03-19 04:00:40 -05:00
|
|
|
/*
|
2007-04-25 20:02:07 -04:00
|
|
|
* callback.c
|
|
|
|
*
|
2009-07-01 03:08:33 -04:00
|
|
|
* Copyright (c) 2006-2009 Pacman Development Team <pacman-dev@archlinux.org>
|
|
|
|
* Copyright (c) 2002-2006 by Judd Vinet <jvinet@zeroflux.org>
|
2007-04-25 20:02:07 -04:00
|
|
|
*
|
2005-03-19 04:00:40 -05:00
|
|
|
* This program is free software; you can redistribute it and/or modify
|
|
|
|
* it under the terms of the GNU General Public License as published by
|
|
|
|
* the Free Software Foundation; either version 2 of the License, or
|
|
|
|
* (at your option) any later version.
|
|
|
|
*
|
|
|
|
* This program is distributed in the hope that it will be useful,
|
|
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
* GNU General Public License for more details.
|
|
|
|
*
|
|
|
|
* You should have received a copy of the GNU General Public License
|
2007-12-10 23:55:22 -05:00
|
|
|
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
2005-03-19 04:00:40 -05:00
|
|
|
*/
|
|
|
|
|
|
|
|
#include "config.h"
|
2007-03-05 17:13:33 -05:00
|
|
|
|
2005-03-19 04:00:40 -05:00
|
|
|
#include <stdio.h>
|
|
|
|
#include <stdlib.h>
|
|
|
|
#include <string.h>
|
2007-04-25 20:02:07 -04:00
|
|
|
#include <sys/time.h>
|
2008-06-01 22:47:31 -04:00
|
|
|
#include <sys/types.h> /* off_t */
|
2005-03-19 04:00:40 -05:00
|
|
|
#include <unistd.h>
|
|
|
|
#include <dirent.h>
|
2007-03-03 04:43:16 -05:00
|
|
|
#include <wchar.h>
|
2005-03-19 04:00:40 -05:00
|
|
|
|
|
|
|
#include <alpm.h>
|
2007-03-05 17:13:33 -05:00
|
|
|
|
2005-03-19 04:00:40 -05:00
|
|
|
/* pacman */
|
2007-04-25 20:02:07 -04:00
|
|
|
#include "callback.h"
|
2005-10-10 16:42:48 -04:00
|
|
|
#include "util.h"
|
2006-02-22 15:39:24 -05:00
|
|
|
#include "conf.h"
|
2005-03-19 04:00:40 -05:00
|
|
|
|
2007-04-25 20:02:07 -04:00
|
|
|
/* download progress bar */
|
|
|
|
static float rate_last;
|
2008-06-01 22:47:31 -04:00
|
|
|
static off_t xfered_last;
|
2008-06-02 00:10:30 -04:00
|
|
|
static off_t list_xfered = 0.0;
|
|
|
|
static off_t list_total = 0.0;
|
2007-04-25 20:02:07 -04:00
|
|
|
static struct timeval initial_time;
|
|
|
|
|
2007-12-03 16:57:54 -05:00
|
|
|
/* transaction progress bar */
|
|
|
|
static int prevpercent = 0; /* for less progressbar output */
|
|
|
|
|
|
|
|
/* delayed output during progress bar */
|
|
|
|
static int on_progress = 0;
|
|
|
|
static alpm_list_t *output = NULL;
|
2006-02-22 15:39:24 -05:00
|
|
|
|
2007-04-26 19:03:24 -04:00
|
|
|
/* Silly little helper function, determines if the caller needs a visual update
|
|
|
|
* since the last time this function was called.
|
|
|
|
* This is made for the two progress bar functions, to prevent flicker
|
|
|
|
*
|
|
|
|
* first_call indicates if this is the first time it is called, for
|
|
|
|
* initialization purposes */
|
|
|
|
static float get_update_timediff(int first_call)
|
|
|
|
{
|
|
|
|
float retval = 0.0;
|
2007-08-16 16:19:06 -04:00
|
|
|
static struct timeval last_time = {0, 0};
|
2007-04-26 19:03:24 -04:00
|
|
|
|
|
|
|
/* on first call, simply set the last time and return */
|
|
|
|
if(first_call) {
|
|
|
|
gettimeofday(&last_time, NULL);
|
|
|
|
} else {
|
|
|
|
struct timeval this_time;
|
|
|
|
float diff_sec, diff_usec;
|
|
|
|
|
|
|
|
gettimeofday(&this_time, NULL);
|
|
|
|
diff_sec = this_time.tv_sec - last_time.tv_sec;
|
|
|
|
diff_usec = this_time.tv_usec - last_time.tv_usec;
|
|
|
|
|
|
|
|
retval = diff_sec + (diff_usec / 1000000.0);
|
|
|
|
|
|
|
|
/* return 0 and do not update last_time if interval was too short */
|
|
|
|
if(retval < UPDATE_SPEED_SEC) {
|
|
|
|
retval = 0.0;
|
|
|
|
} else {
|
|
|
|
last_time = this_time;
|
|
|
|
/* printf("\nupdate retval: %f\n", retval); DEBUG*/
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return(retval);
|
|
|
|
}
|
|
|
|
|
2007-04-25 20:02:07 -04:00
|
|
|
/* refactored from cb_trans_progress */
|
2008-06-02 00:10:30 -04:00
|
|
|
static void fill_progress(const int bar_percent, const int disp_percent,
|
|
|
|
const int proglen)
|
2007-04-25 20:02:07 -04:00
|
|
|
{
|
|
|
|
const unsigned int hashlen = proglen - 8;
|
2008-06-02 00:10:30 -04:00
|
|
|
const unsigned int hash = bar_percent * hashlen / 100;
|
2007-04-25 20:02:07 -04:00
|
|
|
static unsigned int lasthash = 0, mouth = 0;
|
|
|
|
unsigned int i;
|
|
|
|
|
2008-06-02 00:10:30 -04:00
|
|
|
if(bar_percent == 0) {
|
2007-04-25 20:02:07 -04:00
|
|
|
lasthash = 0;
|
|
|
|
mouth = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* magic numbers, how I loathe thee */
|
|
|
|
if(proglen > 8) {
|
|
|
|
printf(" [");
|
|
|
|
for(i = hashlen; i > 1; --i) {
|
|
|
|
/* if special progress bar enabled */
|
2007-06-04 12:51:23 -04:00
|
|
|
if(config->chomp) {
|
2007-04-25 20:02:07 -04:00
|
|
|
if(i > hashlen - hash) {
|
|
|
|
printf("-");
|
|
|
|
} else if(i == hashlen - hash) {
|
|
|
|
if(lasthash == hash) {
|
|
|
|
if(mouth) {
|
|
|
|
printf("\033[1;33mC\033[m");
|
|
|
|
} else {
|
|
|
|
printf("\033[1;33mc\033[m");
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
lasthash = hash;
|
|
|
|
mouth = mouth == 1 ? 0 : 1;
|
|
|
|
if(mouth) {
|
|
|
|
printf("\033[1;33mC\033[m");
|
|
|
|
} else {
|
|
|
|
printf("\033[1;33mc\033[m");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
} else if(i%3 == 0) {
|
|
|
|
printf("\033[0;37mo\033[m");
|
|
|
|
} else {
|
|
|
|
printf("\033[0;37m \033[m");
|
|
|
|
}
|
|
|
|
} /* else regular progress bar */
|
|
|
|
else if(i > hashlen - hash) {
|
|
|
|
printf("#");
|
|
|
|
} else {
|
|
|
|
printf("-");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
printf("]");
|
|
|
|
}
|
2008-08-29 11:24:34 -04:00
|
|
|
/* print display percent after progress bar */
|
2007-04-25 20:02:07 -04:00
|
|
|
if(proglen > 5) {
|
2008-08-29 11:24:34 -04:00
|
|
|
printf(" %3d%%", disp_percent);
|
2007-04-25 20:02:07 -04:00
|
|
|
}
|
|
|
|
|
2008-06-02 00:10:30 -04:00
|
|
|
if(bar_percent == 100) {
|
2007-04-25 20:02:07 -04:00
|
|
|
printf("\n");
|
|
|
|
} else {
|
|
|
|
printf("\r");
|
|
|
|
}
|
|
|
|
fflush(stdout);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* callback to handle messages/notifications from libalpm transactions */
|
2007-01-23 22:02:53 -05:00
|
|
|
void cb_trans_evt(pmtransevt_t event, void *data1, void *data2)
|
2005-03-19 04:00:40 -05:00
|
|
|
{
|
|
|
|
switch(event) {
|
2005-04-02 15:31:40 -05:00
|
|
|
case PM_TRANS_EVT_CHECKDEPS_START:
|
2007-12-02 14:48:49 -05:00
|
|
|
printf(_("checking dependencies...\n"));
|
2007-01-23 22:02:53 -05:00
|
|
|
break;
|
2005-04-02 15:31:40 -05:00
|
|
|
case PM_TRANS_EVT_FILECONFLICTS_START:
|
2006-10-15 19:54:43 -04:00
|
|
|
if(config->noprogressbar) {
|
2007-12-02 14:48:49 -05:00
|
|
|
printf(_("checking for file conflicts...\n"));
|
2006-10-15 19:54:43 -04:00
|
|
|
}
|
2007-01-23 22:02:53 -05:00
|
|
|
break;
|
2005-04-02 15:31:40 -05:00
|
|
|
case PM_TRANS_EVT_RESOLVEDEPS_START:
|
2007-12-02 14:48:49 -05:00
|
|
|
printf(_("resolving dependencies...\n"));
|
2007-01-23 22:02:53 -05:00
|
|
|
break;
|
2005-04-13 15:59:04 -04:00
|
|
|
case PM_TRANS_EVT_INTERCONFLICTS_START:
|
2007-12-02 14:48:49 -05:00
|
|
|
printf(_("looking for inter-conflicts...\n"));
|
2007-01-23 22:02:53 -05:00
|
|
|
break;
|
2005-03-19 04:00:40 -05:00
|
|
|
case PM_TRANS_EVT_ADD_START:
|
2006-10-15 15:34:52 -04:00
|
|
|
if(config->noprogressbar) {
|
2007-12-02 14:48:49 -05:00
|
|
|
printf(_("installing %s...\n"), alpm_pkg_get_name(data1));
|
2006-10-15 15:34:52 -04:00
|
|
|
}
|
2007-01-23 22:02:53 -05:00
|
|
|
break;
|
2005-03-19 04:00:40 -05:00
|
|
|
case PM_TRANS_EVT_ADD_DONE:
|
2008-02-24 01:54:11 -05:00
|
|
|
alpm_logaction("installed %s (%s)\n",
|
2006-11-20 04:10:23 -05:00
|
|
|
alpm_pkg_get_name(data1),
|
|
|
|
alpm_pkg_get_version(data1));
|
2008-07-31 10:35:21 -04:00
|
|
|
display_optdepends(data1);
|
2007-01-23 22:02:53 -05:00
|
|
|
break;
|
2005-03-19 04:00:40 -05:00
|
|
|
case PM_TRANS_EVT_REMOVE_START:
|
2006-10-15 15:34:52 -04:00
|
|
|
if(config->noprogressbar) {
|
2007-12-02 14:48:49 -05:00
|
|
|
printf(_("removing %s...\n"), alpm_pkg_get_name(data1));
|
2006-10-15 15:34:52 -04:00
|
|
|
}
|
2007-01-23 22:02:53 -05:00
|
|
|
break;
|
2005-03-19 04:00:40 -05:00
|
|
|
case PM_TRANS_EVT_REMOVE_DONE:
|
2008-02-24 01:54:11 -05:00
|
|
|
alpm_logaction("removed %s (%s)\n",
|
2006-11-20 04:10:23 -05:00
|
|
|
alpm_pkg_get_name(data1),
|
|
|
|
alpm_pkg_get_version(data1));
|
2007-01-23 22:02:53 -05:00
|
|
|
break;
|
2005-03-19 04:00:40 -05:00
|
|
|
case PM_TRANS_EVT_UPGRADE_START:
|
2006-10-15 15:34:52 -04:00
|
|
|
if(config->noprogressbar) {
|
2007-12-02 14:48:49 -05:00
|
|
|
printf(_("upgrading %s...\n"), alpm_pkg_get_name(data1));
|
2006-10-15 15:34:52 -04:00
|
|
|
}
|
2007-01-23 22:02:53 -05:00
|
|
|
break;
|
2005-03-19 04:00:40 -05:00
|
|
|
case PM_TRANS_EVT_UPGRADE_DONE:
|
2008-02-24 01:54:11 -05:00
|
|
|
alpm_logaction("upgraded %s (%s -> %s)\n",
|
2006-11-20 04:10:23 -05:00
|
|
|
(char *)alpm_pkg_get_name(data1),
|
|
|
|
(char *)alpm_pkg_get_version(data2),
|
|
|
|
(char *)alpm_pkg_get_version(data1));
|
2008-08-23 20:29:10 -04:00
|
|
|
display_new_optdepends(data2,data1);
|
2007-01-23 22:02:53 -05:00
|
|
|
break;
|
2006-10-15 15:34:52 -04:00
|
|
|
case PM_TRANS_EVT_INTEGRITY_START:
|
2007-12-02 14:48:49 -05:00
|
|
|
printf(_("checking package integrity...\n"));
|
2007-01-23 22:02:53 -05:00
|
|
|
break;
|
2007-10-19 13:17:53 -04:00
|
|
|
case PM_TRANS_EVT_DELTA_INTEGRITY_START:
|
2007-12-02 14:48:49 -05:00
|
|
|
printf(_("checking delta integrity...\n"));
|
2007-10-19 13:17:53 -04:00
|
|
|
break;
|
|
|
|
case PM_TRANS_EVT_DELTA_PATCHES_START:
|
|
|
|
printf(_("applying deltas...\n"));
|
|
|
|
break;
|
|
|
|
case PM_TRANS_EVT_DELTA_PATCH_START:
|
|
|
|
printf(_("generating %s with %s... "), (char *)data1, (char *)data2);
|
|
|
|
break;
|
2007-12-02 14:48:49 -05:00
|
|
|
case PM_TRANS_EVT_DELTA_PATCH_DONE:
|
|
|
|
printf(_("success!\n"));
|
|
|
|
break;
|
2007-10-19 13:17:53 -04:00
|
|
|
case PM_TRANS_EVT_DELTA_PATCH_FAILED:
|
|
|
|
printf(_("failed.\n"));
|
|
|
|
break;
|
2007-11-04 10:47:21 -05:00
|
|
|
case PM_TRANS_EVT_SCRIPTLET_INFO:
|
|
|
|
printf("%s", (char*)data1);
|
|
|
|
break;
|
2006-10-15 15:34:52 -04:00
|
|
|
case PM_TRANS_EVT_RETRIEVE_START:
|
2007-04-26 15:28:54 -04:00
|
|
|
printf(_(":: Retrieving packages from %s...\n"), (char*)data1);
|
2007-11-09 00:41:05 -05:00
|
|
|
break;
|
|
|
|
/* all the simple done events, with fallthrough for each */
|
2007-12-02 14:48:49 -05:00
|
|
|
case PM_TRANS_EVT_FILECONFLICTS_DONE:
|
2007-11-09 00:41:05 -05:00
|
|
|
case PM_TRANS_EVT_CHECKDEPS_DONE:
|
|
|
|
case PM_TRANS_EVT_RESOLVEDEPS_DONE:
|
|
|
|
case PM_TRANS_EVT_INTERCONFLICTS_DONE:
|
|
|
|
case PM_TRANS_EVT_INTEGRITY_DONE:
|
|
|
|
case PM_TRANS_EVT_DELTA_INTEGRITY_DONE:
|
2007-12-02 14:48:49 -05:00
|
|
|
case PM_TRANS_EVT_DELTA_PATCHES_DONE:
|
|
|
|
/* nothing */
|
2007-01-23 22:02:53 -05:00
|
|
|
break;
|
2005-03-19 04:00:40 -05:00
|
|
|
}
|
2007-11-09 00:41:05 -05:00
|
|
|
fflush(stdout);
|
2005-03-19 04:00:40 -05:00
|
|
|
}
|
|
|
|
|
2007-04-25 20:02:07 -04:00
|
|
|
/* callback to handle questions from libalpm transactions (yes/no) */
|
2007-04-26 16:59:38 -04:00
|
|
|
/* TODO this is one of the worst ever functions written. void *data ? wtf */
|
2007-01-23 22:02:53 -05:00
|
|
|
void cb_trans_conv(pmtransconv_t event, void *data1, void *data2,
|
|
|
|
void *data3, int *response)
|
2005-10-09 02:09:57 -04:00
|
|
|
{
|
|
|
|
switch(event) {
|
|
|
|
case PM_TRANS_CONV_INSTALL_IGNOREPKG:
|
2009-02-22 05:25:32 -05:00
|
|
|
*response = yesno(_(":: %s is in IgnorePkg/IgnoreGroup. Install anyway?"),
|
|
|
|
alpm_pkg_get_name(data1));
|
2007-01-23 22:02:53 -05:00
|
|
|
break;
|
2005-10-09 02:09:57 -04:00
|
|
|
case PM_TRANS_CONV_REPLACE_PKG:
|
2008-08-20 16:08:11 -04:00
|
|
|
*response = yesno(_(":: Replace %s with %s/%s?"),
|
2008-02-18 18:44:09 -05:00
|
|
|
alpm_pkg_get_name(data1),
|
|
|
|
(char *)data3,
|
|
|
|
alpm_pkg_get_name(data2));
|
2007-01-23 22:02:53 -05:00
|
|
|
break;
|
2005-12-26 01:40:29 -05:00
|
|
|
case PM_TRANS_CONV_CONFLICT_PKG:
|
2009-08-31 10:20:18 -04:00
|
|
|
/* data parameters: target package, local package, conflict (strings) */
|
|
|
|
/* print conflict only if it contains new information */
|
|
|
|
if(!strcmp(data1, data3) || !strcmp(data2, data3)) {
|
|
|
|
*response = yesno(_(":: %s and %s are in conflict. Remove %s?"),
|
|
|
|
(char *)data1,
|
|
|
|
(char *)data2,
|
|
|
|
(char *)data2);
|
|
|
|
} else {
|
|
|
|
*response = yesno(_(":: %s and %s are in conflict (%s). Remove %s?"),
|
|
|
|
(char *)data1,
|
|
|
|
(char *)data2,
|
|
|
|
(char *)data3,
|
|
|
|
(char *)data2);
|
|
|
|
}
|
2007-01-23 22:02:53 -05:00
|
|
|
break;
|
2009-02-22 05:25:31 -05:00
|
|
|
case PM_TRANS_CONV_REMOVE_PKGS:
|
|
|
|
{
|
|
|
|
alpm_list_t *unresolved = (alpm_list_t *) data1;
|
|
|
|
alpm_list_t *namelist = NULL, *i;
|
|
|
|
for (i = unresolved; i; i = i->next) {
|
|
|
|
namelist = alpm_list_add(namelist,
|
|
|
|
(char *)alpm_pkg_get_name(i->data));
|
|
|
|
}
|
2009-07-28 07:56:17 -04:00
|
|
|
printf(_(":: the following package(s) cannot be upgraded due to "
|
|
|
|
"unresolvable dependencies:\n"));
|
2009-02-22 05:25:31 -05:00
|
|
|
list_display(" ", namelist);
|
2009-07-27 08:21:26 -04:00
|
|
|
*response = noyes(_("\nDo you want to skip the above "
|
2009-02-22 05:25:31 -05:00
|
|
|
"package(s) for this upgrade?"));
|
|
|
|
alpm_list_free(namelist);
|
|
|
|
}
|
|
|
|
break;
|
2005-10-09 02:09:57 -04:00
|
|
|
case PM_TRANS_CONV_LOCAL_NEWER:
|
2007-08-20 16:34:43 -04:00
|
|
|
if(!config->op_s_downloadonly) {
|
2008-08-20 16:08:11 -04:00
|
|
|
*response = yesno(_(":: %s-%s: local version is newer. Upgrade anyway?"),
|
2007-08-20 16:34:43 -04:00
|
|
|
alpm_pkg_get_name(data1),
|
|
|
|
alpm_pkg_get_version(data1));
|
2006-10-15 15:34:52 -04:00
|
|
|
} else {
|
2007-08-20 16:34:43 -04:00
|
|
|
*response = 1;
|
2006-10-15 15:34:52 -04:00
|
|
|
}
|
2007-01-23 22:02:53 -05:00
|
|
|
break;
|
2006-10-15 15:34:52 -04:00
|
|
|
case PM_TRANS_CONV_CORRUPTED_PKG:
|
2008-08-20 16:08:11 -04:00
|
|
|
*response = yesno(_(":: File %s is corrupted. Do you want to delete it?"),
|
2008-02-18 18:44:09 -05:00
|
|
|
(char *)data1);
|
2007-01-23 22:02:53 -05:00
|
|
|
break;
|
2005-10-09 02:09:57 -04:00
|
|
|
}
|
Re-add the non-user friendly --ask option
This re-implements the --ask option which was removed in commit
1ff8e7f364a9f640ada7526384646d510ac29967.
This option does not have to be exposed to the user (help,doc,etc), but is
very very useful for pactest if we want to have more coverage there.
This was rewritten in a smarter way, without code duplication. And with a
different behavior : this option is now only used to inverse default
behavior to questions.
We still use bit operations based on the following struct :
/* Transaction Conversations (ie, questions) */
typedef enum _pmtransconv_t {
PM_TRANS_CONV_INSTALL_IGNOREPKG = 0x01,
PM_TRANS_CONV_REPLACE_PKG = 0x02,
PM_TRANS_CONV_CONFLICT_PKG = 0x04,
PM_TRANS_CONV_CORRUPTED_PKG = 0x08,
PM_TRANS_CONV_LOCAL_NEWER = 0x10,
PM_TRANS_CONV_REMOVE_PKGS = 0x20,
} pmtransconv_t;
for each conv matched, the default answer is inversed.
--ask 0 : all default answers are preserved
--ask 4 : only conflict question is inversed
--ask 63 : all questions are inversed (63 == 1+2+4+8+16+32)
Signed-off-by: Xavier Chantry <shiningxc@gmail.com>
Signed-off-by: Dan McGee <dan@archlinux.org>
2009-08-31 14:17:05 -04:00
|
|
|
if(config->noask) {
|
|
|
|
if(config->ask & event) {
|
|
|
|
/* inverse the default answer */
|
|
|
|
*response = !*response;
|
|
|
|
}
|
|
|
|
}
|
2005-10-09 02:09:57 -04:00
|
|
|
}
|
|
|
|
|
2007-04-25 20:02:07 -04:00
|
|
|
/* callback to handle display of transaction progress */
|
2007-03-03 03:13:59 -05:00
|
|
|
void cb_trans_progress(pmtransprog_t event, const char *pkgname, int percent,
|
|
|
|
int howmany, int remain)
|
2006-10-15 15:34:52 -04:00
|
|
|
{
|
2007-02-03 20:36:45 -05:00
|
|
|
float timediff;
|
|
|
|
|
2007-01-30 20:37:41 -05:00
|
|
|
/* size of line to allocate for text printing (e.g. not progressbar) */
|
|
|
|
const int infolen = 50;
|
2008-02-22 23:00:15 -05:00
|
|
|
int tmp, digits, textlen;
|
2007-02-14 14:35:41 -05:00
|
|
|
char *opr = NULL;
|
2008-02-22 23:00:15 -05:00
|
|
|
/* used for wide character width determination and printing */
|
|
|
|
int len, wclen, wcwid, padwid;
|
|
|
|
wchar_t *wcstr;
|
2006-10-15 15:34:52 -04:00
|
|
|
|
|
|
|
if(config->noprogressbar) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2006-12-22 02:11:20 -05:00
|
|
|
if(percent == 0) {
|
2007-02-03 20:36:45 -05:00
|
|
|
timediff = get_update_timediff(1);
|
|
|
|
} else {
|
|
|
|
timediff = get_update_timediff(0);
|
|
|
|
}
|
|
|
|
|
|
|
|
if(percent > 0 && percent < 100 && !timediff) {
|
|
|
|
/* only update the progress bar when
|
|
|
|
* a) we first start
|
|
|
|
* b) we end the progress
|
|
|
|
* c) it has been long enough since the last call
|
|
|
|
*/
|
|
|
|
return;
|
2006-12-22 02:11:20 -05:00
|
|
|
}
|
|
|
|
|
2007-01-30 20:37:41 -05:00
|
|
|
/* if no pkgname, percent is too high or unchanged, then return */
|
2007-02-03 20:36:45 -05:00
|
|
|
if(!pkgname || percent == prevpercent) {
|
2006-10-15 15:34:52 -04:00
|
|
|
return;
|
2007-01-30 20:37:41 -05:00
|
|
|
}
|
2006-10-15 15:34:52 -04:00
|
|
|
|
|
|
|
prevpercent=percent;
|
2007-03-03 04:43:16 -05:00
|
|
|
/* set text of message to display */
|
2006-10-15 15:34:52 -04:00
|
|
|
switch (event) {
|
|
|
|
case PM_TRANS_PROGRESS_ADD_START:
|
2007-02-14 14:35:41 -05:00
|
|
|
opr = _("installing");
|
2007-01-23 22:02:53 -05:00
|
|
|
break;
|
2006-10-15 15:34:52 -04:00
|
|
|
case PM_TRANS_PROGRESS_UPGRADE_START:
|
2007-02-14 14:35:41 -05:00
|
|
|
opr = _("upgrading");
|
2007-01-23 22:02:53 -05:00
|
|
|
break;
|
2006-10-15 15:34:52 -04:00
|
|
|
case PM_TRANS_PROGRESS_REMOVE_START:
|
2007-02-14 14:35:41 -05:00
|
|
|
opr = _("removing");
|
2007-01-23 22:02:53 -05:00
|
|
|
break;
|
2006-10-15 19:54:43 -04:00
|
|
|
case PM_TRANS_PROGRESS_CONFLICTS_START:
|
2007-02-14 14:35:41 -05:00
|
|
|
opr = _("checking for file conflicts");
|
2007-01-23 22:02:53 -05:00
|
|
|
break;
|
2006-10-15 15:34:52 -04:00
|
|
|
}
|
|
|
|
|
2007-01-30 20:37:41 -05:00
|
|
|
/* find # of digits in package counts to scale output */
|
|
|
|
digits = 1;
|
2007-03-03 04:43:16 -05:00
|
|
|
tmp = howmany;
|
|
|
|
while((tmp /= 10)) {
|
2007-01-30 20:37:41 -05:00
|
|
|
++digits;
|
|
|
|
}
|
|
|
|
/* determine room left for non-digits text [not ( 1/12) part] */
|
|
|
|
textlen = infolen - 3 - (2 * digits);
|
2008-02-17 17:31:26 -05:00
|
|
|
|
2008-02-22 23:00:15 -05:00
|
|
|
/* In order to deal with characters from all locales, we have to worry
|
|
|
|
* about wide characters and their column widths. A lot of stuff is
|
|
|
|
* done here to figure out the actual number of screen columns used
|
|
|
|
* by the output, and then pad it accordingly so we fill the terminal.
|
|
|
|
*/
|
|
|
|
/* len = opr len + pkgname len (if available) + space + null */
|
|
|
|
len = strlen(opr) + ((pkgname) ? strlen(pkgname) : 0) + 2;
|
|
|
|
wcstr = calloc(len, sizeof(wchar_t));
|
|
|
|
/* print our strings to the alloc'ed memory */
|
2008-04-07 19:36:18 -04:00
|
|
|
#if defined(HAVE_SWPRINTF)
|
2008-02-22 23:00:15 -05:00
|
|
|
wclen = swprintf(wcstr, len, L"%s %s", opr, pkgname);
|
2008-04-07 19:36:18 -04:00
|
|
|
#else
|
|
|
|
/* because the format string was simple, we can easily do this without
|
|
|
|
* using swprintf, although it is probably not as safe/fast. The max
|
|
|
|
* chars we can copy is decremented each time by subtracting the length
|
|
|
|
* of the already printed/copied wide char string. */
|
|
|
|
wclen = mbstowcs(wcstr, opr, len);
|
|
|
|
wclen += mbstowcs(wcstr + wclen, " ", len - wclen);
|
|
|
|
wclen += mbstowcs(wcstr + wclen, pkgname, len - wclen);
|
|
|
|
#endif
|
2008-02-22 23:00:15 -05:00
|
|
|
wcwid = wcswidth(wcstr, wclen);
|
|
|
|
padwid = textlen - wcwid;
|
|
|
|
/* if padwid is < 0, we need to trim the string so padwid = 0 */
|
|
|
|
if(padwid < 0) {
|
|
|
|
int i = textlen - 3;
|
|
|
|
wchar_t *p = wcstr;
|
|
|
|
/* grab the max number of char columns we can fill */
|
|
|
|
while(i > 0 && wcwidth(*p) < i) {
|
|
|
|
i -= wcwidth(*p);
|
|
|
|
p++;
|
|
|
|
}
|
|
|
|
/* then add the ellipsis and fill out any extra padding */
|
|
|
|
wcscpy(p, L"...");
|
|
|
|
padwid = i;
|
2006-10-15 15:34:52 -04:00
|
|
|
|
|
|
|
}
|
2006-10-31 01:41:42 -05:00
|
|
|
|
2008-02-22 23:00:15 -05:00
|
|
|
printf("(%*d/%*d) %ls%-*s", digits, remain, digits, howmany,
|
|
|
|
wcstr, padwid, "");
|
|
|
|
|
|
|
|
free(wcstr);
|
|
|
|
|
2007-01-30 20:37:41 -05:00
|
|
|
/* call refactored fill progress function */
|
2008-06-02 00:10:30 -04:00
|
|
|
fill_progress(percent, percent, getcols() - infolen);
|
2007-12-03 16:57:54 -05:00
|
|
|
|
|
|
|
if(percent == 100) {
|
|
|
|
alpm_list_t *i = NULL;
|
|
|
|
on_progress = 0;
|
|
|
|
for(i = output; i; i = i->next) {
|
|
|
|
printf("%s", (char *)i->data);
|
|
|
|
}
|
|
|
|
fflush(stdout);
|
2007-12-08 03:58:49 -05:00
|
|
|
FREELIST(output);
|
2007-12-03 16:57:54 -05:00
|
|
|
} else {
|
|
|
|
on_progress = 1;
|
|
|
|
}
|
2007-04-25 20:02:07 -04:00
|
|
|
}
|
|
|
|
|
2008-06-02 00:10:30 -04:00
|
|
|
/* callback to handle receipt of total download value */
|
|
|
|
void cb_dl_total(off_t total)
|
|
|
|
{
|
|
|
|
list_total = total;
|
|
|
|
/* if we get a 0 value, it means this list has finished downloading,
|
|
|
|
* so clear out our list_xfered as well */
|
|
|
|
if(total == 0) {
|
|
|
|
list_xfered = 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2007-04-25 20:02:07 -04:00
|
|
|
/* callback to handle display of download progress */
|
2008-06-02 00:10:30 -04:00
|
|
|
void cb_dl_progress(const char *filename, off_t file_xfered, off_t file_total)
|
2007-04-25 20:02:07 -04:00
|
|
|
{
|
|
|
|
const int infolen = 50;
|
2008-02-22 21:57:45 -05:00
|
|
|
const int filenamelen = infolen - 27;
|
2007-11-16 21:18:45 -05:00
|
|
|
char *fname, *p;
|
2008-02-22 21:57:45 -05:00
|
|
|
/* used for wide character width determination and printing */
|
|
|
|
int len, wclen, wcwid, padwid;
|
|
|
|
wchar_t *wcfname;
|
2007-04-25 20:02:07 -04:00
|
|
|
|
2008-08-29 11:24:34 -04:00
|
|
|
int totaldownload;
|
2008-06-02 00:10:30 -04:00
|
|
|
off_t xfered, total;
|
2007-04-25 20:02:07 -04:00
|
|
|
float rate = 0.0, timediff = 0.0, f_xfered = 0.0;
|
|
|
|
unsigned int eta_h = 0, eta_m = 0, eta_s = 0;
|
2008-06-02 00:10:30 -04:00
|
|
|
int file_percent = 0, total_percent = 0;
|
2007-04-25 20:02:07 -04:00
|
|
|
char rate_size = 'K', xfered_size = 'K';
|
|
|
|
|
2008-08-20 17:17:02 -04:00
|
|
|
if(config->noprogressbar || file_total == -1) {
|
|
|
|
if(file_xfered == 0) {
|
|
|
|
printf(_("downloading %s...\n"), filename);
|
2008-11-25 00:31:10 -05:00
|
|
|
fflush(stdout);
|
2008-08-20 17:17:02 -04:00
|
|
|
}
|
2007-04-25 20:02:07 -04:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2008-06-02 00:10:30 -04:00
|
|
|
/* only use TotalDownload if enabled and we have a callback value */
|
|
|
|
if(config->totaldownload && list_total) {
|
2008-08-29 11:24:34 -04:00
|
|
|
totaldownload = 1;
|
|
|
|
} else {
|
|
|
|
totaldownload = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
if(totaldownload) {
|
2008-06-02 00:10:30 -04:00
|
|
|
xfered = list_xfered + file_xfered;
|
|
|
|
total = list_total;
|
|
|
|
} else {
|
|
|
|
xfered = file_xfered;
|
|
|
|
total = file_total;
|
|
|
|
}
|
|
|
|
|
2008-06-01 22:47:31 -04:00
|
|
|
/* this is basically a switch on xfered: 0, total, and
|
2007-11-09 19:54:19 -05:00
|
|
|
* anything else */
|
2008-06-02 00:10:30 -04:00
|
|
|
if(file_xfered == 0) {
|
|
|
|
/* set default starting values, ensure we only call this once
|
|
|
|
* if TotalDownload is enabled */
|
2008-08-29 11:24:34 -04:00
|
|
|
if(!totaldownload || (totaldownload && list_xfered == 0)) {
|
2008-06-02 00:10:30 -04:00
|
|
|
gettimeofday(&initial_time, NULL);
|
|
|
|
xfered_last = (off_t)0;
|
|
|
|
rate_last = 0.0;
|
|
|
|
timediff = get_update_timediff(1);
|
|
|
|
}
|
|
|
|
} else if(file_xfered == file_total) {
|
2007-04-25 20:02:07 -04:00
|
|
|
/* compute final values */
|
|
|
|
struct timeval current_time;
|
|
|
|
float diff_sec, diff_usec;
|
2007-11-16 21:18:45 -05:00
|
|
|
|
2007-04-25 20:02:07 -04:00
|
|
|
gettimeofday(¤t_time, NULL);
|
|
|
|
diff_sec = current_time.tv_sec - initial_time.tv_sec;
|
|
|
|
diff_usec = current_time.tv_usec - initial_time.tv_usec;
|
|
|
|
timediff = diff_sec + (diff_usec / 1000000.0);
|
2008-06-02 00:10:30 -04:00
|
|
|
rate = xfered / (timediff * 1024.0);
|
2007-04-25 20:02:07 -04:00
|
|
|
|
|
|
|
/* round elapsed time to the nearest second */
|
2007-10-31 16:12:33 -04:00
|
|
|
eta_s = (int)(timediff + 0.5);
|
2007-04-25 20:02:07 -04:00
|
|
|
} else {
|
|
|
|
/* compute current average values */
|
|
|
|
timediff = get_update_timediff(0);
|
|
|
|
|
|
|
|
if(timediff < UPDATE_SPEED_SEC) {
|
|
|
|
/* return if the calling interval was too short */
|
|
|
|
return;
|
|
|
|
}
|
2007-05-14 03:16:55 -04:00
|
|
|
rate = (xfered - xfered_last) / (timediff * 1024.0);
|
2007-04-25 20:02:07 -04:00
|
|
|
/* average rate to reduce jumpiness */
|
2008-01-23 00:11:31 -05:00
|
|
|
rate = (rate + 2 * rate_last) / 3;
|
2007-05-14 03:16:55 -04:00
|
|
|
eta_s = (total - xfered) / (rate * 1024.0);
|
2007-04-25 20:02:07 -04:00
|
|
|
rate_last = rate;
|
|
|
|
xfered_last = xfered;
|
|
|
|
}
|
|
|
|
|
2008-06-02 00:10:30 -04:00
|
|
|
file_percent = (int)((float)file_xfered) / ((float)file_total) * 100;
|
|
|
|
|
2008-08-29 11:24:34 -04:00
|
|
|
if(totaldownload) {
|
2008-06-02 00:10:30 -04:00
|
|
|
total_percent = (int)((float)list_xfered + file_xfered) /
|
|
|
|
((float)list_total) * 100;
|
|
|
|
|
|
|
|
/* if we are at the end, add the completed file to list_xfered */
|
|
|
|
if(file_xfered == file_total) {
|
|
|
|
list_xfered += file_total;
|
|
|
|
}
|
|
|
|
}
|
2008-01-23 00:11:31 -05:00
|
|
|
|
2007-04-25 20:02:07 -04:00
|
|
|
/* fix up time for display */
|
|
|
|
eta_h = eta_s / 3600;
|
|
|
|
eta_s -= eta_h * 3600;
|
|
|
|
eta_m = eta_s / 60;
|
|
|
|
eta_s -= eta_m * 60;
|
2007-02-03 20:36:45 -05:00
|
|
|
|
2007-04-25 20:02:07 -04:00
|
|
|
fname = strdup(filename);
|
2007-09-27 23:47:25 -04:00
|
|
|
/* strip package or DB extension for cleaner look */
|
2007-05-31 02:51:28 -04:00
|
|
|
if((p = strstr(fname, PKGEXT)) || (p = strstr(fname, DBEXT))) {
|
2007-04-25 20:02:07 -04:00
|
|
|
*p = '\0';
|
|
|
|
}
|
2008-02-22 21:57:45 -05:00
|
|
|
/* In order to deal with characters from all locales, we have to worry
|
|
|
|
* about wide characters and their column widths. A lot of stuff is
|
|
|
|
* done here to figure out the actual number of screen columns used
|
|
|
|
* by the output, and then pad it accordingly so we fill the terminal.
|
|
|
|
*/
|
|
|
|
/* len = filename len + null */
|
|
|
|
len = strlen(filename) + 1;
|
|
|
|
wcfname = calloc(len, sizeof(wchar_t));
|
|
|
|
wclen = mbstowcs(wcfname, fname, len);
|
|
|
|
wcwid = wcswidth(wcfname, wclen);
|
|
|
|
padwid = filenamelen - wcwid;
|
|
|
|
/* if padwid is < 0, we need to trim the string so padwid = 0 */
|
|
|
|
if(padwid < 0) {
|
|
|
|
int i = filenamelen - 3;
|
|
|
|
wchar_t *p = wcfname;
|
|
|
|
/* grab the max number of char columns we can fill */
|
|
|
|
while(i > 0 && wcwidth(*p) < i) {
|
|
|
|
i -= wcwidth(*p);
|
|
|
|
p++;
|
|
|
|
}
|
|
|
|
/* then add the ellipsis and fill out any extra padding */
|
|
|
|
wcscpy(p, L"...");
|
|
|
|
padwid = i;
|
|
|
|
|
2007-04-25 20:02:07 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Awesome formatting for progress bar. We need a mess of Kb->Mb->Gb stuff
|
|
|
|
* here. We'll use limit of 2048 for each until we get some empirical */
|
|
|
|
/* rate_size = 'K'; was set above */
|
|
|
|
if(rate > 2048.0) {
|
|
|
|
rate /= 1024.0;
|
|
|
|
rate_size = 'M';
|
|
|
|
if(rate > 2048.0) {
|
|
|
|
rate /= 1024.0;
|
|
|
|
rate_size = 'G';
|
|
|
|
/* we should not go higher than this for a few years (9999.9 Gb/s?)*/
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2007-05-14 03:16:55 -04:00
|
|
|
f_xfered = xfered / 1024.0; /* convert to K by default */
|
2007-04-25 20:02:07 -04:00
|
|
|
/* xfered_size = 'K'; was set above */
|
|
|
|
if(f_xfered > 2048.0) {
|
|
|
|
f_xfered /= 1024.0;
|
|
|
|
xfered_size = 'M';
|
|
|
|
if(f_xfered > 2048.0) {
|
|
|
|
f_xfered /= 1024.0;
|
|
|
|
xfered_size = 'G';
|
|
|
|
/* I should seriously hope that archlinux packages never break
|
|
|
|
* the 9999.9GB mark... we'd have more serious problems than the progress
|
2007-11-16 21:18:45 -05:00
|
|
|
* bar in pacman */
|
2007-04-25 20:02:07 -04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-02-22 21:57:45 -05:00
|
|
|
printf(" %ls%-*s %6.1f%c %#6.1f%c/s %02u:%02u:%02u", wcfname,
|
|
|
|
padwid, "", f_xfered, xfered_size,
|
|
|
|
rate, rate_size, eta_h, eta_m, eta_s);
|
2007-04-25 20:02:07 -04:00
|
|
|
|
|
|
|
free(fname);
|
2008-02-22 21:57:45 -05:00
|
|
|
free(wcfname);
|
2007-11-16 21:18:45 -05:00
|
|
|
|
2008-08-29 11:24:34 -04:00
|
|
|
if(totaldownload) {
|
|
|
|
fill_progress(file_percent, total_percent, getcols() - infolen);
|
|
|
|
} else {
|
|
|
|
fill_progress(file_percent, file_percent, getcols() - infolen);
|
|
|
|
}
|
2007-04-25 20:02:07 -04:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Callback to handle notifications from the library */
|
2007-06-07 20:55:13 -04:00
|
|
|
void cb_log(pmloglevel_t level, char *fmt, va_list args)
|
2007-04-25 20:02:07 -04:00
|
|
|
{
|
2008-02-24 02:17:17 -05:00
|
|
|
if(!fmt || strlen(fmt) == 0) {
|
2007-04-25 20:02:07 -04:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2007-12-03 16:57:54 -05:00
|
|
|
if(on_progress) {
|
|
|
|
char *string = NULL;
|
|
|
|
pm_vasprintf(&string, level, fmt, args);
|
|
|
|
if(string != NULL) {
|
|
|
|
output = alpm_list_add(output, string);
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
pm_vfprintf(stdout, level, fmt, args);
|
|
|
|
}
|
2006-10-15 15:34:52 -04:00
|
|
|
}
|
|
|
|
|
2005-03-19 04:00:40 -05:00
|
|
|
/* vim: set ts=2 sw=2 noet: */
|