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