/** * 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); }
static void pk_backend_transaction_sig_check (PkBackend *self) { g_return_if_fail (self != NULL); pk_backend_set_status (self, PK_STATUS_ENUM_SIG_CHECK); }
/** * backend_get_requires: */ static void backend_get_requires (PkBackend *backend, PkBitfield filters, gchar **package_ids, gboolean recursive) { guint i; guint len; const gchar *package_id; PkPackageId *pi; slapt_pkg_info_t *pkg; slapt_pkg_list_t *installed; slapt_pkg_list_t *available; slapt_pkg_list_t *requires; PkInfoEnum state; const char *summary; installed = slapt_get_installed_pkgs(); available = slapt_get_available_pkgs(); pk_backend_set_status (backend, PK_STATUS_ENUM_QUERY); len = g_strv_length (package_ids); for (i=0; i<len; i++) { package_id = package_ids[i]; pi = pk_package_id_new_from_string (package_id); 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); pk_package_id_free (pi); if (pkg == NULL) { pk_backend_error_code (backend, PK_ERROR_ENUM_PACKAGE_NOT_FOUND, "package not found"); continue; } requires = slapt_is_required_by(_config, available, pkg); for (i = 0; i < requires->pkg_count; i++) { pkg = requires->pkgs[i]; state = pkg->installed ? PK_INFO_ENUM_INSTALLED : PK_INFO_ENUM_AVAILABLE; 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(requires); } slapt_free_pkg_list(available); slapt_free_pkg_list(installed); pk_backend_finished (backend); }
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_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_set_status (self, state); pk_backend_pkg (self, pkg, info); pk_backend_output_start (self, pkg); }
static gboolean backend_get_depends_requires_thread (PkBackend *backend) { GList *list = NULL; sqlite3 *db; gchar **package_ids; int deps_type; gchar **package_id_data; db = db_open (); package_ids = pk_backend_get_strv (backend, "package_ids"); deps_type = pk_backend_get_uint (backend, "type"); /* FIXME: support multiple packages */ package_id_data = pk_package_id_split (package_ids[0]); pk_backend_set_status (backend, PK_STATUS_ENUM_QUERY); if (deps_type == DEPS_TYPE_DEPENDS) list = box_db_repos_get_depends (db, package_id_data[PK_PACKAGE_ID_NAME]); else if (deps_type == DEPS_TYPE_REQUIRES) list = box_db_repos_get_requires (db, package_id_data[PK_PACKAGE_ID_NAME]); add_packages_from_list (backend, list, FALSE); box_db_repos_package_list_free (list); db_close (db); pk_backend_finished (backend); return TRUE; }
/** * 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); }
static void pk_backend_transaction_test_commit (PkBackend *self) { g_return_if_fail (self != NULL); pk_backend_set_status (self, PK_STATUS_ENUM_TEST_COMMIT); }
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 pk_backend_transaction_setup (PkBackend *self) { g_return_if_fail (self != NULL); pk_backend_set_status (self, PK_STATUS_ENUM_SETUP); }
static void pk_backend_transaction_download (PkBackend *self) { g_return_if_fail (self != NULL); pk_backend_set_status (self, PK_STATUS_ENUM_DOWNLOAD); }
static void pk_backend_transaction_dep_resolve (PkBackend *self) { g_return_if_fail (self != NULL); pk_backend_set_status (self, PK_STATUS_ENUM_DEP_RESOLVE); }
static void pk_backend_transaction_repackaging (PkBackend *self) { g_return_if_fail (self != NULL); pk_backend_set_status (self, PK_STATUS_ENUM_REPACKAGING); }
/** * 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); }
static gboolean backend_get_details_thread (PkBackend *backend) { PackageSearch *ps; GList *list; sqlite3 *db; gchar **package_ids; gchar **package_id_data; package_ids = pk_backend_get_strv (backend, "package_ids"); /* FIXME: support multiple packages */ package_id_data = pk_package_id_split (package_ids[0]); db = db_open (); pk_backend_set_status (backend, PK_STATUS_ENUM_QUERY); /* only one element is returned */ list = box_db_repos_packages_search_by_data (db, package_id_data[PK_PACKAGE_ID_NAME], package_id_data[PK_PACKAGE_ID_VERSION]); if (list == NULL) { pk_backend_error_code (backend, PK_ERROR_ENUM_PACKAGE_ID_INVALID, "cannot find package by id"); db_close (db); return FALSE; } ps = (PackageSearch*) list->data; pk_backend_details (backend, package_ids[0], "unknown", PK_GROUP_ENUM_OTHER, ps->description, "", 0); box_db_repos_package_list_free (list); db_close (db); pk_backend_finished (backend); return TRUE; }
/** * 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 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); }
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); }
/** * backend_refresh_cache: */ static void backend_refresh_cache (PkBackend *backend, gboolean force) { pk_backend_set_allow_cancel (backend, TRUE); pk_backend_set_status (backend, PK_STATUS_ENUM_REFRESH_CACHE); slapt_update_pkg_cache(_config); pk_backend_finished (backend); }
/** * backend_refresh_cache_thread: */ static gboolean backend_refresh_cache_thread (PkBackend *backend) { pk_backend_set_allow_cancel (backend, true); 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_apt; pk_backend_finished (backend); return false; } pk_backend_set_status (backend, PK_STATUS_ENUM_REFRESH_CACHE); // Lock the list directory FileFd Lock; if (_config->FindB("Debug::NoLocking", false) == false) { Lock.Fd(GetLock(_config->FindDir("Dir::State::Lists") + "lock")); if (_error->PendingError() == true) { pk_backend_error_code (backend, PK_ERROR_ENUM_CANNOT_GET_LOCK, "Unable to lock the list directory"); delete m_apt; pk_backend_finished (backend); return false; // return _error->Error(_("Unable to lock the list directory")); } } // Create the progress AcqPackageKitStatus Stat(m_apt, backend, _cancel); // do the work if (_config->FindB("APT::Get::Download",true) == true) { ListUpdate(Stat, *m_apt->packageSourceList); } // Rebuild the cache. pkgCacheFile Cache; OpTextProgress Prog(*_config); if (Cache.BuildCaches(Prog, true) == false) { if (_error->PendingError() == true) { show_errors(backend, PK_ERROR_ENUM_CANNOT_GET_LOCK); } delete m_apt; pk_backend_finished (backend); return false; } // missing gpg signature would appear here // TODO we need a better enum if (_error->PendingError() == false && _error->empty() == false) { show_warnings(backend, PK_MESSAGE_ENUM_UNTRUSTED_PACKAGE); } pk_backend_finished (backend); delete m_apt; return true; }
/** * backend_repo_enable: **/ void backend_repo_enable (PkBackend *backend, const gchar *repo, gboolean enabled) { g_return_if_fail (backend != NULL); g_return_if_fail (repo != NULL); pk_backend_set_status (backend, PK_STATUS_ENUM_QUERY); pk_backend_thread_create (backend, backend_repo_enable_thread); }
/** * backend_repo_enable: */ static void backend_repo_enable (PkBackend *backend, const gchar *rid, gboolean enabled) { pk_backend_set_status (backend, PK_STATUS_ENUM_QUERY); box_repos_enable_repo(rid, enabled); pk_backend_finished (backend); }
static gboolean backend_refresh_cache_thread (PkBackend *backend) { pk_backend_set_status (backend, PK_STATUS_ENUM_REFRESH_CACHE); box_repos_sync(ROOT_DIRECTORY, common_progress, backend); pk_backend_finished (backend); return TRUE; }
/** * 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_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); }
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_set_status (self, PK_STATUS_ENUM_REMOVE); pk_backend_pkg (self, pkg, PK_INFO_ENUM_REMOVING); pk_backend_output_start (self, pkg); }
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_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_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); }
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_set_allow_cancel (self, FALSE); pk_backend_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; }
/** * backend_repo_set_data: */ static void backend_repo_set_data (PkBackend *backend, const gchar *rid, const gchar *parameter, const gchar *value) { pk_backend_set_status (backend, PK_STATUS_ENUM_QUERY); if (!box_repos_set_param (rid, parameter, value)) { g_warning ("Cannot set PARAMETER '%s' TO '%s' for REPO '%s'", parameter, value, rid); } pk_backend_finished (backend); }