/**
* pk_backend_job_require_restart:
**/
void
pk_backend_job_require_restart (PkBackendJob *job,
PkRestartEnum restart,
const gchar *package_id)
{
_cleanup_object_unref_ PkRequireRestart *item = NULL;
g_return_if_fail (PK_IS_BACKEND_JOB (job));
/* have we already set an error? */
if (job->priv->set_error) {
g_warning ("already set error: require-restart %s", pk_restart_enum_to_string (restart));
return;
}
/* check we are valid */
if (!pk_package_id_check (package_id)) {
g_warning ("package_id invalid and cannot be processed: %s", package_id);
return;
}
/* form PkRequireRestart struct */
item = pk_require_restart_new ();
g_object_set (item,
"restart", restart,
"package-id", package_id,
NULL);
/* emit */
pk_backend_job_call_vfunc (job,
PK_BACKEND_SIGNAL_REQUIRE_RESTART,
g_object_ref (item),
g_object_unref);
}
/**
* pk_backend_job_set_transaction_flags:
**/
void
pk_backend_job_set_transaction_flags (PkBackendJob *job,
PkBitfield transaction_flags)
{
g_return_if_fail (PK_IS_BACKEND_JOB (job));
job->priv->transaction_flags = transaction_flags;
}
/**
* pk_backend_job_thread_create:
* @func: (scope call):
**/
gboolean
pk_backend_job_thread_create (PkBackendJob *job,
PkBackendJobThreadFunc func,
gpointer user_data,
GDestroyNotify destroy_func)
{
PkBackendJobThreadHelper *helper = NULL;
g_return_val_if_fail (PK_IS_BACKEND_JOB (job), FALSE);
g_return_val_if_fail (func != NULL, FALSE);
g_return_val_if_fail (pk_is_thread_default (), FALSE);
/* create a helper object to allow us to call a _setup() function */
helper = g_new0 (PkBackendJobThreadHelper, 1);
helper->job = g_object_ref (job);
helper->backend = job->priv->backend;
helper->func = func;
helper->user_data = user_data;
/* create a thread and unref it immediately as we do not need to join()
* this at any stage */
g_thread_unref (g_thread_new ("PK-Backend",
pk_backend_job_thread_setup,
helper));
return TRUE;
}
/**
* pk_backend_job_thread_create:
* @func: (scope call):
**/
gboolean
pk_backend_job_thread_create (PkBackendJob *job,
PkBackendJobThreadFunc func,
gpointer user_data,
GDestroyNotify destroy_func)
{
PkBackendJobThreadHelper *helper = NULL;
g_return_val_if_fail (PK_IS_BACKEND_JOB (job), FALSE);
g_return_val_if_fail (func != NULL, FALSE);
g_return_val_if_fail (pk_is_thread_default (), FALSE);
if (job->priv->thread != NULL) {
g_warning ("already has thread");
return FALSE;
}
/* create a helper object to allow us to call a _setup() function */
helper = g_new0 (PkBackendJobThreadHelper, 1);
helper->job = g_object_ref (job);
helper->backend = job->priv->backend;
helper->func = func;
helper->user_data = user_data;
/* create a thread */
job->priv->thread = g_thread_new ("PK-Backend",
pk_backend_job_thread_setup,
helper);
if (job->priv->thread == NULL) {
g_warning ("failed to create thread");
return FALSE;
}
return TRUE;
}
/**
* pk_backend_job_set_download_size_remaining:
**/
void
pk_backend_job_set_download_size_remaining (PkBackendJob *job, guint64 download_size_remaining)
{
guint64 *tmp;
g_return_if_fail (PK_IS_BACKEND_JOB (job));
/* have we already set an error? */
if (job->priv->set_error) {
g_warning ("already set error: download-size-remaining");
return;
}
/* set the same twice? */
if (job->priv->download_size_remaining == download_size_remaining)
return;
/* set new value */
job->priv->download_size_remaining = download_size_remaining;
/* we can't squash a 64bit value into a pointer on a 32bit arch */
tmp = g_new0 (guint64, 1);
*tmp = download_size_remaining;
pk_backend_job_call_vfunc (job,
PK_BACKEND_SIGNAL_DOWNLOAD_SIZE_REMAINING,
tmp,
g_free);
}
/**
* pk_backend_job_category:
**/
void
pk_backend_job_category (PkBackendJob *job,
const gchar *parent_id,
const gchar *cat_id,
const gchar *name,
const gchar *summary,
const gchar *icon)
{
_cleanup_object_unref_ PkCategory *item = NULL;
g_return_if_fail (PK_IS_BACKEND_JOB (job));
g_return_if_fail (cat_id != NULL);
/* have we already set an error? */
if (job->priv->set_error) {
g_warning ("already set error: category %s", cat_id);
return;
}
/* form PkCategory struct */
item = pk_category_new ();
g_object_set (item,
"parent-id", parent_id,
"cat-id", cat_id,
"name", name,
"summary", summary,
"icon", icon,
NULL);
/* emit */
pk_backend_job_call_vfunc (job,
PK_BACKEND_SIGNAL_CATEGORY,
g_object_ref (item),
g_object_unref);
}
/**
* pk_backend_job_error_code:
**/
void
pk_backend_job_error_code (PkBackendJob *job,
PkErrorEnum error_code,
const gchar *format, ...)
{
va_list args;
gboolean need_untrusted;
_cleanup_free_ gchar *buffer = NULL;
_cleanup_object_unref_ PkError *error = NULL;
g_return_if_fail (PK_IS_BACKEND_JOB (job));
va_start (args, format);
buffer = g_strdup_vprintf (format, args);
va_end (args);
/* did we set a duplicate error? (we can override LOCK_REQUIRED errors,
* so the transaction list can fail transactions) */
if (job->priv->set_error) {
if (job->priv->last_error_code == PK_ERROR_ENUM_LOCK_REQUIRED) {
/* reset the exit status, we're resetting the error now */
job->priv->exit = PK_EXIT_ENUM_UNKNOWN;
job->priv->finished = FALSE;
} else {
g_warning ("More than one error emitted! You tried to set '%s'", buffer);
return;
}
}
job->priv->set_error = TRUE;
/* some error codes have a different exit code */
need_untrusted = pk_backend_job_error_code_is_need_untrusted (error_code);
if (need_untrusted)
pk_backend_job_set_exit_code (job, PK_EXIT_ENUM_NEED_UNTRUSTED);
else if (error_code == PK_ERROR_ENUM_CANCELLED_PRIORITY)
pk_backend_job_set_exit_code (job, PK_EXIT_ENUM_CANCELLED_PRIORITY);
else if (job->priv->exit == PK_EXIT_ENUM_UNKNOWN)
pk_backend_job_set_exit_code (job, PK_EXIT_ENUM_FAILED);
/* set the hint that RepairSystem is needed */
if (error_code == PK_ERROR_ENUM_UNFINISHED_TRANSACTION) {
pk_backend_job_set_exit_code (job, PK_EXIT_ENUM_REPAIR_REQUIRED);
}
/* save so we can check the parallel failure later */
job->priv->last_error_code = error_code;
/* form PkError struct */
error = pk_error_new ();
g_object_set (error,
"code", error_code,
"details", buffer,
NULL);
/* emit */
pk_backend_job_call_vfunc (job,
PK_BACKEND_SIGNAL_ERROR_CODE,
g_object_ref (error),
g_object_unref);
}
/**
* pk_backend_job_media_change_required:
**/
void
pk_backend_job_media_change_required (PkBackendJob *job,
PkMediaTypeEnum media_type,
const gchar *media_id,
const gchar *media_text)
{
_cleanup_object_unref_ PkMediaChangeRequired *item = NULL;
g_return_if_fail (PK_IS_BACKEND_JOB (job));
g_return_if_fail (media_id != NULL);
g_return_if_fail (media_text != NULL);
/* have we already set an error? */
if (job->priv->set_error) {
g_warning ("already set error: media change required");
return;
}
/* form PkMediaChangeRequired struct */
item = pk_media_change_required_new ();
g_object_set (item,
"media-type", media_type,
"media-id", media_id,
"media-text", media_text,
NULL);
/* emit */
pk_backend_job_call_vfunc (job,
PK_BACKEND_SIGNAL_MEDIA_CHANGE_REQUIRED,
g_object_ref (item),
g_object_unref);
}
/**
* pk_backend_job_repo_detail:
**/
void
pk_backend_job_repo_detail (PkBackendJob *job,
const gchar *repo_id,
const gchar *description,
gboolean enabled)
{
_cleanup_object_unref_ PkRepoDetail *item = NULL;
g_return_if_fail (PK_IS_BACKEND_JOB (job));
g_return_if_fail (repo_id != NULL);
/* have we already set an error? */
if (job->priv->set_error) {
g_warning ("already set error: repo-detail %s", repo_id);
return;
}
/* form PkRepoDetail struct */
item = pk_repo_detail_new ();
g_object_set (item,
"repo-id", repo_id,
"description", description,
"enabled", enabled,
NULL);
/* emit */
pk_backend_job_call_vfunc (job,
PK_BACKEND_SIGNAL_REPO_DETAIL,
g_object_ref (item),
g_object_unref);
}
/**
* pk_backend_job_set_item_progress:
**/
void
pk_backend_job_set_item_progress (PkBackendJob *job,
const gchar *package_id,
PkStatusEnum status,
guint percentage)
{
PkItemProgress *item;
g_return_if_fail (PK_IS_BACKEND_JOB (job));
/* have we already set an error? */
if (job->priv->set_error) {
g_warning ("already set error: item-progress %i", percentage);
return;
}
/* invalid number? */
if (percentage > 100 && percentage != PK_BACKEND_PERCENTAGE_INVALID) {
g_debug ("invalid number %i", percentage);
return;
}
/* emit */
item = g_object_new (PK_TYPE_ITEM_PROGRESS,
"package-id", package_id,
"status", status,
"percentage", percentage,
NULL);
pk_backend_job_call_vfunc (job,
PK_BACKEND_SIGNAL_ITEM_PROGRESS,
g_object_ref (item),
g_object_unref);
g_object_unref (item);
}
/**
* pk_backend_job_distro_upgrade:
**/
void
pk_backend_job_distro_upgrade (PkBackendJob *job,
PkDistroUpgradeEnum state,
const gchar *name,
const gchar *summary)
{
_cleanup_object_unref_ PkDistroUpgrade *item = NULL;
g_return_if_fail (PK_IS_BACKEND_JOB (job));
g_return_if_fail (state != PK_DISTRO_UPGRADE_ENUM_UNKNOWN);
g_return_if_fail (name != NULL);
g_return_if_fail (summary != NULL);
/* have we already set an error? */
if (job->priv->set_error) {
g_warning ("already set error: distro-upgrade");
return;
}
/* form PkDistroUpgrade struct */
item = pk_distro_upgrade_new ();
g_object_set (item,
"state", state,
"name", name,
"summary", summary,
NULL);
/* emit */
pk_backend_job_call_vfunc (job,
PK_BACKEND_SIGNAL_DISTRO_UPGRADE,
g_object_ref (item),
g_object_unref);
}
/**
* pk_backend_job_set_parameters:
**/
void
pk_backend_job_set_parameters (PkBackendJob *job, GVariant *params)
{
g_return_if_fail (PK_IS_BACKEND_JOB (job));
g_return_if_fail (params != NULL);
job->priv->params = g_variant_ref_sink (params);
}
/**
* pk_backend_job_set_cmdline:
**/
void
pk_backend_job_set_cmdline (PkBackendJob *job, const gchar *cmdline)
{
g_return_if_fail (PK_IS_BACKEND_JOB (job));
g_free (job->priv->cmdline);
job->priv->cmdline = g_strdup (cmdline);
g_debug ("install cmdline now %s", job->priv->cmdline);
}
/**
* 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);
}
/**
* pk_backend_job_set_uid:
**/
void
pk_backend_job_set_uid (PkBackendJob *job, guint uid)
{
g_return_if_fail (PK_IS_BACKEND_JOB (job));
if (job->priv->uid == uid)
return;
job->priv->uid = uid;
g_debug ("install uid now %i", job->priv->uid);
}
/**
* pk_backend_job_set_locked:
*
* Set if your backend job currently locks the cache, so no other tool will
* have write access on it. (read-only transactions will still be permitted)
**/
void
pk_backend_job_set_locked (PkBackendJob *job, gboolean locked)
{
g_return_if_fail (PK_IS_BACKEND_JOB (job));
job->priv->locked = locked;
pk_backend_job_call_vfunc (job,
PK_BACKEND_SIGNAL_LOCKED_CHANGED,
GUINT_TO_POINTER (job->priv->locked),
NULL);
}
/**
* pk_backend_job_set_frontend_socket:
**/
void
pk_backend_job_set_frontend_socket (PkBackendJob *job, const gchar *frontend_socket)
{
g_return_if_fail (PK_IS_BACKEND_JOB (job));
if (g_strcmp0 (job->priv->frontend_socket, frontend_socket) == 0)
return;
g_debug ("frontend_socket changed to %s", frontend_socket);
g_free (job->priv->frontend_socket);
job->priv->frontend_socket = g_strdup (frontend_socket);
}
/**
* pk_backend_job_set_locale:
**/
void
pk_backend_job_set_locale (PkBackendJob *job, const gchar *code)
{
g_return_if_fail (PK_IS_BACKEND_JOB (job));
g_return_if_fail (code != NULL);
if (g_strcmp0 (job->priv->locale, code) == 0)
return;
g_debug ("locale changed to %s", code);
g_free (job->priv->locale);
job->priv->locale = g_strdup (code);
}
/**
* pk_backend_job_repo_signature_required:
**/
void
pk_backend_job_repo_signature_required (PkBackendJob *job,
const gchar *package_id,
const gchar *repository_name,
const gchar *key_url,
const gchar *key_userid,
const gchar *key_id,
const gchar *key_fingerprint,
const gchar *key_timestamp,
PkSigTypeEnum type)
{
_cleanup_object_unref_ PkRepoSignatureRequired *item = NULL;
g_return_if_fail (PK_IS_BACKEND_JOB (job));
g_return_if_fail (repository_name != NULL);
/* have we already set an error? */
if (job->priv->set_error) {
g_warning ("already set error: repo-sig-reqd");
return;
}
/* check we don't do this more than once */
if (job->priv->set_signature) {
g_warning ("already asked for a signature, cannot process");
return;
}
/* form PkRepoSignatureRequired struct */
item = pk_repo_signature_required_new ();
g_object_set (item,
"package-id", package_id,
"repository-name", repository_name,
"key-url", key_url,
"key-userid", key_userid,
"key-id", key_id,
"key-fingerprint", key_fingerprint,
"key-timestamp", key_timestamp,
"type", type,
NULL);
/* emit */
pk_backend_job_call_vfunc (job,
PK_BACKEND_SIGNAL_REPO_SIGNATURE_REQUIRED,
g_object_ref (item),
g_object_unref);
/* success */
job->priv->set_signature = TRUE;
}
/**
* pk_backend_cancel:
*/
void
pk_backend_cancel (PkBackend *backend, PkBackendJob *job)
{
GCancellable *cancellable;
g_return_if_fail (PK_IS_BACKEND (backend));
g_return_if_fail (PK_IS_BACKEND_JOB (job));
/* cancel */
cancellable = pk_backend_job_get_cancellable (job);
g_cancellable_cancel (cancellable);
/* call into the backend */
backend->priv->desc->cancel (backend, job);
}
/**
* pk_backend_job_set_exit_code:
*
* Should only be used internally, or from PkRunner when setting CANCELLED.
**/
void
pk_backend_job_set_exit_code (PkBackendJob *job, PkExitEnum exit_enum)
{
g_return_if_fail (PK_IS_BACKEND_JOB (job));
if (job->priv->exit != PK_EXIT_ENUM_UNKNOWN) {
g_warning ("already set exit status: old=%s, new=%s",
pk_exit_enum_to_string (job->priv->exit),
pk_exit_enum_to_string (exit_enum));
return;
}
/* new value */
job->priv->exit = exit_enum;
}
/**
* pk_backend_job_set_vfunc:
* @job: A valid PkBackendJob
* @signal_kind: Kind of the backend signal we want to connect
* @vfunc: (scope call): The function we want to call
* @user_data: User data we want to pass to the callback
*
* Connect backend
**/
void
pk_backend_job_set_vfunc (PkBackendJob *job,
PkBackendJobSignal signal_kind,
PkBackendJobVFunc vfunc,
gpointer user_data)
{
PkBackendJobVFuncItem *item;
g_return_if_fail (PK_IS_BACKEND_JOB (job));
item = &job->priv->vfunc_items[signal_kind];
item->enabled = TRUE;
item->vfunc = vfunc;
item->user_data = user_data;
}
/**
* pk_backend_job_finished:
**/
void
pk_backend_job_finished (PkBackendJob *job)
{
const gchar *role_text;
g_return_if_fail (PK_IS_BACKEND_JOB (job));
/* check we have not already finished */
if (job->priv->finished) {
g_warning ("already finished");
return;
}
/* find out what we just did */
role_text = pk_role_enum_to_string (job->priv->role);
/* ensure the same number of ::Files() were sent as packages for DownloadPackages */
if (!job->priv->set_error &&
job->priv->role == PK_ROLE_ENUM_DOWNLOAD_PACKAGES &&
job->priv->download_files == 0) {
g_warning ("required multiple Files() for each package_id!");
}
/* check we sent at least one status calls */
if (job->priv->set_error == FALSE &&
job->priv->status == PK_STATUS_ENUM_SETUP) {
g_warning ("required status signals for %s!", role_text);
}
/* drop any inhibits */
pk_backend_job_set_allow_cancel (job, TRUE);
/* mark as finished for the UI that might only be watching status */
pk_backend_job_set_status (job, PK_STATUS_ENUM_FINISHED);
/* we can't ever be re-used */
job->priv->finished = TRUE;
/* this wasn't set otherwise, assume success */
if (job->priv->exit == PK_EXIT_ENUM_UNKNOWN)
pk_backend_job_set_exit_code (job, PK_EXIT_ENUM_SUCCESS);
/* emit */
pk_backend_job_call_vfunc (job,
PK_BACKEND_SIGNAL_FINISHED,
GUINT_TO_POINTER (job->priv->exit),
NULL);
}
/**
* pk_backend_job_set_allow_cancel:
**/
void
pk_backend_job_set_allow_cancel (PkBackendJob *job, gboolean allow_cancel)
{
g_return_if_fail (PK_IS_BACKEND_JOB (job));
/* same as last state? */
if (job->priv->allow_cancel == allow_cancel)
return;
/* emit */
job->priv->allow_cancel = allow_cancel;
pk_backend_job_call_vfunc (job,
PK_BACKEND_SIGNAL_ALLOW_CANCEL,
GUINT_TO_POINTER (allow_cancel),
NULL);
}
/**
* pk_backend_job_eula_required:
**/
void
pk_backend_job_eula_required (PkBackendJob *job,
const gchar *eula_id,
const gchar *package_id,
const gchar *vendor_name,
const gchar *license_agreement)
{
_cleanup_object_unref_ PkEulaRequired *item = NULL;
g_return_if_fail (PK_IS_BACKEND_JOB (job));
g_return_if_fail (eula_id != NULL);
g_return_if_fail (package_id != NULL);
g_return_if_fail (vendor_name != NULL);
g_return_if_fail (license_agreement != NULL);
/* have we already set an error? */
if (job->priv->set_error) {
g_warning ("already set error: eula required");
return;
}
/* check we don't do this more than once */
if (job->priv->set_eula) {
g_warning ("already asked for a signature, cannot process");
return;
}
/* form PkEulaRequired struct */
item = pk_eula_required_new ();
g_object_set (item,
"eula-id", eula_id,
"package-id", package_id,
"vendor-name", vendor_name,
"license-agreement", license_agreement,
NULL);
/* emit */
pk_backend_job_call_vfunc (job,
PK_BACKEND_SIGNAL_EULA_REQUIRED,
g_object_ref (item),
g_object_unref);
/* success */
job->priv->set_eula = TRUE;
}
/**
* pk_backend_job_files:
*
* package_id is NULL when we are using this as a calback from DownloadPackages
**/
void
pk_backend_job_files (PkBackendJob *job,
const gchar *package_id,
gchar **files)
{
_cleanup_object_unref_ PkFiles *item = NULL;
g_return_if_fail (PK_IS_BACKEND_JOB (job));
g_return_if_fail (files != NULL);
/* have we already set an error? */
if (job->priv->set_error) {
g_warning ("already set error: files %s", package_id);
return;
}
/* check we are valid if specified */
if (package_id != NULL) {
if (!pk_package_id_check (package_id)) {
g_warning ("package_id invalid and cannot be processed: %s", package_id);
return;
}
}
/* form PkFiles struct */
item = pk_files_new ();
g_object_set (item,
"package-id", package_id,
"files", files,
NULL);
/* emit */
pk_backend_job_call_vfunc (job,
PK_BACKEND_SIGNAL_FILES,
g_object_ref (item),
g_object_unref);
/* success */
job->priv->download_files++;
}
/**
* pk_backend_job_set_speed:
**/
void
pk_backend_job_set_speed (PkBackendJob *job, guint speed)
{
g_return_if_fail (PK_IS_BACKEND_JOB (job));
/* have we already set an error? */
if (job->priv->set_error) {
g_warning ("already set error: speed %i", speed);
return;
}
/* set the same twice? */
if (job->priv->speed == speed)
return;
/* set new value */
job->priv->speed = speed;
pk_backend_job_call_vfunc (job,
PK_BACKEND_SIGNAL_SPEED,
GUINT_TO_POINTER (speed),
NULL);
}
/**
* pk_backend_job_details:
**/
void
pk_backend_job_details (PkBackendJob *job,
const gchar *package_id,
const gchar *summary,
const gchar *license,
PkGroupEnum group,
const gchar *description,
const gchar *url,
gulong size)
{
_cleanup_object_unref_ PkDetails *item = NULL;
g_return_if_fail (PK_IS_BACKEND_JOB (job));
g_return_if_fail (package_id != NULL);
/* have we already set an error? */
if (job->priv->set_error) {
g_warning ("already set error: details %s", package_id);
return;
}
/* form PkDetails struct */
item = pk_details_new ();
g_object_set (item,
"package-id", package_id,
"summary", summary,
"license", license,
"group", group,
"description", description,
"url", url,
"size", (guint64) size,
NULL);
/* emit */
pk_backend_job_call_vfunc (job,
PK_BACKEND_SIGNAL_DETAILS,
g_object_ref (item),
g_object_unref);
}
/**
* pk_backend_job_set_proxy:
**/
void
pk_backend_job_set_proxy (PkBackendJob *job,
const gchar *proxy_http,
const gchar *proxy_https,
const gchar *proxy_ftp,
const gchar *proxy_socks,
const gchar *no_proxy,
const gchar *pac)
{
g_return_if_fail (PK_IS_BACKEND_JOB (job));
g_free (job->priv->proxy_http);
g_free (job->priv->proxy_https);
g_free (job->priv->proxy_ftp);
g_free (job->priv->proxy_socks);
g_free (job->priv->no_proxy);
g_free (job->priv->pac);
job->priv->proxy_http = g_strdup (proxy_http);
job->priv->proxy_https = g_strdup (proxy_https);
job->priv->proxy_ftp = g_strdup (proxy_ftp);
job->priv->proxy_socks = g_strdup (proxy_socks);
job->priv->no_proxy = g_strdup (no_proxy);
job->priv->pac = g_strdup (pac);
}
/**
* pk_backend_job_set_percentage:
**/
void
pk_backend_job_set_percentage (PkBackendJob *job, guint percentage)
{
g_return_if_fail (PK_IS_BACKEND_JOB (job));
/* have we already set an error? */
if (job->priv->set_error) {
g_warning ("already set error: percentage %i", percentage);
return;
}
/* set the same twice? */
if (job->priv->percentage == percentage)
return;
/* check over */
if (percentage > PK_BACKEND_PERCENTAGE_INVALID) {
g_warning ("percentage value is invalid: %i", percentage);
return;
}
/* check under */
if (percentage < 100 &&
job->priv->percentage < 100 &&
percentage < job->priv->percentage) {
g_warning ("percentage value is going down to %i from %i",
percentage, job->priv->percentage);
return;
}
/* save in case we need this from coldplug */
job->priv->percentage = percentage;
pk_backend_job_call_vfunc (job,
PK_BACKEND_SIGNAL_PERCENTAGE,
GUINT_TO_POINTER (percentage),
NULL);
}
