static gboolean
pk_backend_resolve_package (PkBackend *self, const gchar *package,
GError **error)
{
alpm_pkg_t *pkg;
PkBitfield filters;
gboolean skip_local, skip_remote;
g_return_val_if_fail (self != NULL, FALSE);
g_return_val_if_fail (package != NULL, FALSE);
g_return_val_if_fail (localdb != NULL, FALSE);
pkg = pk_backend_find_pkg (self, package, error);
if (pkg == NULL) {
return FALSE;
}
filters = pk_backend_get_uint (self, "filters");
skip_local = pk_bitfield_contain (filters,
PK_FILTER_ENUM_NOT_INSTALLED);
skip_remote = pk_bitfield_contain (filters, PK_FILTER_ENUM_INSTALLED);
if (alpm_pkg_get_origin (pkg) == ALPM_PKG_FROM_LOCALDB) {
if (!skip_local) {
pk_backend_pkg (self, pkg, PK_INFO_ENUM_INSTALLED);
}
} else {
if (!skip_remote) {
pk_backend_pkg (self, pkg, PK_INFO_ENUM_AVAILABLE);
}
}
return TRUE;
}
static alpm_list_t *
pk_backend_find_requirer (PkBackend *self, alpm_list_t *pkgs, const gchar *name,
GError **error)
{
alpm_pkg_t *requirer;
g_return_val_if_fail (self != NULL, pkgs);
g_return_val_if_fail (name != NULL, pkgs);
g_return_val_if_fail (localdb != NULL, pkgs);
if (alpm_list_find_pkg (pkgs, name) != NULL) {
return pkgs;
}
/* look for local requirers */
requirer = alpm_db_get_pkg (localdb, name);
if (requirer != NULL) {
pk_backend_pkg (self, requirer, PK_INFO_ENUM_INSTALLED);
if (pk_backend_get_bool (self, "recursive")) {
pkgs = alpm_list_add (pkgs, requirer);
}
} else {
int code = ALPM_ERR_PKG_NOT_FOUND;
g_set_error (error, ALPM_ERROR, code, "%s: %s", name,
alpm_strerror (code));
}
return pkgs;
}
static void
pk_backend_transaction_upgrade_done (PkBackend *self, alpm_pkg_t *pkg,
alpm_pkg_t *old, gint direction)
{
const gchar *name, *pre, *post;
g_return_if_fail (self != NULL);
g_return_if_fail (pkg != NULL);
g_return_if_fail (old != NULL || direction == 0);
g_return_if_fail (alpm != NULL);
name = alpm_pkg_get_name (pkg);
if (direction != 0) {
pre = alpm_pkg_get_version (old);
}
post = alpm_pkg_get_version (pkg);
if (direction > 0) {
alpm_logaction (alpm, PK_LOG_PREFIX, "upgraded %s (%s -> %s)\n",
name, pre, post);
} else if (direction < 0) {
alpm_logaction (alpm, PK_LOG_PREFIX,
"downgraded %s (%s -> %s)\n", name, pre, post);
} else {
alpm_logaction (alpm, PK_LOG_PREFIX, "reinstalled %s (%s)\n",
name, post);
}
pk_backend_pkg (self, pkg, PK_INFO_ENUM_FINISHED);
if (direction != 0) {
pk_backend_transaction_process_new_optdepends (self, pkg, old);
}
pk_backend_output_end (self);
}
static void
pk_backend_transaction_upgrade_start (PkBackend *self, alpm_pkg_t *pkg,
alpm_pkg_t *old)
{
PkRoleEnum role;
PkStatusEnum state;
PkInfoEnum info;
g_return_if_fail (self != NULL);
g_return_if_fail (pkg != NULL);
role = pk_backend_job_get_role (self);
if (role == PK_ROLE_ENUM_INSTALL_FILES ||
role == PK_ROLE_ENUM_SIMULATE_INSTALL_FILES) {
state = PK_STATUS_ENUM_INSTALL;
info = PK_INFO_ENUM_INSTALLING;
} else {
state = PK_STATUS_ENUM_UPDATE;
info = PK_INFO_ENUM_UPDATING;
}
pk_backend_job_set_status (self, state);
pk_backend_pkg (self, pkg, info);
pk_backend_output_start (self, pkg);
}
static void
pk_backend_transaction_add_done (PkBackend *self, alpm_pkg_t *pkg)
{
const gchar *name, *version;
const alpm_list_t *i, *optdepends;
g_return_if_fail (self != NULL);
g_return_if_fail (pkg != NULL);
g_return_if_fail (alpm != NULL);
name = alpm_pkg_get_name (pkg);
version = alpm_pkg_get_version (pkg);
alpm_logaction (alpm, PK_LOG_PREFIX, "installed %s (%s)\n", name,
version);
pk_backend_pkg (self, pkg, PK_INFO_ENUM_FINISHED);
optdepends = alpm_pkg_get_optdepends (pkg);
if (optdepends != NULL) {
pk_backend_output (self, "Optional dependencies:\n");
for (i = optdepends; i != NULL; i = i->next) {
gchar *depend = alpm_dep_compute_string (i->data);
gchar *output = g_strdup_printf ("%s\n", depend);
free (depend);
pk_backend_output (self, output);
g_free (output);
}
}
pk_backend_output_end (self);
}
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);
}
}
}
static void
pk_backend_transaction_remove_start (PkBackend *self, alpm_pkg_t *pkg)
{
g_return_if_fail (self != NULL);
g_return_if_fail (pkg != NULL);
pk_backend_job_set_status (self, PK_STATUS_ENUM_REMOVE);
pk_backend_pkg (self, pkg, PK_INFO_ENUM_REMOVING);
pk_backend_output_start (self, pkg);
}
static gboolean
pk_backend_resolve_name (PkBackend *self, const gchar *name, GError **error)
{
alpm_pkg_t *pkg;
int code;
PkBitfield filters;
gboolean skip_local, skip_remote;
g_return_val_if_fail (self != NULL, FALSE);
g_return_val_if_fail (name != NULL, FALSE);
g_return_val_if_fail (alpm != NULL, FALSE);
g_return_val_if_fail (localdb != NULL, FALSE);
filters = pk_backend_get_uint (self, "filters");
skip_local = pk_bitfield_contain (filters,
PK_FILTER_ENUM_NOT_INSTALLED);
skip_remote = pk_bitfield_contain (filters, PK_FILTER_ENUM_INSTALLED);
pkg = alpm_db_get_pkg (localdb, name);
if (pkg != NULL) {
if (!skip_local) {
pk_backend_pkg (self, pkg, PK_INFO_ENUM_INSTALLED);
return TRUE;
}
} else if (!skip_remote) {
const alpm_list_t *i = alpm_get_syncdbs (alpm);
for (; i != NULL; i = i->next) {
pkg = alpm_db_get_pkg (i->data, name);
if (pkg != NULL) {
pk_backend_pkg (self, pkg,
PK_INFO_ENUM_AVAILABLE);
return TRUE;
}
}
}
code = ALPM_ERR_PKG_NOT_FOUND;
g_set_error (error, ALPM_ERROR, code, "%s: %s", name,
alpm_strerror (code));
return FALSE;
}
static void
pk_backend_transaction_download_start (PkBackend *self, const gchar *basename)
{
gchar *path;
const alpm_list_t *i;
g_return_if_fail (self != NULL);
g_return_if_fail (basename != NULL);
g_return_if_fail (alpm != NULL);
/* continue or finish downloading the current package */
if (dpkg != NULL) {
if (alpm_pkg_has_basename (dpkg, basename)) {
if (dfiles != NULL) {
path = pk_backend_resolve_path (self, basename);
g_string_append_printf (dfiles, ";%s", path);
g_free (path);
}
return;
} else {
pk_backend_transaction_download_end (self);
dpkg = NULL;
}
}
/* figure out what the next package is */
for (i = alpm_trans_get_add (alpm); i != NULL; i = i->next) {
alpm_pkg_t *pkg = (alpm_pkg_t *) i->data;
if (alpm_pkg_has_basename (pkg, basename)) {
dpkg = pkg;
break;
}
}
if (dpkg == NULL) {
return;
}
pk_backend_pkg (self, dpkg, PK_INFO_ENUM_DOWNLOADING);
/* start collecting files for the new package */
if (pk_backend_job_get_role (self) == PK_ROLE_ENUM_DOWNLOAD_PACKAGES) {
path = pk_backend_resolve_path (self, basename);
dfiles = g_string_new (path);
g_free (path);
}
}
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 void
pk_backend_transaction_remove_done (PkBackend *self, alpm_pkg_t *pkg)
{
const gchar *name, *version;
g_return_if_fail (self != NULL);
g_return_if_fail (pkg != NULL);
g_return_if_fail (alpm != NULL);
name = alpm_pkg_get_name (pkg);
version = alpm_pkg_get_version (pkg);
alpm_logaction (alpm, PK_LOG_PREFIX, "removed %s (%s)\n", name,
version);
pk_backend_pkg (self, pkg, PK_INFO_ENUM_FINISHED);
pk_backend_output_end (self);
}
static void
pk_backend_transaction_download_end (PkBackend *self)
{
g_return_if_fail (self != NULL);
g_return_if_fail (dpkg != NULL);
pk_backend_pkg (self, dpkg, PK_INFO_ENUM_FINISHED);
/* tell DownloadPackages what files were downloaded */
if (dfiles != NULL) {
gchar *package_id;
package_id = alpm_pkg_build_id (dpkg);
pk_backend_job_files (self, package_id, dfiles->str);
g_free (package_id);
g_string_free (dfiles, TRUE);
}
dpkg = NULL;
dfiles = NULL;
}
static alpm_list_t *
pk_backend_find_provider (PkBackend *self, alpm_list_t *pkgs,
const gchar *depend, GError **error)
{
PkBitfield filters;
gboolean recursive, skip_local, skip_remote;
alpm_pkg_t *provider;
alpm_list_t *pkgcache, *syncdbs;
g_return_val_if_fail (self != NULL, pkgs);
g_return_val_if_fail (depend != NULL, pkgs);
g_return_val_if_fail (alpm != NULL, pkgs);
g_return_val_if_fail (localdb != NULL, pkgs);
recursive = pk_backend_get_bool (self, "recursive");
filters = pk_backend_get_uint (self, "filters");
skip_local = pk_bitfield_contain (filters,
PK_FILTER_ENUM_NOT_INSTALLED);
skip_remote = pk_bitfield_contain (filters, PK_FILTER_ENUM_INSTALLED);
if (alpm_find_satisfier (pkgs, depend) != NULL) {
return pkgs;
}
/* look for local dependencies */
pkgcache = alpm_db_get_pkgcache (localdb);
provider = alpm_find_satisfier (pkgcache, depend);
if (provider != NULL) {
if (!skip_local) {
pk_backend_pkg (self, provider, PK_INFO_ENUM_INSTALLED);
/* assume later dependencies will also be local */
if (recursive) {
pkgs = alpm_list_add (pkgs, provider);
}
}
return pkgs;
}
/* look for remote dependencies */
syncdbs = alpm_get_syncdbs (alpm);
provider = alpm_find_dbs_satisfier (alpm, syncdbs, depend);
if (provider != NULL) {
if (!skip_remote) {
pk_backend_pkg (self, provider, PK_INFO_ENUM_AVAILABLE);
}
/* keep looking for local dependencies */
if (recursive) {
pkgs = alpm_list_add (pkgs, provider);
}
} else {
int code = ALPM_ERR_UNSATISFIED_DEPS;
g_set_error (error, ALPM_ERROR, code, "%s: %s", depend,
alpm_strerror (code));
}
return pkgs;
}
