/**
* backend_update_packages:
*/
static void
backend_update_packages (PkBackend *backend, gboolean only_trusted, gchar **package_ids)
{
guint i;
guint len;
const gchar *package_id;
int ret;
slapt_pkg_list_t *installed;
slapt_pkg_list_t *available;
const gchar *search;
slapt_pkg_list_t *results = NULL;
slapt_transaction_t *transaction;
slapt_pkg_info_t *pkg;
slapt_pkg_info_t *oldpkg;
/* FIXME: support only_trusted */
pk_backend_set_status (backend, PK_STATUS_ENUM_UPDATE);
pk_backend_set_percentage (backend, 0);
installed = slapt_get_installed_pkgs();
available = slapt_get_available_pkgs();
transaction = slapt_init_transaction();
len = g_strv_length (package_ids);
for (i=0; i<len; i++) {
package_id = package_ids[i];
pkg = _get_pkg_from_string(package_id, available, installed);
if (pkg == NULL) {
pk_backend_error_code (backend, PK_ERROR_ENUM_PACKAGE_NOT_FOUND, "package not found");
continue;
}
oldpkg = NULL;
search = g_strdup_printf("^%s$", pkg->name);
results = slapt_search_pkg_list(installed, search);
g_free((gpointer) search);
if (results->pkg_count > 0) {
oldpkg = results->pkgs[0];
} else {
continue;
}
slapt_add_upgrade_to_transaction(transaction, oldpkg, pkg);
}
ret = slapt_handle_transaction(_config, transaction);
if (ret != 0) {
pk_backend_error_code (backend, PK_ERROR_ENUM_TRANSACTION_ERROR, "install failed");
}
slapt_free_transaction(transaction);
slapt_free_pkg_list(available);
slapt_free_pkg_list(installed);
pk_backend_set_percentage (backend, 100);
pk_backend_finished (backend);
}
/**
* backend_remove_packages:
*/
static void
backend_remove_packages (PkBackend *backend, gchar **package_ids, gboolean allow_deps, gboolean autoremove)
{
guint i;
guint len;
gchar *pi;
int ret;
slapt_pkg_list_t *installed;
slapt_pkg_list_t *available;
slapt_transaction_t *transaction;
slapt_pkg_info_t *pkg;
/* FIXME: support only_trusted */
pk_backend_set_status (backend, PK_STATUS_ENUM_REMOVE);
pk_backend_set_percentage (backend, 0);
installed = slapt_get_installed_pkgs();
available = slapt_get_available_pkgs();
transaction = slapt_init_transaction();
len = g_strv_length (package_ids);
for (i=0; i<len; i++) {
pi = package_ids[i];
if (pi == NULL) {
pk_backend_error_code (backend, PK_ERROR_ENUM_PACKAGE_ID_INVALID, "invalid package id");
pk_backend_finished (backend);
return;
}
pkg = _get_pkg_from_id(pi, installed, NULL);
if (pkg == NULL) {
pk_backend_error_code (backend, PK_ERROR_ENUM_PACKAGE_NOT_FOUND, "package not found");
continue;
}
if (!pkg->installed) {
char *pkgname = slapt_stringify_pkg(pkg);
pk_backend_error_code (backend, PK_ERROR_ENUM_PACKAGE_NOT_INSTALLED, "package %s not installed", pkgname);
free(pkgname);
continue;
}
slapt_add_remove_to_transaction(transaction, pkg);
}
ret = slapt_handle_transaction(_config, transaction);
if (ret != 0) {
pk_backend_error_code (backend, PK_ERROR_ENUM_TRANSACTION_ERROR, "remove failed");
}
slapt_free_transaction(transaction);
slapt_free_pkg_list(available);
slapt_free_pkg_list(installed);
pk_backend_set_percentage (backend, 100);
pk_backend_finished (backend);
}
/**
* backend_search_group:
*/
static void
backend_search_group (PkBackend *backend, PkBitfield filters, const gchar *search)
{
guint i;
const gchar *package_id;
slapt_pkg_list_t *pkglist;
slapt_pkg_info_t *pkg = NULL;
PkGroupEnum group;
PkGroupEnum search_group;
const char *category;
struct category_map *catgroup;
PkInfoEnum state;
const char *summary;
pk_backend_set_status (backend, PK_STATUS_ENUM_QUERY);
pk_backend_set_percentage (backend, 0);
if (pk_bitfield_contain (filters, PK_FILTER_ENUM_INSTALLED)) {
pkglist = slapt_get_installed_pkgs();
state = PK_INFO_ENUM_INSTALLED;
} else {
pkglist = slapt_get_available_pkgs();
state = PK_INFO_ENUM_AVAILABLE;
}
search_group = pk_group_enum_from_string(search);
for (i = 0; i < pkglist->pkg_count; i++) {
pkg = pkglist->pkgs[i];
category = _get_pkg_category(pkg);
group = PK_GROUP_ENUM_UNKNOWN;
for (catgroup = CATGROUP; catgroup->category != NULL; catgroup++) {
if (strcmp(catgroup->category, category) == 0) {
group = catgroup->group;
break;
}
}
if (group == search_group) {
package_id = _get_string_from_pkg(pkg);
summary = _get_pkg_summary(pkg);
pk_backend_package (backend, state, package_id, summary);
g_free((gpointer) summary);
g_free((gpointer) package_id);
}
}
slapt_free_pkg_list(pkglist);
pk_backend_set_percentage (backend, 100);
pk_backend_finished (backend);
}
/**
* backend_download_packages:
*/
static void
backend_download_packages (PkBackend *backend, gchar **package_ids, const gchar *directory)
{
guint i;
guint len;
const gchar *package_id;
const gchar *files;
const char *error;
slapt_pkg_list_t *installed;
slapt_pkg_list_t *available;
slapt_pkg_info_t *pkg;
const char *summary;
const char *note = NULL;
char *filename;
pk_backend_set_status (backend, PK_STATUS_ENUM_LOADING_CACHE);
installed = slapt_get_installed_pkgs();
available = slapt_get_available_pkgs();
pk_backend_set_status (backend, PK_STATUS_ENUM_DOWNLOAD);
pk_backend_set_percentage (backend, 0);
len = g_strv_length (package_ids);
for (i=0; i<len; i++) {
package_id = package_ids[i];
pkg = _get_pkg_from_string(package_id, available, installed);
if (pkg == NULL) {
pk_backend_error_code (backend, PK_ERROR_ENUM_PACKAGE_NOT_FOUND, "package not found");
continue;
}
summary = _get_pkg_summary(pkg);
pk_backend_package (backend, PK_INFO_ENUM_DOWNLOADING, package_id, summary);
g_free((gpointer) summary);
error = slapt_download_pkg(_config, pkg, note);
if (error == NULL) {
filename = slapt_gen_pkg_file_name(_config, pkg);
files = g_strdup(filename);
pk_backend_files (backend, package_id, files);
g_free((gpointer) files);
free(filename);
} else {
pk_backend_error_code (backend, PK_ERROR_ENUM_PACKAGE_DOWNLOAD_FAILED, error);
}
}
slapt_free_pkg_list(available);
slapt_free_pkg_list(installed);
pk_backend_set_percentage (backend, 100);
pk_backend_finished (backend);
}
/**
* backend_get_details:
*/
static void
backend_get_details (PkBackend *backend, gchar **package_ids)
{
guint i;
guint len;
const gchar *package_id;
gchar *pi;
const gchar *license = "";
const gchar *homepage = "";
const gchar *description;
PkGroupEnum group;
slapt_pkg_list_t *installed;
slapt_pkg_list_t *available;
slapt_pkg_info_t *pkg;
const char *category;
pk_backend_set_status (backend, PK_STATUS_ENUM_QUERY);
pk_backend_set_percentage (backend, 0);
installed = slapt_get_installed_pkgs();
available = slapt_get_available_pkgs();
len = g_strv_length (package_ids);
for (i=0; i<len; i++) {
pi = package_ids[i];
if (pi == NULL) {
pk_backend_error_code (backend, PK_ERROR_ENUM_PACKAGE_ID_INVALID, "invalid package id");
pk_backend_finished (backend);
return;
}
pkg = _get_pkg_from_id(pi, available, installed);
if (pkg == NULL) {
pk_backend_error_code (backend, PK_ERROR_ENUM_PACKAGE_NOT_FOUND, "package not found");
continue;
}
category = _get_pkg_category(pkg);
group = _get_pkg_group(category);
package_id = _get_string_from_pkg(pkg);
description = g_strstrip((gchar*) _get_pkg_description(pkg));
pk_backend_details (backend, package_id,
license, group, description, homepage, pkg->size_c * 1024);
g_free((gpointer) description);
g_free((gpointer) package_id);
}
slapt_free_pkg_list(available);
slapt_free_pkg_list(installed);
pk_backend_set_percentage (backend, 100);
pk_backend_finished (backend);
}
/**
* backend_search_groups:
*/
static void
backend_search_groups (PkBackend *backend, PkBitfield filters, gchar **values)
{
guint i;
gchar *search;
const gchar *package_id;
slapt_pkg_list_t *pkglist;
slapt_pkg_info_t *pkg = NULL;
PkGroupEnum group;
PkGroupEnum search_group;
const char *category;
PkInfoEnum state;
const char *summary;
pk_backend_set_status (backend, PK_STATUS_ENUM_QUERY);
pk_backend_set_percentage (backend, 0);
search = g_strjoinv ("&", values);
if (pk_bitfield_contain (filters, PK_FILTER_ENUM_INSTALLED)) {
pkglist = slapt_get_installed_pkgs();
state = PK_INFO_ENUM_INSTALLED;
} else {
pkglist = slapt_get_available_pkgs();
state = PK_INFO_ENUM_AVAILABLE;
}
search_group = pk_group_enum_from_string(search);
for (i = 0; i < pkglist->pkg_count; i++) {
pkg = pkglist->pkgs[i];
category = _get_pkg_category(pkg);
group = _get_pkg_group(category);
if (group == search_group) {
package_id = _get_string_from_pkg(pkg);
summary = _get_pkg_summary(pkg);
pk_backend_package (backend, state, package_id, summary);
g_free((gpointer) summary);
g_free((gpointer) package_id);
}
}
slapt_free_pkg_list(pkglist);
g_free (search);
pk_backend_set_percentage (backend, 100);
pk_backend_finished (backend);
}
/**
* backend_resolve:
*/
static void
backend_resolve (PkBackend *backend, PkBitfield filters, gchar **packages)
{
guint i;
guint len;
const gchar *package_id;
slapt_pkg_list_t *pkglist;
slapt_pkg_info_t *pkg = NULL;
slapt_pkg_list_t *results = NULL;
PkInfoEnum state;
const gchar *search;
const char *summary;
pk_backend_set_status (backend, PK_STATUS_ENUM_QUERY);
pk_backend_set_percentage (backend, 0);
if (pk_bitfield_contain (filters, PK_FILTER_ENUM_INSTALLED)) {
pkglist = slapt_get_installed_pkgs();
state = PK_INFO_ENUM_INSTALLED;
} else {
pkglist = slapt_get_available_pkgs();
state = PK_INFO_ENUM_AVAILABLE;
}
len = g_strv_length (packages);
for (i=0; i<len; i++) {
search = g_strdup_printf("^%s$", packages[i]); /* regexp */
results = slapt_search_pkg_list(pkglist, search);
g_free((gpointer) search);
if (results == NULL) {
pk_backend_error_code (backend, PK_ERROR_ENUM_PACKAGE_NOT_FOUND, "package not found");
continue;
}
for (i = 0; i < results->pkg_count; i++) {
pkg = results->pkgs[i];
package_id = _get_string_from_pkg(pkg);
summary = _get_pkg_summary(pkg);
pk_backend_package (backend, state, package_id, summary);
g_free((gpointer) summary);
g_free((gpointer) package_id);
}
slapt_free_pkg_list(results);
}
slapt_free_pkg_list(pkglist);
pk_backend_set_percentage (backend, 100);
pk_backend_finished (backend);
}
/**
* backend_search_names:
*/
static void
backend_search_names (PkBackend *backend, PkBitfield filters, gchar **values)
{
unsigned int i;
gchar *search;
const gchar *package_id;
slapt_pkg_list_t *pkglist;
slapt_pkg_info_t *pkg = NULL;
slapt_pkg_list_t *results = NULL;
PkInfoEnum state;
const char *summary;
pk_backend_set_status (backend, PK_STATUS_ENUM_QUERY);
pk_backend_set_percentage (backend, 0);
search = g_strjoinv ("&", values);
if (pk_bitfield_contain (filters, PK_FILTER_ENUM_INSTALLED)) {
pkglist = slapt_get_installed_pkgs();
state = PK_INFO_ENUM_INSTALLED;
} else {
pkglist = slapt_get_available_pkgs();
state = PK_INFO_ENUM_AVAILABLE;
}
results = slapt_search_pkg_list(pkglist, search);
g_free((gpointer) search);
if (results == NULL) {
pk_backend_error_code (backend, PK_ERROR_ENUM_PACKAGE_NOT_FOUND, "package not found");
goto out;
}
for (i = 0; i < results->pkg_count; i++) {
pkg = results->pkgs[i];
package_id = _get_string_from_pkg(pkg);
summary = _get_pkg_summary(pkg);
pk_backend_package (backend, state, package_id, summary);
g_free((gpointer) summary);
g_free((gpointer) package_id);
}
slapt_free_pkg_list(results);
out:
slapt_free_pkg_list(pkglist);
g_free (search);
pk_backend_set_percentage (backend, 100);
pk_backend_finished (backend);
}
/**
* backend_get_updates:
*/
static void
backend_get_updates (PkBackend *backend, PkBitfield filters)
{
guint i;
const gchar *package_id;
const gchar *new_package_id;
slapt_pkg_list_t *installed;
slapt_pkg_list_t *available;
slapt_pkg_info_t *pkg;
slapt_pkg_info_t *newpkg;
const gchar *summary;
const char *changelog;
PkInfoEnum state;
pk_backend_set_status (backend, PK_STATUS_ENUM_QUERY);
pk_backend_set_percentage (backend, 0);
installed = slapt_get_installed_pkgs();
available = slapt_get_available_pkgs();
for (i = 0; i < installed->pkg_count; i++) {
pkg = installed->pkgs[i];
newpkg = slapt_get_newest_pkg(available, pkg->name);
if (newpkg == NULL)
continue;
if (slapt_cmp_pkgs(pkg,newpkg) >= 0)
continue;
package_id = _get_string_from_pkg(pkg);
new_package_id = _get_string_from_pkg(newpkg);
changelog = slapt_get_pkg_changelog(newpkg);
if (changelog != NULL &&
strstr(changelog, "(* Security fix *)") != NULL)
state = PK_INFO_ENUM_SECURITY;
else
state = PK_INFO_ENUM_NORMAL;
summary =_get_pkg_summary(newpkg);
pk_backend_package (backend, state,
new_package_id, summary);
g_free((gpointer) summary);
g_free((gpointer) new_package_id);
g_free((gpointer) package_id);
}
slapt_free_pkg_list(available);
slapt_free_pkg_list(installed);
pk_backend_set_percentage (backend, 100);
pk_backend_finished (backend);
}
static gboolean
backend_get_packages_thread (PkBackend *backend)
{
PkBitfield filters;
GList *list = NULL;
sqlite3 *db = NULL;
filters = pk_backend_get_uint (backend, "filters");
pk_backend_set_status (backend, PK_STATUS_ENUM_QUERY);
pk_backend_set_percentage (backend, PK_BACKEND_PERCENTAGE_INVALID);
db = db_open();
if ((pk_bitfield_contain (filters, PK_FILTER_ENUM_INSTALLED) &&
pk_bitfield_contain (filters, PK_FILTER_ENUM_NOT_INSTALLED)) ||
(!pk_bitfield_contain (filters, PK_FILTER_ENUM_INSTALLED) &&
!pk_bitfield_contain (filters, PK_FILTER_ENUM_NOT_INSTALLED))) {
list = box_db_repos_packages_search_all (db, NULL, 0);
} else if (pk_bitfield_contain (filters, PK_FILTER_ENUM_INSTALLED)) {
list = box_db_repos_packages_search_installed (db, NULL, 0);
} else if (pk_bitfield_contain (filters, PK_FILTER_ENUM_NOT_INSTALLED)) {
list = box_db_repos_packages_search_available (db, NULL, 0);
}
add_packages_from_list (backend, list, FALSE);
box_db_repos_package_list_free (list);
db_close(db);
pk_backend_finished (backend);
return TRUE;
}
static void
backend_update_system (PkBackend *backend, gboolean only_trusted)
{
pk_backend_set_status (backend, PK_STATUS_ENUM_UPDATE);
pk_backend_set_percentage (backend, PK_BACKEND_PERCENTAGE_INVALID);
pk_backend_thread_create (backend, backend_update_system_thread);
}
static void
backend_get_updates (PkBackend *backend, PkBitfield filters)
{
pk_backend_set_status (backend, PK_STATUS_ENUM_QUERY);
pk_backend_set_percentage (backend, PK_BACKEND_PERCENTAGE_INVALID);
pk_backend_thread_create (backend, backend_get_updates_thread);
}
/**
* backend_refresh_cache:
*/
static void
backend_refresh_cache (PkBackend *backend, gboolean force)
{
pk_backend_set_status (backend, PK_STATUS_ENUM_REFRESH_CACHE);
pk_backend_set_percentage (backend, PK_BACKEND_PERCENTAGE_INVALID);
pk_backend_thread_create (backend, backend_refresh_cache_thread);
}
static void
pk_backend_transaction_progress_cb (alpm_progress_t type, const gchar *target,
gint percent, gsize targets, gsize current)
{
static gint recent = 101;
gsize overall = percent + (current - 1) * 100;
/* TODO: remove block if/when this is made consistent upstream */
if (type == ALPM_PROGRESS_CONFLICTS_START ||
type == ALPM_PROGRESS_DISKSPACE_START ||
type == ALPM_PROGRESS_INTEGRITY_START ||
type == ALPM_PROGRESS_LOAD_START ||
type == ALPM_PROGRESS_KEYRING_START) {
if (current < targets) {
++current;
overall += 100;
}
}
if (current < 1 || targets < current) {
g_warning ("TODO: CURRENT/TARGETS FAILED for %d", type);
}
g_return_if_fail (target != NULL);
g_return_if_fail (0 <= percent && percent <= 100);
g_return_if_fail (1 <= current && current <= targets);
g_return_if_fail (backend != NULL);
/* update transaction progress */
switch (type) {
case ALPM_PROGRESS_ADD_START:
case ALPM_PROGRESS_UPGRADE_START:
case ALPM_PROGRESS_DOWNGRADE_START:
case ALPM_PROGRESS_REINSTALL_START:
case ALPM_PROGRESS_REMOVE_START:
case ALPM_PROGRESS_CONFLICTS_START:
case ALPM_PROGRESS_DISKSPACE_START:
case ALPM_PROGRESS_INTEGRITY_START:
case ALPM_PROGRESS_LOAD_START:
case ALPM_PROGRESS_KEYRING_START:
if (percent == recent) {
break;
}
pk_backend_set_sub_percentage (backend, percent);
pk_backend_set_percentage (backend, overall / targets);
recent = percent;
g_debug ("%d%% of %s complete (%zu of %zu)", percent,
target, current, targets);
break;
default:
g_warning ("unknown progress type %d", type);
break;
}
}
static void
backend_install_packages (PkBackend *backend, gboolean only_trusted, gchar **package_ids)
{
pk_backend_set_percentage (backend, PK_BACKEND_PERCENTAGE_INVALID);
pk_backend_set_status (backend, PK_STATUS_ENUM_INSTALL);
pk_backend_set_strv (backend, "pkids", package_ids);
pk_backend_thread_create (backend, backend_install_packages_thread);
}
/**
* backend_search_details:
*/
static void
backend_search_details (PkBackend *backend, PkBitfield filters, const gchar *search)
{
guint i;
const gchar *package_id;
slapt_pkg_list_t *pkglist;
slapt_pkg_info_t *pkg = NULL;
slapt_pkg_list_t *results = NULL;
PkInfoEnum state;
const char *summary;
pk_backend_set_status (backend, PK_STATUS_ENUM_QUERY);
pk_backend_set_percentage (backend, 0);
if (pk_bitfield_contain (filters, PK_FILTER_ENUM_INSTALLED)) {
pkglist = slapt_get_installed_pkgs();
state = PK_INFO_ENUM_INSTALLED;
} else {
pkglist = slapt_get_available_pkgs();
state = PK_INFO_ENUM_AVAILABLE;
}
results = slapt_search_pkg_list(pkglist, search);
for (i = 0; i < results->pkg_count; i++) {
pkg = results->pkgs[i];
package_id = _get_string_from_pkg(pkg);
summary = _get_pkg_summary(pkg);
pk_backend_package (backend, state, package_id, summary);
g_free((gpointer) summary);
g_free((gpointer) package_id);
}
slapt_free_pkg_list(results);
slapt_free_pkg_list(pkglist);
pk_backend_set_percentage (backend, 100);
pk_backend_finished (backend);
}
/**
* backend_search_name_thread:
*/
static gboolean
backend_search_name_thread (PkBackend *backend)
{
GTimer *timer;
guint percentage;
PkBitfield filters;
gchar *filters_text;
const gchar *search;
filters = pk_backend_get_uint (backend, "filters");
search = pk_backend_get_string (backend, "search");
filters_text = pk_filter_bitfield_to_text (filters);
egg_debug ("started task (%p) search=%s filters=%s", backend, search, filters_text);
g_free (filters_text);
pk_backend_set_status (backend, PK_STATUS_ENUM_QUERY);
timer = g_timer_new ();
percentage = 0;
do {
/* now is a good time to see if we should cancel the thread */
if (is_cancelled) {
pk_backend_error_code (backend, PK_ERROR_ENUM_TRANSACTION_CANCELLED,
"The thread was stopped successfully");
pk_backend_finished (backend);
return TRUE;
}
pk_backend_set_percentage (backend, percentage);
percentage += 10;
g_usleep (1000*100);
} while (percentage < 100);
g_timer_destroy (timer);
pk_backend_set_percentage (backend, 100);
egg_debug ("exited task (%p)", backend);
pk_backend_package (backend, PK_INFO_ENUM_INSTALLED,
"glib2;2.14.0;i386;fedora", "The GLib library");
pk_backend_package (backend, PK_INFO_ENUM_INSTALLED,
"gtk2;gtk2-2.11.6-6.fc8;i386;fedora", "GTK+ Libraries for GIMP");
pk_backend_finished (backend);
return TRUE;
}
static void
backend_update_packages (PkBackend *backend, gboolean only_trusted, gchar **package_ids)
{
gint i;
pk_backend_set_status (backend, PK_STATUS_ENUM_UPDATE);
pk_backend_set_percentage (backend, PK_BACKEND_PERCENTAGE_INVALID);
for (i = 0; package_ids[i]; i++) {
pk_backend_set_string (backend, "pkgid", package_ids[i]);
pk_backend_thread_create (backend, backend_update_package_thread);
}
}
/* CURLOPT_PROGRESSFUNCTION */
static int backend_progress_callback(void *clientp,
double dltotal, double dlnow, double ultotal, double ulnow)
{
unsigned int percentage;
struct slapt_progress_data *cb_data = clientp;
(void) cb_data; /* unused */
if (dltotal == 0)
percentage = 0;
else
percentage = (dlnow * 100.0) / dltotal;
pk_backend_set_percentage (_backend, percentage);
return 0;
}
static void
backend_search_group (PkBackend *backend, PkBitfield filters, gchar **search)
{
SearchParams *params;
pk_backend_set_status (backend, PK_STATUS_ENUM_QUERY);
pk_backend_set_percentage (backend, PK_BACKEND_PERCENTAGE_INVALID);
params = g_new0 (SearchParams, 1);
params->filters = filters;
params->search_type = SEARCH_TAG;
params->needle = g_strdup_printf ("group::%s", search[0]);
params->backend = backend;
pk_backend_set_pointer (backend, "search-params", params);
pk_backend_thread_create (backend, backend_search_thread);
}
/**
* backend_search_description:
*/
static void
backend_search_description (PkBackend *backend, PkBitfield filters, gchar **search)
{
SearchParams *params;
pk_backend_set_status (backend, PK_STATUS_ENUM_QUERY);
pk_backend_set_percentage (backend, PK_BACKEND_PERCENTAGE_INVALID);
params = g_new0 (SearchParams, 1);
params->filters = filters;
params->search_type = SEARCH_DESCRIPTION;
params->needle = g_utf8_strdown (search[0], -1);
params->backend = backend;
pk_backend_set_pointer (backend, "search-params", params);
pk_backend_thread_create (backend, backend_search_thread);
}
static void
backend_remove_packages (PkBackend *backend, gchar **package_ids, gboolean allow_deps, gboolean autoremove)
{
gpointer *params;
pk_backend_set_status (backend, PK_STATUS_ENUM_REMOVE);
pk_backend_set_percentage (backend, PK_BACKEND_PERCENTAGE_INVALID);
/* params is a small array we can pack our thread parameters into */
params = g_new0 (gpointer, 2);
params[0] = g_strdupv (package_ids);
params[1] = GINT_TO_POINTER (allow_deps);
params[2] = GINT_TO_POINTER (autoremove);
pk_backend_set_pointer (backend, "remove-params", params);
pk_backend_thread_create (backend, backend_remove_packages_thread);
}
static void
pk_opkg_progress_cb (const opkg_progress_data_t *pdata, void *data)
{
PkBackend *backend = (PkBackend*) data;
if (!backend)
return;
pk_backend_set_percentage (backend, pdata->percentage);
if (pdata->pkg)
{
gchar *uid;
pkg_t *pkg = pdata->pkg;
gint status = PK_INFO_ENUM_UNKNOWN;
uid = g_strdup_printf ("%s;%s;%s;",
pkg->name, pkg->version, pkg->architecture);
if (pdata->action == OPKG_DOWNLOAD)
status = PK_INFO_ENUM_DOWNLOADING;
else if (pdata->action == OPKG_INSTALL)
status = PK_INFO_ENUM_INSTALLING;
else if (pdata->action == OPKG_REMOVE)
status = PK_INFO_ENUM_REMOVING;
pk_backend_package (backend, status, uid, pkg->description);
g_free (uid);
}
switch (pdata->action)
{
case OPKG_DOWNLOAD:
pk_backend_set_status (backend, PK_STATUS_ENUM_DOWNLOAD);
break;
case OPKG_INSTALL:
pk_backend_set_status (backend, PK_STATUS_ENUM_INSTALL);
break;
case OPKG_REMOVE:
pk_backend_set_status (backend, PK_STATUS_ENUM_REMOVE);
break;
}
}
static void
pk_backend_transaction_dlcb (const gchar *basename, off_t complete, off_t total)
{
guint percentage = 100, sub_percentage = 100;
g_return_if_fail (basename != NULL);
g_return_if_fail (complete <= total);
g_return_if_fail (backend != NULL);
if (total > 0) {
sub_percentage = complete * 100 / total;
}
if (dtotal > 0) {
percentage = (dcomplete + complete) * 100 / dtotal;
} else if (dtotal < 0) {
/* database files */
percentage = (dcomplete * 100 + sub_percentage) / -dtotal;
if (complete == total) {
complete = total = 1;
} else {
complete = total + 1;
}
}
if (complete == 0) {
g_debug ("downloading file %s", basename);
pk_backend_set_status (backend, PK_STATUS_ENUM_DOWNLOAD);
pk_backend_transaction_download_start (backend, basename);
} else if (complete == total) {
dcomplete += complete;
}
pk_backend_set_sub_percentage (backend, sub_percentage);
pk_backend_set_percentage (backend, percentage);
}
static gboolean
backend_find_packages_thread (PkBackend *backend)
{
PkBitfield filters;
const gchar *search;
gchar **values;
guint mode;
GList *list = NULL;
sqlite3 *db = NULL;
gint filter_box = 0;
filters = pk_backend_get_uint (backend, "filters");
mode = pk_backend_get_uint (backend, "mode");
values = pk_backend_get_strv (backend, "search");
/* FIXME: support multiple packages */
search = values[0];
pk_backend_set_status (backend, PK_STATUS_ENUM_QUERY);
if (pk_bitfield_contain (filters, PK_FILTER_ENUM_INSTALLED)) {
filter_box = filter_box | PKG_INSTALLED;
}
if (pk_bitfield_contain (filters, PK_FILTER_ENUM_NOT_INSTALLED)) {
filter_box = filter_box | PKG_AVAILABLE;
}
if (pk_bitfield_contain (filters, PK_FILTER_ENUM_DEVELOPMENT)) {
filter_box = filter_box | PKG_DEVEL;
}
if (pk_bitfield_contain (filters, PK_FILTER_ENUM_NOT_DEVELOPMENT)) {
filter_box = filter_box | PKG_NON_DEVEL;
}
if (pk_bitfield_contain (filters, PK_FILTER_ENUM_GUI)) {
filter_box = filter_box | PKG_GUI;
}
if (pk_bitfield_contain (filters, PK_FILTER_ENUM_NOT_GUI)) {
filter_box = filter_box | PKG_TEXT;
}
if (mode == SEARCH_TYPE_DETAILS) {
filter_box = filter_box | PKG_SEARCH_DETAILS;
}
pk_backend_set_percentage (backend, PK_BACKEND_PERCENTAGE_INVALID);
db = db_open ();
if (mode == SEARCH_TYPE_FILE) {
list = box_db_repos_search_file_with_filter (db, search, filter_box);
add_packages_from_list (backend, list, FALSE);
box_db_repos_package_list_free (list);
} else if (mode == SEARCH_TYPE_RESOLVE) {
list = box_db_repos_packages_search_one (db, (gchar *)search);
add_packages_from_list (backend, list, FALSE);
box_db_repos_package_list_free (list);
} else {
if ((pk_bitfield_contain (filters, PK_FILTER_ENUM_INSTALLED) &&
pk_bitfield_contain (filters, PK_FILTER_ENUM_NOT_INSTALLED)) ||
(!pk_bitfield_contain (filters, PK_FILTER_ENUM_INSTALLED) &&
!pk_bitfield_contain (filters, PK_FILTER_ENUM_NOT_INSTALLED))) {
list = box_db_repos_packages_search_all (db, (gchar *)search, filter_box);
} else if (pk_bitfield_contain (filters, PK_FILTER_ENUM_INSTALLED)) {
list = box_db_repos_packages_search_installed (db, (gchar *)search, filter_box);
} else if (pk_bitfield_contain (filters, PK_FILTER_ENUM_NOT_INSTALLED)) {
list = box_db_repos_packages_search_available (db, (gchar *)search, filter_box);
}
add_packages_from_list (backend, list, FALSE);
box_db_repos_package_list_free (list);
}
db_close (db);
pk_backend_finished (backend);
return TRUE;
}
static void
common_progress(int value, gpointer user_data)
{
PkBackend* backend = (PkBackend *) user_data;
pk_backend_set_percentage (backend, value);
}
static gboolean
backend_search_package_thread (PkBackend *backend)
{
const gchar *search;
PkBitfield filters;
search = pk_backend_get_string (backend, "search");
filters = (PkBitfield) pk_backend_get_uint (backend, "filters");
pk_backend_set_percentage (backend, PK_BACKEND_PERCENTAGE_INVALID);
pk_backend_set_allow_cancel (backend, true);
matcher *m_matcher = new matcher(string(search));
if (m_matcher->hasError()) {
egg_debug("Regex compilation error");
delete m_matcher;
pk_backend_finished (backend);
return false;
}
aptcc *m_apt = new aptcc(backend, _cancel);
pk_backend_set_pointer(backend, "aptcc_obj", m_apt);
if (m_apt->init()) {
egg_debug ("Failed to create apt cache");
delete m_matcher;
delete m_apt;
pk_backend_finished (backend);
return false;
}
if (_error->PendingError() == true)
{
delete m_matcher;
delete m_apt;
pk_backend_finished (backend);
return false;
}
pk_backend_set_status (backend, PK_STATUS_ENUM_QUERY);
pkgDepCache::Policy Plcy;
vector<pair<pkgCache::PkgIterator, pkgCache::VerIterator> > output;
if (pk_backend_get_bool (backend, "search_details")) {
for (pkgCache::PkgIterator pkg = m_apt->packageCache->PkgBegin(); !pkg.end(); ++pkg) {
if (_cancel) {
break;
}
// Ignore packages that exist only due to dependencies.
if (pkg.VersionList().end() && pkg.ProvidesList().end()) {
continue;
}
if (m_matcher->matches(pkg.Name())) {
// Don't insert virtual packages instead add what it provides
pkgCache::VerIterator ver = m_apt->find_ver(pkg);
if (ver.end() == false) {
output.push_back(pair<pkgCache::PkgIterator, pkgCache::VerIterator>(pkg, ver));
} else {
// iterate over the provides list
for (pkgCache::PrvIterator Prv = pkg.ProvidesList(); Prv.end() == false; Prv++) {
ver = m_apt->find_ver(Prv.OwnerPkg());
// check to see if the provided package isn't virtual too
if (ver.end() == false)
{
// we add the package now because we will need to
// remove duplicates later anyway
output.push_back(pair<pkgCache::PkgIterator, pkgCache::VerIterator>(Prv.OwnerPkg(), ver));
}
}
}
} else {
// Don't insert virtual packages instead add what it provides
pkgCache::VerIterator ver = m_apt->find_ver(pkg);
if (ver.end() == false) {
if (m_matcher->matches(get_default_short_description(ver, m_apt->packageRecords))
|| m_matcher->matches(get_default_long_description(ver, m_apt->packageRecords))
|| m_matcher->matches(get_short_description(ver, m_apt->packageRecords))
|| m_matcher->matches(get_long_description(ver, m_apt->packageRecords)))
{
output.push_back(pair<pkgCache::PkgIterator, pkgCache::VerIterator>(pkg, ver));
}
} else {
// iterate over the provides list
for (pkgCache::PrvIterator Prv = pkg.ProvidesList(); Prv.end() == false; Prv++) {
ver = m_apt->find_ver(Prv.OwnerPkg());
// check to see if the provided package isn't virtual too
if (ver.end() == false)
{
// we add the package now because we will need to
// remove duplicates later anyway
if (m_matcher->matches(Prv.OwnerPkg().Name())
|| m_matcher->matches(get_default_short_description(ver, m_apt->packageRecords))
|| m_matcher->matches(get_default_long_description(ver, m_apt->packageRecords))
|| m_matcher->matches(get_short_description(ver, m_apt->packageRecords))
|| m_matcher->matches(get_long_description(ver, m_apt->packageRecords)))
{
output.push_back(pair<pkgCache::PkgIterator, pkgCache::VerIterator>(Prv.OwnerPkg(), ver));
}
}
}
}
}
}
} else {
for (pkgCache::PkgIterator pkg = m_apt->packageCache->PkgBegin(); !pkg.end(); ++pkg) {
if (_cancel) {
break;
}
// Ignore packages that exist only due to dependencies.
if (pkg.VersionList().end() && pkg.ProvidesList().end()) {
continue;
}
if (m_matcher->matches(pkg.Name())) {
// Don't insert virtual packages instead add what it provides
pkgCache::VerIterator ver = m_apt->find_ver(pkg);
if (ver.end() == false) {
output.push_back(pair<pkgCache::PkgIterator, pkgCache::VerIterator>(pkg, ver));
} else {
// iterate over the provides list
for (pkgCache::PrvIterator Prv = pkg.ProvidesList(); Prv.end() == false; Prv++) {
ver = m_apt->find_ver(Prv.OwnerPkg());
// check to see if the provided package isn't virtual too
if (ver.end() == false)
{
// we add the package now because we will need to
// remove duplicates later anyway
output.push_back(pair<pkgCache::PkgIterator, pkgCache::VerIterator>(Prv.OwnerPkg(), ver));
}
}
}
}
}
}
// It's faster to emmit the packages here than in the matching part
m_apt->emit_packages(output, filters);
delete m_matcher;
delete m_apt;
pk_backend_set_percentage (backend, 100);
pk_backend_finished (backend);
return true;
}
static void
backend_get_details (PkBackend *backend, gchar **package_ids)
{
pk_backend_set_percentage (backend, PK_BACKEND_PERCENTAGE_INVALID);
pk_backend_thread_create (backend, backend_get_details_thread);
}
/**
* backend_get_update_detail:
*/
static void
backend_get_update_detail (PkBackend *backend, gchar **package_ids)
{
guint i;
guint len;
const gchar *package_id;
const gchar *old_package_id;
gchar *pi;
slapt_pkg_list_t *installed;
slapt_pkg_list_t *available;
const gchar *search;
slapt_pkg_list_t *results;
slapt_pkg_info_t *pkg;
slapt_pkg_info_t *oldpkg;
const gchar *title;
char *changelog;
const gchar *issued;
pk_backend_set_status (backend, PK_STATUS_ENUM_QUERY);
pk_backend_set_percentage (backend, 0);
installed = slapt_get_installed_pkgs();
available = slapt_get_available_pkgs();
len = g_strv_length (package_ids);
for (i=0; i<len; i++) {
pi = package_ids[i];
if (pi == NULL) {
pk_backend_error_code (backend, PK_ERROR_ENUM_PACKAGE_ID_INVALID, "invalid package id");
pk_backend_finished (backend);
return;
}
pkg = _get_pkg_from_id(pi, available, installed);
if (pkg == NULL) {
pk_backend_error_code (backend, PK_ERROR_ENUM_PACKAGE_NOT_FOUND, "package not found");
continue;
}
package_id = _get_string_from_pkg(pkg);
search = g_strdup_printf("^%s$", pkg->name);
results = slapt_search_pkg_list(installed, search);
g_free((gpointer) search);
if (results->pkg_count > 0) {
oldpkg = results->pkgs[0];
old_package_id = _get_string_from_pkg(oldpkg);
} else {
oldpkg = NULL;
old_package_id = "";
}
changelog = slapt_get_pkg_changelog(pkg);
title = ""; /* first line of changelog */
issued = NULL;
pk_backend_update_detail (backend, package_id, old_package_id,
"", "", "", NULL, PK_RESTART_ENUM_NONE,
title, changelog, PK_UPDATE_STATE_ENUM_UNKNOWN, issued, NULL);
g_free((gpointer) issued);
if (changelog != NULL)
free(changelog);
}
slapt_free_pkg_list(available);
slapt_free_pkg_list(installed);
pk_backend_set_percentage (backend, 100);
pk_backend_finished (backend);
}
gboolean
zypp_refresh_cache (PkBackend *backend, gboolean force)
{
get_zypp (); //This call is needed as it calls initializeTarget which appears to properly setup the keyring
if (!pk_backend_is_online (backend)) {
pk_backend_error_code (backend, PK_ERROR_ENUM_NO_NETWORK, "Cannot refresh cache whilst offline");
return FALSE;
}
pk_backend_set_status (backend, PK_STATUS_ENUM_REFRESH_CACHE);
pk_backend_set_percentage (backend, 0);
zypp::RepoManager manager;
std::list <zypp::RepoInfo> repos;
try
{
repos = std::list<zypp::RepoInfo>(manager.repoBegin(),manager.repoEnd());
}
catch ( const zypp::Exception &e)
{
// FIXME: make sure this dumps out the right sring.
pk_backend_error_code (backend, PK_ERROR_ENUM_REPO_NOT_FOUND, e.asUserString().c_str() );
pk_backend_finished (backend);
return FALSE;
}
int i = 1;
int num_of_repos = repos.size ();
int percentage_increment = 100 / num_of_repos;
gchar *repo_messages = NULL;
for (std::list <zypp::RepoInfo>::iterator it = repos.begin(); it != repos.end(); it++, i++) {
zypp::RepoInfo repo (*it);
// skip disabled repos
if (repo.enabled () == false)
continue;
// skip changeable meda (DVDs and CDs). Without doing this,
// the disc would be required to be physically present.
if (zypp_is_changeable_media (*repo.baseUrlsBegin ()) == true)
continue;
try {
// Refreshing metadata
_repoName = g_strdup (repo.alias ().c_str ());
manager.refreshMetadata (repo, force == TRUE ?
zypp::RepoManager::RefreshForced :
zypp::RepoManager::RefreshIfNeeded);
} catch (const zypp::Exception &ex) {
if (repo_messages == NULL) {
repo_messages = g_strdup_printf ("%s: %s%s", repo.alias ().c_str (), ex.asUserString ().c_str (), "\n");
}else{
repo_messages = g_strdup_printf ("%s%s: %s%s", repo_messages, repo.alias ().c_str (), ex.asUserString ().c_str (), "\n");
}
repo_messages = pk_strsafe (repo_messages);
if (repo_messages == NULL)
repo_messages = g_strdup ("A repository could not be refreshed");
continue;
}
try {
// Building cache
manager.buildCache (repo, force == TRUE ?
zypp::RepoManager::BuildForced :
zypp::RepoManager::BuildIfNeeded);
//} catch (const zypp::repo::RepoNoUrlException &ex) {
//} catch (const zypp::repo::RepoNoAliasException &ex) {
//} catch (const zypp::repo::RepoUnknownTypeException &ex) {
//} catch (const zypp::repo::RepoException &ex) {
} catch (const zypp::Exception &ex) {
if (repo_messages == NULL) {
repo_messages = g_strdup_printf ("%s: %s%s", repo.alias ().c_str (), ex.asUserString ().c_str (), "\n");
}else{
repo_messages = g_strdup_printf ("%s%s: %s%s", repo_messages, repo.alias ().c_str (), ex.asUserString ().c_str (), "\n");
}
repo_messages = pk_strsafe (repo_messages);
if (repo_messages == NULL)
repo_messages = g_strdup ("A repository could not be refreshed");
}
// Update the percentage completed
pk_backend_set_percentage (backend, i == num_of_repos ? 100 : i * percentage_increment);
}
if (repo_messages != NULL)
pk_backend_message (backend, PK_MESSAGE_ENUM_CONNECTION_REFUSED, repo_messages);
g_free (repo_messages);
return TRUE;
}
