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