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