diff options
Diffstat (limited to 'plugins/rpm-ostree/gs-plugin-rpm-ostree.c')
| -rw-r--r-- | plugins/rpm-ostree/gs-plugin-rpm-ostree.c | 2878 |
1 files changed, 2878 insertions, 0 deletions
diff --git a/plugins/rpm-ostree/gs-plugin-rpm-ostree.c b/plugins/rpm-ostree/gs-plugin-rpm-ostree.c new file mode 100644 index 0000000..b983c24 --- /dev/null +++ b/plugins/rpm-ostree/gs-plugin-rpm-ostree.c @@ -0,0 +1,2878 @@ +/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- + * vi:set noexpandtab tabstop=8 shiftwidth=8: + * + * Copyright (C) 2017-2020 Kalev Lember <klember@redhat.com> + * + * SPDX-License-Identifier: GPL-2.0+ + */ + +#include <config.h> + +#include <gnome-software.h> + +#include <fcntl.h> +#include <gio/gio.h> +#include <gio/gunixfdlist.h> +#include <glib/gstdio.h> +#include <glib/gi18n-lib.h> +#include <libdnf/libdnf.h> +#include <ostree.h> +#include <rpm/rpmdb.h> +#include <rpm/rpmlib.h> +#include <rpm/rpmts.h> +#include <rpmostree.h> + +#include "gs-plugin-private.h" +#include "gs-plugin-rpm-ostree.h" +#include "gs-rpmostree-generated.h" + +/* + * SECTION: + * Exposes rpm-ostree system updates and overlays. + * + * The plugin has a worker thread which all operations are delegated to, as + * while the rpm-ostreed API is asynchronous over D-Bus, the plugin also needs + * to use lower level libostree and libdnf APIs which are entirely synchronous. + * Message passing to the worker thread is by gs_worker_thread_queue(). + */ + +/* This shows up in the `rpm-ostree status` as the software that + * initiated the update. + */ +#define GS_RPMOSTREE_CLIENT_ID PACKAGE_NAME + +/* How long to wait between two consecutive requests, before considering + * the connection to the rpm-ostree daemon inactive and disconnect from it. + */ +#define INACTIVE_TIMEOUT_SECONDS 60 + +G_DEFINE_AUTO_CLEANUP_FREE_FUNC(Header, headerFree, NULL) +G_DEFINE_AUTO_CLEANUP_FREE_FUNC(rpmts, rpmtsFree, NULL); +G_DEFINE_AUTO_CLEANUP_FREE_FUNC(rpmdbMatchIterator, rpmdbFreeIterator, NULL); + +struct _GsPluginRpmOstree { + GsPlugin parent; + + GsWorkerThread *worker; /* (owned) */ + + GMutex mutex; + GsRPMOSTreeOS *os_proxy; + GsRPMOSTreeSysroot *sysroot_proxy; + OstreeRepo *ot_repo; + OstreeSysroot *ot_sysroot; + DnfContext *dnf_context; + gboolean update_triggered; + guint inactive_timeout_id; +}; + +G_DEFINE_TYPE (GsPluginRpmOstree, gs_plugin_rpm_ostree, GS_TYPE_PLUGIN) + +#define assert_in_worker(self) \ + g_assert (gs_worker_thread_is_in_worker_context (self->worker)) + +static void +gs_plugin_rpm_ostree_dispose (GObject *object) +{ + GsPluginRpmOstree *self = GS_PLUGIN_RPM_OSTREE (object); + + g_clear_handle_id (&self->inactive_timeout_id, g_source_remove); + g_clear_object (&self->os_proxy); + g_clear_object (&self->sysroot_proxy); + g_clear_object (&self->ot_sysroot); + g_clear_object (&self->ot_repo); + g_clear_object (&self->dnf_context); + g_clear_object (&self->worker); + + G_OBJECT_CLASS (gs_plugin_rpm_ostree_parent_class)->dispose (object); +} + +static void +gs_plugin_rpm_ostree_finalize (GObject *object) +{ + GsPluginRpmOstree *self = GS_PLUGIN_RPM_OSTREE (object); + + g_mutex_clear (&self->mutex); + + G_OBJECT_CLASS (gs_plugin_rpm_ostree_parent_class)->finalize (object); +} + +static void +gs_plugin_rpm_ostree_init (GsPluginRpmOstree *self) +{ + /* only works on OSTree */ + if (!g_file_test ("/run/ostree-booted", G_FILE_TEST_EXISTS)) { + gs_plugin_set_enabled (GS_PLUGIN (self), FALSE); + return; + } + + g_mutex_init (&self->mutex); + + /* open transaction */ + rpmReadConfigFiles (NULL, NULL); + + /* rpm-ostree is already a daemon with a DBus API; hence it makes + * more sense to use a custom plugin instead of using PackageKit. + */ + gs_plugin_add_rule (GS_PLUGIN (self), GS_PLUGIN_RULE_CONFLICTS, "packagekit"); + + /* need pkgname */ + gs_plugin_add_rule (GS_PLUGIN (self), GS_PLUGIN_RULE_RUN_AFTER, "appstream"); +} + +static void +gs_rpmostree_error_convert (GError **perror) +{ + GError *error = perror != NULL ? *perror : NULL; + + /* not set */ + if (error == NULL) + return; + + /* parse remote RPM_OSTREED_ERROR */ + if (g_dbus_error_is_remote_error (error)) { + g_autofree gchar *remote_error = g_dbus_error_get_remote_error (error); + + g_dbus_error_strip_remote_error (error); + + if (g_strcmp0 (remote_error, "org.projectatomic.rpmostreed.Error.NotAuthorized") == 0) { + error->code = GS_PLUGIN_ERROR_NO_SECURITY; + } else if (g_str_has_prefix (remote_error, "org.projectatomic.rpmostreed.Error")) { + error->code = GS_PLUGIN_ERROR_FAILED; + } else { + g_warning ("can't reliably fixup remote error %s", remote_error); + error->code = GS_PLUGIN_ERROR_FAILED; + } + error->domain = GS_PLUGIN_ERROR; + return; + } + + /* this are allowed for low-level errors */ + if (gs_utils_error_convert_gio (perror)) + return; + + /* this are allowed for low-level errors */ + if (gs_utils_error_convert_gdbus (perror)) + return; +} + +static void +gs_rpmostree_unregister_client_done_cb (GObject *source_object, + GAsyncResult *result, + gpointer user_data) +{ + g_autoptr(GError) error = NULL; + + if (!gs_rpmostree_sysroot_call_unregister_client_finish (GS_RPMOSTREE_SYSROOT (source_object), result, &error)) + g_debug ("Failed to unregister client: %s", error->message); + else + g_debug ("Unregistered client from the rpm-ostreed"); +} + +static gboolean +gs_rpmostree_inactive_timeout_cb (gpointer user_data) +{ + GsPluginRpmOstree *self = GS_PLUGIN_RPM_OSTREE (user_data); + g_autoptr(GMutexLocker) locker = NULL; + + if (g_source_is_destroyed (g_main_current_source ())) + return G_SOURCE_REMOVE; + + locker = g_mutex_locker_new (&self->mutex); + + /* In case it gets destroyed before the lock is acquired */ + if (!g_source_is_destroyed (g_main_current_source ()) && + self->inactive_timeout_id == g_source_get_id (g_main_current_source ())) { + g_autoptr(GsRPMOSTreeSysroot) sysroot_proxy = NULL; + + if (self->sysroot_proxy) + sysroot_proxy = g_steal_pointer (&self->sysroot_proxy); + + g_clear_object (&self->os_proxy); + g_clear_object (&self->sysroot_proxy); + g_clear_object (&self->ot_sysroot); + g_clear_object (&self->ot_repo); + g_clear_object (&self->dnf_context); + self->inactive_timeout_id = 0; + + g_clear_pointer (&locker, g_mutex_locker_free); + + if (sysroot_proxy) { + g_autoptr(GVariantBuilder) options_builder = NULL; + options_builder = g_variant_builder_new (G_VARIANT_TYPE ("a{sv}")); + g_variant_builder_add (options_builder, "{sv}", "id", + g_variant_new_string (GS_RPMOSTREE_CLIENT_ID)); + gs_rpmostree_sysroot_call_unregister_client (sysroot_proxy, + g_variant_builder_end (options_builder), + NULL, + gs_rpmostree_unregister_client_done_cb, + NULL); + } + } + + return G_SOURCE_REMOVE; +} + +/* Hold the plugin mutex when called */ +static gboolean +gs_rpmostree_ref_proxies_locked (GsPluginRpmOstree *self, + GsRPMOSTreeOS **out_os_proxy, + GsRPMOSTreeSysroot **out_sysroot_proxy, + GCancellable *cancellable, + GError **error) +{ + if (self->inactive_timeout_id) { + g_source_remove (self->inactive_timeout_id); + self->inactive_timeout_id = 0; + } + + /* Create a proxy for sysroot */ + if (self->sysroot_proxy == NULL) { + g_autoptr(GVariantBuilder) options_builder = NULL; + + self->sysroot_proxy = gs_rpmostree_sysroot_proxy_new_sync (gs_plugin_get_system_bus_connection (GS_PLUGIN (self)), + G_DBUS_PROXY_FLAGS_NONE, + "org.projectatomic.rpmostree1", + "/org/projectatomic/rpmostree1/Sysroot", + cancellable, + error); + if (self->sysroot_proxy == NULL) { + gs_rpmostree_error_convert (error); + return FALSE; + } + + options_builder = g_variant_builder_new (G_VARIANT_TYPE ("a{sv}")); + g_variant_builder_add (options_builder, "{sv}", "id", + g_variant_new_string (GS_RPMOSTREE_CLIENT_ID)); + /* Register as a client so that the rpm-ostree daemon doesn't exit */ + if (!gs_rpmostree_sysroot_call_register_client_sync (self->sysroot_proxy, + g_variant_builder_end (options_builder), + cancellable, + error)) { + g_clear_object (&self->sysroot_proxy); + gs_rpmostree_error_convert (error); + return FALSE; + } + + g_debug ("Registered client on the rpm-ostreed"); + } + + /* Create a proxy for currently booted OS */ + if (self->os_proxy == NULL) { + g_autofree gchar *os_object_path = NULL; + + os_object_path = gs_rpmostree_sysroot_dup_booted (self->sysroot_proxy); + if (os_object_path == NULL && + !gs_rpmostree_sysroot_call_get_os_sync (self->sysroot_proxy, + "", + &os_object_path, + cancellable, + error)) { + gs_rpmostree_error_convert (error); + g_clear_object (&self->sysroot_proxy); + return FALSE; + } + + self->os_proxy = gs_rpmostree_os_proxy_new_sync (gs_plugin_get_system_bus_connection (GS_PLUGIN (self)), + G_DBUS_PROXY_FLAGS_NONE, + "org.projectatomic.rpmostree1", + os_object_path, + cancellable, + error); + if (self->os_proxy == NULL) { + gs_rpmostree_error_convert (error); + g_clear_object (&self->sysroot_proxy); + return FALSE; + } + } + + /* Load ostree sysroot and repo */ + if (self->ot_sysroot == NULL) { + g_autofree gchar *sysroot_path = NULL; + g_autoptr(GFile) sysroot_file = NULL; + + sysroot_path = gs_rpmostree_sysroot_dup_path (self->sysroot_proxy); + sysroot_file = g_file_new_for_path (sysroot_path); + + self->ot_sysroot = ostree_sysroot_new (sysroot_file); + if (!ostree_sysroot_load (self->ot_sysroot, cancellable, error)) { + gs_rpmostree_error_convert (error); + g_clear_object (&self->sysroot_proxy); + g_clear_object (&self->os_proxy); + g_clear_object (&self->ot_sysroot); + return FALSE; + } + + if (!ostree_sysroot_get_repo (self->ot_sysroot, &self->ot_repo, cancellable, error)) { + gs_rpmostree_error_convert (error); + g_clear_object (&self->sysroot_proxy); + g_clear_object (&self->os_proxy); + g_clear_object (&self->ot_sysroot); + return FALSE; + } + } + + self->inactive_timeout_id = g_timeout_add_seconds (INACTIVE_TIMEOUT_SECONDS, + gs_rpmostree_inactive_timeout_cb, self); + + if (out_os_proxy) + *out_os_proxy = g_object_ref (self->os_proxy); + + if (out_sysroot_proxy) + *out_sysroot_proxy = g_object_ref (self->sysroot_proxy); + + return TRUE; +} + +static gboolean +gs_rpmostree_ref_proxies (GsPluginRpmOstree *self, + GsRPMOSTreeOS **out_os_proxy, + GsRPMOSTreeSysroot **out_sysroot_proxy, + GCancellable *cancellable, + GError **error) +{ + g_autoptr(GMutexLocker) locker = NULL; + + locker = g_mutex_locker_new (&self->mutex); + + return gs_rpmostree_ref_proxies_locked (self, out_os_proxy, out_sysroot_proxy, cancellable, error); +} + +static gint +get_priority_for_interactivity (gboolean interactive) +{ + return interactive ? G_PRIORITY_DEFAULT : G_PRIORITY_LOW; +} + +static void setup_thread_cb (GTask *task, + gpointer source_object, + gpointer task_data, + GCancellable *cancellable); + +static void +gs_plugin_rpm_ostree_setup_async (GsPlugin *plugin, + GCancellable *cancellable, + GAsyncReadyCallback callback, + gpointer user_data) +{ + GsPluginRpmOstree *self = GS_PLUGIN_RPM_OSTREE (plugin); + g_autoptr(GTask) task = NULL; + + g_debug ("rpm-ostree version: %s", RPM_OSTREE_VERSION_S); + + task = g_task_new (plugin, cancellable, callback, user_data); + g_task_set_source_tag (task, gs_plugin_rpm_ostree_setup_async); + + /* Start up a worker thread to process all the plugin’s function calls. */ + self->worker = gs_worker_thread_new ("gs-plugin-rpm-ostree"); + + /* Queue a job to set up the D-Bus proxies. While these could be set + * up from the main thread asynchronously, setting them up in the worker + * thread means their signal emissions will correctly be in the worker + * thread, and locking is simpler. */ + gs_worker_thread_queue (self->worker, G_PRIORITY_DEFAULT, + setup_thread_cb, g_steal_pointer (&task)); +} + +/* Run in @worker. */ +static void +setup_thread_cb (GTask *task, + gpointer source_object, + gpointer task_data, + GCancellable *cancellable) +{ + GsPluginRpmOstree *self = GS_PLUGIN_RPM_OSTREE (source_object); + g_autoptr(GError) local_error = NULL; + + assert_in_worker (self); + + if (!gs_rpmostree_ref_proxies (self, NULL, NULL, cancellable, &local_error)) + g_task_return_error (task, g_steal_pointer (&local_error)); + else + g_task_return_boolean (task, TRUE); +} + +static gboolean +gs_plugin_rpm_ostree_setup_finish (GsPlugin *plugin, + GAsyncResult *result, + GError **error) +{ + return g_task_propagate_boolean (G_TASK (result), error); +} + +static void shutdown_cb (GObject *source_object, + GAsyncResult *result, + gpointer user_data); + +static void +gs_plugin_rpm_ostree_shutdown_async (GsPlugin *plugin, + GCancellable *cancellable, + GAsyncReadyCallback callback, + gpointer user_data) +{ + GsPluginRpmOstree *self = GS_PLUGIN_RPM_OSTREE (plugin); + g_autoptr(GTask) task = NULL; + + task = g_task_new (self, cancellable, callback, user_data); + g_task_set_source_tag (task, gs_plugin_rpm_ostree_shutdown_async); + + /* Stop checking for inactivity. */ + g_clear_handle_id (&self->inactive_timeout_id, g_source_remove); + + /* Stop the worker thread. */ + gs_worker_thread_shutdown_async (self->worker, cancellable, shutdown_cb, g_steal_pointer (&task)); +} + +static void +shutdown_cb (GObject *source_object, + GAsyncResult *result, + gpointer user_data) +{ + g_autoptr(GTask) task = G_TASK (user_data); + GsPluginRpmOstree *self = g_task_get_source_object (task); + g_autoptr(GsWorkerThread) worker = NULL; + g_autoptr(GError) local_error = NULL; + + worker = g_steal_pointer (&self->worker); + + if (!gs_worker_thread_shutdown_finish (worker, result, &local_error)) + g_task_return_error (task, g_steal_pointer (&local_error)); + else + g_task_return_boolean (task, TRUE); +} + +static gboolean +gs_plugin_rpm_ostree_shutdown_finish (GsPlugin *plugin, + GAsyncResult *result, + GError **error) +{ + return g_task_propagate_boolean (G_TASK (result), error); +} + +static void +app_set_rpm_ostree_packaging_format (GsApp *app) +{ + gs_app_set_metadata (app, "GnomeSoftware::PackagingFormat", "RPM"); + gs_app_set_metadata (app, "GnomeSoftware::PackagingBaseCssColor", "error_color"); +} + +void +gs_plugin_adopt_app (GsPlugin *plugin, GsApp *app) +{ + if (gs_app_get_bundle_kind (app) == AS_BUNDLE_KIND_PACKAGE && + gs_app_get_scope (app) == AS_COMPONENT_SCOPE_SYSTEM) { + gs_app_set_management_plugin (app, plugin); + gs_app_add_quirk (app, GS_APP_QUIRK_NEEDS_REBOOT); + app_set_rpm_ostree_packaging_format (app); + } + + if (gs_app_get_kind (app) == AS_COMPONENT_KIND_OPERATING_SYSTEM) { + gs_app_set_management_plugin (app, plugin); + gs_app_add_quirk (app, GS_APP_QUIRK_NEEDS_REBOOT); + } +} + +typedef struct { + GsPlugin *plugin; + GError *error; + GMainContext *context; + GsApp *app; + gboolean complete; + gboolean owner_changed; +} TransactionProgress; + +static TransactionProgress * +transaction_progress_new (void) +{ + TransactionProgress *self; + + self = g_slice_new0 (TransactionProgress); + self->context = g_main_context_ref_thread_default (); + + return self; +} + +static void +transaction_progress_free (TransactionProgress *self) +{ + g_clear_object (&self->plugin); + g_clear_error (&self->error); + g_main_context_unref (self->context); + g_clear_object (&self->app); + g_slice_free (TransactionProgress, self); +} + +G_DEFINE_AUTOPTR_CLEANUP_FUNC(TransactionProgress, transaction_progress_free); + +static void +transaction_progress_end (TransactionProgress *self) +{ + self->complete = TRUE; + g_main_context_wakeup (self->context); +} + +static void +on_transaction_progress (GDBusProxy *proxy, + gchar *sender_name, + gchar *signal_name, + GVariant *parameters, + gpointer user_data) +{ + TransactionProgress *tp = user_data; + + if (g_strcmp0 (signal_name, "PercentProgress") == 0) { + const gchar *message = NULL; + guint32 percentage; + + g_variant_get_child (parameters, 0, "&s", &message); + g_variant_get_child (parameters, 1, "u", &percentage); + g_debug ("PercentProgress: %u, %s\n", percentage, message); + + if (tp->app != NULL) + gs_app_set_progress (tp->app, (guint) percentage); + + if (tp->app != NULL && tp->plugin != NULL) { + GsPluginStatus plugin_status; + + switch (gs_app_get_state (tp->app)) { + case GS_APP_STATE_INSTALLING: + plugin_status = GS_PLUGIN_STATUS_INSTALLING; + break; + case GS_APP_STATE_REMOVING: + plugin_status = GS_PLUGIN_STATUS_REMOVING; + break; + default: + plugin_status = GS_PLUGIN_STATUS_DOWNLOADING; + break; + } + gs_plugin_status_update (tp->plugin, tp->app, plugin_status); + } + } else if (g_strcmp0 (signal_name, "Finished") == 0) { + if (tp->error == NULL) { + g_autofree gchar *error_message = NULL; + gboolean success = FALSE; + + g_variant_get (parameters, "(bs)", &success, &error_message); + + if (!success) { + tp->error = g_dbus_error_new_for_dbus_error ("org.projectatomic.rpmostreed.Error.Failed", + error_message); + } + } + + transaction_progress_end (tp); + } +} + +static void +on_owner_notify (GObject *obj, + GParamSpec *pspec, + gpointer user_data) +{ + TransactionProgress *tp = user_data; + + tp->owner_changed = TRUE; + + /* Wake up the context so it can notice the server has disappeared. */ + g_main_context_wakeup (tp->context); +} + +static void +cancelled_handler (GCancellable *cancellable, + gpointer user_data) +{ + GsRPMOSTreeTransaction *transaction = user_data; + gs_rpmostree_transaction_call_cancel_sync (transaction, NULL, NULL); +} + +static gboolean +gs_rpmostree_transaction_get_response_sync (GsRPMOSTreeSysroot *sysroot_proxy, + const gchar *transaction_address, + TransactionProgress *tp, + GCancellable *cancellable, + GError **error) +{ + GsRPMOSTreeTransaction *transaction = NULL; + g_autoptr(GDBusConnection) peer_connection = NULL; + gint cancel_handler = 0; + gulong signal_handler = 0; + gulong notify_handler = 0; + gboolean success = FALSE; + gboolean just_started = FALSE; + gboolean saw_name_owner = FALSE; + g_autofree gchar *name_owner = NULL; + + peer_connection = g_dbus_connection_new_for_address_sync (transaction_address, + G_DBUS_CONNECTION_FLAGS_AUTHENTICATION_CLIENT, + NULL, + cancellable, + error); + + if (peer_connection == NULL) + goto out; + + transaction = gs_rpmostree_transaction_proxy_new_sync (peer_connection, + G_DBUS_PROXY_FLAGS_NONE, + NULL, + "/", + cancellable, + error); + if (transaction == NULL) + goto out; + + if (cancellable) { + /* setup cancel handler */ + cancel_handler = g_cancellable_connect (cancellable, + G_CALLBACK (cancelled_handler), + transaction, NULL); + } + + signal_handler = g_signal_connect (transaction, "g-signal", + G_CALLBACK (on_transaction_progress), + tp); + + notify_handler = g_signal_connect (transaction, "notify::g-name-owner", + G_CALLBACK (on_owner_notify), + tp); + + /* Tell the server we're ready to receive signals. */ + if (!gs_rpmostree_transaction_call_start_sync (transaction, + &just_started, + cancellable, + error)) + goto out; + + /* Process all the signals until we receive the Finished signal or the + * daemon disappears (which can happen if it crashes). + * + * The property can be NULL right after connecting to it, before the D-Bus + * transfers the property value to the client. */ + while (!tp->complete && + !g_cancellable_is_cancelled (cancellable) && + ((name_owner = g_dbus_proxy_get_name_owner (G_DBUS_PROXY (transaction))) != NULL || + (!saw_name_owner && !tp->owner_changed))) { + saw_name_owner = saw_name_owner || name_owner != NULL; + g_clear_pointer (&name_owner, g_free); + g_main_context_iteration (tp->context, TRUE); + } + + if (!g_cancellable_set_error_if_cancelled (cancellable, error)) { + if (tp->error) { + g_propagate_error (error, g_steal_pointer (&tp->error)); + } else if (!tp->complete && name_owner == NULL) { + g_set_error_literal (error, G_DBUS_ERROR, G_DBUS_ERROR_NO_REPLY, + "Daemon disappeared"); + } else { + success = TRUE; + } + } + +out: + if (cancel_handler) + g_cancellable_disconnect (cancellable, cancel_handler); + if (notify_handler != 0) + g_signal_handler_disconnect (transaction, notify_handler); + if (signal_handler) + g_signal_handler_disconnect (transaction, signal_handler); + if (transaction != NULL) + g_object_unref (transaction); + + return success; +} + +/* FIXME: Refactor this once rpmostree returns a specific error code + * for ‘transaction in progress’, to avoid the slight race here where + * gnome-software could return from this function just as another client + * starts a new transaction. + * https://github.com/coreos/rpm-ostree/issues/3070 */ +static gboolean +gs_rpmostree_wait_for_ongoing_transaction_end (GsRPMOSTreeSysroot *sysroot_proxy, + GCancellable *cancellable, + GError **error) +{ + g_autofree gchar *current_path = NULL; + g_autoptr(GMainContext) main_context = NULL; + gulong notify_handler, cancelled_handler = 0; + + current_path = gs_rpmostree_sysroot_dup_active_transaction_path (sysroot_proxy); + if (current_path == NULL || *current_path == '\0') + return TRUE; + + main_context = g_main_context_ref_thread_default (); + + notify_handler = g_signal_connect_swapped (sysroot_proxy, "notify::active-transaction-path", + G_CALLBACK (g_main_context_wakeup), main_context); + if (cancellable) { + /* Not using g_cancellable_connect() here for simplicity and because checking the state below anyway. */ + cancelled_handler = g_signal_connect_swapped (cancellable, "cancelled", + G_CALLBACK (g_main_context_wakeup), main_context); + } + + while (!g_cancellable_set_error_if_cancelled (cancellable, error)) { + g_clear_pointer (¤t_path, g_free); + current_path = gs_rpmostree_sysroot_dup_active_transaction_path (sysroot_proxy); + if (current_path == NULL || *current_path == '\0') { + g_clear_signal_handler (¬ify_handler, sysroot_proxy); + g_clear_signal_handler (&cancelled_handler, cancellable); + return TRUE; + } + g_main_context_iteration (main_context, TRUE); + } + + g_clear_signal_handler (¬ify_handler, sysroot_proxy); + g_clear_signal_handler (&cancelled_handler, cancellable); + + gs_rpmostree_error_convert (error); + + return FALSE; +} + +static GsApp * +app_from_modified_pkg_variant (GsPlugin *plugin, GVariant *variant) +{ + g_autoptr(GsApp) app = NULL; + const char *name; + const char *old_evr, *old_arch; + const char *new_evr, *new_arch; + g_autofree char *old_nevra = NULL; + g_autofree char *new_nevra = NULL; + + g_variant_get (variant, "(us(ss)(ss))", NULL /* type*/, &name, &old_evr, &old_arch, &new_evr, &new_arch); + old_nevra = g_strdup_printf ("%s-%s-%s", name, old_evr, old_arch); + new_nevra = g_strdup_printf ("%s-%s-%s", name, new_evr, new_arch); + + app = gs_plugin_cache_lookup (plugin, old_nevra); + if (app != NULL) + return g_steal_pointer (&app); + + /* create new app */ + app = gs_app_new (NULL); + gs_app_set_management_plugin (app, plugin); + gs_app_add_quirk (app, GS_APP_QUIRK_NEEDS_REBOOT); + app_set_rpm_ostree_packaging_format (app); + gs_app_set_size_download (app, GS_SIZE_TYPE_VALID, 0); + gs_app_set_kind (app, AS_COMPONENT_KIND_GENERIC); + gs_app_set_bundle_kind (app, AS_BUNDLE_KIND_PACKAGE); + gs_app_set_scope (app, AS_COMPONENT_SCOPE_SYSTEM); + + /* update or downgrade */ + gs_app_add_source (app, name); + gs_app_set_version (app, old_evr); + gs_app_set_update_version (app, new_evr); + gs_app_set_state (app, GS_APP_STATE_UPDATABLE); + + g_debug ("!%s\n", old_nevra); + g_debug ("=%s\n", new_nevra); + + gs_plugin_cache_add (plugin, old_nevra, app); + return g_steal_pointer (&app); +} + +static GsApp * +app_from_single_pkg_variant (GsPlugin *plugin, GVariant *variant, gboolean addition) +{ + g_autoptr(GsApp) app = NULL; + const char *name; + const char *evr; + const char *arch; + g_autofree char *nevra = NULL; + + g_variant_get (variant, "(usss)", NULL /* type*/, &name, &evr, &arch); + nevra = g_strdup_printf ("%s-%s-%s", name, evr, arch); + + app = gs_plugin_cache_lookup (plugin, nevra); + if (app != NULL) + return g_steal_pointer (&app); + + /* create new app */ + app = gs_app_new (NULL); + gs_app_set_management_plugin (app, plugin); + gs_app_add_quirk (app, GS_APP_QUIRK_NEEDS_REBOOT); + app_set_rpm_ostree_packaging_format (app); + gs_app_set_size_download (app, GS_SIZE_TYPE_VALID, 0); + gs_app_set_kind (app, AS_COMPONENT_KIND_GENERIC); + gs_app_set_bundle_kind (app, AS_BUNDLE_KIND_PACKAGE); + gs_app_set_scope (app, AS_COMPONENT_SCOPE_SYSTEM); + + if (addition) { + /* addition */ + gs_app_add_source (app, name); + gs_app_set_version (app, evr); + gs_app_set_state (app, GS_APP_STATE_AVAILABLE); + + g_debug ("+%s\n", nevra); + } else { + /* removal */ + gs_app_add_source (app, name); + gs_app_set_version (app, evr); + gs_app_set_state (app, GS_APP_STATE_UNAVAILABLE); + + g_debug ("-%s\n", nevra); + } + + gs_plugin_cache_add (plugin, nevra, app); + return g_steal_pointer (&app); +} + +static GVariant * +make_rpmostree_options_variant (gboolean reboot, + gboolean allow_downgrade, + gboolean cache_only, + gboolean download_only, + gboolean skip_purge, + gboolean no_pull_base, + gboolean dry_run, + gboolean no_overrides) +{ + GVariantDict dict; + g_variant_dict_init (&dict, NULL); + g_variant_dict_insert (&dict, "reboot", "b", reboot); + g_variant_dict_insert (&dict, "allow-downgrade", "b", allow_downgrade); + g_variant_dict_insert (&dict, "cache-only", "b", cache_only); + g_variant_dict_insert (&dict, "download-only", "b", download_only); + g_variant_dict_insert (&dict, "skip-purge", "b", skip_purge); + g_variant_dict_insert (&dict, "no-pull-base", "b", no_pull_base); + g_variant_dict_insert (&dict, "dry-run", "b", dry_run); + g_variant_dict_insert (&dict, "no-overrides", "b", no_overrides); + return g_variant_ref_sink (g_variant_dict_end (&dict)); +} + +static GVariant * +make_refresh_md_options_variant (gboolean force) +{ + GVariantDict dict; + g_variant_dict_init (&dict, NULL); + g_variant_dict_insert (&dict, "force", "b", force); + return g_variant_ref_sink (g_variant_dict_end (&dict)); +} + +static gboolean +make_rpmostree_modifiers_variant (const char *install_package, + const char *uninstall_package, + const char *install_local_package, + GVariant **out_modifiers, + GUnixFDList **out_fd_list, + GError **error) +{ + GVariantDict dict; + g_autoptr(GUnixFDList) fd_list = g_unix_fd_list_new (); + + g_variant_dict_init (&dict, NULL); + + if (install_package != NULL) { + g_autoptr(GPtrArray) repo_pkgs = g_ptr_array_new (); + + g_ptr_array_add (repo_pkgs, (gpointer) install_package); + + g_variant_dict_insert_value (&dict, "install-packages", + g_variant_new_strv ((const char *const*)repo_pkgs->pdata, + repo_pkgs->len)); + + } + + if (uninstall_package != NULL) { + g_autoptr(GPtrArray) repo_pkgs = g_ptr_array_new (); + + g_ptr_array_add (repo_pkgs, (gpointer) uninstall_package); + + g_variant_dict_insert_value (&dict, "uninstall-packages", + g_variant_new_strv ((const char *const*)repo_pkgs->pdata, + repo_pkgs->len)); + + } + + if (install_local_package != NULL) { + g_auto(GVariantBuilder) builder; + int fd; + int idx; + + g_variant_builder_init (&builder, G_VARIANT_TYPE ("ah")); + + fd = openat (AT_FDCWD, install_local_package, O_RDONLY | O_CLOEXEC | O_NOCTTY); + if (fd == -1) { + g_set_error (error, GS_PLUGIN_ERROR, GS_PLUGIN_ERROR_FAILED, + "Failed to open %s", install_local_package); + return FALSE; + } + + idx = g_unix_fd_list_append (fd_list, fd, error); + if (idx < 0) { + close (fd); + return FALSE; + } + + g_variant_builder_add (&builder, "h", idx); + g_variant_dict_insert_value (&dict, "install-local-packages", + g_variant_new ("ah", &builder)); + close (fd); + } + + *out_fd_list = g_steal_pointer (&fd_list); + *out_modifiers = g_variant_ref_sink (g_variant_dict_end (&dict)); + return TRUE; +} + +static gboolean +rpmostree_update_deployment (GsRPMOSTreeOS *os_proxy, + const char *install_package, + const char *uninstall_package, + const char *install_local_package, + GVariant *options, + char **out_transaction_address, + GCancellable *cancellable, + GError **error) +{ + g_autoptr(GUnixFDList) fd_list = NULL; + g_autoptr(GVariant) modifiers = NULL; + + if (!make_rpmostree_modifiers_variant (install_package, + uninstall_package, + install_local_package, + &modifiers, &fd_list, error)) + return FALSE; + + return gs_rpmostree_os_call_update_deployment_sync (os_proxy, + modifiers, + options, + fd_list, + out_transaction_address, + NULL, + cancellable, + error); +} + +#define RPMOSTREE_CORE_CACHEDIR "/var/cache/rpm-ostree/" +#define RPMOSTREE_DIR_CACHE_REPOMD "repomd" +#define RPMOSTREE_DIR_CACHE_SOLV "solv" + +static DnfContext * +gs_rpmostree_create_bare_dnf_context (GCancellable *cancellable, + GError **error) +{ + g_autoptr(DnfContext) context = dnf_context_new (); + + dnf_context_set_repo_dir (context, "/etc/yum.repos.d"); + dnf_context_set_cache_dir (context, RPMOSTREE_CORE_CACHEDIR RPMOSTREE_DIR_CACHE_REPOMD); + dnf_context_set_solv_dir (context, RPMOSTREE_CORE_CACHEDIR RPMOSTREE_DIR_CACHE_SOLV); + dnf_context_set_cache_age (context, G_MAXUINT); + dnf_context_set_enable_filelists (context, FALSE); + + if (!dnf_context_setup (context, cancellable, error)) { + gs_rpmostree_error_convert (error); + return NULL; + } + + return g_steal_pointer (&context); +} + +static gboolean +gs_rpmostree_ref_dnf_context_locked (GsPluginRpmOstree *self, + GsRPMOSTreeOS **out_os_proxy, + GsRPMOSTreeSysroot **out_sysroot_proxy, + DnfContext **out_dnf_context, + GCancellable *cancellable, + GError **error) +{ + g_autoptr(DnfContext) context = NULL; + g_autoptr(DnfState) state = NULL; + g_autoptr(GsRPMOSTreeOS) os_proxy = NULL; + g_autoptr(GsRPMOSTreeSysroot) sysroot_proxy = NULL; + + if (!gs_rpmostree_ref_proxies_locked (self, &os_proxy, &sysroot_proxy, cancellable, error)) + return FALSE; + + if (self->dnf_context != NULL) { + if (out_os_proxy) + *out_os_proxy = g_steal_pointer (&os_proxy); + if (out_sysroot_proxy) + *out_sysroot_proxy = g_steal_pointer (&sysroot_proxy); + if (out_dnf_context) + *out_dnf_context = g_object_ref (self->dnf_context); + return TRUE; + } + + context = gs_rpmostree_create_bare_dnf_context (cancellable, error); + if (!context) + return FALSE; + + state = dnf_state_new (); + + if (!dnf_context_setup_sack_with_flags (context, state, DNF_CONTEXT_SETUP_SACK_FLAG_SKIP_RPMDB, error)) { + gs_rpmostree_error_convert (error); + return FALSE; + } + + g_set_object (&self->dnf_context, context); + + if (out_os_proxy) + *out_os_proxy = g_steal_pointer (&os_proxy); + if (out_sysroot_proxy) + *out_sysroot_proxy = g_steal_pointer (&sysroot_proxy); + if (out_dnf_context) + *out_dnf_context = g_object_ref (self->dnf_context); + + return TRUE; +} + +static void refresh_metadata_thread_cb (GTask *task, + gpointer source_object, + gpointer task_data, + GCancellable *cancellable); + +static void +gs_plugin_rpm_ostree_refresh_metadata_async (GsPlugin *plugin, + guint64 cache_age_secs, + GsPluginRefreshMetadataFlags flags, + GCancellable *cancellable, + GAsyncReadyCallback callback, + gpointer user_data) +{ + GsPluginRpmOstree *self = GS_PLUGIN_RPM_OSTREE (plugin); + g_autoptr(GTask) task = NULL; + gboolean interactive = (flags & GS_PLUGIN_REFRESH_METADATA_FLAGS_INTERACTIVE); + + task = g_task_new (plugin, cancellable, callback, user_data); + g_task_set_source_tag (task, gs_plugin_rpm_ostree_refresh_metadata_async); + g_task_set_task_data (task, gs_plugin_refresh_metadata_data_new (cache_age_secs, flags), (GDestroyNotify) gs_plugin_refresh_metadata_data_free); + + gs_worker_thread_queue (self->worker, get_priority_for_interactivity (interactive), + refresh_metadata_thread_cb, g_steal_pointer (&task)); +} + +static gboolean +gs_plugin_rpm_ostree_refresh_metadata_in_worker (GsPluginRpmOstree *self, + GsPluginRefreshMetadataData *data, + GsRPMOSTreeOS *os_proxy, + GsRPMOSTreeSysroot *sysroot_proxy, + GCancellable *cancellable, + GError **error) +{ + GsPlugin *plugin = GS_PLUGIN (self); + g_autoptr(GError) local_error = NULL; + gboolean done; + + assert_in_worker (self); + + { + g_autofree gchar *transaction_address = NULL; + g_autoptr(GsApp) progress_app = NULL; + g_autoptr(GVariant) options = NULL; + g_autoptr(TransactionProgress) tp = NULL; + + if (!gs_rpmostree_wait_for_ongoing_transaction_end (sysroot_proxy, cancellable, error)) + return FALSE; + + progress_app = gs_app_new (gs_plugin_get_name (plugin)); + tp = transaction_progress_new (); + tp->app = g_object_ref (progress_app); + tp->plugin = g_object_ref (plugin); + + options = make_refresh_md_options_variant (FALSE /* force */); + done = FALSE; + while (!done) { + done = TRUE; + if (!gs_rpmostree_os_call_refresh_md_sync (os_proxy, + options, + &transaction_address, + cancellable, + &local_error)) { + if (g_error_matches (local_error, G_IO_ERROR, G_IO_ERROR_BUSY)) { + g_clear_error (&local_error); + if (!gs_rpmostree_wait_for_ongoing_transaction_end (sysroot_proxy, cancellable, error)) + return FALSE; + done = FALSE; + continue; + } + + g_propagate_error (error, g_steal_pointer (&local_error)); + gs_rpmostree_error_convert (error); + return FALSE; + } + } + + if (!gs_rpmostree_transaction_get_response_sync (sysroot_proxy, + transaction_address, + tp, + cancellable, + error)) { + gs_rpmostree_error_convert (error); + return FALSE; + } + } + + if (data->cache_age_secs == G_MAXUINT64) + return TRUE; + + { + g_autofree gchar *transaction_address = NULL; + g_autoptr(GsApp) progress_app = gs_app_new (gs_plugin_get_name (plugin)); + g_autoptr(GVariant) options = NULL; + g_autoptr(TransactionProgress) tp = transaction_progress_new (); + + if (!gs_rpmostree_wait_for_ongoing_transaction_end (sysroot_proxy, cancellable, error)) + return FALSE; + + tp->app = g_object_ref (progress_app); + tp->plugin = g_object_ref (plugin); + + options = make_rpmostree_options_variant (FALSE, /* reboot */ + FALSE, /* allow-downgrade */ + FALSE, /* cache-only */ + TRUE, /* download-only */ + FALSE, /* skip-purge */ + FALSE, /* no-pull-base */ + FALSE, /* dry-run */ + FALSE); /* no-overrides */ + done = FALSE; + while (!done) { + done = TRUE; + if (!gs_rpmostree_os_call_upgrade_sync (os_proxy, + options, + NULL /* fd list */, + &transaction_address, + NULL /* fd list out */, + cancellable, + &local_error)) { + if (g_error_matches (local_error, G_IO_ERROR, G_IO_ERROR_BUSY)) { + g_clear_error (&local_error); + if (!gs_rpmostree_wait_for_ongoing_transaction_end (sysroot_proxy, cancellable, error)) + return FALSE; + done = FALSE; + continue; + } + g_propagate_error (error, g_steal_pointer (&local_error)); + gs_rpmostree_error_convert (error); + return FALSE; + } + } + + if (!gs_rpmostree_transaction_get_response_sync (sysroot_proxy, + transaction_address, + tp, + cancellable, + error)) { + gs_rpmostree_error_convert (error); + return FALSE; + } + } + + { + g_autofree gchar *transaction_address = NULL; + g_autoptr(GsApp) progress_app = gs_app_new (gs_plugin_get_name (plugin)); + g_autoptr(GVariant) options = NULL; + GVariantDict dict; + g_autoptr(TransactionProgress) tp = transaction_progress_new (); + + if (!gs_rpmostree_wait_for_ongoing_transaction_end (sysroot_proxy, cancellable, error)) + return FALSE; + + tp->app = g_object_ref (progress_app); + tp->plugin = g_object_ref (plugin); + + g_variant_dict_init (&dict, NULL); + g_variant_dict_insert (&dict, "mode", "s", "check"); + options = g_variant_ref_sink (g_variant_dict_end (&dict)); + + done = FALSE; + while (!done) { + done = TRUE; + if (!gs_rpmostree_os_call_automatic_update_trigger_sync (os_proxy, + options, + NULL, + &transaction_address, + cancellable, + &local_error)) { + if (g_error_matches (local_error, G_IO_ERROR, G_IO_ERROR_BUSY)) { + g_clear_error (&local_error); + if (!gs_rpmostree_wait_for_ongoing_transaction_end (sysroot_proxy, cancellable, error)) + return FALSE; + done = FALSE; + continue; + } + g_propagate_error (error, g_steal_pointer (&local_error)); + gs_rpmostree_error_convert (error); + return FALSE; + } + } + + if (!gs_rpmostree_transaction_get_response_sync (sysroot_proxy, + transaction_address, + tp, + cancellable, + error)) { + gs_rpmostree_error_convert (error); + return FALSE; + } + } + + /* update UI */ + gs_plugin_updates_changed (plugin); + + return TRUE; +} + +static void +refresh_metadata_thread_cb (GTask *task, + gpointer source_object, + gpointer task_data, + GCancellable *cancellable) +{ + GsPlugin *plugin = GS_PLUGIN (source_object); + GsPluginRpmOstree *self = GS_PLUGIN_RPM_OSTREE (plugin); + GsPluginRefreshMetadataData *data = task_data; + g_autoptr(GsRPMOSTreeOS) os_proxy = NULL; + g_autoptr(GsRPMOSTreeSysroot) sysroot_proxy = NULL; + g_autoptr(GError) local_error = NULL; + + assert_in_worker (self); + + if (!gs_rpmostree_ref_proxies (self, &os_proxy, &sysroot_proxy, cancellable, &local_error)) { + g_task_return_error (task, g_steal_pointer (&local_error)); + return; + } + + if (gs_plugin_rpm_ostree_refresh_metadata_in_worker (self, data, os_proxy, sysroot_proxy, cancellable, &local_error)) + g_task_return_boolean (task, TRUE); + else + g_task_return_error (task, g_steal_pointer (&local_error)); +} + +static gboolean +gs_plugin_rpm_ostree_refresh_metadata_finish (GsPlugin *plugin, + GAsyncResult *result, + GError **error) +{ + return g_task_propagate_boolean (G_TASK (result), error); +} + +gboolean +gs_plugin_add_updates (GsPlugin *plugin, + GsAppList *list, + GCancellable *cancellable, + GError **error) +{ + GsPluginRpmOstree *self = GS_PLUGIN_RPM_OSTREE (plugin); + g_autoptr(GVariant) cached_update = NULL; + g_autoptr(GVariant) rpm_diff = NULL; + g_autoptr(GsRPMOSTreeOS) os_proxy = NULL; + g_autoptr(GsRPMOSTreeSysroot) sysroot_proxy = NULL; + g_autoptr(GError) local_error = NULL; + const gchar *checksum = NULL; + const gchar *version = NULL; + g_auto(GVariantDict) cached_update_dict; + + if (!gs_rpmostree_ref_proxies (self, &os_proxy, &sysroot_proxy, cancellable, &local_error)) { + g_debug ("Failed to ref proxies to get updates: %s", local_error->message); + return TRUE; + } + + /* ensure D-Bus properties are updated before reading them */ + if (!gs_rpmostree_sysroot_call_reload_sync (sysroot_proxy, cancellable, &local_error)) { + g_debug ("Failed to call reload to get updates: %s", local_error->message); + return TRUE; + } + + cached_update = gs_rpmostree_os_dup_cached_update (os_proxy); + g_variant_dict_init (&cached_update_dict, cached_update); + + if (!g_variant_dict_lookup (&cached_update_dict, "checksum", "&s", &checksum)) + return TRUE; + if (!g_variant_dict_lookup (&cached_update_dict, "version", "&s", &version)) + return TRUE; + + g_debug ("got CachedUpdate version '%s', checksum '%s'", version, checksum); + + rpm_diff = g_variant_dict_lookup_value (&cached_update_dict, "rpm-diff", G_VARIANT_TYPE ("a{sv}")); + if (rpm_diff != NULL) { + GVariantIter iter; + GVariant *child; + g_autoptr(GVariant) upgraded = NULL; + g_autoptr(GVariant) downgraded = NULL; + g_autoptr(GVariant) removed = NULL; + g_autoptr(GVariant) added = NULL; + g_auto(GVariantDict) rpm_diff_dict; + g_variant_dict_init (&rpm_diff_dict, rpm_diff); + + upgraded = g_variant_dict_lookup_value (&rpm_diff_dict, "upgraded", G_VARIANT_TYPE ("a(us(ss)(ss))")); + if (upgraded == NULL) { + g_set_error_literal (error, + GS_PLUGIN_ERROR, + GS_PLUGIN_ERROR_INVALID_FORMAT, + "no 'upgraded' in rpm-diff dict"); + return FALSE; + } + downgraded = g_variant_dict_lookup_value (&rpm_diff_dict, "downgraded", G_VARIANT_TYPE ("a(us(ss)(ss))")); + if (downgraded == NULL) { + g_set_error_literal (error, + GS_PLUGIN_ERROR, + GS_PLUGIN_ERROR_INVALID_FORMAT, + "no 'downgraded' in rpm-diff dict"); + return FALSE; + } + removed = g_variant_dict_lookup_value (&rpm_diff_dict, "removed", G_VARIANT_TYPE ("a(usss)")); + if (removed == NULL) { + g_set_error_literal (error, + GS_PLUGIN_ERROR, + GS_PLUGIN_ERROR_INVALID_FORMAT, + "no 'removed' in rpm-diff dict"); + return FALSE; + } + added = g_variant_dict_lookup_value (&rpm_diff_dict, "added", G_VARIANT_TYPE ("a(usss)")); + if (added == NULL) { + g_set_error_literal (error, + GS_PLUGIN_ERROR, + GS_PLUGIN_ERROR_INVALID_FORMAT, + "no 'added' in rpm-diff dict"); + return FALSE; + } + + /* iterate over all upgraded packages and add them */ + g_variant_iter_init (&iter, upgraded); + while ((child = g_variant_iter_next_value (&iter)) != NULL) { + g_autoptr(GsApp) app = app_from_modified_pkg_variant (plugin, child); + if (app != NULL) + gs_app_list_add (list, app); + g_variant_unref (child); + } + + /* iterate over all downgraded packages and add them */ + g_variant_iter_init (&iter, downgraded); + while ((child = g_variant_iter_next_value (&iter)) != NULL) { + g_autoptr(GsApp) app = app_from_modified_pkg_variant (plugin, child); + if (app != NULL) + gs_app_list_add (list, app); + g_variant_unref (child); + } + + /* iterate over all removed packages and add them */ + g_variant_iter_init (&iter, removed); + while ((child = g_variant_iter_next_value (&iter)) != NULL) { + g_autoptr(GsApp) app = app_from_single_pkg_variant (plugin, child, FALSE); + if (app != NULL) + gs_app_list_add (list, app); + g_variant_unref (child); + } + + /* iterate over all added packages and add them */ + g_variant_iter_init (&iter, added); + while ((child = g_variant_iter_next_value (&iter)) != NULL) { + g_autoptr(GsApp) app = app_from_single_pkg_variant (plugin, child, TRUE); + if (app != NULL) + gs_app_list_add (list, app); + g_variant_unref (child); + } + } + + return TRUE; +} + +static gboolean +trigger_rpmostree_update (GsPluginRpmOstree *self, + GsApp *app, + GsRPMOSTreeOS *os_proxy, + GsRPMOSTreeSysroot *sysroot_proxy, + GCancellable *cancellable, + GError **error) +{ + g_autofree gchar *transaction_address = NULL; + g_autoptr(GVariant) options = NULL; + g_autoptr(TransactionProgress) tp = transaction_progress_new (); + g_autoptr(GError) local_error = NULL; + gboolean done; + + /* if we can process this online do not require a trigger */ + if (gs_app_get_state (app) != GS_APP_STATE_UPDATABLE) + return TRUE; + + /* only process this app if was created by this plugin */ + if (!gs_app_has_management_plugin (app, GS_PLUGIN (self))) + return TRUE; + + /* already in correct state */ + if (self->update_triggered) + return TRUE; + + if (!gs_rpmostree_wait_for_ongoing_transaction_end (sysroot_proxy, cancellable, error)) + return FALSE; + + /* trigger the update */ + options = make_rpmostree_options_variant (FALSE, /* reboot */ + FALSE, /* allow-downgrade */ + TRUE, /* cache-only */ + FALSE, /* download-only */ + FALSE, /* skip-purge */ + FALSE, /* no-pull-base */ + FALSE, /* dry-run */ + FALSE); /* no-overrides */ + done = FALSE; + while (!done) { + done = TRUE; + if (!gs_rpmostree_os_call_upgrade_sync (os_proxy, + options, + NULL /* fd list */, + &transaction_address, + NULL /* fd list out */, + cancellable, + &local_error)) { + if (g_error_matches (local_error, G_IO_ERROR, G_IO_ERROR_BUSY)) { + g_clear_error (&local_error); + if (!gs_rpmostree_wait_for_ongoing_transaction_end (sysroot_proxy, cancellable, error)) + return FALSE; + done = FALSE; + continue; + } + if (local_error) + g_propagate_error (error, g_steal_pointer (&local_error)); + gs_rpmostree_error_convert (error); + return FALSE; + } + } + + if (!gs_rpmostree_transaction_get_response_sync (sysroot_proxy, + transaction_address, + tp, + cancellable, + error)) { + gs_rpmostree_error_convert (error); + return FALSE; + } + + self->update_triggered = TRUE; + + /* success */ + return TRUE; +} + +gboolean +gs_plugin_update_app (GsPlugin *plugin, + GsApp *app, + GCancellable *cancellable, + GError **error) +{ + GsPluginRpmOstree *self = GS_PLUGIN_RPM_OSTREE (plugin); + GsAppList *related = gs_app_get_related (app); + g_autoptr(GsRPMOSTreeOS) os_proxy = NULL; + g_autoptr(GsRPMOSTreeSysroot) sysroot_proxy = NULL; + + if (!gs_rpmostree_ref_proxies (self, &os_proxy, &sysroot_proxy, cancellable, error)) + return FALSE; + + /* we don't currently don't put all updates in the OsUpdate proxy app */ + if (!gs_app_has_quirk (app, GS_APP_QUIRK_IS_PROXY)) + return trigger_rpmostree_update (self, app, os_proxy, sysroot_proxy, cancellable, error); + + /* try to trigger each related app */ + for (guint i = 0; i < gs_app_list_length (related); i++) { + GsApp *app_tmp = gs_app_list_index (related, i); + if (!trigger_rpmostree_update (self, app_tmp, os_proxy, sysroot_proxy, cancellable, error)) + return FALSE; + } + + /* success */ + return TRUE; +} + +gboolean +gs_plugin_app_upgrade_trigger (GsPlugin *plugin, + GsApp *app, + GCancellable *cancellable, + GError **error) +{ + GsPluginRpmOstree *self = GS_PLUGIN_RPM_OSTREE (plugin); + const char *packages[] = { NULL }; + g_autofree gchar *new_refspec = NULL; + g_autofree gchar *transaction_address = NULL; + g_autoptr(GVariant) options = NULL; + g_autoptr(TransactionProgress) tp = transaction_progress_new (); + g_autoptr(GsRPMOSTreeOS) os_proxy = NULL; + g_autoptr(GsRPMOSTreeSysroot) sysroot_proxy = NULL; + g_autoptr(GError) local_error = NULL; + gboolean done; + + /* only process this app if was created by this plugin */ + if (!gs_app_has_management_plugin (app, plugin)) + return TRUE; + + /* check is distro-upgrade */ + if (gs_app_get_kind (app) != AS_COMPONENT_KIND_OPERATING_SYSTEM) + return TRUE; + + if (!gs_rpmostree_ref_proxies (self, &os_proxy, &sysroot_proxy, cancellable, error)) + return FALSE; + + if (!gs_rpmostree_wait_for_ongoing_transaction_end (sysroot_proxy, cancellable, error)) + return FALSE; + + /* construct new refspec based on the distro version we're upgrading to */ + new_refspec = g_strdup_printf ("ostree://fedora/%s/x86_64/silverblue", + gs_app_get_version (app)); + + /* trigger the upgrade */ + options = make_rpmostree_options_variant (FALSE, /* reboot */ + TRUE, /* allow-downgrade */ + TRUE, /* cache-only */ + FALSE, /* download-only */ + FALSE, /* skip-purge */ + FALSE, /* no-pull-base */ + FALSE, /* dry-run */ + FALSE); /* no-overrides */ + + done = FALSE; + while (!done) { + done = TRUE; + if (!gs_rpmostree_os_call_rebase_sync (os_proxy, + options, + new_refspec, + packages, + NULL /* fd list */, + &transaction_address, + NULL /* fd list out */, + cancellable, + &local_error)) { + if (g_error_matches (local_error, G_IO_ERROR, G_IO_ERROR_BUSY)) { + g_clear_error (&local_error); + if (!gs_rpmostree_wait_for_ongoing_transaction_end (sysroot_proxy, cancellable, error)) + return FALSE; + done = FALSE; + continue; + } + if (local_error) + g_propagate_error (error, g_steal_pointer (&local_error)); + gs_rpmostree_error_convert (error); + return FALSE; + } + } + + if (!gs_rpmostree_transaction_get_response_sync (sysroot_proxy, + transaction_address, + tp, + cancellable, + error)) { + gs_rpmostree_error_convert (error); + + if (g_strrstr ((*error)->message, "Old and new refs are equal")) { + /* don't error out if the correct tree is already deployed */ + g_debug ("ignoring rpm-ostree error: %s", (*error)->message); + g_clear_error (error); + } else { + return FALSE; + } + } + + /* success */ + return TRUE; +} + +static gboolean +gs_rpmostree_repo_enable (GsPlugin *plugin, + GsApp *app, + gboolean enable, + GsRPMOSTreeOS *os_proxy, + GsRPMOSTreeSysroot *sysroot_proxy, + GCancellable *cancellable, + GError **error) +{ + g_autofree gchar *transaction_address = NULL; + g_autoptr(GVariantBuilder) options_builder = NULL; + g_autoptr(TransactionProgress) tp = NULL; + g_autoptr(GError) local_error = NULL; + gboolean done; + + if (!gs_rpmostree_wait_for_ongoing_transaction_end (sysroot_proxy, cancellable, error)) + return FALSE; + + if (enable) + gs_app_set_state (app, GS_APP_STATE_INSTALLING); + else + gs_app_set_state (app, GS_APP_STATE_REMOVING); + + done = FALSE; + while (!done) { + done = TRUE; + g_clear_pointer (&options_builder, g_variant_builder_unref); + options_builder = g_variant_builder_new (G_VARIANT_TYPE ("a{ss}")); + g_variant_builder_add (options_builder, "{ss}", "enabled", enable ? "1" : "0"); + if (!gs_rpmostree_os_call_modify_yum_repo_sync (os_proxy, + gs_app_get_id (app), + g_variant_builder_end (options_builder), + &transaction_address, + cancellable, + &local_error)) { + if (g_error_matches (local_error, G_IO_ERROR, G_IO_ERROR_BUSY)) { + g_clear_error (&local_error); + if (!gs_rpmostree_wait_for_ongoing_transaction_end (sysroot_proxy, cancellable, error)) { + gs_app_set_state_recover (app); + gs_utils_error_add_origin_id (error, app); + return FALSE; + } + done = FALSE; + continue; + } + if (local_error) + g_propagate_error (error, g_steal_pointer (&local_error)); + gs_rpmostree_error_convert (error); + gs_app_set_state_recover (app); + gs_utils_error_add_origin_id (error, app); + return FALSE; + } + } + + tp = transaction_progress_new (); + tp->app = g_object_ref (app); + if (!gs_rpmostree_transaction_get_response_sync (sysroot_proxy, + transaction_address, + tp, + cancellable, + error)) { + gs_rpmostree_error_convert (error); + gs_app_set_state_recover (app); + gs_utils_error_add_origin_id (error, app); + return FALSE; + } + + + /* state is known */ + if (enable) + gs_app_set_state (app, GS_APP_STATE_INSTALLED); + else + gs_app_set_state (app, GS_APP_STATE_AVAILABLE); + + gs_plugin_repository_changed (plugin, app); + + return TRUE; +} + +gboolean +gs_plugin_app_install (GsPlugin *plugin, + GsApp *app, + GCancellable *cancellable, + GError **error) +{ + GsPluginRpmOstree *self = GS_PLUGIN_RPM_OSTREE (plugin); + const gchar *install_package = NULL; + g_autofree gchar *local_filename = NULL; + g_autofree gchar *transaction_address = NULL; + g_autoptr(GVariant) options = NULL; + g_autoptr(TransactionProgress) tp = transaction_progress_new (); + g_autoptr(GMutexLocker) locker = NULL; + g_autoptr(GsRPMOSTreeOS) os_proxy = NULL; + g_autoptr(GsRPMOSTreeSysroot) sysroot_proxy = NULL; + g_autoptr(GError) local_error = NULL; + gboolean done; + + /* only process this app if was created by this plugin */ + if (!gs_app_has_management_plugin (app, plugin)) + return TRUE; + + /* enable repo, handled by dedicated function */ + g_return_val_if_fail (gs_app_get_kind (app) != AS_COMPONENT_KIND_REPOSITORY, FALSE); + + if (!gs_rpmostree_ref_proxies (self, &os_proxy, &sysroot_proxy, cancellable, error)) + return FALSE; + + switch (gs_app_get_state (app)) { + case GS_APP_STATE_AVAILABLE: + case GS_APP_STATE_QUEUED_FOR_INSTALL: + if (gs_app_get_source_default (app) == NULL) { + g_set_error_literal (error, + GS_PLUGIN_ERROR, + GS_PLUGIN_ERROR_NOT_SUPPORTED, + "no source set"); + return FALSE; + } + + install_package = gs_app_get_source_default (app); + break; + case GS_APP_STATE_AVAILABLE_LOCAL: + if (gs_app_get_local_file (app) == NULL) { + g_set_error_literal (error, + GS_PLUGIN_ERROR, + GS_PLUGIN_ERROR_NOT_SUPPORTED, + "local package, but no filename"); + return FALSE; + } + + local_filename = g_file_get_path (gs_app_get_local_file (app)); + break; + default: + g_set_error (error, + GS_PLUGIN_ERROR, + GS_PLUGIN_ERROR_NOT_SUPPORTED, + "do not know how to install app in state %s", + gs_app_state_to_string (gs_app_get_state (app))); + return FALSE; + } + + if (!gs_rpmostree_wait_for_ongoing_transaction_end (sysroot_proxy, cancellable, error)) + return FALSE; + + gs_app_set_state (app, GS_APP_STATE_INSTALLING); + tp->app = g_object_ref (app); + + options = make_rpmostree_options_variant (FALSE, /* reboot */ + FALSE, /* allow-downgrade */ + FALSE, /* cache-only */ + FALSE, /* download-only */ + FALSE, /* skip-purge */ + TRUE, /* no-pull-base */ + FALSE, /* dry-run */ + FALSE); /* no-overrides */ + + done = FALSE; + while (!done) { + done = TRUE; + if (!rpmostree_update_deployment (os_proxy, + install_package, + NULL /* remove package */, + local_filename, + options, + &transaction_address, + cancellable, + &local_error)) { + if (g_error_matches (local_error, G_IO_ERROR, G_IO_ERROR_BUSY)) { + g_clear_error (&local_error); + if (!gs_rpmostree_wait_for_ongoing_transaction_end (sysroot_proxy, cancellable, error)) { + gs_app_set_state_recover (app); + return FALSE; + } + done = FALSE; + continue; + } + if (local_error) + g_propagate_error (error, g_steal_pointer (&local_error)); + gs_rpmostree_error_convert (error); + gs_app_set_state_recover (app); + return FALSE; + } + } + + if (!gs_rpmostree_transaction_get_response_sync (sysroot_proxy, + transaction_address, + tp, + cancellable, + error)) { + gs_rpmostree_error_convert (error); + gs_app_set_state_recover (app); + return FALSE; + } + + /* state is known */ + gs_app_set_state (app, GS_APP_STATE_PENDING_INSTALL); + + /* get the new icon from the package */ + gs_app_set_local_file (app, NULL); + gs_app_remove_all_icons (app); + + /* no longer valid */ + gs_app_clear_source_ids (app); + + return TRUE; +} + +gboolean +gs_plugin_app_remove (GsPlugin *plugin, + GsApp *app, + GCancellable *cancellable, + GError **error) +{ + GsPluginRpmOstree *self = GS_PLUGIN_RPM_OSTREE (plugin); + g_autofree gchar *transaction_address = NULL; + g_autoptr(GVariant) options = NULL; + g_autoptr(TransactionProgress) tp = transaction_progress_new (); + g_autoptr(GsRPMOSTreeOS) os_proxy = NULL; + g_autoptr(GsRPMOSTreeSysroot) sysroot_proxy = NULL; + g_autoptr(GError) local_error = NULL; + gboolean done; + + /* only process this app if was created by this plugin */ + if (!gs_app_has_management_plugin (app, plugin)) + return TRUE; + + if (!gs_rpmostree_ref_proxies (self, &os_proxy, &sysroot_proxy, cancellable, error)) + return FALSE; + + /* disable repo, handled by dedicated function */ + g_return_val_if_fail (gs_app_get_kind (app) != AS_COMPONENT_KIND_REPOSITORY, FALSE); + + if (!gs_rpmostree_wait_for_ongoing_transaction_end (sysroot_proxy, cancellable, error)) + return FALSE; + + gs_app_set_state (app, GS_APP_STATE_REMOVING); + tp->app = g_object_ref (app); + + options = make_rpmostree_options_variant (FALSE, /* reboot */ + FALSE, /* allow-downgrade */ + TRUE, /* cache-only */ + FALSE, /* download-only */ + FALSE, /* skip-purge */ + TRUE, /* no-pull-base */ + FALSE, /* dry-run */ + FALSE); /* no-overrides */ + + done = FALSE; + while (!done) { + done = TRUE; + if (!rpmostree_update_deployment (os_proxy, + NULL /* install package */, + gs_app_get_source_default (app), + NULL /* install local package */, + options, + &transaction_address, + cancellable, + &local_error)) { + if (g_error_matches (local_error, G_IO_ERROR, G_IO_ERROR_BUSY)) { + g_clear_error (&local_error); + if (!gs_rpmostree_wait_for_ongoing_transaction_end (sysroot_proxy, cancellable, error)) { + gs_app_set_state_recover (app); + return FALSE; + } + done = FALSE; + continue; + } + if (local_error) + g_propagate_error (error, g_steal_pointer (&local_error)); + gs_rpmostree_error_convert (error); + gs_app_set_state_recover (app); + return FALSE; + } + } + + if (!gs_rpmostree_transaction_get_response_sync (sysroot_proxy, + transaction_address, + tp, + cancellable, + error)) { + gs_rpmostree_error_convert (error); + gs_app_set_state_recover (app); + return FALSE; + } + + if (gs_app_has_quirk (app, GS_APP_QUIRK_NEEDS_REBOOT)) { + gs_app_set_state (app, GS_APP_STATE_PENDING_REMOVE); + } else { + /* state is not known: we don't know if we can re-install this app */ + gs_app_set_state (app, GS_APP_STATE_UNKNOWN); + } + + return TRUE; +} + +static DnfPackage * +find_package_by_name (DnfSack *sack, + const char *pkgname) +{ + g_autoptr(GPtrArray) pkgs = NULL; + hy_autoquery HyQuery query = hy_query_create (sack); + + hy_query_filter (query, HY_PKG_NAME, HY_EQ, pkgname); + hy_query_filter_latest_per_arch (query, TRUE); + + pkgs = hy_query_run (query); + if (pkgs->len == 0) + return NULL; + + return g_object_ref (pkgs->pdata[pkgs->len-1]); +} + +static GPtrArray * +find_packages_by_provides (DnfSack *sack, + gchar **search) +{ + g_autoptr(GPtrArray) pkgs = NULL; + hy_autoquery HyQuery query = hy_query_create (sack); + + hy_query_filter_provides_in (query, search); + hy_query_filter_latest_per_arch (query, TRUE); + + pkgs = hy_query_run (query); + + return g_steal_pointer (&pkgs); +} + +static gboolean +gs_rpm_ostree_has_launchable (GsApp *app) +{ + const gchar *desktop_id; + GDesktopAppInfo *desktop_appinfo; + + if (gs_app_has_quirk (app, GS_APP_QUIRK_NOT_LAUNCHABLE) || + gs_app_has_quirk (app, GS_APP_QUIRK_PARENTAL_NOT_LAUNCHABLE)) + return FALSE; + + desktop_id = gs_app_get_launchable (app, AS_LAUNCHABLE_KIND_DESKTOP_ID); + if (!desktop_id) + desktop_id = gs_app_get_id (app); + if (!desktop_id) + return FALSE; + + desktop_appinfo = gs_utils_get_desktop_app_info (desktop_id); + if (!desktop_appinfo) + return FALSE; + + return TRUE; +} + +static gboolean +resolve_installed_packages_app (GsPlugin *plugin, + GHashTable *packages, + GHashTable *layered_packages, + GHashTable *layered_local_packages, + GsApp *app) +{ + RpmOstreePackage *pkg; + + if (!gs_app_get_source_default (app)) + return FALSE; + + pkg = g_hash_table_lookup (packages, gs_app_get_source_default (app)); + + if (pkg) { + gs_app_set_version (app, rpm_ostree_package_get_evr (pkg)); + if (gs_app_get_state (app) == GS_APP_STATE_UNKNOWN) { + /* Kind of hack, pending installs do not have available the desktop file */ + if (gs_app_get_kind (app) != AS_COMPONENT_KIND_DESKTOP_APP || gs_rpm_ostree_has_launchable (app)) + gs_app_set_state (app, GS_APP_STATE_INSTALLED); + else + gs_app_set_state (app, GS_APP_STATE_PENDING_INSTALL); + } + if ((rpm_ostree_package_get_name (pkg) && + g_hash_table_contains (layered_packages, rpm_ostree_package_get_name (pkg))) || + (rpm_ostree_package_get_nevra (pkg) && + g_hash_table_contains (layered_local_packages, rpm_ostree_package_get_nevra (pkg)))) { + /* layered packages can always be removed */ + gs_app_remove_quirk (app, GS_APP_QUIRK_COMPULSORY); + } else { + /* can't remove packages that are part of the base system */ + gs_app_add_quirk (app, GS_APP_QUIRK_COMPULSORY); + } + if (gs_app_get_origin (app) == NULL) + gs_app_set_origin (app, "rpm-ostree"); + if (gs_app_get_name (app) == NULL) + gs_app_set_name (app, GS_APP_QUALITY_LOWEST, rpm_ostree_package_get_name (pkg)); + return TRUE /* found */; + } + + return FALSE /* not found */; +} + +static gboolean +resolve_available_packages_app (GsPlugin *plugin, + DnfSack *sack, + GsApp *app) +{ + g_autoptr(DnfPackage) pkg = NULL; + + pkg = find_package_by_name (sack, gs_app_get_source_default (app)); + if (pkg != NULL) { + gs_app_set_version (app, dnf_package_get_evr (pkg)); + if (gs_app_get_state (app) == GS_APP_STATE_UNKNOWN) + gs_app_set_state (app, GS_APP_STATE_AVAILABLE); + + /* anything not part of the base system can be removed */ + gs_app_remove_quirk (app, GS_APP_QUIRK_COMPULSORY); + + /* set origin */ + if (gs_app_get_origin (app) == NULL) { + const gchar *reponame = dnf_package_get_reponame (pkg); + gs_app_set_origin (app, reponame); + } + + /* set more metadata for packages that don't have appstream data */ + gs_app_set_name (app, GS_APP_QUALITY_LOWEST, dnf_package_get_name (pkg)); + gs_app_set_summary (app, GS_APP_QUALITY_LOWEST, dnf_package_get_summary (pkg)); + + /* set hide-from-search quirk for available apps we don't want to show; results for non-installed desktop apps + * are intentionally hidden (as recommended by Matthias Clasen) by a special quirk because app layering + * should be intended for power users and not a common practice on Fedora Silverblue */ + if (!gs_app_is_installed (app)) { + switch (gs_app_get_kind (app)) { + case AS_COMPONENT_KIND_DESKTOP_APP: + case AS_COMPONENT_KIND_WEB_APP: + case AS_COMPONENT_KIND_CONSOLE_APP: + gs_app_add_quirk (app, GS_APP_QUIRK_HIDE_FROM_SEARCH); + break; + default: + break; + } + } + + return TRUE /* found */; + } + + return FALSE /* not found */; +} + +static gboolean +resolve_appstream_source_file_to_package_name (GsPlugin *plugin, + GsApp *app, + GsPluginRefineFlags flags, + GCancellable *cancellable, + GError **error) +{ + Header h; + const gchar *fn; + gint rc; + g_auto(rpmdbMatchIterator) mi = NULL; + g_auto(rpmts) ts = NULL; + + /* open db readonly */ + ts = rpmtsCreate(); + rpmtsSetRootDir (ts, NULL); + rc = rpmtsOpenDB (ts, O_RDONLY); + if (rc != 0) { + g_set_error (error, + GS_PLUGIN_ERROR, + GS_PLUGIN_ERROR_NOT_SUPPORTED, + "Failed to open rpmdb: %i", rc); + return FALSE; + } + + /* look for a specific file */ + fn = gs_app_get_metadata_item (app, "appstream::source-file"); + if (fn == NULL) + return TRUE; + + mi = rpmtsInitIterator (ts, RPMDBI_INSTFILENAMES, fn, 0); + if (mi == NULL) { + g_debug ("rpm: no search results for %s", fn); + return TRUE; + } + + /* process any results */ + g_debug ("rpm: querying for %s with %s", gs_app_get_id (app), fn); + while ((h = rpmdbNextIterator (mi)) != NULL) { + const gchar *name; + + /* add default source */ + name = headerGetString (h, RPMTAG_NAME); + if (gs_app_get_source_default (app) == NULL) { + g_debug ("rpm: setting source to %s", name); + gs_app_add_source (app, name); + gs_app_set_management_plugin (app, plugin); + gs_app_add_quirk (app, GS_APP_QUIRK_NEEDS_REBOOT); + app_set_rpm_ostree_packaging_format (app); + gs_app_set_bundle_kind (app, AS_BUNDLE_KIND_PACKAGE); + } + } + + return TRUE; +} + +static gboolean +gs_rpm_ostree_refine_apps (GsPlugin *plugin, + GsAppList *list, + GsPluginRefineFlags flags, + GCancellable *cancellable, + GError **error) +{ + GsPluginRpmOstree *self = GS_PLUGIN_RPM_OSTREE (plugin); + g_autoptr(GHashTable) packages = NULL; + g_autoptr(GHashTable) layered_packages = NULL; + g_autoptr(GHashTable) layered_local_packages = NULL; + g_autoptr(GMutexLocker) locker = NULL; + g_autoptr(GPtrArray) pkglist = NULL; + g_autoptr(GVariant) default_deployment = NULL; + g_autoptr(GsRPMOSTreeOS) os_proxy = NULL; + g_autoptr(GsRPMOSTreeSysroot) sysroot_proxy = NULL; + g_autoptr(DnfContext) dnf_context = NULL; + g_autoptr(OstreeRepo) ot_repo = NULL; + g_auto(GStrv) layered_packages_strv = NULL; + g_auto(GStrv) layered_local_packages_strv = NULL; + g_autofree gchar *checksum = NULL; + + locker = g_mutex_locker_new (&self->mutex); + + if (!gs_rpmostree_ref_dnf_context_locked (self, &os_proxy, &sysroot_proxy, &dnf_context, cancellable, error)) + return FALSE; + + ot_repo = g_object_ref (self->ot_repo); + + if (!dnf_context) + return FALSE; + + g_clear_pointer (&locker, g_mutex_locker_free); + + /* ensure D-Bus properties are updated before reading them */ + if (!gs_rpmostree_sysroot_call_reload_sync (sysroot_proxy, cancellable, error)) { + gs_rpmostree_error_convert (error); + return FALSE; + } + + default_deployment = gs_rpmostree_os_dup_default_deployment (os_proxy); + g_assert (g_variant_lookup (default_deployment, + "packages", "^as", + &layered_packages_strv)); + g_assert (g_variant_lookup (default_deployment, + "requested-local-packages", "^as", + &layered_local_packages_strv)); + g_assert (g_variant_lookup (default_deployment, + "checksum", "s", + &checksum)); + + pkglist = rpm_ostree_db_query_all (ot_repo, checksum, cancellable, error); + if (pkglist == NULL) { + gs_rpmostree_error_convert (error); + return FALSE; + } + + packages = g_hash_table_new (g_str_hash, g_str_equal); + layered_packages = g_hash_table_new (g_str_hash, g_str_equal); + layered_local_packages = g_hash_table_new (g_str_hash, g_str_equal); + + for (guint ii = 0; ii < pkglist->len; ii++) { + RpmOstreePackage *pkg = g_ptr_array_index (pkglist, ii); + if (rpm_ostree_package_get_name (pkg)) + g_hash_table_insert (packages, (gpointer) rpm_ostree_package_get_name (pkg), pkg); + } + + for (guint ii = 0; layered_packages_strv && layered_packages_strv[ii]; ii++) { + g_hash_table_add (layered_packages, layered_packages_strv[ii]); + } + + for (guint ii = 0; layered_local_packages_strv && layered_local_packages_strv[ii]; ii++) { + g_hash_table_add (layered_local_packages, layered_local_packages_strv[ii]); + } + + for (guint i = 0; i < gs_app_list_length (list); i++) { + GsApp *app = gs_app_list_index (list, i); + gboolean found; + + if (gs_app_has_quirk (app, GS_APP_QUIRK_IS_WILDCARD)) + continue; + /* set management plugin for apps where appstream just added the source package name in refine() */ + if (gs_app_has_management_plugin (app, NULL) && + gs_app_get_bundle_kind (app) == AS_BUNDLE_KIND_PACKAGE && + gs_app_get_scope (app) == AS_COMPONENT_SCOPE_SYSTEM && + gs_app_get_source_default (app) != NULL) { + gs_app_set_management_plugin (app, plugin); + gs_app_add_quirk (app, GS_APP_QUIRK_NEEDS_REBOOT); + app_set_rpm_ostree_packaging_format (app); + } + /* resolve the source package name based on installed appdata/desktop file name */ + if (gs_app_has_management_plugin (app, NULL) && + gs_app_get_bundle_kind (app) == AS_BUNDLE_KIND_UNKNOWN && + gs_app_get_scope (app) == AS_COMPONENT_SCOPE_SYSTEM && + gs_app_get_source_default (app) == NULL) { + if (!resolve_appstream_source_file_to_package_name (plugin, app, flags, cancellable, error)) + return FALSE; + } + if (!gs_app_has_management_plugin (app, plugin)) + continue; + if (gs_app_get_source_default (app) == NULL) + continue; + + /* first try to resolve from installed packages */ + found = resolve_installed_packages_app (plugin, packages, layered_packages, layered_local_packages, app); + + /* if we didn't find anything, try resolving from available packages */ + if (!found && dnf_context != NULL) + found = resolve_available_packages_app (plugin, dnf_context_get_sack (dnf_context), app); + + /* if we still didn't find anything then it's likely a package + * that is still in appstream data, but removed from the repos */ + if (!found) + g_debug ("failed to resolve %s", gs_app_get_unique_id (app)); + } + + return TRUE; +} + +static void refine_thread_cb (GTask *task, + gpointer source_object, + gpointer task_data, + GCancellable *cancellable); + +static void +gs_plugin_rpm_ostree_refine_async (GsPlugin *plugin, + GsAppList *list, + GsPluginRefineFlags flags, + GCancellable *cancellable, + GAsyncReadyCallback callback, + gpointer user_data) +{ + GsPluginRpmOstree *self = GS_PLUGIN_RPM_OSTREE (plugin); + g_autoptr(GTask) task = NULL; + gboolean interactive = gs_plugin_has_flags (GS_PLUGIN (self), GS_PLUGIN_FLAGS_INTERACTIVE); + + task = gs_plugin_refine_data_new_task (plugin, list, flags, cancellable, callback, user_data); + g_task_set_source_tag (task, gs_plugin_rpm_ostree_refine_async); + + gs_worker_thread_queue (self->worker, get_priority_for_interactivity (interactive), + refine_thread_cb, g_steal_pointer (&task)); +} + +static void +refine_thread_cb (GTask *task, + gpointer source_object, + gpointer task_data, + GCancellable *cancellable) +{ + GsPlugin *plugin = GS_PLUGIN (source_object); + GsPluginRpmOstree *self = GS_PLUGIN_RPM_OSTREE (plugin); + GsPluginRefineData *data = task_data; + GsAppList *list = data->list; + GsPluginRefineFlags flags = data->flags; + g_autoptr(GError) local_error = NULL; + + assert_in_worker (self); + + if (!gs_rpm_ostree_refine_apps (plugin, list, flags, cancellable, &local_error)) + g_task_return_error (task, g_steal_pointer (&local_error)); + else + g_task_return_boolean (task, TRUE); +} + +static gboolean +gs_plugin_rpm_ostree_refine_finish (GsPlugin *plugin, + GAsyncResult *result, + GError **error) +{ + return g_task_propagate_boolean (G_TASK (result), error); +} + +gboolean +gs_plugin_app_upgrade_download (GsPlugin *plugin, + GsApp *app, + GCancellable *cancellable, + GError **error) +{ + GsPluginRpmOstree *self = GS_PLUGIN_RPM_OSTREE (plugin); + const char *packages[] = { NULL }; + g_autofree gchar *new_refspec = NULL; + g_autofree gchar *transaction_address = NULL; + g_autoptr(GVariant) options = NULL; + g_autoptr(TransactionProgress) tp = transaction_progress_new (); + g_autoptr(GsRPMOSTreeOS) os_proxy = NULL; + g_autoptr(GsRPMOSTreeSysroot) sysroot_proxy = NULL; + g_autoptr(GError) local_error = NULL; + gboolean done; + + /* only process this app if was created by this plugin */ + if (!gs_app_has_management_plugin (app, plugin)) + return TRUE; + + /* check is distro-upgrade */ + if (gs_app_get_kind (app) != AS_COMPONENT_KIND_OPERATING_SYSTEM) + return TRUE; + + if (!gs_rpmostree_ref_proxies (self, &os_proxy, &sysroot_proxy, cancellable, error)) + return FALSE; + + if (!gs_rpmostree_wait_for_ongoing_transaction_end (sysroot_proxy, cancellable, error)) + return FALSE; + + /* construct new refspec based on the distro version we're upgrading to */ + new_refspec = g_strdup_printf ("ostree://fedora/%s/x86_64/silverblue", + gs_app_get_version (app)); + + options = make_rpmostree_options_variant (FALSE, /* reboot */ + TRUE, /* allow-downgrade */ + FALSE, /* cache-only */ + TRUE, /* download-only */ + FALSE, /* skip-purge */ + FALSE, /* no-pull-base */ + FALSE, /* dry-run */ + FALSE); /* no-overrides */ + + gs_app_set_state (app, GS_APP_STATE_INSTALLING); + tp->app = g_object_ref (app); + + done = FALSE; + while (!done) { + done = TRUE; + if (!gs_rpmostree_os_call_rebase_sync (os_proxy, + options, + new_refspec, + packages, + NULL /* fd list */, + &transaction_address, + NULL /* fd list out */, + cancellable, + &local_error)) { + if (g_error_matches (local_error, G_IO_ERROR, G_IO_ERROR_BUSY)) { + g_clear_error (&local_error); + if (!gs_rpmostree_wait_for_ongoing_transaction_end (sysroot_proxy, cancellable, error)) { + gs_app_set_state_recover (app); + return FALSE; + } + done = FALSE; + continue; + } + if (local_error) + g_propagate_error (error, g_steal_pointer (&local_error)); + gs_rpmostree_error_convert (error); + gs_app_set_state_recover (app); + return FALSE; + } + } + + if (!gs_rpmostree_transaction_get_response_sync (sysroot_proxy, + transaction_address, + tp, + cancellable, + error)) { + gs_rpmostree_error_convert (error); + + if (g_strrstr ((*error)->message, "Old and new refs are equal")) { + /* don't error out if the correct tree is already deployed */ + g_debug ("ignoring rpm-ostree error: %s", (*error)->message); + g_clear_error (error); + } else { + gs_app_set_state_recover (app); + return FALSE; + } + } + + /* state is known */ + gs_app_set_state (app, GS_APP_STATE_UPDATABLE); + return TRUE; +} + + +static gboolean +plugin_rpmostree_pick_rpm_desktop_file_cb (GsPlugin *plugin, + GsApp *app, + const gchar *filename, + GKeyFile *key_file) +{ + return strstr (filename, "/snapd/") == NULL && + strstr (filename, "/snap/") == NULL && + strstr (filename, "/flatpak/") == NULL && + g_key_file_has_group (key_file, "Desktop Entry") && + !g_key_file_has_key (key_file, "Desktop Entry", "X-Flatpak", NULL) && + !g_key_file_has_key (key_file, "Desktop Entry", "X-SnapInstanceName", NULL); +} + +gboolean +gs_plugin_launch (GsPlugin *plugin, + GsApp *app, + GCancellable *cancellable, + GError **error) +{ + /* only process this app if was created by this plugin */ + if (!gs_app_has_management_plugin (app, plugin)) + return TRUE; + + return gs_plugin_app_launch_filtered (plugin, app, plugin_rpmostree_pick_rpm_desktop_file_cb, NULL, error); +} + +static void +add_quirks_from_package_name (GsApp *app, const gchar *package_name) +{ + /* these packages don't have a .repo file in their file lists, but + * instead install one through rpm scripts / cron job */ + const gchar *packages_with_repos[] = { + "google-chrome-stable", + "google-earth-pro-stable", + "google-talkplugin", + NULL }; + + if (g_strv_contains (packages_with_repos, package_name)) + gs_app_add_quirk (app, GS_APP_QUIRK_HAS_SOURCE); +} + +gboolean +gs_plugin_file_to_app (GsPlugin *plugin, + GsAppList *list, + GFile *file, + GCancellable *cancellable, + GError **error) +{ + gboolean ret = FALSE; + FD_t rpmfd = NULL; + guint64 epoch; + guint64 size; + const gchar *name; + const gchar *version; + const gchar *release; + const gchar *license; + g_auto(Header) h = NULL; + g_auto(rpmts) ts = NULL; + g_autofree gchar *evr = NULL; + g_autofree gchar *filename = NULL; + g_autoptr(GsApp) app = NULL; + g_autoptr(GsAppList) tmp_list = NULL; + + filename = g_file_get_path (file); + if (!g_str_has_suffix (filename, ".rpm")) { + ret = TRUE; + goto out; + } + + ts = rpmtsCreate (); + rpmtsSetVSFlags (ts, _RPMVSF_NOSIGNATURES); + + /* librpm needs Fopenfd */ + rpmfd = Fopen (filename, "r.fdio"); + if (rpmfd == NULL) { + g_set_error (error, GS_PLUGIN_ERROR, GS_PLUGIN_ERROR_FAILED, + "Opening %s failed", filename); + goto out; + } + if (Ferror (rpmfd)) { + g_set_error (error, + GS_PLUGIN_ERROR, + GS_PLUGIN_ERROR_FAILED, + "Opening %s failed: %s", + filename, + Fstrerror (rpmfd)); + goto out; + } + + if (rpmReadPackageFile (ts, rpmfd, filename, &h) != RPMRC_OK) { + g_set_error (error, + GS_PLUGIN_ERROR, + GS_PLUGIN_ERROR_FAILED, + "Verification of %s failed", + filename); + goto out; + } + + app = gs_app_new (NULL); + gs_app_set_metadata (app, "GnomeSoftware::Creator", gs_plugin_get_name (plugin)); + gs_app_set_management_plugin (app, plugin); + if (h) { + const gchar *str; + + str = headerGetString (h, RPMTAG_NAME); + if (str && *str) + gs_app_set_name (app, GS_APP_QUALITY_HIGHEST, str); + + str = headerGetString (h, RPMTAG_SUMMARY); + if (str && *str) + gs_app_set_summary (app, GS_APP_QUALITY_HIGHEST, str); + + str = headerGetString (h, RPMTAG_DESCRIPTION); + if (str && *str) + gs_app_set_description (app, GS_APP_QUALITY_HIGHEST, str); + } + gs_app_add_quirk (app, GS_APP_QUIRK_NEEDS_REBOOT); + app_set_rpm_ostree_packaging_format (app); + gs_app_set_kind (app, AS_COMPONENT_KIND_GENERIC); + gs_app_set_bundle_kind (app, AS_BUNDLE_KIND_PACKAGE); + gs_app_set_scope (app, AS_COMPONENT_SCOPE_SYSTEM); + + /* add default source */ + name = headerGetString (h, RPMTAG_NAME); + g_debug ("rpm: setting source to %s", name); + gs_app_add_source (app, name); + + /* add version */ + epoch = headerGetNumber (h, RPMTAG_EPOCH); + version = headerGetString (h, RPMTAG_VERSION); + release = headerGetString (h, RPMTAG_RELEASE); + if (epoch > 0) { + evr = g_strdup_printf ("%" G_GUINT64_FORMAT ":%s-%s", + epoch, version, release); + } else { + evr = g_strdup_printf ("%s-%s", + version, release); + } + g_debug ("rpm: setting version to %s", evr); + gs_app_set_version (app, evr); + + /* set size */ + size = headerGetNumber (h, RPMTAG_SIZE); + gs_app_set_size_installed (app, GS_SIZE_TYPE_VALID, size); + + /* set license */ + license = headerGetString (h, RPMTAG_LICENSE); + if (license != NULL) { + g_autofree gchar *license_spdx = NULL; + license_spdx = as_license_to_spdx_id (license); + gs_app_set_license (app, GS_APP_QUALITY_NORMAL, license_spdx); + g_debug ("rpm: setting license to %s", license_spdx); + } + + add_quirks_from_package_name (app, name); + + tmp_list = gs_app_list_new (); + gs_app_list_add (tmp_list, app); + + if (gs_rpm_ostree_refine_apps (plugin, tmp_list, 0, cancellable, error)) { + if (gs_app_get_state (app) == GS_APP_STATE_UNKNOWN) + gs_app_set_state (app, GS_APP_STATE_AVAILABLE_LOCAL); + + gs_app_list_add (list, app); + ret = TRUE; + } + +out: + if (rpmfd != NULL) + (void) Fclose (rpmfd); + return ret; +} + +static gchar ** +what_provides_decompose (GsAppQueryProvidesType provides_type, + const gchar *provides_tag) +{ + g_autoptr(GPtrArray) array = g_ptr_array_new (); + + /* The provides_tag possibly already contains the prefix, thus use it as is */ + if (provides_type != GS_APP_QUERY_PROVIDES_UNKNOWN && + g_str_has_suffix (provides_tag, ")") && + strchr (provides_tag, '(') != NULL) + provides_type = GS_APP_QUERY_PROVIDES_PACKAGE_NAME; + + /* Wrap the @provides_tag with the appropriate Fedora prefix */ + switch (provides_type) { + case GS_APP_QUERY_PROVIDES_PACKAGE_NAME: + g_ptr_array_add (array, g_strdup (provides_tag)); + break; + case GS_APP_QUERY_PROVIDES_GSTREAMER: + g_ptr_array_add (array, g_strdup_printf ("gstreamer0.10(%s)", provides_tag)); + g_ptr_array_add (array, g_strdup_printf ("gstreamer1(%s)", provides_tag)); + break; + case GS_APP_QUERY_PROVIDES_FONT: + g_ptr_array_add (array, g_strdup_printf ("font(%s)", provides_tag)); + break; + case GS_APP_QUERY_PROVIDES_MIME_HANDLER: + g_ptr_array_add (array, g_strdup_printf ("mimehandler(%s)", provides_tag)); + break; + case GS_APP_QUERY_PROVIDES_PS_DRIVER: + g_ptr_array_add (array, g_strdup_printf ("postscriptdriver(%s)", provides_tag)); + break; + case GS_APP_QUERY_PROVIDES_PLASMA: + g_ptr_array_add (array, g_strdup_printf ("plasma4(%s)", provides_tag)); + g_ptr_array_add (array, g_strdup_printf ("plasma5(%s)", provides_tag)); + break; + case GS_APP_QUERY_PROVIDES_UNKNOWN: + default: + g_assert_not_reached (); + } + + g_ptr_array_add (array, NULL); + + return (gchar **) g_ptr_array_free (g_steal_pointer (&array), FALSE); +} + +static void list_apps_thread_cb (GTask *task, + gpointer source_object, + gpointer task_data, + GCancellable *cancellable); + +static void +gs_plugin_rpm_ostree_list_apps_async (GsPlugin *plugin, + GsAppQuery *query, + GsPluginListAppsFlags flags, + GCancellable *cancellable, + GAsyncReadyCallback callback, + gpointer user_data) +{ + GsPluginRpmOstree *self = GS_PLUGIN_RPM_OSTREE (plugin); + g_autoptr(GTask) task = NULL; + gboolean interactive = (flags & GS_PLUGIN_LIST_APPS_FLAGS_INTERACTIVE); + + task = gs_plugin_list_apps_data_new_task (plugin, query, flags, + cancellable, callback, user_data); + g_task_set_source_tag (task, gs_plugin_rpm_ostree_list_apps_async); + + /* Queue a job to get the apps. */ + gs_worker_thread_queue (self->worker, get_priority_for_interactivity (interactive), + list_apps_thread_cb, g_steal_pointer (&task)); +} + +/* Run in @worker. */ +static void +list_apps_thread_cb (GTask *task, + gpointer source_object, + gpointer task_data, + GCancellable *cancellable) +{ + GsPluginRpmOstree *self = GS_PLUGIN_RPM_OSTREE (source_object); + g_autoptr(GsAppList) list = gs_app_list_new (); + GsPluginListAppsData *data = task_data; + const gchar *provides_tag = NULL; + GsAppQueryProvidesType provides_type = GS_APP_QUERY_PROVIDES_UNKNOWN; + g_autoptr(GError) local_error = NULL; + g_autoptr(GMutexLocker) locker = NULL; + g_autoptr(GPtrArray) pkglist = NULL; + g_autoptr(DnfContext) dnf_context = NULL; + g_auto(GStrv) provides = NULL; + + assert_in_worker (self); + + if (data->query != NULL) { + provides_type = gs_app_query_get_provides (data->query, &provides_tag); + } + + /* Currently only support a subset of query properties, and only one set at once. */ + if (provides_tag == NULL || + gs_app_query_get_n_properties_set (data->query) != 1) { + g_task_return_new_error (task, G_IO_ERROR, G_IO_ERROR_NOT_SUPPORTED, + "Unsupported query"); + return; + } + + /* Prepare a dnf context */ + locker = g_mutex_locker_new (&self->mutex); + + if (!gs_rpmostree_ref_dnf_context_locked (self, NULL, NULL, &dnf_context, cancellable, &local_error)) { + g_task_return_error (task, g_steal_pointer (&local_error)); + return; + } + + g_clear_pointer (&locker, g_mutex_locker_free); + + provides = what_provides_decompose (provides_type, provides_tag); + pkglist = find_packages_by_provides (dnf_context_get_sack (dnf_context), provides); + for (guint i = 0; i < pkglist->len; i++) { + DnfPackage *pkg = g_ptr_array_index (pkglist, i); + g_autoptr(GsApp) app = NULL; + + app = gs_plugin_cache_lookup (GS_PLUGIN (self), dnf_package_get_nevra (pkg)); + if (app != NULL) { + gs_app_list_add (list, app); + continue; + } + + /* create new app */ + app = gs_app_new (NULL); + gs_app_set_metadata (app, "GnomeSoftware::Creator", gs_plugin_get_name (GS_PLUGIN (self))); + gs_app_set_management_plugin (app, GS_PLUGIN (self)); + gs_app_add_quirk (app, GS_APP_QUIRK_NEEDS_REBOOT); + app_set_rpm_ostree_packaging_format (app); + gs_app_set_kind (app, AS_COMPONENT_KIND_GENERIC); + gs_app_set_bundle_kind (app, AS_BUNDLE_KIND_PACKAGE); + gs_app_set_scope (app, AS_COMPONENT_SCOPE_SYSTEM); + gs_app_add_source (app, dnf_package_get_name (pkg)); + + gs_plugin_cache_add (GS_PLUGIN (self), dnf_package_get_nevra (pkg), app); + gs_app_list_add (list, app); + } + + g_task_return_pointer (task, g_steal_pointer (&list), g_object_unref); +} + +static GsAppList * +gs_plugin_rpm_ostree_list_apps_finish (GsPlugin *plugin, + GAsyncResult *result, + GError **error) +{ + return g_task_propagate_pointer (G_TASK (result), error); +} + +gboolean +gs_plugin_add_sources (GsPlugin *plugin, + GsAppList *list, + GCancellable *cancellable, + GError **error) +{ + g_autoptr(DnfContext) dnf_context = NULL; + GPtrArray *repos; + + dnf_context = gs_rpmostree_create_bare_dnf_context (cancellable, error); + if (!dnf_context) + return FALSE; + + repos = dnf_context_get_repos (dnf_context); + if (repos == NULL) + return TRUE; + + for (guint i = 0; i < repos->len; i++) { + DnfRepo *repo = g_ptr_array_index (repos, i); + g_autofree gchar *description = NULL; + g_autoptr(GsApp) app = NULL; + gboolean enabled; + + /* hide these from the user */ + if (dnf_repo_is_devel (repo) || dnf_repo_is_source (repo)) + continue; + + app = gs_app_new (dnf_repo_get_id (repo)); + gs_app_set_management_plugin (app, plugin); + gs_app_set_kind (app, AS_COMPONENT_KIND_REPOSITORY); + gs_app_set_bundle_kind (app, AS_BUNDLE_KIND_PACKAGE); + gs_app_add_quirk (app, GS_APP_QUIRK_NOT_LAUNCHABLE); + + enabled = (dnf_repo_get_enabled (repo) & DNF_REPO_ENABLED_PACKAGES) > 0; + gs_app_set_state (app, enabled ? GS_APP_STATE_INSTALLED : GS_APP_STATE_AVAILABLE); + + description = dnf_repo_get_description (repo); + gs_app_set_name (app, GS_APP_QUALITY_LOWEST, description); + gs_app_set_summary (app, GS_APP_QUALITY_LOWEST, description); + + gs_app_set_metadata (app, "GnomeSoftware::SortKey", "200"); + gs_app_set_origin_ui (app, _("Operating System (OSTree)")); + + gs_app_list_add (list, app); + } + + return TRUE; +} + +static void enable_repository_thread_cb (GTask *task, + gpointer source_object, + gpointer task_data, + GCancellable *cancellable); + +static void +gs_plugin_rpm_ostree_enable_repository_async (GsPlugin *plugin, + GsApp *repository, + GsPluginManageRepositoryFlags flags, + GCancellable *cancellable, + GAsyncReadyCallback callback, + gpointer user_data) +{ + GsPluginRpmOstree *self = GS_PLUGIN_RPM_OSTREE (plugin); + g_autoptr(GTask) task = NULL; + gboolean interactive = (flags & GS_PLUGIN_MANAGE_REPOSITORY_FLAGS_INTERACTIVE); + + task = gs_plugin_manage_repository_data_new_task (plugin, repository, flags, cancellable, callback, user_data); + g_task_set_source_tag (task, gs_plugin_rpm_ostree_enable_repository_async); + + /* only process this app if it was created by this plugin */ + if (!gs_app_has_management_plugin (repository, plugin)) { + g_task_return_boolean (task, TRUE); + return; + } + + g_assert (gs_app_get_kind (repository) == AS_COMPONENT_KIND_REPOSITORY); + + gs_worker_thread_queue (self->worker, get_priority_for_interactivity (interactive), + enable_repository_thread_cb, g_steal_pointer (&task)); +} + +/* Run in @worker. */ +static void +enable_repository_thread_cb (GTask *task, + gpointer source_object, + gpointer task_data, + GCancellable *cancellable) +{ + GsPluginRpmOstree *self = GS_PLUGIN_RPM_OSTREE (source_object); + GsPluginManageRepositoryData *data = task_data; + GsPluginRefreshMetadataData refresh_data = { 0 }; + gboolean interactive = (data->flags & GS_PLUGIN_MANAGE_REPOSITORY_FLAGS_INTERACTIVE); + g_autoptr(GsRPMOSTreeOS) os_proxy = NULL; + g_autoptr(GsRPMOSTreeSysroot) sysroot_proxy = NULL; + g_autoptr(GError) local_error = NULL; + + assert_in_worker (self); + + if (!gs_rpmostree_ref_proxies (self, &os_proxy, &sysroot_proxy, cancellable, &local_error)) { + g_task_return_error (task, g_steal_pointer (&local_error)); + return; + } + + if (!gs_rpmostree_repo_enable (GS_PLUGIN (self), data->repository, TRUE, os_proxy, sysroot_proxy, cancellable, &local_error)) { + g_task_return_error (task, g_steal_pointer (&local_error)); + return; + } + + refresh_data.flags = interactive ? GS_PLUGIN_REFRESH_METADATA_FLAGS_INTERACTIVE : GS_PLUGIN_REFRESH_METADATA_FLAGS_NONE; + refresh_data.cache_age_secs = 1; + + if (!gs_plugin_rpm_ostree_refresh_metadata_in_worker (self, &refresh_data, os_proxy, sysroot_proxy, cancellable, &local_error)) + g_debug ("Failed to refresh after repository enable: %s", local_error->message); + + /* This can fail silently, it's only to update necessary caches, to provide + * up-to-date information after the successful repository enable/install. + */ + g_task_return_boolean (task, TRUE); +} + +static gboolean +gs_plugin_rpm_ostree_enable_repository_finish (GsPlugin *plugin, + GAsyncResult *result, + GError **error) +{ + return g_task_propagate_boolean (G_TASK (result), error); +} + +static void disable_repository_thread_cb (GTask *task, + gpointer source_object, + gpointer task_data, + GCancellable *cancellable); + +static void +gs_plugin_rpm_ostree_disable_repository_async (GsPlugin *plugin, + GsApp *repository, + GsPluginManageRepositoryFlags flags, + GCancellable *cancellable, + GAsyncReadyCallback callback, + gpointer user_data) +{ + GsPluginRpmOstree *self = GS_PLUGIN_RPM_OSTREE (plugin); + g_autoptr(GTask) task = NULL; + gboolean interactive = (flags & GS_PLUGIN_MANAGE_REPOSITORY_FLAGS_INTERACTIVE); + + task = gs_plugin_manage_repository_data_new_task (plugin, repository, flags, cancellable, callback, user_data); + g_task_set_source_tag (task, gs_plugin_rpm_ostree_disable_repository_async); + + /* only process this app if it was created by this plugin */ + if (!gs_app_has_management_plugin (repository, plugin)) { + g_task_return_boolean (task, TRUE); + return; + } + + g_assert (gs_app_get_kind (repository) == AS_COMPONENT_KIND_REPOSITORY); + + gs_worker_thread_queue (self->worker, get_priority_for_interactivity (interactive), + disable_repository_thread_cb, g_steal_pointer (&task)); +} + +/* Run in @worker. */ +static void +disable_repository_thread_cb (GTask *task, + gpointer source_object, + gpointer task_data, + GCancellable *cancellable) +{ + GsPluginRpmOstree *self = GS_PLUGIN_RPM_OSTREE (source_object); + GsPluginManageRepositoryData *data = task_data; + g_autoptr(GsRPMOSTreeOS) os_proxy = NULL; + g_autoptr(GsRPMOSTreeSysroot) sysroot_proxy = NULL; + g_autoptr(GError) local_error = NULL; + + assert_in_worker (self); + + if (!gs_rpmostree_ref_proxies (self, &os_proxy, &sysroot_proxy, cancellable, &local_error)) { + g_task_return_error (task, g_steal_pointer (&local_error)); + return; + } + + if (gs_rpmostree_repo_enable (GS_PLUGIN (self), data->repository, FALSE, os_proxy, sysroot_proxy, cancellable, &local_error)) + g_task_return_boolean (task, TRUE); + else + g_task_return_error (task, g_steal_pointer (&local_error)); +} + +static gboolean +gs_plugin_rpm_ostree_disable_repository_finish (GsPlugin *plugin, + GAsyncResult *result, + GError **error) +{ + return g_task_propagate_boolean (G_TASK (result), error); +} + +static void +gs_plugin_rpm_ostree_class_init (GsPluginRpmOstreeClass *klass) +{ + GObjectClass *object_class = G_OBJECT_CLASS (klass); + GsPluginClass *plugin_class = GS_PLUGIN_CLASS (klass); + + object_class->dispose = gs_plugin_rpm_ostree_dispose; + object_class->finalize = gs_plugin_rpm_ostree_finalize; + + plugin_class->setup_async = gs_plugin_rpm_ostree_setup_async; + plugin_class->setup_finish = gs_plugin_rpm_ostree_setup_finish; + plugin_class->shutdown_async = gs_plugin_rpm_ostree_shutdown_async; + plugin_class->shutdown_finish = gs_plugin_rpm_ostree_shutdown_finish; + plugin_class->refine_async = gs_plugin_rpm_ostree_refine_async; + plugin_class->refine_finish = gs_plugin_rpm_ostree_refine_finish; + plugin_class->refresh_metadata_async = gs_plugin_rpm_ostree_refresh_metadata_async; + plugin_class->refresh_metadata_finish = gs_plugin_rpm_ostree_refresh_metadata_finish; + plugin_class->enable_repository_async = gs_plugin_rpm_ostree_enable_repository_async; + plugin_class->enable_repository_finish = gs_plugin_rpm_ostree_enable_repository_finish; + plugin_class->disable_repository_async = gs_plugin_rpm_ostree_disable_repository_async; + plugin_class->disable_repository_finish = gs_plugin_rpm_ostree_disable_repository_finish; + plugin_class->list_apps_async = gs_plugin_rpm_ostree_list_apps_async; + plugin_class->list_apps_finish = gs_plugin_rpm_ostree_list_apps_finish; +} + +GType +gs_plugin_query_type (void) +{ + return GS_TYPE_PLUGIN_RPM_OSTREE; +} |