/** * pk_backend_refresh_cache_thread: */ static void pk_backend_refresh_cache_thread(PkBackendJob *job, GVariant *params, gpointer user_data) { pk_backend_job_set_allow_cancel(job, true); AptIntf *apt = static_cast<AptIntf*>(pk_backend_job_get_user_data(job)); if (!apt->init()) { g_debug("Failed to create apt cache"); apt->emitFinished(); return; } PkBackend *backend = PK_BACKEND(pk_backend_job_get_backend(job)); if (pk_backend_is_online(backend)) { apt->refreshCache(); if (_error->PendingError() == true) { show_errors(job, PK_ERROR_ENUM_CANNOT_FETCH_SOURCES, true); } } else { pk_backend_job_error_code(job, PK_ERROR_ENUM_NO_NETWORK, "Cannot refresh cache whilst offline"); } apt->emitFinished(); }
/** * backend_update_packages: */ static void backend_update_packages (PkBackend *backend, gboolean only_trusted, gchar **package_ids) { /* check network state */ if (!pk_backend_is_online (backend)) { pk_backend_error_code (backend, PK_ERROR_ENUM_NO_NETWORK, "Cannot update when offline"); pk_backend_finished (backend); return; } pk_backend_thread_create (backend, backend_update_packages_thread); }
/** * backend_refresh_cache: */ static void backend_refresh_cache (PkBackend *backend, gboolean force) { /* check network state */ if (!pk_backend_is_online (backend)) { pk_backend_error_code (backend, PK_ERROR_ENUM_NO_NETWORK, "Cannot refresh cache whilst offline"); pk_backend_finished (backend); return; } /* FIXME: support force */ pk_backend_thread_create (backend, backend_refresh_cache_thread); }
/** * pk_backend_refresh_cache: */ void pk_backend_refresh_cache (PkBackend *backend, gboolean force) { /* check network state */ if (!pk_backend_is_online (backend)) { pk_backend_error_code (backend, PK_ERROR_ENUM_NO_NETWORK, "Cannot refresh cache whilst offline"); pk_backend_finished (backend); return; } pk_backend_spawn_helper (spawn, BACKEND_FILE, "refresh-cache", pk_backend_bool_to_string (force), NULL); }
/** * pk_backend_install_packages: */ static void pk_backend_install_packages (PkBackend *backend, PkBackendJob *job, gboolean only_trusted, gchar **package_ids) { /* check network state */ if (!pk_backend_is_online (backend)) { pk_backend_job_error_code (job, PK_ERROR_ENUM_NO_NETWORK, "Cannot install when offline"); pk_backend_job_finished (job); return; } pk_backend_set_strv (backend, "package_ids", package_ids); pk_backend_job_thread_create (job, backend_install_packages_thread, NULL, NULL); }
/** * pk_backend_update_packages: */ void pk_backend_update_packages (PkBackend *backend, gboolean only_trusted, gchar **package_ids) { gchar *package_ids_temp; /* check network state */ if (!pk_backend_is_online (backend)) { pk_backend_error_code (backend, PK_ERROR_ENUM_NO_NETWORK, "Cannot install when offline"); pk_backend_finished (backend); return; } /* send the complete list as stdin */ package_ids_temp = pk_package_ids_to_string (package_ids); pk_backend_spawn_helper (spawn, BACKEND_FILE, "update-packages", pk_backend_bool_to_string (only_trusted), package_ids_temp, NULL); g_free (package_ids_temp); }
/** * pk_backend_update_packages: */ void pk_backend_update_packages (PkBackend *backend, PkBackendJob *job, PkBitfield transaction_flags, gchar **package_ids) { gchar *package_ids_temp; gchar *transaction_flags_temp; /* check network state */ if (!pk_backend_is_online (backend)) { pk_backend_job_error_code (job, PK_ERROR_ENUM_NO_NETWORK, "Cannot install when offline"); pk_backend_job_finished (job); return; } /* send the complete list as stdin */ package_ids_temp = pk_package_ids_to_string (package_ids); transaction_flags_temp = pk_transaction_flag_bitfield_to_string (transaction_flags); pk_backend_spawn_helper (spawn, job, BACKEND_FILE, "update-packages", transaction_flags_temp, package_ids_temp, NULL); g_free (package_ids_temp); g_free (transaction_flags_temp); }
/** * pk_backend_download_packages_thread: */ static void pk_backend_download_packages_thread(PkBackendJob *job, GVariant *params, gpointer user_data) { gchar **package_ids; const gchar *tmpDir; string directory; g_variant_get(params, "(^a&ss)", &package_ids, &tmpDir); directory = _config->FindDir("Dir::Cache::archives"); pk_backend_job_set_allow_cancel(job, true); AptIntf *apt = static_cast<AptIntf*>(pk_backend_job_get_user_data(job)); if (!apt->init()) { g_debug("Failed to create apt cache"); return; } PkBackend *backend = PK_BACKEND(pk_backend_job_get_backend(job)); if (pk_backend_is_online(backend)) { pk_backend_job_set_status(job, PK_STATUS_ENUM_QUERY); // Create the progress AcqPackageKitStatus Stat(apt, job); // get a fetcher pkgAcquire fetcher(&Stat); gchar *pi; // TODO this might be useful when the item is in the cache // for (pkgAcquire::ItemIterator I = fetcher.ItemsBegin(); I < fetcher.ItemsEnd();) // { // if ((*I)->Local == true) // { // I++; // continue; // } // // // Close the item and check if it was found in cache // (*I)->Finished(); // if ((*I)->Complete == false) { // Transient = true; // } // // // Clear it out of the fetch list // delete *I; // I = fetcher.ItemsBegin(); // } for (uint i = 0; i < g_strv_length(package_ids); ++i) { pi = package_ids[i]; if (pk_package_id_check(pi) == false) { pk_backend_job_error_code(job, PK_ERROR_ENUM_PACKAGE_ID_INVALID, "%s", pi); return; } if (apt->cancelled()) { break; } const pkgCache::VerIterator &ver = apt->aptCacheFile()->resolvePkgID(pi); // Ignore packages that could not be found or that exist only due to dependencies. if (ver.end()) { _error->Error("Can't find this package id \"%s\".", pi); continue; } else { if(!ver.Downloadable()) { _error->Error("No downloadable files for %s," "perhaps it is a local or obsolete" "package?", pi); continue; } string storeFileName; if (!apt->getArchive(&fetcher, ver, directory, storeFileName)) { return; } gchar **files = (gchar **) g_malloc(2 * sizeof(gchar *)); files[0] = g_strdup_printf("%s/%s", directory.c_str(), flNotDir(storeFileName).c_str()); files[1] = NULL; pk_backend_job_files(job, pi, files); g_strfreev(files); } } if (fetcher.Run() != pkgAcquire::Continue && apt->cancelled() == false) { // We failed and we did not cancel show_errors(job, PK_ERROR_ENUM_PACKAGE_DOWNLOAD_FAILED); return; } } else { pk_backend_job_error_code(job, PK_ERROR_ENUM_NO_NETWORK, "Cannot download packages whilst offline"); } }
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; }