static void
pk_direct_item_progress_cb (PkBackendJob *job, gpointer object, gpointer user_data)
{
PkItemProgress *ip = PK_ITEM_PROGRESS (object);
g_print ("ItemProgress: %s\t%i%%\t%s\n",
pk_status_enum_to_string (pk_item_progress_get_status (ip)),
pk_item_progress_get_percentage (ip),
pk_item_progress_get_package_id (ip));
}
/**
* pk_backend_job_set_status:
**/
void
pk_backend_job_set_status (PkBackendJob *job, PkStatusEnum status)
{
g_return_if_fail (PK_IS_BACKEND_JOB (job));
/* already this? */
if (job->priv->status == status)
return;
/* have we already set an error? */
if (job->priv->set_error && status != PK_STATUS_ENUM_FINISHED) {
g_warning ("already set error: status %s",
pk_status_enum_to_string (status));
return;
}
/* backends don't do this */
if (status == PK_STATUS_ENUM_WAIT) {
g_warning ("backend tried to status WAIT");
return;
}
/* do we have to enumate a running call? */
if (status != PK_STATUS_ENUM_RUNNING && status != PK_STATUS_ENUM_SETUP) {
if (job->priv->status == PK_STATUS_ENUM_SETUP) {
/* emit */
pk_backend_job_call_vfunc (job,
PK_BACKEND_SIGNAL_STATUS_CHANGED,
GUINT_TO_POINTER (PK_STATUS_ENUM_RUNNING),
NULL);
}
}
job->priv->status = status;
/* don't emit some states when simulating */
if (pk_bitfield_contain (job->priv->transaction_flags,
PK_TRANSACTION_FLAG_ENUM_SIMULATE)) {
switch (status) {
case PK_STATUS_ENUM_DOWNLOAD:
case PK_STATUS_ENUM_UPDATE:
case PK_STATUS_ENUM_INSTALL:
case PK_STATUS_ENUM_REMOVE:
case PK_STATUS_ENUM_CLEANUP:
case PK_STATUS_ENUM_OBSOLETE:
return;
default:
break;
}
}
/* emit */
pk_backend_job_call_vfunc (job,
PK_BACKEND_SIGNAL_STATUS_CHANGED,
GUINT_TO_POINTER (status),
NULL);
}
/**
* hif_state_child_percentage_changed_cb:
**/
static void
hif_state_child_percentage_changed_cb (HifState *child, guint percentage, HifState *state)
{
gfloat offset;
gfloat range;
gfloat extra;
guint parent_percentage;
/* propagate up the stack if HifState has only one step */
if (state->priv->steps == 1) {
hif_state_set_percentage (state, percentage);
return;
}
/* did we call done on a state that did not have a size set? */
if (state->priv->steps == 0)
return;
/* already at >= 100% */
if (state->priv->current >= state->priv->steps) {
g_warning ("already at %i/%i steps on %p", state->priv->current, state->priv->steps, state);
return;
}
/* we have to deal with non-linear steps */
if (state->priv->step_data != NULL) {
/* we don't store zero */
if (state->priv->current == 0) {
parent_percentage = percentage * state->priv->step_data[state->priv->current] / 100;
} else {
/* bilinearly interpolate for speed */
parent_percentage = (((100 - percentage) * state->priv->step_data[state->priv->current-1]) +
(percentage * state->priv->step_data[state->priv->current])) / 100;
}
goto out;
}
/* get the offset */
offset = hif_state_discrete_to_percent (state->priv->current, state->priv->steps);
/* get the range between the parent step and the next parent step */
range = hif_state_discrete_to_percent (state->priv->current+1, state->priv->steps) - offset;
if (range < 0.01) {
g_warning ("range=%f (from %i to %i), should be impossible", range, state->priv->current+1, state->priv->steps);
return;
}
/* restore the pre-child action */
if (percentage == 100) {
state->priv->last_action = state->priv->child_action;
if (state->priv->child_action != PK_STATUS_ENUM_UNKNOWN) {
g_debug ("restoring last action %s",
pk_status_enum_to_string (state->priv->child_action));
}
}
/* get the extra contributed by the child */
extra = ((gfloat) percentage / 100.0f) * range;
/* emit from the parent */
parent_percentage = (guint) (offset + extra);
out:
hif_state_set_percentage (state, parent_percentage);
}
/**
* hif_state_set_percentage:
**/
gboolean
hif_state_set_percentage (HifState *state, guint percentage)
{
gboolean ret = FALSE;
/* do we care */
if (!state->priv->report_progress) {
ret = TRUE;
goto out;
}
/* is it the same */
if (percentage == state->priv->last_percentage)
goto out;
/* is it invalid */
if (percentage > 100) {
hif_state_print_parent_chain (state, 0);
g_warning ("percentage %i%% is invalid on %p!",
percentage, state);
goto out;
}
/* is it less */
if (percentage < state->priv->last_percentage) {
if (state->priv->enable_profile) {
hif_state_print_parent_chain (state, 0);
g_warning ("percentage should not go down from %i to %i on %p!",
state->priv->last_percentage, percentage, state);
}
goto out;
}
/* we're done, so we're not preventing cancellation anymore */
if (percentage == 100 && !state->priv->allow_cancel) {
g_debug ("done, so allow cancel 1 for %p", state);
hif_state_set_allow_cancel (state, TRUE);
}
/* automatically cancel any action */
if (percentage == 100 && state->priv->action != PK_STATUS_ENUM_UNKNOWN) {
g_debug ("done, so cancelling action %s",
pk_status_enum_to_string (state->priv->action));
hif_state_action_stop (state);
}
/* speed no longer valid */
if (percentage == 100)
hif_state_set_speed_internal (state, 0);
/* release locks? */
if (percentage == 100) {
ret = hif_state_release_locks (state);
if (!ret)
goto out;
}
/* save */
state->priv->last_percentage = percentage;
/* emit */
g_signal_emit (state, signals [SIGNAL_PERCENTAGE_CHANGED], 0, percentage);
/* success */
ret = TRUE;
out:
return ret;
}
/**
* pk_offline_update_progress_cb:
**/
static void
pk_offline_update_progress_cb (PkProgress *progress,
PkProgressType type,
gpointer user_data)
{
PkInfoEnum info;
PkProgressBar *progressbar = PK_PROGRESS_BAR (user_data);
PkStatusEnum status;
gint percentage;
_cleanup_free_ gchar *msg = NULL;
_cleanup_object_unref_ PkPackage *pkg = NULL;
switch (type) {
case PK_PROGRESS_TYPE_ROLE:
sd_journal_print (LOG_INFO, "assigned role");
pk_progress_bar_start (progressbar, "Updating system");
break;
case PK_PROGRESS_TYPE_PACKAGE:
g_object_get (progress, "package", &pkg, NULL);
info = pk_package_get_info (pkg);
if (info == PK_INFO_ENUM_UPDATING) {
msg = g_strdup_printf ("Updating %s",
pk_package_get_name (pkg));
pk_progress_bar_start (progressbar, msg);
} else if (info == PK_INFO_ENUM_INSTALLING) {
msg = g_strdup_printf ("Installing %s",
pk_package_get_name (pkg));
pk_progress_bar_start (progressbar, msg);
} else if (info == PK_INFO_ENUM_REMOVING) {
msg = g_strdup_printf ("Removing %s",
pk_package_get_name (pkg));
pk_progress_bar_start (progressbar, msg);
}
sd_journal_print (LOG_INFO,
"package %s\t%s-%s.%s (%s)",
pk_info_enum_to_string (info),
pk_package_get_name (pkg),
pk_package_get_version (pkg),
pk_package_get_arch (pkg),
pk_package_get_data (pkg));
break;
case PK_PROGRESS_TYPE_PERCENTAGE:
g_object_get (progress, "percentage", &percentage, NULL);
if (percentage < 0)
return;
sd_journal_print (LOG_INFO, "percentage %i%%", percentage);
/* TRANSLATORS: this is the message we send plymouth to
* advise of the new percentage completion */
msg = g_strdup_printf ("%s - %i%%", _("Installing Updates"), percentage);
if (percentage > 10)
pk_offline_update_set_plymouth_msg (msg);
/* print on terminal */
pk_progress_bar_set_percentage (progressbar, percentage);
/* update plymouth */
pk_offline_update_set_plymouth_percentage (percentage);
break;
case PK_PROGRESS_TYPE_STATUS:
g_object_get (progress, "status", &status, NULL);
sd_journal_print (LOG_INFO,
"status %s",
pk_status_enum_to_string (status));
default:
break;
}
}
static void
pk_direct_status_changed_cb (PkBackendJob *job, gpointer object, gpointer user_data)
{
PkStatusEnum status_enum = GPOINTER_TO_UINT (object);
g_print ("Status: %s\n", pk_status_enum_to_string (status_enum));
}
/**
* pk_status_enum_to_localised_text:
**/
const gchar *
pk_status_enum_to_localised_text (PkStatusEnum status)
{
const gchar *text = NULL;
switch (status) {
case PK_STATUS_ENUM_UNKNOWN:
/* TRANSLATORS: This is when the transaction status is not known */
text = _("Unknown state");
break;
case PK_STATUS_ENUM_SETUP:
/* TRANSLATORS: transaction state, the daemon is in the process of starting */
text = _("Starting");
break;
case PK_STATUS_ENUM_WAIT:
/* TRANSLATORS: transaction state, the transaction is waiting for another to complete */
text = _("Waiting in queue");
break;
case PK_STATUS_ENUM_RUNNING:
/* TRANSLATORS: transaction state, just started */
text = _("Running");
break;
case PK_STATUS_ENUM_QUERY:
/* TRANSLATORS: transaction state, is querying data */
text = _("Querying");
break;
case PK_STATUS_ENUM_INFO:
/* TRANSLATORS: transaction state, getting data from a server */
text = _("Getting information");
break;
case PK_STATUS_ENUM_REMOVE:
/* TRANSLATORS: transaction state, removing packages */
text = _("Removing packages");
break;
case PK_STATUS_ENUM_DOWNLOAD:
/* TRANSLATORS: transaction state, downloading package files */
text = _("Downloading packages");
break;
case PK_STATUS_ENUM_INSTALL:
/* TRANSLATORS: transaction state, installing packages */
text = _("Installing packages");
break;
case PK_STATUS_ENUM_REFRESH_CACHE:
/* TRANSLATORS: transaction state, refreshing internal lists */
text = _("Refreshing software list");
break;
case PK_STATUS_ENUM_UPDATE:
/* TRANSLATORS: transaction state, installing updates */
text = _("Installing updates");
break;
case PK_STATUS_ENUM_CLEANUP:
/* TRANSLATORS: transaction state, removing old packages, and cleaning config files */
text = _("Cleaning up packages");
break;
case PK_STATUS_ENUM_OBSOLETE:
/* TRANSLATORS: transaction state, obsoleting old packages */
text = _("Obsoleting packages");
break;
case PK_STATUS_ENUM_DEP_RESOLVE:
/* TRANSLATORS: transaction state, checking the transaction before we do it */
text = _("Resolving dependencies");
break;
case PK_STATUS_ENUM_SIG_CHECK:
/* TRANSLATORS: transaction state, checking if we have all the security keys for the operation */
text = _("Checking signatures");
break;
case PK_STATUS_ENUM_ROLLBACK:
/* TRANSLATORS: transaction state, when we return to a previous system state */
text = _("Rolling back");
break;
case PK_STATUS_ENUM_TEST_COMMIT:
/* TRANSLATORS: transaction state, when we're doing a test transaction */
text = _("Testing changes");
break;
case PK_STATUS_ENUM_COMMIT:
/* TRANSLATORS: transaction state, when we're writing to the system package database */
text = _("Committing changes");
break;
case PK_STATUS_ENUM_REQUEST:
/* TRANSLATORS: transaction state, requesting data from a server */
text = _("Requesting data");
break;
case PK_STATUS_ENUM_FINISHED:
/* TRANSLATORS: transaction state, all done! */
text = _("Finished");
break;
case PK_STATUS_ENUM_CANCEL:
/* TRANSLATORS: transaction state, in the process of cancelling */
text = _("Cancelling");
break;
case PK_STATUS_ENUM_DOWNLOAD_REPOSITORY:
/* TRANSLATORS: transaction state, downloading metadata */
text = _("Downloading repository information");
break;
case PK_STATUS_ENUM_DOWNLOAD_PACKAGELIST:
/* TRANSLATORS: transaction state, downloading metadata */
text = _("Downloading list of packages");
break;
case PK_STATUS_ENUM_DOWNLOAD_FILELIST:
/* TRANSLATORS: transaction state, downloading metadata */
text = _("Downloading file lists");
break;
case PK_STATUS_ENUM_DOWNLOAD_CHANGELOG:
/* TRANSLATORS: transaction state, downloading metadata */
text = _("Downloading lists of changes");
break;
case PK_STATUS_ENUM_DOWNLOAD_GROUP:
/* TRANSLATORS: transaction state, downloading metadata */
text = _("Downloading groups");
break;
case PK_STATUS_ENUM_DOWNLOAD_UPDATEINFO:
/* TRANSLATORS: transaction state, downloading metadata */
text = _("Downloading update information");
break;
case PK_STATUS_ENUM_REPACKAGING:
/* TRANSLATORS: transaction state, repackaging delta files */
text = _("Repackaging files");
break;
case PK_STATUS_ENUM_LOADING_CACHE:
/* TRANSLATORS: transaction state, loading databases */
text = _("Loading cache");
break;
case PK_STATUS_ENUM_SCAN_APPLICATIONS:
/* TRANSLATORS: transaction state, scanning for running processes */
text = _("Scanning applications");
break;
case PK_STATUS_ENUM_GENERATE_PACKAGE_LIST:
/* TRANSLATORS: transaction state, generating a list of packages installed on the system */
text = _("Generating package lists");
break;
case PK_STATUS_ENUM_WAITING_FOR_LOCK:
/* TRANSLATORS: transaction state, when we're waiting for the native tools to exit */
text = _("Waiting for package manager lock");
break;
case PK_STATUS_ENUM_WAITING_FOR_AUTH:
/* TRANSLATORS: transaction state, waiting for user to type in a password */
text = _("Waiting for authentication");
break;
case PK_STATUS_ENUM_SCAN_PROCESS_LIST:
/* TRANSLATORS: transaction state, we are updating the list of processes */
text = _("Updating running applications");
break;
case PK_STATUS_ENUM_CHECK_EXECUTABLE_FILES:
/* TRANSLATORS: transaction state, we are checking executable files currently in use */
text = _("Checking applications in use");
break;
case PK_STATUS_ENUM_CHECK_LIBRARIES:
/* TRANSLATORS: transaction state, we are checking for libraries currently in use */
text = _("Checking libraries in use");
break;
case PK_STATUS_ENUM_COPY_FILES:
/* TRANSLATORS: transaction state, we are copying package files before or after the transaction */
text = _("Copying files");
break;
default:
g_warning ("status unrecognised: %s", pk_status_enum_to_string (status));
}
return text;
}
