static gboolean pk_backend_depends_on_thread (PkBackend *self) { gchar **packages; alpm_list_t *i, *pkgs = NULL; GError *error = NULL; g_return_val_if_fail (self != NULL, FALSE); packages = pk_backend_get_strv (self, "package_ids"); g_return_val_if_fail (packages != NULL, FALSE); /* construct an initial package list */ for (; *packages != NULL; ++packages) { alpm_pkg_t *pkg; if (pk_backend_cancelled (self)) { break; } pkg = pk_backend_find_pkg (self, *packages, &error); if (pkg == NULL) { break; } pkgs = alpm_list_add (pkgs, pkg); } /* package list might be modified along the way but that is ok */ for (i = pkgs; i != NULL; i = i->next) { const alpm_list_t *depends; if (pk_backend_cancelled (self) || error != NULL) { break; } depends = alpm_pkg_depends_on (i->data); for (; depends != NULL; depends = depends->next) { gchar *depend; if (pk_backend_cancelled (self) || error != NULL) { break; } depend = alpm_dep_compute_string (depends->data); pkgs = pk_backend_find_provider (self, pkgs, depend, &error); free (depend); } } alpm_list_free (pkgs); return pk_backend_finish (self, NULL); }
static gboolean pk_backend_required_by_thread (PkBackend *self) { gchar **packages; alpm_list_t *i, *pkgs = NULL; GError *error = NULL; g_return_val_if_fail (self != NULL, FALSE); packages = pk_backend_get_strv (self, "package_ids"); g_return_val_if_fail (packages != NULL, FALSE); /* construct an initial package list */ for (; *packages != NULL; ++packages) { alpm_pkg_t *pkg; if (pk_backend_cancelled (self)) { break; } pkg = pk_backend_find_pkg (self, *packages, &error); if (pkg == NULL) { break; } pkgs = alpm_list_add (pkgs, pkg); } /* package list might be modified along the way but that is ok */ for (i = pkgs; i != NULL; i = i->next) { alpm_list_t *requiredby; if (pk_backend_cancelled (self) || error != NULL) { break; } requiredby = alpm_pkg_compute_requiredby (i->data); for (; requiredby != NULL; requiredby = requiredby->next) { if (pk_backend_cancelled (self) || error != NULL) { break; } pkgs = pk_backend_find_requirer (self, pkgs, requiredby->data, &error); } FREELIST (requiredby); } alpm_list_free (pkgs); return pk_backend_finish (self, error); }
static gboolean pk_backend_resolve_thread (PkBackend *self) { gchar **packages; GError *error = NULL; g_return_val_if_fail (self != NULL, FALSE); packages = pk_backend_get_strv (self, "package_ids"); g_return_val_if_fail (packages != NULL, FALSE); for (; *packages != NULL; ++packages) { if (pk_backend_cancelled (self)) { break; } /* find a package with the given id or name */ if (pk_package_id_check (*packages)) { if (!pk_backend_resolve_package (self, *packages, &error)) { break; } } else { if (!pk_backend_resolve_name (self, *packages, &error)) { break; } } } return pk_backend_finish (self, error); }
void pk_backend_transaction_packages (PkBackend *self) { const alpm_list_t *i; PkInfoEnum info; g_return_if_fail (self != NULL); g_return_if_fail (alpm != NULL); g_return_if_fail (localdb != NULL); /* emit packages that would have been installed */ for (i = alpm_trans_get_add (alpm); i != NULL; i = i->next) { if (pk_backend_cancelled (self)) { break; } else { const gchar *name = alpm_pkg_get_name (i->data); if (alpm_db_get_pkg (localdb, name) != NULL) { info = PK_INFO_ENUM_UPDATING; } else { info = PK_INFO_ENUM_INSTALLING; } pk_backend_pkg (self, i->data, info); } } switch (pk_backend_job_get_role (self)) { case PK_ROLE_ENUM_SIMULATE_UPDATE_PACKAGES: info = PK_INFO_ENUM_OBSOLETING; break; default: info = PK_INFO_ENUM_REMOVING; break; } /* emit packages that would have been removed */ for (i = alpm_trans_get_remove (alpm); i != NULL; i = i->next) { if (pk_backend_cancelled (self)) { break; } else { pk_backend_pkg (self, i->data, info); } } }
gboolean pk_backend_transaction_commit (PkBackend *self, GError **error) { alpm_list_t *data = NULL; gchar *prefix; g_return_val_if_fail (self != NULL, FALSE); g_return_val_if_fail (alpm != NULL, FALSE); if (pk_backend_cancelled (self)) { return TRUE; } pk_backend_job_set_allow_cancel (self, FALSE); pk_backend_job_set_status (self, PK_STATUS_ENUM_RUNNING); if (alpm_trans_commit (alpm, &data) >= 0) { return TRUE; } switch (alpm_errno (alpm)) { case ALPM_ERR_FILE_CONFLICTS: prefix = alpm_fileconflict_build_list (data); alpm_list_free_inner (data, alpm_fileconflict_free); alpm_list_free (data); break; case ALPM_ERR_PKG_INVALID: case ALPM_ERR_DLT_INVALID: prefix = alpm_string_build_list (data); alpm_list_free (data); break; default: prefix = NULL; if (data != NULL) { g_warning ("unhandled error %d", alpm_errno (alpm)); } break; } if (prefix != NULL) { alpm_errno_t errno = alpm_errno (alpm); g_set_error (error, ALPM_ERROR, errno, "%s: %s", prefix, alpm_strerror (errno)); g_free (prefix); } else { alpm_errno_t errno = alpm_errno (alpm); g_set_error_literal (error, ALPM_ERROR, errno, alpm_strerror (errno)); } return FALSE; }
static gboolean pk_backend_update_databases (PkBackend *self, gint force, GError **error) { alpm_cb_download dlcb; alpm_cb_totaldl totaldlcb; const alpm_list_t *i; g_return_val_if_fail (self != NULL, FALSE); if (!pk_backend_transaction_initialize (self, 0, error)) { return FALSE; } alpm_logaction ("synchronizing package lists\n"); dlcb = alpm_option_get_dlcb (); totaldlcb = alpm_option_get_totaldlcb (); /* set total size to minus the number of databases */ i = alpm_option_get_syncdbs (); totaldlcb (-alpm_list_count (i)); for (; i != NULL; i = i->next) { gint result; if (pk_backend_cancelled (self)) { /* pretend to be finished */ i = NULL; break; } result = alpm_db_update (force, i->data); if (result > 0) { /* fake the download when already up to date */ dlcb ("", 1, 1); } else if (result < 0) { g_set_error (error, ALPM_ERROR, pm_errno, "[%s]: %s", alpm_db_get_name (i->data), alpm_strerrorlast ()); break; } } totaldlcb (0); if (i == NULL) { return pk_backend_transaction_end (self, error); } else { pk_backend_transaction_end (self, NULL); return FALSE; } }
static gboolean pk_backend_get_repo_list_thread (PkBackend *self) { const alpm_list_t *i; GHashTableIter iter; gpointer key, value; g_return_val_if_fail (self != NULL, FALSE); g_return_val_if_fail (alpm != NULL, FALSE); g_return_val_if_fail (disabled != NULL, FALSE); /* emit enabled repos */ for (i = alpm_get_syncdbs (alpm); i != NULL; i = i->next) { alpm_db_t *db = (alpm_db_t *) i->data; const gchar *repo = alpm_db_get_name (db); if (pk_backend_cancelled (self)) { goto out; } else { pk_backend_repo_info (self, repo, TRUE); } } /* emit disabled repos */ g_hash_table_iter_init (&iter, disabled); while (g_hash_table_iter_next (&iter, &key, &value)) { const gchar *repo = (const gchar *) key; if (pk_backend_cancelled (self)) { goto out; } else { pk_backend_repo_info (self, repo, FALSE); } } out: return pk_backend_finish (self, NULL); }
static void pk_backend_get_repo_list_thread (PkBackendJob *job, GVariant *params, gpointer user_data) { const alpm_list_t *i; GHashTableIter iter; gpointer key, value; g_return_val_if_fail (self != NULL, FALSE); g_return_val_if_fail (disabled != NULL, FALSE); /* emit enabled repos */ for (i = alpm_option_get_syncdbs (); i != NULL; i = i->next) { pmdb_t *db = (pmdb_t *) i->data; const gchar *repo = alpm_db_get_name (db); if (pk_backend_cancelled (self)) { goto out; } else { pk_backend_repo_info (self, repo, TRUE); } } /* emit disabled repos */ g_hash_table_iter_init (&iter, disabled); while (g_hash_table_iter_next (&iter, &key, &value)) { const gchar *repo = (const gchar *) key; if (pk_backend_cancelled (self)) { goto out; } else { pk_backend_repo_info (self, repo, FALSE); } } out: pk_backend_finish (self, NULL); }
static gboolean pk_backend_get_updates_thread (PkBackend *self) { struct stat cache; time_t one_hour_ago; const alpm_list_t *i, *syncdbs; g_return_val_if_fail (self != NULL, FALSE); g_return_val_if_fail (localdb != NULL, FALSE); time (&one_hour_ago); one_hour_ago -= 60 * 60; /* refresh databases if they are older than an hour */ if (g_stat (ALPM_CACHE_PATH, &cache) < 0 || cache.st_mtime < one_hour_ago) { GError *error = NULL; /* show updates even if the databases could not be updated */ if (!pk_backend_update_databases (self, 0, &error)) { g_warning ("%s", error->message); } } else { g_debug ("databases have been refreshed recently"); } /* find outdated and replacement packages */ syncdbs = alpm_option_get_syncdbs (); for (i = alpm_db_get_pkgcache (localdb); i != NULL; i = i->next) { pmpkg_t *upgrade = alpm_pkg_find_update (i->data, syncdbs); if (pk_backend_cancelled (self)) { break; } else if (upgrade != NULL) { PkInfoEnum info; if (alpm_pkg_is_ignorepkg (upgrade)) { info = PK_INFO_ENUM_BLOCKED; } else if (alpm_pkg_is_syncfirst (upgrade)) { info = PK_INFO_ENUM_IMPORTANT; } else { info = PK_INFO_ENUM_NORMAL; } pk_backend_pkg (self, upgrade, info); } } return pk_backend_finish (self, NULL); }
static gboolean pk_backend_get_files_thread (PkBackend *self) { gchar **packages; GError *error = NULL; g_return_val_if_fail (self != NULL, FALSE); g_return_val_if_fail (alpm != NULL, FALSE); packages = pk_backend_get_strv (self, "package_ids"); g_return_val_if_fail (packages != NULL, FALSE); for (; *packages != NULL; ++packages) { alpm_pkg_t *pkg; const gchar *root; GString *files; alpm_filelist_t *filelist; gsize i; if (pk_backend_cancelled (self)) { break; } pkg = pk_backend_find_pkg (self, *packages, &error); if (pkg == NULL) { break; } root = alpm_option_get_root (alpm); files = g_string_new (""); filelist = alpm_pkg_get_files (pkg); for (i = 0; i < filelist->count; ++i) { const gchar *file = filelist->files[i].name; g_string_append_printf (files, "%s%s;", root, file); } g_string_truncate (files, MAX (files->len, 1) - 1); pk_backend_job_files (self, *packages, files->str); g_string_free (files, TRUE); } return pk_backend_finish (self, error); }
static gboolean pk_backend_get_update_detail_thread (PkBackend *self) { gchar **packages; GError *error = NULL; g_return_val_if_fail (self != NULL, FALSE); g_return_val_if_fail (localdb != NULL, FALSE); packages = pk_backend_get_strv (self, "package_ids"); g_return_val_if_fail (packages != NULL, FALSE); /* collect details about updates */ for (; *packages != NULL; ++packages) { pmpkg_t *pkg, *old; pmdb_t *db; gchar *upgrades, *replaces, *urls; const gchar *reason; PkRestartEnum restart; PkUpdateStateEnum state; GTimeVal built = { 0 }, installed = { 0 }; gchar *issued, *updated; if (pk_backend_cancelled (self)) { break; } pkg = pk_backend_find_pkg (self, *packages, &error); if (pkg == NULL) { break; } old = alpm_db_get_pkg (localdb, alpm_pkg_get_name (pkg)); if (old != NULL) { upgrades = alpm_pkg_build_id (old); if (alpm_pkg_same_pkgver (pkg, old)) { reason = "Update to a newer release"; } else { reason = "Update to a new upstream version"; } } else { upgrades = NULL; reason = "Install to replace an older package"; } db = alpm_pkg_get_db (pkg); replaces = alpm_pkg_build_replaces (pkg); urls = alpm_pkg_build_urls (pkg); if (g_str_has_prefix (alpm_pkg_get_name (pkg), "kernel")) { restart = PK_RESTART_ENUM_SYSTEM; } else { restart = PK_RESTART_ENUM_NONE; } if (g_str_has_suffix (alpm_db_get_name (db), "testing")) { state = PK_UPDATE_STATE_ENUM_TESTING; } else { state = PK_UPDATE_STATE_ENUM_STABLE; } built.tv_sec = alpm_pkg_get_builddate (pkg); if (built.tv_sec > 0) { issued = g_time_val_to_iso8601 (&built); } else { issued = NULL; } if (upgrades != NULL) { installed.tv_sec = alpm_pkg_get_installdate (old); if (installed.tv_sec > 0) { updated = g_time_val_to_iso8601 (&installed); } else { updated = NULL; } } else { updated = NULL; } pk_backend_update_detail (self, *packages, upgrades, replaces, urls, NULL, NULL, restart, reason, NULL, state, issued, updated); g_free (issued); g_free (updated); g_free (urls); g_free (replaces); g_free (upgrades); } return pk_backend_finish (self, error); }
static gboolean pk_backend_get_details_thread (PkBackend *self) { gchar **packages; GError *error = NULL; g_return_val_if_fail (self != NULL, FALSE); g_return_val_if_fail (localdb != NULL, FALSE); packages = pk_backend_get_strv (self, "package_ids"); g_return_val_if_fail (packages != NULL, FALSE); for (; *packages != NULL; ++packages) { alpm_pkg_t *pkg; const alpm_list_t *i; GString *licenses; PkGroupEnum group; const gchar *desc, *url; gulong size; if (pk_backend_cancelled (self)) { break; } pkg = pk_backend_find_pkg (self, *packages, &error); if (pkg == NULL) { break; } i = alpm_pkg_get_licenses (pkg); if (i == NULL) { licenses = g_string_new ("Unknown"); } else { licenses = g_string_new ((const gchar *) i->data); while ((i = i->next) != NULL) { const gchar *license = (const gchar *) i->data; /* assume OR although it may not be correct */ g_string_append_printf (licenses, " or %s", license); } } group = pk_group_enum_from_string (alpm_pkg_get_group (pkg)); desc = alpm_pkg_get_desc (pkg); url = alpm_pkg_get_url (pkg); if (alpm_pkg_get_origin (pkg) == ALPM_PKG_FROM_LOCALDB) { size = alpm_pkg_get_isize (pkg); } else { size = alpm_pkg_download_size (pkg); } pk_backend_job_details (self, *packages, licenses->str, group, desc, url, size); g_string_free (licenses, TRUE); } return pk_backend_finish (self, error); }