gchar *
zypp_build_package_id_from_resolvable (zypp::sat::Solvable resolvable)
{
gchar *package_id;
package_id = pk_package_id_build (resolvable.name ().c_str (),
resolvable.edition ().asString ().c_str (),
resolvable.arch ().asString ().c_str (),
resolvable.repository (). alias().c_str ());
return package_id;
}
/*
* Converts a pkg_dep into a (partial) package ID.
*
* The result may be NULL and should be freed using g_free.
*/
static gchar *
dep_to_package_id(struct pkg_dep *dep)
{
const char *name;
const char *version;
assert(dep != NULL);
name = pkg_dep_get(dep, PKG_DEP_NAME);
version = pkg_dep_get(dep, PKG_DEP_VERSION);
return pk_package_id_build(name, version, "", "");
}
static gchar* _get_id_from_pkg(slapt_pkg_info_t *pkg)
{
gchar *pi;
gchar **fields;
const gchar *version;
const char *data;
fields = g_strsplit(pkg->version, "-", 3);
version = g_strdup_printf("%s-%s", fields[0], fields[2]);
data = pkg->installed ? "installed" : "available"; /* TODO: source */
pi = pk_package_id_build(pkg->name, version, fields[1], data);
g_free((gpointer) version);
g_strfreev(fields);
return pi;
}
gchar* utilBuildPackageId(const pkgCache::VerIterator &ver)
{
gchar *package_id;
pkgCache::VerFileIterator vf = ver.FileList();
string data = "";
const pkgCache::PkgIterator &pkg = ver.ParentPkg();
if (pkg->CurrentState == pkgCache::State::Installed && pkg.CurrentVer() == ver) {
// when a package is installed, the data part of a package-id is "installed:<repo-id>"
data = "installed:" + utilBuildPackageOriginId(vf);
} else {
data = utilBuildPackageOriginId(vf);
}
package_id = pk_package_id_build(ver.ParentPkg().Name(),
ver.VerStr(),
ver.Arch(),
data.c_str());
return package_id;
}
static void
add_packages_from_list (PkBackend *backend, GList *list, gboolean updates)
{
PackageSearch *package = NULL;
GList *li = NULL;
gchar *pkg_string = NULL;
PkInfoEnum info;
for (li = list; li != NULL; li = li->next) {
package = (PackageSearch*)li->data;
pkg_string = pk_package_id_build (package->package, package->version, package->arch, package->reponame);
if (updates == TRUE)
info = PK_INFO_ENUM_NORMAL;
else if (package->installed)
info = PK_INFO_ENUM_INSTALLED;
else
info = PK_INFO_ENUM_AVAILABLE;
pk_backend_package (backend, info, pkg_string, package->description);
g_free (pkg_string);
}
}
gchar* utilBuildPackageId(const pkgCache::VerIterator &ver)
{
gchar *package_id;
pkgCache::VerFileIterator vf = ver.FileList();
string data;
const pkgCache::PkgIterator &pkg = ver.ParentPkg();
if (pkg->CurrentState == pkgCache::State::Installed &&
pkg.CurrentVer() == ver) {
if (vf.File().Archive() == NULL) {
data = "installed";
} else {
data += vf.File().Archive();
}
} else if (vf.File().Archive() != NULL) {
data = vf.File().Archive();
}
package_id = pk_package_id_build(ver.ParentPkg().Name(),
ver.VerStr(),
ver.Arch(),
data.c_str());
return package_id;
}
gchar *
alpm_pkg_build_id (alpm_pkg_t *pkg)
{
const gchar *name, *version, *arch, *repo;
g_return_val_if_fail (pkg != NULL, NULL);
name = alpm_pkg_get_name (pkg);
version = alpm_pkg_get_version (pkg);
arch = alpm_pkg_get_arch (pkg);
if (arch == NULL) {
arch = "any";
}
/* TODO: check correctness */
if (alpm_pkg_get_origin (pkg) == ALPM_PKG_FROM_SYNCDB) {
repo = alpm_db_get_name (alpm_pkg_get_db (pkg));
} else {
repo = "installed";
}
return pk_package_id_build (name, version, arch, repo);
}
/**
* pk_plugin_transaction_finished_results:
*/
void
pk_plugin_transaction_finished_results (PkPlugin *plugin,
PkTransaction *transaction)
{
gchar **package_ids = NULL;
gchar *package_id_tmp;
GPtrArray *array = NULL;
GPtrArray *list = NULL;
guint i;
PkInfoEnum info;
PkPackage *item;
PkResults *results;
PkRoleEnum role;
/* skip simulate actions */
if (pk_bitfield_contain (pk_transaction_get_transaction_flags (transaction),
PK_TRANSACTION_FLAG_ENUM_SIMULATE)) {
goto out;
}
/* skip only-download */
if (pk_bitfield_contain (pk_transaction_get_transaction_flags (transaction),
PK_TRANSACTION_FLAG_ENUM_ONLY_DOWNLOAD)) {
goto out;
}
/* load */
if (plugin->priv->db == NULL)
pk_transaction_plugin_load_db (plugin, transaction);
/* no database */
if (plugin->priv->db == NULL)
goto out;
/* check the role */
role = pk_transaction_get_role (transaction);
if (role != PK_ROLE_ENUM_INSTALL_PACKAGES)
goto out;
/* connect to backend */
if (!pk_backend_is_implemented (plugin->backend,
PK_ROLE_ENUM_GET_FILES)) {
g_debug ("cannot get files");
goto out;
}
/* get results */
results = pk_transaction_get_results (transaction);
array = pk_results_get_package_array (results);
/* filter on INSTALLING | UPDATING */
list = g_ptr_array_new_with_free_func (g_free);
for (i=0; i<array->len; i++) {
item = g_ptr_array_index (array, i);
info = pk_package_get_info (item);
if (info == PK_INFO_ENUM_INSTALLING ||
info == PK_INFO_ENUM_UPDATING) {
/* we convert the package_id data to be 'installed' */
package_id_tmp = pk_package_id_build (pk_package_get_name (item),
pk_package_get_version (item),
pk_package_get_arch (item),
"installed");
g_ptr_array_add (list, package_id_tmp);
}
}
/* process file lists on these packages */
g_debug ("processing %i packags for desktop files", list->len);
if (list->len == 0)
goto out;
/* get all the files touched in the packages we just installed */
pk_backend_reset_job (plugin->backend, plugin->job);
pk_backend_job_set_vfunc (plugin->job,
PK_BACKEND_SIGNAL_FINISHED,
(PkBackendJobVFunc) pk_plugin_finished_cb,
plugin);
pk_backend_job_set_vfunc (plugin->job,
PK_BACKEND_SIGNAL_FILES,
(PkBackendJobVFunc) pk_plugin_files_cb,
plugin);
pk_backend_job_set_status (plugin->job, PK_STATUS_ENUM_SCAN_APPLICATIONS);
pk_backend_job_set_percentage (plugin->job, 101);
package_ids = pk_ptr_array_to_strv (list);
pk_backend_get_files (plugin->backend, plugin->job, package_ids);
/* wait for finished */
g_main_loop_run (plugin->priv->loop);
pk_backend_job_set_percentage (plugin->job, 100);
out:
if (array != NULL)
g_ptr_array_unref (array);
if (list != NULL)
g_ptr_array_unref (list);
g_strfreev (package_ids);
}
static void pk_backend_get_updates_thread(PkBackendJob *job, GVariant *params, gpointer user_data) {
gchar *pkg_id, *full_name, *desc, **pkg_tokens;
const gchar *pkg_metadata_filename;
GFile *pkg_metadata_dir;
GFileEnumerator *pkg_metadata_enumerator;
GFileInfo *pkg_metadata_file_info;
GError *err = NULL;
sqlite3_stmt *stmt;
PkBackendKatjaJobData *job_data = pk_backend_job_get_user_data(job);
pk_backend_job_set_status(job, PK_STATUS_ENUM_QUERY);
if ((sqlite3_prepare_v2(job_data->db,
"SELECT p1.full_name, p1.name, p1.ver, p1.arch, r.repo, p1.summary, p1.ext "
"FROM pkglist AS p1 NATURAL JOIN repos AS r "
"WHERE p1.name LIKE @name AND p1.repo_order = "
"(SELECT MIN(p2.repo_order) FROM pkglist AS p2 WHERE p2.name = p1.name GROUP BY p2.name)",
-1,
&stmt,
NULL) != SQLITE_OK)) {
pk_backend_job_error_code(job, PK_ERROR_ENUM_CANNOT_GET_FILELIST, "%s", sqlite3_errmsg(job_data->db));
goto out;
}
/* Read the package metadata directory and comprare all installed packages with ones in the cache */
pkg_metadata_dir = g_file_new_for_path("/var/log/packages");
pkg_metadata_enumerator = g_file_enumerate_children(pkg_metadata_dir, "standard::name",
G_FILE_QUERY_INFO_NONE,
NULL,
&err);
g_object_unref(pkg_metadata_dir);
if (err) {
pk_backend_job_error_code(job, PK_ERROR_ENUM_NO_CACHE, "/var/log/packages: %s", err->message);
g_error_free(err);
goto out;
}
while ((pkg_metadata_file_info = g_file_enumerator_next_file(pkg_metadata_enumerator, NULL, NULL))) {
pkg_metadata_filename = g_file_info_get_name(pkg_metadata_file_info);
pkg_tokens = katja_cut_pkg(pkg_metadata_filename);
/* Select the package from the database */
sqlite3_bind_text(stmt, 1, pkg_tokens[0], -1, SQLITE_TRANSIENT);
/* If there are more packages with the same name, remember the one from the repository with the lowest order */
if ((sqlite3_step(stmt) == SQLITE_ROW) ||
g_slist_find_custom(repos, ((gchar *) sqlite3_column_text(stmt, 4)), katja_cmp_repo)) {
full_name = g_strdup((gchar *) sqlite3_column_text(stmt, 0));
if (!g_strcmp0((gchar *) sqlite3_column_text(stmt, 6), "obsolete")) { /* Remove if obsolete */
pkg_id = pk_package_id_build(pkg_tokens[PK_PACKAGE_ID_NAME],
pkg_tokens[PK_PACKAGE_ID_VERSION],
pkg_tokens[PK_PACKAGE_ID_ARCH],
"obsolete");
/* TODO:
* 1: Use the repository name instead of "obsolete" above and check in pk_backend_update_packages()
if the package is obsolete or not
* 2: Get description from /var/log/packages, not from the database */
desc = g_strdup((gchar *) sqlite3_column_text(stmt, 5));
pk_backend_job_package(job, PK_INFO_ENUM_REMOVING, pkg_id, desc);
g_free(desc);
g_free(pkg_id);
} else if (g_strcmp0(pkg_metadata_filename, full_name)) { /* Update available */
pkg_id = pk_package_id_build((gchar *) sqlite3_column_text(stmt, 1),
(gchar *) sqlite3_column_text(stmt, 2),
(gchar *) sqlite3_column_text(stmt, 3),
(gchar *) sqlite3_column_text(stmt, 4));
desc = g_strdup((gchar *) sqlite3_column_text(stmt, 5));
pk_backend_job_package(job, PK_INFO_ENUM_NORMAL, pkg_id, desc);
g_free(desc);
g_free(pkg_id);
}
g_free(full_name);
}
sqlite3_clear_bindings(stmt);
sqlite3_reset(stmt);
g_strfreev(pkg_tokens);
g_object_unref(pkg_metadata_file_info);
}
g_object_unref(pkg_metadata_enumerator);
out:
sqlite3_finalize(stmt);
pk_backend_job_finished (job);
}
void
pk_package_id_test (EggTest *test)
{
gboolean ret;
gchar *text;
const gchar *temp;
PkPackageId *id;
PkPackageId *id2;
gchar **array;
if (!egg_test_start (test, "PkPackageId"))
return;
/************************************************************
**************** id ******************
************************************************************/
egg_test_title (test, "id build valid");
text = pk_package_id_build ("moo", "0.0.1", "i386", "fedora");
if (g_strcmp0 (text, "moo;0.0.1;i386;fedora") == 0)
egg_test_success (test, NULL);
else
egg_test_failed (test, NULL);
g_free (text);
egg_test_title (test, "id build partial");
text = pk_package_id_build ("moo", NULL, NULL, NULL);
if (g_strcmp0 (text, "moo;;;") == 0)
egg_test_success (test, NULL);
else
egg_test_failed (test, "got '%s', expected '%s'", text, "moo;;;");
g_free (text);
egg_test_title (test, "pid equal pass (same)");
ret = pk_package_id_equal_strings ("moo;0.0.1;i386;fedora", "moo;0.0.1;i386;fedora");
egg_test_assert (test, ret);
/************************************************************/
egg_test_title (test, "pid equal pass (different)");
ret = pk_package_id_equal_strings ("moo;0.0.1;i386;fedora", "moo;0.0.1;i386;data");
egg_test_assert (test, ret);
/************************************************************/
egg_test_title (test, "get an id object");
id = pk_package_id_new ();
egg_test_assert (test, id != NULL);
/************************************************************/
egg_test_title (test, "test id freeing early");
ret = pk_package_id_free (id);
egg_test_assert (test, ret);
/************************************************************/
egg_test_title (test, "parse incorrect package_id from string (empty)");
temp = "";
id = pk_package_id_new_from_string (temp);
if (id == NULL)
egg_test_success (test, NULL);
else
egg_test_failed (test, "passed an invalid string '%s'", temp);
/************************************************************/
egg_test_title (test, "parse incorrect package_id from string (not enough)");
temp = "moo;0.0.1;i386";
id = pk_package_id_new_from_string (temp);
if (id == NULL)
egg_test_success (test, NULL);
else
egg_test_failed (test, "passed an invalid string '%s'", temp);
/************************************************************/
egg_test_title (test, "parse package_id from string");
id = pk_package_id_new_from_string ("moo;0.0.1;i386;fedora");
if (id != NULL &&
g_strcmp0 (id->name, "moo") == 0 &&
g_strcmp0 (id->arch, "i386") == 0 &&
g_strcmp0 (id->data, "fedora") == 0 &&
g_strcmp0 (id->version, "0.0.1") == 0)
egg_test_success (test, NULL);
else
egg_test_failed (test, NULL);
/************************************************************/
egg_test_title (test, "test copying");
id2 = pk_package_id_copy (id);
if (id2 != NULL)
egg_test_success (test, NULL);
else
egg_test_failed (test, NULL);
/************************************************************/
egg_test_title (test, "test id building with valid data");
text = pk_package_id_to_string (id2);
if (g_strcmp0 (text, "moo;0.0.1;i386;fedora") == 0)
egg_test_success (test, NULL);
else
egg_test_failed (test, "package_id is '%s'", text);
g_free (text);
pk_package_id_free (id);
pk_package_id_free (id2);
/************************************************************/
egg_test_title (test, "test id building with partial data");
id = pk_package_id_new_from_string ("moo;;;");
text = pk_package_id_to_string (id);
if (g_strcmp0 (text, "moo;;;") == 0)
egg_test_success (test, NULL);
else
egg_test_failed (test, "package_id is '%s', should be '%s'", text, "moo;;;");
g_free (text);
pk_package_id_free (id);
/************************************************************/
egg_test_title (test, "parse short package_id from string");
id = pk_package_id_new_from_string ("moo;0.0.1;;");
if (id != NULL &&
(g_strcmp0 (id->name, "moo") == 0) &&
(g_strcmp0 (id->version, "0.0.1") == 0) &&
id->data == NULL &&
id->arch == NULL)
egg_test_success (test, NULL);
else
egg_test_failed (test, NULL);
pk_package_id_free (id);
egg_test_title (test, "id equal pass (same)");
ret = pk_strcmp_sections ("moo;0.0.1;i386;fedora", "moo;0.0.1;i386;fedora", 4, 3);
egg_test_assert (test, ret);
egg_test_title (test, "id equal pass (parts==match)");
ret = pk_strcmp_sections ("moo;0.0.1;i386;fedora", "moo;0.0.1;i386;fedora", 4, 4);
egg_test_assert (test, ret);
egg_test_title (test, "id equal pass (different)");
ret = pk_strcmp_sections ("moo;0.0.1;i386;fedora", "moo;0.0.1;i386;data", 4, 3);
egg_test_assert (test, ret);
egg_test_title (test, "id equal fail1");
ret = pk_strcmp_sections ("moo;0.0.1;i386;fedora", "moo;0.0.2;x64;fedora", 4, 3);
egg_test_assert (test, !ret);
egg_test_title (test, "id equal fail2");
ret = pk_strcmp_sections ("moo;0.0.1;i386;fedora", "gnome;0.0.2;i386;fedora", 4, 3);
egg_test_assert (test, !ret);
egg_test_title (test, "id equal fail3");
ret = pk_strcmp_sections ("moo;0.0.1;i386;fedora", "moo;0.0.3;i386;fedora", 4, 3);
egg_test_assert (test, !ret);
egg_test_title (test, "id equal fail (match too high)");
ret = pk_strcmp_sections ("moo;0.0.1;i386;fedora", "moo;0.0.3;i386;fedora", 4, 5);
egg_test_assert (test, !ret);
/************************************************************
**************** splitting ****************
************************************************************/
egg_test_title (test, "test pass 1");
array = pk_strsplit ("foo", 1);
if (array != NULL &&
g_strcmp0 (array[0], "foo") == 0)
egg_test_success (test, NULL);
else
egg_test_failed (test, "got %s", array[0]);
g_strfreev (array);
/************************************************************/
egg_test_title (test, "test pass 2");
array = pk_strsplit ("foo;moo", 2);
if (array != NULL &&
g_strcmp0 (array[0], "foo") == 0 &&
g_strcmp0 (array[1], "moo") == 0)
egg_test_success (test, NULL);
else
egg_test_failed (test, "got %s, %s", array[0], array[1]);
g_strfreev (array);
/************************************************************/
egg_test_title (test, "test pass 3");
array = pk_strsplit ("foo;moo;bar", 3);
if (array != NULL &&
g_strcmp0 (array[0], "foo") == 0 &&
g_strcmp0 (array[1], "moo") == 0 &&
g_strcmp0 (array[2], "bar") == 0)
egg_test_success (test, NULL);
else
egg_test_failed (test, "got %s, %s, %s, %s", array[0], array[1], array[2], array[3]);
g_strfreev (array);
/************************************************************/
egg_test_title (test, "test on real packageid");
array = pk_strsplit ("kde-i18n-csb;4:3.5.8~pre20071001-0ubuntu1;all;", 4);
if (array != NULL &&
g_strcmp0 (array[0], "kde-i18n-csb") == 0 &&
g_strcmp0 (array[1], "4:3.5.8~pre20071001-0ubuntu1") == 0 &&
g_strcmp0 (array[2], "all") == 0 &&
g_strcmp0 (array[3], "") == 0)
egg_test_success (test, NULL);
else
egg_test_failed (test, "got %s, %s, %s, %s", array[0], array[1], array[2], array[3]);
g_strfreev (array);
/************************************************************/
egg_test_title (test, "test on short packageid");
array = pk_strsplit ("kde-i18n-csb;4:3.5.8~pre20071001-0ubuntu1;;", 4);
if (array != NULL &&
g_strcmp0 (array[0], "kde-i18n-csb") == 0 &&
g_strcmp0 (array[1], "4:3.5.8~pre20071001-0ubuntu1") == 0 &&
g_strcmp0 (array[2], "") == 0 &&
g_strcmp0 (array[3], "") == 0)
egg_test_success (test, NULL);
else
egg_test_failed (test, "got %s, %s, %s, %s", array[0], array[1], array[2], array[3]);
g_strfreev (array);
/************************************************************/
egg_test_title (test, "test fail under");
array = pk_strsplit ("foo;moo", 1);
egg_test_assert (test, array == NULL);
/************************************************************/
egg_test_title (test, "test fail over");
array = pk_strsplit ("foo;moo", 3);
egg_test_assert (test, array == NULL);
/************************************************************/
egg_test_title (test, "test fail missing first");
array = pk_strsplit (";moo", 2);
egg_test_assert (test, array == NULL);
egg_test_end (test);
}
