OSS/katja
1
0
Fork 0
Code Issues Actions Releases Activity

Add toml11 to the CI
All checks were successful
Test / build (push) Successful in 47s
Details

Browse Source
This commit is contained in:
Eugen Wissner
2026-03-01 14:03:12 +01:00
parent 2c65a2c6b0
commit 1bc1f4e4d2
6 changed files with 128 additions and 249 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
.gitea/workflows/test.yaml
View File

@@ -15,7 +15,7 @@ jobs:
shell: ash {0} shell: ash {0}
run: | run: |
apk -U upgrade apk -U upgrade
apk add --no-cache git bash cmake build-base ninja-is-really-ninja boost-dev apk add --no-cache git bash cmake build-base ninja-is-really-ninja boost-dev toml11
- uses: actions/checkout@v4 - uses: actions/checkout@v4
- name: Build - name: Build
run: | run: |

50
backend/job.cc
View File

@@ -7,6 +7,8 @@
#include <string> #include <string>
#include "utils.h" #include "utils.h"
#include <pk-backend.h>
#include <pk-backend-job.h>
namespace slack { namespace slack {
@@ -25,34 +27,6 @@ filter_package (PkBitfield filters, bool is_installed)
return false; return false;
} }
static std::string
generate_query(PkBitfield filters)
{
std::string query(
"SELECT (p1.name || ';' || p1.ver || ';' || p1.arch || ';' || r.repo), p1.summary, "
"p1.full_name FROM pkglist AS p1 NATURAL JOIN repos AS r "
"WHERE p1.%s LIKE '%%%q%%' AND p1.ext NOT LIKE 'obsolete' AND p1.repo_order = "
"(SELECT MIN(p2.repo_order) FROM pkglist AS p2 WHERE p2.name = p1.name GROUP BY p2.name)");
if (pk_bitfield_contain (filters, PK_FILTER_ENUM_APPLICATION))
{
query.append(
" AND EXISTS (SELECT filelist.full_name "
"FROM filelist "
"WHERE filelist.full_name = p1.full_name "
"AND filelist.filename LIKE 'usr/share/applications/%%.desktop')");
}
else if (pk_bitfield_contain (filters, PK_FILTER_ENUM_NOT_APPLICATION))
{
query.append(
" AND NOT EXISTS (SELECT filelist.full_name "
"FROM filelist "
"WHERE filelist.full_name = p1.full_name "
"AND filelist.filename LIKE 'usr/share/applications/%%.desktop')");
}
return query;
}
} }
void void
@@ -60,16 +34,16 @@ pk_backend_search_thread (PkBackendJob *job, GVariant *params, void *user_data)
{ {
auto job_data = reinterpret_cast<slack::JobData *> (pk_backend_job_get_user_data (job)); auto job_data = reinterpret_cast<slack::JobData *> (pk_backend_job_get_user_data (job));
pk_backend_job_set_status (job, PK_STATUS_ENUM_QUERY);
pk_backend_job_set_percentage (job, 0);
char **vals; char **vals;
PkBitfield filters; PkBitfield filters;
g_variant_get (params, "(t^a&s)", &filters, &vals); g_variant_get (params, "(t^a&s)", &filters, &vals);
char *search = g_strjoinv ("%", vals); char *search = g_strjoinv ("%", vals);
char *query = sqlite3_mprintf (slack::generate_query(filters).c_str(), const char *generate_query = "SELECT (p1.name || ';' || p1.ver || ';' || p1.arch || ';' || r.repo), p1.summary, "
user_data, search); "p1.full_name FROM pkglist AS p1 NATURAL JOIN repos AS r "
"WHERE p1.%s LIKE '%%%q%%' AND p1.ext NOT LIKE 'obsolete' AND p1.repo_order = "
"(SELECT MIN(p2.repo_order) FROM pkglist AS p2 WHERE p2.name = p1.name GROUP BY p2.name)";
char *query = sqlite3_mprintf (generate_query, user_data, search);
sqlite3_stmt *stmt; sqlite3_stmt *stmt;
if ((sqlite3_prepare_v2 (job_data->db, query, -1, &stmt, nullptr) == SQLITE_OK)) if ((sqlite3_prepare_v2 (job_data->db, query, -1, &stmt, nullptr) == SQLITE_OK))
@@ -77,17 +51,17 @@ pk_backend_search_thread (PkBackendJob *job, GVariant *params, void *user_data)
/* Now we're ready to output all packages */ /* Now we're ready to output all packages */
while (sqlite3_step (stmt) == SQLITE_ROW) while (sqlite3_step (stmt) == SQLITE_ROW)
{ {
PkInfoEnum info = slack::is_installed ( slack::Info info = slack::is_installed (
reinterpret_cast<const char *> (sqlite3_column_text (stmt, 2))); reinterpret_cast<const char *> (sqlite3_column_text (stmt, 2)));
if ((info == PK_INFO_ENUM_INSTALLED || info == PK_INFO_ENUM_UPDATING) if ((info == slack::Info::installed || info == slack::Info::updating)
&& slack::filter_package (filters, true)) && slack::filter_package (filters, true))
{ {
pk_backend_job_package (job, PK_INFO_ENUM_INSTALLED, pk_backend_job_package (job, slack::Info::installed,
reinterpret_cast<const char *> (sqlite3_column_text (stmt, 0)), reinterpret_cast<const char *> (sqlite3_column_text (stmt, 0)),
reinterpret_cast<const char *> (sqlite3_column_text (stmt, 1))); reinterpret_cast<const char *> (sqlite3_column_text (stmt, 1)));
} }
else if (info == PK_INFO_ENUM_INSTALLING && slack::filter_package (filters, false)) else if (info == slack::Info::installing && slack::filter_package (filters, false))
{ {
pk_backend_job_package(job, PK_INFO_ENUM_AVAILABLE, pk_backend_job_package(job, PK_INFO_ENUM_AVAILABLE,
reinterpret_cast<const char *> (sqlite3_column_text (stmt, 0)), reinterpret_cast<const char *> (sqlite3_column_text (stmt, 0)),
@@ -104,6 +78,4 @@ pk_backend_search_thread (PkBackendJob *job, GVariant *params, void *user_data)
sqlite3_free (query); sqlite3_free (query);
g_free (search); g_free (search);
pk_backend_job_set_percentage (job, 100);
} }

288
backend/pk-backend-slack.cc
View File

@@ -5,7 +5,6 @@
*/ */
#include <dirent.h> #include <dirent.h>
#include <glib/gstdio.h> #include <glib/gstdio.h>
#include <packagekit-glib2/pk-debug.h>
#include <cstdint> #include <cstdint>
#include <stdlib.h> #include <stdlib.h>
#include <stdio.h> #include <stdio.h>
@@ -23,7 +22,7 @@ using namespace slack;
static GSList *repos = nullptr; static GSList *repos = nullptr;
void pk_backend_initialize(GKeyFile *conf, PkBackend *backend) void pk_backend_initialize(GKeyFile *conf)
{ {
char *path, **groups; char *path, **groups;
int ret; int ret;
@@ -130,7 +129,7 @@ void pk_backend_initialize(GKeyFile *conf, PkBackend *backend)
} }
void void
pk_backend_destroy(PkBackend *backend) pk_backend_destroy()
{ {
g_debug("backend: destroy"); g_debug("backend: destroy");
@@ -144,14 +143,11 @@ pk_backend_destroy(PkBackend *backend)
} }
void void
pk_backend_start_job(PkBackend *backend, PkBackendJob *job) pk_backend_start_job(PkBackendJob *job)
{ {
char *db_filename = nullptr; char *db_filename = nullptr;
JobData *job_data = g_new0(JobData, 1); JobData *job_data = g_new0(JobData, 1);
pk_backend_job_set_allow_cancel(job, true);
pk_backend_job_set_allow_cancel(job, false);
db_filename = g_build_filename(LOCALSTATEDIR, "cache", "PackageKit", "metadata", "metadata.db", nullptr); db_filename = g_build_filename(LOCALSTATEDIR, "cache", "PackageKit", "metadata", "metadata.db", nullptr);
if (sqlite3_open(db_filename, &job_data->db) == SQLITE_OK) { /* Some SQLite settings */ if (sqlite3_open(db_filename, &job_data->db) == SQLITE_OK) { /* Some SQLite settings */
sqlite3_exec(job_data->db, "PRAGMA foreign_keys = ON", nullptr, nullptr, nullptr); sqlite3_exec(job_data->db, "PRAGMA foreign_keys = ON", nullptr, nullptr, nullptr);
@@ -166,14 +162,13 @@ pk_backend_start_job(PkBackend *backend, PkBackendJob *job)
} }
pk_backend_job_set_user_data(job, job_data); pk_backend_job_set_user_data(job, job_data);
pk_backend_job_set_status(job, PK_STATUS_ENUM_RUNNING);
out: out:
g_free(db_filename); g_free(db_filename);
} }
void void
pk_backend_stop_job(PkBackend *backend, PkBackendJob *job) pk_backend_stop_job(PkBackendJob *job)
{ {
auto job_data = static_cast<JobData *> (pk_backend_job_get_user_data(job)); auto job_data = static_cast<JobData *> (pk_backend_job_get_user_data(job));
@@ -188,19 +183,19 @@ pk_backend_stop_job(PkBackend *backend, PkBackendJob *job)
} }
void void
pk_backend_search_names(PkBackend *backend, PkBackendJob *job, PkBitfield filters, char **values) pk_backend_search_names(PkBackendJob *job, char **values)
{ {
pk_backend_job_thread_create(job, pk_backend_search_thread, (void *) "name", nullptr); pk_backend_job_thread_create(job, pk_backend_search_thread, (void *) "name", nullptr);
} }
void void
pk_backend_search_details(PkBackend *backend, PkBackendJob *job, PkBitfield filters, char **values) pk_backend_search_details(PkBackendJob *job, char **values)
{ {
pk_backend_job_thread_create(job, pk_backend_search_thread, (void *) "desc", nullptr); pk_backend_job_thread_create(job, pk_backend_search_thread, (void *) "desc", nullptr);
} }
void void
pk_backend_search_groups(PkBackend *backend, PkBackendJob *job, PkBitfield filters, char **values) pk_backend_search_groups(PkBackendJob *job, char **values)
{ {
pk_backend_job_thread_create(job, pk_backend_search_thread, (void *) "cat", nullptr); pk_backend_job_thread_create(job, pk_backend_search_thread, (void *) "cat", nullptr);
} }
@@ -211,10 +206,9 @@ pk_backend_search_files_thread(PkBackendJob *job, GVariant *params, void *user_d
char **vals, *search; char **vals, *search;
char *query; char *query;
sqlite3_stmt *stmt; sqlite3_stmt *stmt;
PkInfoEnum ret; Info ret;
auto job_data = static_cast<JobData *> (pk_backend_job_get_user_data(job)); auto job_data = static_cast<JobData *> (pk_backend_job_get_user_data(job));
pk_backend_job_set_status(job, PK_STATUS_ENUM_QUERY);
pk_backend_job_set_percentage(job, 0); pk_backend_job_set_percentage(job, 0);
g_variant_get(params, "(t^a&s)", nullptr, &vals); g_variant_get(params, "(t^a&s)", nullptr, &vals);
@@ -230,7 +224,7 @@ pk_backend_search_files_thread(PkBackendJob *job, GVariant *params, void *user_d
while (sqlite3_step(stmt) == SQLITE_ROW) while (sqlite3_step(stmt) == SQLITE_ROW)
{ {
ret = is_installed((char*) sqlite3_column_text(stmt, 2)); ret = is_installed((char*) sqlite3_column_text(stmt, 2));
if ((ret == PK_INFO_ENUM_INSTALLED) || (ret == PK_INFO_ENUM_UPDATING)) if ((ret == Info::installed) || (ret == Info::updating))
{ {
pk_backend_job_package(job, PK_INFO_ENUM_INSTALLED, pk_backend_job_package(job, PK_INFO_ENUM_INSTALLED,
(char*) sqlite3_column_text(stmt, 0), (char*) sqlite3_column_text(stmt, 0),
@@ -256,15 +250,15 @@ pk_backend_search_files_thread(PkBackendJob *job, GVariant *params, void *user_d
} }
void void
pk_backend_search_files(PkBackend *backend, PkBackendJob *job, PkBitfield filters, char **values) pk_backend_search_files(PkBackendJob *job, char **values)
{ {
pk_backend_job_thread_create(job, pk_backend_search_files_thread, nullptr, nullptr); pk_backend_job_thread_create(job, pk_backend_search_files_thread, nullptr, nullptr);
} }
static void static void
pk_backend_get_details_thread(PkBackendJob *job, GVariant *params, void *user_data) pk_backend_get_details_thread(PkBackendJob *job, char **pkg_ids, void *user_data)
{ {
char **pkg_ids, *homepage = nullptr; char *homepage = nullptr;
char** tokens; char** tokens;
gsize i; gsize i;
GString *desc; GString *desc;
@@ -274,10 +268,6 @@ pk_backend_get_details_thread(PkBackendJob *job, GVariant *params, void *user_da
sqlite3_stmt *stmt; sqlite3_stmt *stmt;
auto job_data = static_cast<JobData *> (pk_backend_job_get_user_data(job)); auto job_data = static_cast<JobData *> (pk_backend_job_get_user_data(job));
pk_backend_job_set_status(job, PK_STATUS_ENUM_QUERY);
g_variant_get(params, "(^a&s)", &pkg_ids);
if ((sqlite3_prepare_v2(job_data->db, if ((sqlite3_prepare_v2(job_data->db,
"SELECT p.desc, p.cat, p.uncompressed FROM pkglist AS p NATURAL JOIN repos AS r " "SELECT p.desc, p.cat, p.uncompressed FROM pkglist AS p NATURAL JOIN repos AS r "
"WHERE name LIKE @name AND r.repo LIKE @repo AND ext NOT LIKE 'obsolete'", "WHERE name LIKE @name AND r.repo LIKE @repo AND ext NOT LIKE 'obsolete'",
@@ -347,7 +337,7 @@ out:
} }
void void
pk_backend_get_details(PkBackend *backend, PkBackendJob *job, char **package_ids) pk_backend_get_details(PkBackendJob *job, char **package_ids)
{ {
pk_backend_job_thread_create(job, pk_backend_get_details_thread, nullptr, nullptr); pk_backend_job_thread_create(job, pk_backend_get_details_thread, nullptr, nullptr);
} }
@@ -360,7 +350,6 @@ pk_backend_resolve_thread(PkBackendJob *job, GVariant *params, void *user_data)
PkInfoEnum ret; PkInfoEnum ret;
auto job_data = static_cast<JobData *> (pk_backend_job_get_user_data(job)); auto job_data = static_cast<JobData *> (pk_backend_job_get_user_data(job));
pk_backend_job_set_status(job, PK_STATUS_ENUM_QUERY);
pk_backend_job_set_percentage(job, 0); pk_backend_job_set_percentage(job, 0);
g_variant_get(params, "(t^a&s)", nullptr, &vals); g_variant_get(params, "(t^a&s)", nullptr, &vals);
@@ -380,8 +369,7 @@ pk_backend_resolve_thread(PkBackendJob *job, GVariant *params, void *user_data)
while (sqlite3_step(stmt) == SQLITE_ROW) while (sqlite3_step(stmt) == SQLITE_ROW)
{ {
ret = is_installed((char*) sqlite3_column_text(stmt, 2)); if ((ret == Info::installed) || (ret == Info::updating))
if ((ret == PK_INFO_ENUM_INSTALLED) || (ret == PK_INFO_ENUM_UPDATING))
{ {
pk_backend_job_package(job, PK_INFO_ENUM_INSTALLED, pk_backend_job_package(job, PK_INFO_ENUM_INSTALLED,
(char*) sqlite3_column_text(stmt, 0), (char*) sqlite3_column_text(stmt, 0),
@@ -407,7 +395,7 @@ pk_backend_resolve_thread(PkBackendJob *job, GVariant *params, void *user_data)
} }
void void
pk_backend_resolve(PkBackend *backend, PkBackendJob *job, PkBitfield filters, char **packages) pk_backend_resolve(PkBackendJob *job, char **packages)
{ {
pk_backend_job_thread_create(job, pk_backend_resolve_thread, nullptr, nullptr); pk_backend_job_thread_create(job, pk_backend_resolve_thread, nullptr, nullptr);
} }
@@ -421,7 +409,6 @@ pk_backend_download_packages_thread(PkBackendJob *job, GVariant *params, void *u
auto job_data = static_cast<JobData *> (pk_backend_job_get_user_data(job)); auto job_data = static_cast<JobData *> (pk_backend_job_get_user_data(job));
g_variant_get(params, "(^a&ss)", &pkg_ids, &dir_path); g_variant_get(params, "(^a&ss)", &pkg_ids, &dir_path);
pk_backend_job_set_status (job, PK_STATUS_ENUM_DOWNLOAD);
if ((sqlite3_prepare_v2(job_data->db, if ((sqlite3_prepare_v2(job_data->db,
"SELECT summary, (full_name || '.' || ext) FROM pkglist NATURAL JOIN repos " "SELECT summary, (full_name || '.' || ext) FROM pkglist NATURAL JOIN repos "
@@ -468,27 +455,22 @@ out:
} }
void void
pk_backend_download_packages(PkBackend *backend, PkBackendJob *job, char **package_ids, const char *directory) pk_backend_download_packages(PkBackendJob *job, char **package_ids, const char *directory)
{ {
pk_backend_job_thread_create(job, pk_backend_download_packages_thread, nullptr, nullptr); pk_backend_job_thread_create(job, pk_backend_download_packages_thread, nullptr, nullptr);
} }
static void static void
pk_backend_install_packages_thread(PkBackendJob *job, GVariant *params, void *user_data) pk_backend_install_packages_thread(PkBackendJob *job, char **pkg_ids, void *user_data)
{ {
char *dest_dir_name; char *dest_dir_name;
char **pkg_ids;
unsigned i; unsigned i;
gdouble percent_step; gdouble percent_step;
GSList *install_list = nullptr, *l; GSList *install_list = nullptr, *l;
sqlite3_stmt *pkglist_stmt = nullptr, *collection_stmt = nullptr; sqlite3_stmt *pkglist_stmt = nullptr, *collection_stmt = nullptr;
PkBitfield transaction_flags = 0;
PkInfoEnum ret; PkInfoEnum ret;
auto job_data = static_cast<JobData *> (pk_backend_job_get_user_data(job)); auto job_data = static_cast<JobData *> (pk_backend_job_get_user_data(job));
g_variant_get(params, "(t^a&s)", &transaction_flags, &pkg_ids);
pk_backend_job_set_status(job, PK_STATUS_ENUM_DEP_RESOLVE);
if ((sqlite3_prepare_v2(job_data->db, if ((sqlite3_prepare_v2(job_data->db,
"SELECT summary, cat FROM pkglist NATURAL JOIN repos " "SELECT summary, cat FROM pkglist NATURAL JOIN repos "
"WHERE name LIKE @name AND ver LIKE @ver AND arch LIKE @arch AND repo LIKE @repo", "WHERE name LIKE @name AND ver LIKE @ver AND arch LIKE @arch AND repo LIKE @repo",
@@ -522,16 +504,7 @@ pk_backend_install_packages_thread(PkBackendJob *job, GVariant *params, void *us
/* If it isn't a collection */ /* If it isn't a collection */
if (g_strcmp0((char *) sqlite3_column_text(pkglist_stmt, 1), "collections")) if (g_strcmp0((char *) sqlite3_column_text(pkglist_stmt, 1), "collections"))
{ {
if (pk_bitfield_contain(transaction_flags, PK_TRANSACTION_FLAG_ENUM_SIMULATE)) install_list = g_slist_append(install_list, g_strdup(pkg_ids[i]));
{
pk_backend_job_package(job, PK_INFO_ENUM_INSTALLING,
pkg_ids[i],
(char *) sqlite3_column_text(pkglist_stmt, 0));
}
else
{
install_list = g_slist_append(install_list, g_strdup(pkg_ids[i]));
}
} }
else else
{ {
@@ -541,24 +514,10 @@ pk_backend_install_packages_thread(PkBackendJob *job, GVariant *params, void *us
while (sqlite3_step(collection_stmt) == SQLITE_ROW) while (sqlite3_step(collection_stmt) == SQLITE_ROW)
{ {
ret = is_installed((char*) sqlite3_column_text(collection_stmt, 2)); ret = is_installed((char*) sqlite3_column_text(collection_stmt, 2));
if ((ret == PK_INFO_ENUM_INSTALLING) || (ret == PK_INFO_ENUM_UPDATING)) if ((ret == Info::installing) || (ret == Info::updating))
{ {
if ((pk_bitfield_contain(transaction_flags, PK_TRANSACTION_FLAG_ENUM_SIMULATE)) && install_list = g_slist_append(install_list,
!g_strcmp0((char *) sqlite3_column_text(collection_stmt, 3), "obsolete")) g_strdup((char *) sqlite3_column_text(collection_stmt, 0)));
{
/* TODO: Don't just skip obsolete packages but remove them */
}
else if (pk_bitfield_contain(transaction_flags, PK_TRANSACTION_FLAG_ENUM_SIMULATE))
{
pk_backend_job_package(job, ret,
(char *) sqlite3_column_text(collection_stmt, 0),
(char *) sqlite3_column_text(collection_stmt, 1));
}
else
{
install_list = g_slist_append(install_list,
g_strdup((char *) sqlite3_column_text(collection_stmt, 0)));
}
} }
} }
sqlite3_clear_bindings(collection_stmt); sqlite3_clear_bindings(collection_stmt);
@@ -571,13 +530,12 @@ pk_backend_install_packages_thread(PkBackendJob *job, GVariant *params, void *us
g_strfreev(tokens); g_strfreev(tokens);
} }
if (install_list && !pk_bitfield_contain(transaction_flags, PK_TRANSACTION_FLAG_ENUM_SIMULATE)) if (install_list)
{ {
/* / 2 means total percentage for installing and for downloading */ /* / 2 means total percentage for installing and for downloading */
percent_step = 100.0 / g_slist_length(install_list) / 2; percent_step = 100.0 / g_slist_length(install_list) / 2;
/* Download the packages */ /* Download the packages */
pk_backend_job_set_status(job, PK_STATUS_ENUM_DOWNLOAD);
dest_dir_name = g_build_filename(LOCALSTATEDIR, "cache", "PackageKit", "downloads", nullptr); dest_dir_name = g_build_filename(LOCALSTATEDIR, "cache", "PackageKit", "downloads", nullptr);
for (l = install_list, i = 0; l; l = g_slist_next(l), i++) for (l = install_list, i = 0; l; l = g_slist_next(l), i++)
{ {
@@ -598,7 +556,6 @@ pk_backend_install_packages_thread(PkBackendJob *job, GVariant *params, void *us
g_free(dest_dir_name); g_free(dest_dir_name);
/* Install the packages */ /* Install the packages */
pk_backend_job_set_status(job, PK_STATUS_ENUM_INSTALL);
for (l = install_list; l; l = g_slist_next(l), i++) for (l = install_list; l; l = g_slist_next(l), i++)
{ {
char **tokens; char **tokens;
@@ -623,76 +580,55 @@ out:
} }
void void
pk_backend_install_packages(PkBackend *backend, pk_backend_install_packages(PkBackendJob *job, char **package_ids)
PkBackendJob *job,
PkBitfield transaction_flags,
char **package_ids)
{ {
pk_backend_job_thread_create(job, pk_backend_install_packages_thread, nullptr, nullptr); pk_backend_job_thread_create(job, pk_backend_install_packages_thread, nullptr, nullptr);
} }
static void static void
pk_backend_remove_packages_thread(PkBackendJob* job, GVariant* params, void *user_data) pk_backend_remove_packages_thread(PkBackendJob* job, char **pkg_ids)
{ {
char **pkg_ids, *cmd_line; char *cmd_line;
unsigned i; unsigned i;
gdouble percent_step; gdouble percent_step;
bool allow_deps, autoremove;
GError *err = nullptr; GError *err = nullptr;
PkBitfield transaction_flags = 0;
g_variant_get(params, "(t^a&sbb)", &transaction_flags, &pkg_ids, &allow_deps, &autoremove);
if (pk_bitfield_contain(transaction_flags, PK_TRANSACTION_FLAG_ENUM_SIMULATE)) /* Add percent_step percents per removed package */
{ percent_step = 100.0 / g_strv_length(pkg_ids);
pk_backend_job_set_status(job, PK_STATUS_ENUM_DEP_RESOLVE); for (i = 0; pkg_ids[i]; i++)
} {
else char **tokens;
{
pk_backend_job_set_status(job, PK_STATUS_ENUM_REMOVE);
/* Add percent_step percents per removed package */ pk_backend_job_set_percentage(job, percent_step * i);
percent_step = 100.0 / g_strv_length(pkg_ids); tokens = pk_package_id_split(pkg_ids[i]);
for (i = 0; pkg_ids[i]; i++) cmd_line = g_strconcat("/sbin/removepkg ", tokens[PK_PACKAGE_ID_NAME], nullptr);
{
char **tokens;
pk_backend_job_set_percentage(job, percent_step * i); /* Pkgtools return always 0 */
tokens = pk_package_id_split(pkg_ids[i]); g_spawn_command_line_sync(cmd_line, nullptr, nullptr, nullptr, &err);
cmd_line = g_strconcat("/sbin/removepkg ", tokens[PK_PACKAGE_ID_NAME], nullptr);
/* Pkgtools return always 0 */ g_free(cmd_line);
g_spawn_command_line_sync(cmd_line, nullptr, nullptr, nullptr, &err); g_strfreev(tokens);
g_free(cmd_line); if (err)
g_strfreev(tokens); {
pk_backend_job_error_code(job, PK_ERROR_ENUM_PACKAGE_FAILED_TO_REMOVE, "%s", err->message);
g_error_free(err);
if (err) return;
{ }
pk_backend_job_error_code(job, PK_ERROR_ENUM_PACKAGE_FAILED_TO_REMOVE, "%s", err->message);
g_error_free(err);
return; pk_backend_job_set_percentage(job, 100);
} }
pk_backend_job_set_percentage(job, 100);
}
}
} }
void void
pk_backend_remove_packages(PkBackend *backend, pk_backend_remove_packages(PkBackendJob *job, char **package_ids)
PkBackendJob *job,
PkBitfield transaction_flags,
char **package_ids,
bool allow_deps,
bool autoremove)
{ {
pk_backend_job_thread_create(job, pk_backend_remove_packages_thread, nullptr, nullptr); pk_backend_job_thread_create(job, pk_backend_remove_packages_thread, nullptr, nullptr);
} }
static void static void
pk_backend_get_updates_thread(PkBackendJob *job, GVariant *params, void *user_data) pk_backend_get_updates_thread(PkBackendJob *job, void *user_data)
{ {
char *pkg_id, *full_name, *desc; char *pkg_id, *full_name, *desc;
const char *pkg_metadata_filename; const char *pkg_metadata_filename;
@@ -703,8 +639,6 @@ pk_backend_get_updates_thread(PkBackendJob *job, GVariant *params, void *user_da
sqlite3_stmt *stmt; sqlite3_stmt *stmt;
auto job_data = static_cast<JobData *> (pk_backend_job_get_user_data(job)); auto job_data = static_cast<JobData *> (pk_backend_job_get_user_data(job));
pk_backend_job_set_status(job, PK_STATUS_ENUM_QUERY);
if ((sqlite3_prepare_v2(job_data->db, if ((sqlite3_prepare_v2(job_data->db,
"SELECT p1.full_name, p1.name, p1.ver, p1.arch, r.repo, p1.summary, p1.ext " "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 " "FROM pkglist AS p1 NATURAL JOIN repos AS r "
@@ -796,88 +730,76 @@ out:
} }
void void
pk_backend_get_updates(PkBackend *backend, PkBackendJob *job, PkBitfield filters) pk_backend_get_updates(PkBackendJob *job)
{ {
pk_backend_job_thread_create(job, pk_backend_get_updates_thread, nullptr, nullptr); pk_backend_job_thread_create(job, pk_backend_get_updates_thread, nullptr, nullptr);
} }
static void static void
pk_backend_update_packages_thread(PkBackendJob *job, GVariant *params, void *user_data) pk_backend_update_packages_thread(PkBackendJob *job, char **pkg_ids, void *user_data)
{ {
char *dest_dir_name, *cmd_line, **pkg_ids; char *dest_dir_name, *cmd_line;
unsigned i; unsigned i;
PkBitfield transaction_flags = 0;
g_variant_get(params, "(t^a&s)", &transaction_flags, &pkg_ids); /* Download the packages */
dest_dir_name = g_build_filename(LOCALSTATEDIR, "cache", "PackageKit", "downloads", nullptr);
for (i = 0; pkg_ids[i]; i++)
{
char **tokens = pk_package_id_split(pkg_ids[i]);
if (!pk_bitfield_contain(transaction_flags, PK_TRANSACTION_FLAG_ENUM_SIMULATE)) { if (g_strcmp0(tokens[PK_PACKAGE_ID_DATA], "obsolete"))
pk_backend_job_set_status(job, PK_STATUS_ENUM_DOWNLOAD); {
GSList *repo = g_slist_find_custom(repos, tokens[PK_PACKAGE_ID_DATA], cmp_repo);
/* Download the packages */ if (repo)
dest_dir_name = g_build_filename(LOCALSTATEDIR, "cache", "PackageKit", "downloads", nullptr); {
for (i = 0; pkg_ids[i]; i++) static_cast<Pkgtools *> (repo->data)->download (job,
{ dest_dir_name, tokens[PK_PACKAGE_ID_NAME]);
char **tokens = pk_package_id_split(pkg_ids[i]); }
}
if (g_strcmp0(tokens[PK_PACKAGE_ID_DATA], "obsolete")) g_strfreev(tokens);
{ }
GSList *repo = g_slist_find_custom(repos, tokens[PK_PACKAGE_ID_DATA], cmp_repo); g_free(dest_dir_name);
if (repo) /* Install the packages */
{ for (i = 0; pkg_ids[i]; i++)
static_cast<Pkgtools *> (repo->data)->download (job, {
dest_dir_name, tokens[PK_PACKAGE_ID_NAME]); char **tokens = pk_package_id_split(pkg_ids[i]);
}
}
g_strfreev(tokens); if (g_strcmp0(tokens[PK_PACKAGE_ID_DATA], "obsolete"))
} {
g_free(dest_dir_name); GSList *repo = g_slist_find_custom(repos, tokens[PK_PACKAGE_ID_DATA], cmp_repo);
/* Install the packages */ if (repo)
pk_backend_job_set_status(job, PK_STATUS_ENUM_UPDATE); {
for (i = 0; pkg_ids[i]; i++) static_cast<Pkgtools *> (repo->data)->install (job,
{ tokens[PK_PACKAGE_ID_NAME]);
char **tokens = pk_package_id_split(pkg_ids[i]); }
}
if (g_strcmp0(tokens[PK_PACKAGE_ID_DATA], "obsolete")) else
{ {
GSList *repo = g_slist_find_custom(repos, tokens[PK_PACKAGE_ID_DATA], cmp_repo); /* Remove obsolete package
* TODO: Removing should be an independent operation (not during installing updates) */
if (repo) cmd_line = g_strconcat("/sbin/removepkg ", tokens[PK_PACKAGE_ID_NAME], nullptr);
{ g_spawn_command_line_sync(cmd_line, nullptr, nullptr, nullptr, nullptr);
static_cast<Pkgtools *> (repo->data)->install (job, g_free(cmd_line);
tokens[PK_PACKAGE_ID_NAME]); }
} g_strfreev(tokens);
}
else
{
/* Remove obsolete package
* TODO: Removing should be an independent operation (not during installing updates) */
cmd_line = g_strconcat("/sbin/removepkg ", tokens[PK_PACKAGE_ID_NAME], nullptr);
g_spawn_command_line_sync(cmd_line, nullptr, nullptr, nullptr, nullptr);
g_free(cmd_line);
}
g_strfreev(tokens);
}
} }
} }
void void
pk_backend_update_packages(PkBackend *backend, pk_backend_update_packages(PkBackendJob *job, char **package_ids)
PkBackendJob *job,
PkBitfield transaction_flags,
char **package_ids)
{ {
pk_backend_job_thread_create(job, pk_backend_update_packages_thread, nullptr, nullptr); pk_backend_job_thread_create(job, pk_backend_update_packages_thread, nullptr, nullptr);
} }
static void static void
pk_backend_refresh_cache_thread(PkBackendJob *job, GVariant *params, void *user_data) pk_backend_refresh_cache_thread(PkBackendJob *job, bool force, void *user_data)
{ {
char *tmp_dir_name, *db_err, *path = nullptr; char *tmp_dir_name, *db_err, *path = nullptr;
int ret; int ret;
bool force;
GSList *file_list = nullptr; GSList *file_list = nullptr;
GFile *db_file = nullptr; GFile *db_file = nullptr;
GFileInfo *file_info = nullptr; GFileInfo *file_info = nullptr;
@@ -885,8 +807,6 @@ pk_backend_refresh_cache_thread(PkBackendJob *job, GVariant *params, void *user_
sqlite3_stmt *stmt = nullptr; sqlite3_stmt *stmt = nullptr;
auto job_data = static_cast<JobData *> (pk_backend_job_get_user_data(job)); auto job_data = static_cast<JobData *> (pk_backend_job_get_user_data(job));
pk_backend_job_set_status(job, PK_STATUS_ENUM_DOWNLOAD_CHANGELOG);
/* Create temporary directory */ /* Create temporary directory */
tmp_dir_name = g_dir_make_tmp("PackageKit.XXXXXX", &err); tmp_dir_name = g_dir_make_tmp("PackageKit.XXXXXX", &err);
if (!tmp_dir_name) if (!tmp_dir_name)
@@ -896,8 +816,6 @@ pk_backend_refresh_cache_thread(PkBackendJob *job, GVariant *params, void *user_
return; return;
} }
g_variant_get(params, "(b)", &force);
/* Force the complete cache refresh if the read configuration file is newer than the metadata cache */ /* Force the complete cache refresh if the read configuration file is newer than the metadata cache */
if (!force) if (!force)
{ {
@@ -947,8 +865,6 @@ pk_backend_refresh_cache_thread(PkBackendJob *job, GVariant *params, void *user_
} }
/* Download repository */ /* Download repository */
pk_backend_job_set_status(job, PK_STATUS_ENUM_DOWNLOAD_REPOSITORY);
for (GSList *l = file_list; l; l = g_slist_next(l)) for (GSList *l = file_list; l; l = g_slist_next(l))
{ {
get_file(&job_data->curl, static_cast<char **> (l->data)[0], get_file(&job_data->curl, static_cast<char **> (l->data)[0],
@@ -957,8 +873,6 @@ pk_backend_refresh_cache_thread(PkBackendJob *job, GVariant *params, void *user_
g_slist_free_full(file_list, (GDestroyNotify)g_strfreev); g_slist_free_full(file_list, (GDestroyNotify)g_strfreev);
/* Refresh cache */ /* Refresh cache */
pk_backend_job_set_status(job, PK_STATUS_ENUM_REFRESH_CACHE);
for (GSList *l = repos; l; l = g_slist_next(l)) for (GSList *l = repos; l; l = g_slist_next(l))
{ {
static_cast<Pkgtools *> (l->data)->generate_cache (job, tmp_dir_name); static_cast<Pkgtools *> (l->data)->generate_cache (job, tmp_dir_name);
@@ -982,20 +896,15 @@ out:
} }
void void
pk_backend_refresh_cache(PkBackend *backend, PkBackendJob *job, bool force) pk_backend_refresh_cache(PkBackendJob *job, bool force)
{ {
pk_backend_job_thread_create(job, pk_backend_refresh_cache_thread, nullptr, nullptr); pk_backend_job_thread_create(job, pk_backend_refresh_cache_thread, nullptr, nullptr);
} }
static void static void
pk_backend_get_update_detail_thread(PkBackendJob *job, GVariant *params, void *user_data) pk_backend_get_update_detail_thread(PkBackendJob *job, char **pkg_ids, void *user_data)
{ {
unsigned i; unsigned i;
char **pkg_ids;
pk_backend_job_set_status(job, PK_STATUS_ENUM_QUERY);
g_variant_get(params, "(^a&s)", &pkg_ids);
for (i = 0; pkg_ids[i] != nullptr; i++) for (i = 0; pkg_ids[i] != nullptr; i++)
{ {
@@ -1016,16 +925,7 @@ pk_backend_get_update_detail_thread(PkBackendJob *job, GVariant *params, void *u
} }
void void
pk_backend_get_update_detail(PkBackend *backend, PkBackendJob *job, char **package_ids) pk_backend_get_update_detail(PkBackendJob *job, char **package_ids)
{ {
pk_backend_job_thread_create(job, pk_backend_get_update_detail_thread, nullptr, nullptr); pk_backend_job_thread_create(job, pk_backend_get_update_detail_thread, nullptr, nullptr);
} }
PkBitfield
pk_backend_get_filters (PkBackend *backend)
{
return pk_bitfield_from_enums (
PK_FILTER_ENUM_INSTALLED, PK_FILTER_ENUM_NOT_INSTALLED,
PK_FILTER_ENUM_APPLICATION, PK_FILTER_ENUM_NOT_APPLICATION,
-1);
}

1
backend/pkgtools.h
View File

@@ -7,7 +7,6 @@
#include <cstdint> #include <cstdint>
#include <glib-object.h> #include <glib-object.h>
#include <pk-backend.h>
#include "utils.h" #include "utils.h"
namespace slack { namespace slack {

20
backend/utils.cc
View File

@@ -131,22 +131,20 @@ split_package_name (const char *pkg_filename)
* Params: * Params:
* pkg_fullname = Package name should be looked for. * pkg_fullname = Package name should be looked for.
* *
* Returns: PK_INFO_ENUM_INSTALLING if pkg_fullname is already installed, * Returns: Package installation information.
* PK_INFO_ENUM_UPDATING if an elder version of pkg_fullname is
* installed, PK_INFO_ENUM_UNKNOWN if pkg_fullname is malformed.
**/ **/
PkInfoEnum Info
is_installed (const char *pkg_fullname) is_installed (const char *pkg_fullname)
{ {
GFileEnumerator *pkg_metadata_enumerator; GFileEnumerator *pkg_metadata_enumerator;
GFileInfo *pkg_metadata_file_info; GFileInfo *pkg_metadata_file_info;
GFile *pkg_metadata_dir; GFile *pkg_metadata_dir;
PkInfoEnum ret = PK_INFO_ENUM_INSTALLING; Info ret = Info::installing;
const char *it; const char *it;
std::uint8_t dashes = 0; std::uint8_t dashes = 0;
ptrdiff_t pkg_name; ptrdiff_t pkg_name;
g_return_val_if_fail(pkg_fullname != nullptr, PK_INFO_ENUM_UNKNOWN); g_return_val_if_fail(pkg_fullname != nullptr, Info::unknown);
// We want to find the package name without version for the package we're // We want to find the package name without version for the package we're
// looking for. // looking for.
@@ -165,7 +163,7 @@ is_installed (const char *pkg_fullname)
} }
if (dashes < 2) if (dashes < 2)
{ {
return PK_INFO_ENUM_UNKNOWN; return Info::unknown;
} }
pkg_name = it - pkg_fullname; pkg_name = it - pkg_fullname;
@@ -179,7 +177,7 @@ is_installed (const char *pkg_fullname)
nullptr))) nullptr)))
{ {
g_object_unref(pkg_metadata_dir); g_object_unref(pkg_metadata_dir);
return PK_INFO_ENUM_UNKNOWN; return Info::unknown;
} }
while ((pkg_metadata_file_info = g_file_enumerator_next_file(pkg_metadata_enumerator, nullptr, nullptr))) while ((pkg_metadata_file_info = g_file_enumerator_next_file(pkg_metadata_enumerator, nullptr, nullptr)))
@@ -189,7 +187,7 @@ is_installed (const char *pkg_fullname)
if (strcmp(dir, pkg_fullname) == 0) if (strcmp(dir, pkg_fullname) == 0)
{ {
ret = PK_INFO_ENUM_INSTALLED; ret = Info::installed;
} }
else else
{ {
@@ -206,13 +204,13 @@ is_installed (const char *pkg_fullname)
} }
if (pkg_name == (it - dir) && strncmp(pkg_fullname, dir, pkg_name) == 0) if (pkg_name == (it - dir) && strncmp(pkg_fullname, dir, pkg_name) == 0)
{ {
ret = PK_INFO_ENUM_UPDATING; ret = Info::updating;
} }
} }
g_object_unref(pkg_metadata_file_info); g_object_unref(pkg_metadata_file_info);
if (ret != PK_INFO_ENUM_INSTALLING) /* If installed */ if (ret != Info::installing) /* If installed */
{ {
break; break;
} }

16
backend/utils.h
View File

@@ -6,8 +6,6 @@
#pragma once #pragma once
#include <curl/curl.h> #include <curl/curl.h>
#include <pk-backend.h>
#include <pk-backend-job.h>
namespace slack { namespace slack {
@@ -17,11 +15,23 @@ struct JobData
CURL *curl; CURL *curl;
}; };
enum class Info
{
// Error.
unknown,
// Installed in the same version.
installed,
// A different version is installed.
updating
// Available, but not installed.
installing,
};
CURLcode get_file (CURL **curl, char *source_url, char *dest); CURLcode get_file (CURL **curl, char *source_url, char *dest);
char **split_package_name (const char *pkg_filename); char **split_package_name (const char *pkg_filename);
PkInfoEnum is_installed (const char *pkg_fullname); Info is_installed (const char *pkg_fullname);
extern "C" { extern "C" {