/** * 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); }