diff options
Diffstat (limited to 'lib/gs-plugin-loader.c')
| -rw-r--r-- | lib/gs-plugin-loader.c | 3968 |
1 files changed, 3968 insertions, 0 deletions
diff --git a/lib/gs-plugin-loader.c b/lib/gs-plugin-loader.c new file mode 100644 index 0000000..7783f77 --- /dev/null +++ b/lib/gs-plugin-loader.c @@ -0,0 +1,3968 @@ +/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- + * vi:set noexpandtab tabstop=8 shiftwidth=8: + * + * Copyright (C) 2007-2018 Richard Hughes <richard@hughsie.com> + * Copyright (C) 2014-2020 Kalev Lember <klember@redhat.com> + * + * SPDX-License-Identifier: GPL-2.0+ + */ + +#include "config.h" + +#include <locale.h> +#include <glib/gi18n.h> +#include <appstream-glib.h> +#include <math.h> + +#ifdef HAVE_SYSPROF +#include <sysprof-capture.h> +#endif + +#include "gs-app-collation.h" +#include "gs-app-private.h" +#include "gs-app-list-private.h" +#include "gs-category-private.h" +#include "gs-ioprio.h" +#include "gs-plugin-loader.h" +#include "gs-plugin.h" +#include "gs-plugin-event.h" +#include "gs-plugin-job-private.h" +#include "gs-plugin-private.h" +#include "gs-utils.h" + +#define GS_PLUGIN_LOADER_UPDATES_CHANGED_DELAY 3 /* s */ +#define GS_PLUGIN_LOADER_RELOAD_DELAY 5 /* s */ + +typedef struct +{ + GPtrArray *plugins; + GPtrArray *locations; + gchar *locale; + gchar *language; + gboolean plugin_dir_dirty; + SoupSession *soup_session; + GPtrArray *file_monitors; + GsPluginStatus global_status_last; + + GMutex pending_apps_mutex; + GPtrArray *pending_apps; + + GThreadPool *queued_ops_pool; + + GSettings *settings; + + GMutex events_by_id_mutex; + GHashTable *events_by_id; /* unique-id : GsPluginEvent */ + + gchar **compatible_projects; + guint scale; + + guint updates_changed_id; + guint updates_changed_cnt; + guint reload_id; + GHashTable *disallow_updates; /* GsPlugin : const char *name */ + + GNetworkMonitor *network_monitor; + gulong network_changed_handler; + gulong network_available_notify_handler; + gulong network_metered_notify_handler; + +#ifdef HAVE_SYSPROF + SysprofCaptureWriter *sysprof_writer; /* (owned) (nullable) */ +#endif +} GsPluginLoaderPrivate; + +static void gs_plugin_loader_monitor_network (GsPluginLoader *plugin_loader); +static void add_app_to_install_queue (GsPluginLoader *plugin_loader, GsApp *app); +static void gs_plugin_loader_process_in_thread_pool_cb (gpointer data, gpointer user_data); + +G_DEFINE_TYPE_WITH_PRIVATE (GsPluginLoader, gs_plugin_loader, G_TYPE_OBJECT) + +enum { + SIGNAL_STATUS_CHANGED, + SIGNAL_PENDING_APPS_CHANGED, + SIGNAL_UPDATES_CHANGED, + SIGNAL_RELOAD, + SIGNAL_BASIC_AUTH_START, + SIGNAL_LAST +}; + +enum { + PROP_0, + PROP_EVENTS, + PROP_ALLOW_UPDATES, + PROP_NETWORK_AVAILABLE, + PROP_NETWORK_METERED, + PROP_LAST +}; + +static guint signals [SIGNAL_LAST] = { 0 }; + +typedef void (*GsPluginFunc) (GsPlugin *plugin); +typedef gboolean (*GsPluginSetupFunc) (GsPlugin *plugin, + GCancellable *cancellable, + GError **error); +typedef gboolean (*GsPluginSearchFunc) (GsPlugin *plugin, + gchar **value, + GsAppList *list, + GCancellable *cancellable, + GError **error); +typedef gboolean (*GsPluginAlternatesFunc) (GsPlugin *plugin, + GsApp *app, + GsAppList *list, + GCancellable *cancellable, + GError **error); +typedef gboolean (*GsPluginCategoryFunc) (GsPlugin *plugin, + GsCategory *category, + GsAppList *list, + GCancellable *cancellable, + GError **error); +typedef gboolean (*GsPluginGetRecentFunc) (GsPlugin *plugin, + GsAppList *list, + guint64 age, + GCancellable *cancellable, + GError **error); +typedef gboolean (*GsPluginResultsFunc) (GsPlugin *plugin, + GsAppList *list, + GCancellable *cancellable, + GError **error); +typedef gboolean (*GsPluginCategoriesFunc) (GsPlugin *plugin, + GPtrArray *list, + GCancellable *cancellable, + GError **error); +typedef gboolean (*GsPluginActionFunc) (GsPlugin *plugin, + GsApp *app, + GCancellable *cancellable, + GError **error); +typedef gboolean (*GsPluginReviewFunc) (GsPlugin *plugin, + GsApp *app, + AsReview *review, + GCancellable *cancellable, + GError **error); +typedef gboolean (*GsPluginRefineFunc) (GsPlugin *plugin, + GsAppList *list, + GsPluginRefineFlags refine_flags, + GCancellable *cancellable, + GError **error); +typedef gboolean (*GsPluginRefineAppFunc) (GsPlugin *plugin, + GsApp *app, + GsPluginRefineFlags refine_flags, + GCancellable *cancellable, + GError **error); +typedef gboolean (*GsPluginRefineWildcardFunc) (GsPlugin *plugin, + GsApp *app, + GsAppList *list, + GsPluginRefineFlags refine_flags, + GCancellable *cancellable, + GError **error); +typedef gboolean (*GsPluginRefreshFunc) (GsPlugin *plugin, + guint cache_age, + GCancellable *cancellable, + GError **error); +typedef gboolean (*GsPluginFileToAppFunc) (GsPlugin *plugin, + GsAppList *list, + GFile *file, + GCancellable *cancellable, + GError **error); +typedef gboolean (*GsPluginUrlToAppFunc) (GsPlugin *plugin, + GsAppList *list, + const gchar *url, + GCancellable *cancellable, + GError **error); +typedef gboolean (*GsPluginUpdateFunc) (GsPlugin *plugin, + GsAppList *apps, + GCancellable *cancellable, + GError **error); +typedef void (*GsPluginAdoptAppFunc) (GsPlugin *plugin, + GsApp *app); +typedef gboolean (*GsPluginGetLangPacksFunc) (GsPlugin *plugin, + GsAppList *list, + const gchar *locale, + GCancellable *cancellable, + GError **error); + + +/* async helper */ +typedef struct { + GsPluginLoader *plugin_loader; + GCancellable *cancellable; + GCancellable *cancellable_caller; + gulong cancellable_id; + const gchar *function_name; + const gchar *function_name_parent; + GPtrArray *catlist; + GsPluginJob *plugin_job; + gboolean anything_ran; + guint timeout_id; + gboolean timeout_triggered; + gchar **tokens; +} GsPluginLoaderHelper; + +static GsPluginLoaderHelper * +gs_plugin_loader_helper_new (GsPluginLoader *plugin_loader, GsPluginJob *plugin_job) +{ + GsPluginLoaderHelper *helper = g_slice_new0 (GsPluginLoaderHelper); + GsPluginAction action = gs_plugin_job_get_action (plugin_job); + helper->plugin_loader = g_object_ref (plugin_loader); + helper->plugin_job = g_object_ref (plugin_job); + helper->function_name = gs_plugin_action_to_function_name (action); + return helper; +} + +static void +reset_app_progress (GsApp *app) +{ + GsAppList *addons = gs_app_get_addons (app); + GsAppList *related = gs_app_get_related (app); + + gs_app_set_progress (app, GS_APP_PROGRESS_UNKNOWN); + + for (guint i = 0; i < gs_app_list_length (addons); i++) { + GsApp *app_addons = gs_app_list_index (addons, i); + gs_app_set_progress (app_addons, GS_APP_PROGRESS_UNKNOWN); + } + for (guint i = 0; i < gs_app_list_length (related); i++) { + GsApp *app_related = gs_app_list_index (related, i); + gs_app_set_progress (app_related, GS_APP_PROGRESS_UNKNOWN); + } +} + +static void +gs_plugin_loader_helper_free (GsPluginLoaderHelper *helper) +{ + /* reset progress */ + switch (gs_plugin_job_get_action (helper->plugin_job)) { + case GS_PLUGIN_ACTION_INSTALL: + case GS_PLUGIN_ACTION_REMOVE: + case GS_PLUGIN_ACTION_UPDATE: + case GS_PLUGIN_ACTION_DOWNLOAD: + { + GsApp *app; + GsAppList *list; + + app = gs_plugin_job_get_app (helper->plugin_job); + if (app != NULL) + reset_app_progress (app); + + list = gs_plugin_job_get_list (helper->plugin_job); + for (guint i = 0; i < gs_app_list_length (list); i++) { + GsApp *app_tmp = gs_app_list_index (list, i); + reset_app_progress (app_tmp); + } + } + break; + default: + break; + } + + if (helper->cancellable_id > 0) { + g_debug ("Disconnecting cancellable %p", helper->cancellable_caller); + g_cancellable_disconnect (helper->cancellable_caller, + helper->cancellable_id); + } + g_object_unref (helper->plugin_loader); + if (helper->timeout_id != 0) + g_source_remove (helper->timeout_id); + if (helper->plugin_job != NULL) + g_object_unref (helper->plugin_job); + if (helper->cancellable != NULL) + g_object_unref (helper->cancellable); + if (helper->cancellable_caller != NULL) + g_object_unref (helper->cancellable_caller); + if (helper->catlist != NULL) + g_ptr_array_unref (helper->catlist); + g_strfreev (helper->tokens); + g_slice_free (GsPluginLoaderHelper, helper); +} + +static void +gs_plugin_loader_job_debug (GsPluginLoaderHelper *helper) +{ + g_autofree gchar *str = gs_plugin_job_to_string (helper->plugin_job); + g_debug ("%s", str); +} + +G_DEFINE_AUTOPTR_CLEANUP_FUNC(GsPluginLoaderHelper, gs_plugin_loader_helper_free) + +static gint +gs_plugin_loader_app_sort_name_cb (GsApp *app1, GsApp *app2, gpointer user_data) +{ + return gs_utils_sort_strcmp (gs_app_get_name (app1), gs_app_get_name (app2)); +} + +GsPlugin * +gs_plugin_loader_find_plugin (GsPluginLoader *plugin_loader, + const gchar *plugin_name) +{ + GsPluginLoaderPrivate *priv = gs_plugin_loader_get_instance_private (plugin_loader); + + for (guint i = 0; i < priv->plugins->len; i++) { + GsPlugin *plugin = g_ptr_array_index (priv->plugins, i); + if (g_strcmp0 (gs_plugin_get_name (plugin), plugin_name) == 0) + return plugin; + } + return NULL; +} + +static gboolean +gs_plugin_loader_notify_idle_cb (gpointer user_data) +{ + GsPluginLoader *plugin_loader = GS_PLUGIN_LOADER (user_data); + g_object_notify (G_OBJECT (plugin_loader), "events"); + return FALSE; +} + +static void +gs_plugin_loader_add_event (GsPluginLoader *plugin_loader, GsPluginEvent *event) +{ + GsPluginLoaderPrivate *priv = gs_plugin_loader_get_instance_private (plugin_loader); + g_autoptr(GMutexLocker) locker = g_mutex_locker_new (&priv->events_by_id_mutex); + + /* events should always have a unique ID, either constructed from the + * app they are processing or preferably from the GError message */ + if (gs_plugin_event_get_unique_id (event) == NULL) { + g_warning ("failed to add event from action %s", + gs_plugin_action_to_string (gs_plugin_event_get_action (event))); + return; + } + + g_hash_table_insert (priv->events_by_id, + g_strdup (gs_plugin_event_get_unique_id (event)), + g_object_ref (event)); + g_idle_add (gs_plugin_loader_notify_idle_cb, plugin_loader); +} + +static GsPluginEvent * +gs_plugin_job_to_failed_event (GsPluginJob *plugin_job, const GError *error) +{ + GsPluginEvent *event; + g_autoptr(GError) error_copy = NULL; + + g_return_val_if_fail (error != NULL, NULL); + + /* invalid */ + if (error->domain != GS_PLUGIN_ERROR) { + g_warning ("not GsPlugin error %s:%i: %s", + g_quark_to_string (error->domain), + error->code, + error->message); + g_set_error_literal (&error_copy, + GS_PLUGIN_ERROR, + GS_PLUGIN_ERROR_FAILED, + error->message); + } else { + error_copy = g_error_copy (error); + } + + /* create plugin event */ + event = gs_plugin_event_new (); + gs_plugin_event_set_error (event, error_copy); + gs_plugin_event_set_action (event, gs_plugin_job_get_action (plugin_job)); + if (gs_plugin_job_get_app (plugin_job) != NULL) + gs_plugin_event_set_app (event, gs_plugin_job_get_app (plugin_job)); + if (gs_plugin_job_get_interactive (plugin_job)) + gs_plugin_event_add_flag (event, GS_PLUGIN_EVENT_FLAG_INTERACTIVE); + gs_plugin_event_add_flag (event, GS_PLUGIN_EVENT_FLAG_WARNING); + return event; +} + +static gboolean +gs_plugin_loader_is_error_fatal (const GError *err) +{ + if (g_error_matches (err, GS_PLUGIN_ERROR, GS_PLUGIN_ERROR_TIMED_OUT)) + return TRUE; + if (g_error_matches (err, GS_PLUGIN_ERROR, GS_PLUGIN_ERROR_AUTH_REQUIRED)) + return TRUE; + if (g_error_matches (err, GS_PLUGIN_ERROR, GS_PLUGIN_ERROR_AUTH_INVALID)) + return TRUE; + return FALSE; +} + +static gboolean +gs_plugin_error_handle_failure (GsPluginLoaderHelper *helper, + GsPlugin *plugin, + const GError *error_local, + GError **error) +{ + g_autofree gchar *app_id = NULL; + g_autofree gchar *origin_id = NULL; + g_autoptr(GsPluginEvent) event = NULL; + + /* badly behaved plugin */ + if (error_local == NULL) { + g_critical ("%s did not set error for %s", + gs_plugin_get_name (plugin), + helper->function_name); + return TRUE; + } + + /* this is only ever informational */ + if (g_error_matches (error_local, GS_PLUGIN_ERROR, GS_PLUGIN_ERROR_CANCELLED) || + g_error_matches (error_local, G_IO_ERROR, G_IO_ERROR_CANCELLED)) { + g_debug ("ignoring error cancelled: %s", error_local->message); + return TRUE; + } + + /* find and strip any unique IDs from the error message */ + for (guint i = 0; i < 2; i++) { + if (app_id == NULL) + app_id = gs_utils_error_strip_app_id (error_local); + if (origin_id == NULL) + origin_id = gs_utils_error_strip_origin_id (error_local); + } + + /* fatal error */ + if (gs_plugin_job_get_action (helper->plugin_job) == GS_PLUGIN_ACTION_SETUP || + gs_plugin_loader_is_error_fatal (error_local) || + g_getenv ("GS_SELF_TEST_PLUGIN_ERROR_FAIL_HARD") != NULL) { + if (error != NULL) + *error = g_error_copy (error_local); + return FALSE; + } + + /* create event which is handled by the GsShell */ + event = gs_plugin_job_to_failed_event (helper->plugin_job, error_local); + + /* set the app and origin IDs if we managed to scrape them from the error above */ + if (as_utils_unique_id_valid (app_id)) { + g_autoptr(GsApp) app = gs_plugin_cache_lookup (plugin, app_id); + if (app != NULL) { + g_debug ("found app %s in error", origin_id); + gs_plugin_event_set_app (event, app); + } else { + g_debug ("no unique ID found for app %s", app_id); + } + } + if (as_utils_unique_id_valid (origin_id)) { + g_autoptr(GsApp) origin = gs_plugin_cache_lookup (plugin, origin_id); + if (origin != NULL) { + g_debug ("found origin %s in error", origin_id); + gs_plugin_event_set_origin (event, origin); + } else { + g_debug ("no unique ID found for origin %s", origin_id); + } + } + + /* add event to queue */ + gs_plugin_loader_add_event (helper->plugin_loader, event); + return TRUE; +} + +static void +gs_plugin_loader_run_adopt (GsPluginLoader *plugin_loader, GsAppList *list) +{ + GsPluginLoaderPrivate *priv = gs_plugin_loader_get_instance_private (plugin_loader); + guint i; + guint j; + + /* go through each plugin in order */ + for (i = 0; i < priv->plugins->len; i++) { + GsPluginAdoptAppFunc adopt_app_func = NULL; + GsPlugin *plugin = g_ptr_array_index (priv->plugins, i); + adopt_app_func = gs_plugin_get_symbol (plugin, "gs_plugin_adopt_app"); + if (adopt_app_func == NULL) + continue; + for (j = 0; j < gs_app_list_length (list); j++) { + GsApp *app = gs_app_list_index (list, j); + if (gs_app_get_management_plugin (app) != NULL) + continue; + if (gs_app_has_quirk (app, GS_APP_QUIRK_IS_WILDCARD)) + continue; + adopt_app_func (plugin, app); + if (gs_app_get_management_plugin (app) != NULL) { + g_debug ("%s adopted %s", + gs_plugin_get_name (plugin), + gs_app_get_unique_id (app)); + } + } + } + for (j = 0; j < gs_app_list_length (list); j++) { + GsApp *app = gs_app_list_index (list, j); + if (gs_app_get_management_plugin (app) != NULL) + continue; + if (gs_app_has_quirk (app, GS_APP_QUIRK_IS_WILDCARD)) + continue; + g_debug ("nothing adopted %s", gs_app_get_unique_id (app)); + } +} + +static gint +gs_plugin_loader_review_score_sort_cb (gconstpointer a, gconstpointer b) +{ + AsReview *ra = *((AsReview **) a); + AsReview *rb = *((AsReview **) b); + if (as_review_get_priority (ra) < as_review_get_priority (rb)) + return 1; + if (as_review_get_priority (ra) > as_review_get_priority (rb)) + return -1; + return 0; +} + +static gboolean +gs_plugin_loader_call_vfunc (GsPluginLoaderHelper *helper, + GsPlugin *plugin, + GsApp *app, + GsAppList *list, + GsPluginRefineFlags refine_flags, + GCancellable *cancellable, + GError **error) +{ +#ifdef HAVE_SYSPROF + GsPluginLoaderPrivate *priv = gs_plugin_loader_get_instance_private (helper->plugin_loader); +#endif + GsPluginAction action = gs_plugin_job_get_action (helper->plugin_job); + gboolean ret = TRUE; + gpointer func = NULL; + g_autoptr(GError) error_local = NULL; + g_autoptr(GTimer) timer = g_timer_new (); +#ifdef HAVE_SYSPROF + gint64 begin_time_nsec = SYSPROF_CAPTURE_CURRENT_TIME; +#endif + + /* load the possible symbol */ + func = gs_plugin_get_symbol (plugin, helper->function_name); + if (func == NULL) + return TRUE; + + /* fallback if unset */ + if (app == NULL) + app = gs_plugin_job_get_app (helper->plugin_job); + if (list == NULL) + list = gs_plugin_job_get_list (helper->plugin_job); + if (refine_flags == GS_PLUGIN_REFINE_FLAGS_DEFAULT) + refine_flags = gs_plugin_job_get_refine_flags (helper->plugin_job); + + /* set what plugin is running on the job */ + gs_plugin_job_set_plugin (helper->plugin_job, plugin); + + /* run the correct vfunc */ + if (gs_plugin_job_get_interactive (helper->plugin_job)) + gs_plugin_interactive_inc (plugin); + switch (action) { + case GS_PLUGIN_ACTION_INITIALIZE: + case GS_PLUGIN_ACTION_DESTROY: + { + GsPluginFunc plugin_func = func; + plugin_func (plugin); + } + break; + case GS_PLUGIN_ACTION_SETUP: + { + GsPluginSetupFunc plugin_func = func; + ret = plugin_func (plugin, cancellable, &error_local); + } + break; + case GS_PLUGIN_ACTION_REFINE: + if (g_strcmp0 (helper->function_name, "gs_plugin_refine_wildcard") == 0) { + GsPluginRefineWildcardFunc plugin_func = func; + ret = plugin_func (plugin, app, list, refine_flags, cancellable, &error_local); + } else if (g_strcmp0 (helper->function_name, "gs_plugin_refine") == 0) { + GsPluginRefineFunc plugin_func = func; + ret = plugin_func (plugin, list, refine_flags, cancellable, &error_local); + } else { + g_critical ("function_name %s invalid for %s", + helper->function_name, + gs_plugin_action_to_string (action)); + } + break; + case GS_PLUGIN_ACTION_UPDATE: + if (g_strcmp0 (helper->function_name, "gs_plugin_update_app") == 0) { + GsPluginActionFunc plugin_func = func; + ret = plugin_func (plugin, app, cancellable, &error_local); + } else if (g_strcmp0 (helper->function_name, "gs_plugin_update") == 0) { + GsPluginUpdateFunc plugin_func = func; + ret = plugin_func (plugin, list, cancellable, &error_local); + } else { + g_critical ("function_name %s invalid for %s", + helper->function_name, + gs_plugin_action_to_string (action)); + } + break; + case GS_PLUGIN_ACTION_DOWNLOAD: + if (g_strcmp0 (helper->function_name, "gs_plugin_download_app") == 0) { + GsPluginActionFunc plugin_func = func; + ret = plugin_func (plugin, app, cancellable, &error_local); + } else if (g_strcmp0 (helper->function_name, "gs_plugin_download") == 0) { + GsPluginUpdateFunc plugin_func = func; + ret = plugin_func (plugin, list, cancellable, &error_local); + } else { + g_critical ("function_name %s invalid for %s", + helper->function_name, + gs_plugin_action_to_string (action)); + } + break; + case GS_PLUGIN_ACTION_INSTALL: + case GS_PLUGIN_ACTION_REMOVE: + case GS_PLUGIN_ACTION_SET_RATING: + case GS_PLUGIN_ACTION_UPGRADE_DOWNLOAD: + case GS_PLUGIN_ACTION_UPGRADE_TRIGGER: + case GS_PLUGIN_ACTION_LAUNCH: + case GS_PLUGIN_ACTION_UPDATE_CANCEL: + case GS_PLUGIN_ACTION_ADD_SHORTCUT: + case GS_PLUGIN_ACTION_REMOVE_SHORTCUT: + { + GsPluginActionFunc plugin_func = func; + ret = plugin_func (plugin, app, cancellable, &error_local); + } + break; + case GS_PLUGIN_ACTION_REVIEW_SUBMIT: + case GS_PLUGIN_ACTION_REVIEW_UPVOTE: + case GS_PLUGIN_ACTION_REVIEW_DOWNVOTE: + case GS_PLUGIN_ACTION_REVIEW_REPORT: + case GS_PLUGIN_ACTION_REVIEW_REMOVE: + case GS_PLUGIN_ACTION_REVIEW_DISMISS: + { + GsPluginReviewFunc plugin_func = func; + ret = plugin_func (plugin, app, + gs_plugin_job_get_review (helper->plugin_job), + cancellable, &error_local); + } + break; + case GS_PLUGIN_ACTION_GET_RECENT: + { + GsPluginGetRecentFunc plugin_func = func; + ret = plugin_func (plugin, list, + gs_plugin_job_get_age (helper->plugin_job), + cancellable, &error_local); + } + break; + case GS_PLUGIN_ACTION_GET_UPDATES: + case GS_PLUGIN_ACTION_GET_UPDATES_HISTORICAL: + case GS_PLUGIN_ACTION_GET_DISTRO_UPDATES: + case GS_PLUGIN_ACTION_GET_UNVOTED_REVIEWS: + case GS_PLUGIN_ACTION_GET_SOURCES: + case GS_PLUGIN_ACTION_GET_INSTALLED: + case GS_PLUGIN_ACTION_GET_POPULAR: + case GS_PLUGIN_ACTION_GET_FEATURED: + { + GsPluginResultsFunc plugin_func = func; + ret = plugin_func (plugin, list, cancellable, &error_local); + } + break; + case GS_PLUGIN_ACTION_SEARCH: + { + GsPluginSearchFunc plugin_func = func; + ret = plugin_func (plugin, helper->tokens, list, + cancellable, &error_local); + } + break; + case GS_PLUGIN_ACTION_SEARCH_FILES: + case GS_PLUGIN_ACTION_SEARCH_PROVIDES: + { + GsPluginSearchFunc plugin_func = func; + gchar *search[2] = { gs_plugin_job_get_search (helper->plugin_job), NULL }; + ret = plugin_func (plugin, search, list, + cancellable, &error_local); + } + break; + case GS_PLUGIN_ACTION_GET_ALTERNATES: + { + GsPluginAlternatesFunc plugin_func = func; + ret = plugin_func (plugin, app, list, + cancellable, &error_local); + } + break; + case GS_PLUGIN_ACTION_GET_CATEGORIES: + { + GsPluginCategoriesFunc plugin_func = func; + ret = plugin_func (plugin, helper->catlist, + cancellable, &error_local); + } + break; + case GS_PLUGIN_ACTION_GET_CATEGORY_APPS: + { + GsPluginCategoryFunc plugin_func = func; + ret = plugin_func (plugin, + gs_plugin_job_get_category (helper->plugin_job), + list, + cancellable, &error_local); + } + break; + case GS_PLUGIN_ACTION_REFRESH: + { + GsPluginRefreshFunc plugin_func = func; + ret = plugin_func (plugin, + gs_plugin_job_get_age (helper->plugin_job), + cancellable, &error_local); + } + break; + case GS_PLUGIN_ACTION_FILE_TO_APP: + { + GsPluginFileToAppFunc plugin_func = func; + ret = plugin_func (plugin, list, + gs_plugin_job_get_file (helper->plugin_job), + cancellable, &error_local); + } + break; + case GS_PLUGIN_ACTION_URL_TO_APP: + { + GsPluginUrlToAppFunc plugin_func = func; + ret = plugin_func (plugin, list, + gs_plugin_job_get_search (helper->plugin_job), + cancellable, &error_local); + } + break; + case GS_PLUGIN_ACTION_GET_LANGPACKS: + { + GsPluginGetLangPacksFunc plugin_func = func; + ret = plugin_func (plugin, list, + gs_plugin_job_get_search (helper->plugin_job), + cancellable, &error_local); + } + break; + default: + g_critical ("no handler for %s", helper->function_name); + break; + } + if (gs_plugin_job_get_interactive (helper->plugin_job)) + gs_plugin_interactive_dec (plugin); + + /* plugin did not return error on cancellable abort */ + if (ret && g_cancellable_set_error_if_cancelled (cancellable, &error_local)) { + g_debug ("plugin %s did not return error with cancellable set", + gs_plugin_get_name (plugin)); + gs_utils_error_convert_gio (&error_local); + ret = FALSE; + } + + /* failed */ + if (!ret) { + /* we returned cancelled, but this was because of a timeout, + * so re-create error, throwing the plugin under the bus */ + if (helper->timeout_triggered && + g_error_matches (error_local, GS_PLUGIN_ERROR, GS_PLUGIN_ERROR_CANCELLED)) { + g_debug ("converting cancelled to timeout"); + g_clear_error (&error_local); + g_set_error (&error_local, + GS_PLUGIN_ERROR, + GS_PLUGIN_ERROR_TIMED_OUT, + "Timeout was reached as %s took " + "too long to return results", + gs_plugin_get_name (plugin)); + } + return gs_plugin_error_handle_failure (helper, + plugin, + error_local, + error); + } + + /* add app to the pending installation queue if necessary */ + if (action == GS_PLUGIN_ACTION_INSTALL && + app != NULL && gs_app_get_state (app) == AS_APP_STATE_QUEUED_FOR_INSTALL) { + add_app_to_install_queue (helper->plugin_loader, app); + } + +#ifdef HAVE_SYSPROF + if (priv->sysprof_writer != NULL) { + g_autofree gchar *sysprof_name = NULL; + g_autofree gchar *sysprof_message = NULL; + + sysprof_name = g_strconcat ("vfunc:", gs_plugin_action_to_string (action), NULL); + sysprof_message = gs_plugin_job_to_string (helper->plugin_job); + sysprof_capture_writer_add_mark (priv->sysprof_writer, + begin_time_nsec, + sched_getcpu (), + getpid (), + SYSPROF_CAPTURE_CURRENT_TIME - begin_time_nsec, + "gnome-software", + sysprof_name, + sysprof_message); + } +#endif /* HAVE_SYSPROF */ + + /* check the plugin didn't take too long */ + if (g_timer_elapsed (timer, NULL) > 1.0f) { + GLogLevelFlags log_level; + + switch (action) { + case GS_PLUGIN_ACTION_INITIALIZE: + case GS_PLUGIN_ACTION_DESTROY: + case GS_PLUGIN_ACTION_SETUP: + if (g_getenv ("GS_SELF_TEST_PLUGIN_ERROR_FAIL_HARD") == NULL) + log_level = G_LOG_LEVEL_WARNING; + else + log_level = G_LOG_LEVEL_DEBUG; + break; + default: + log_level = G_LOG_LEVEL_DEBUG; + break; + } + + g_log_structured_standard (G_LOG_DOMAIN, log_level, + __FILE__, G_STRINGIFY (__LINE__), + G_STRFUNC, + "plugin %s took %.1f seconds to do %s", + gs_plugin_get_name (plugin), + g_timer_elapsed (timer, NULL), + gs_plugin_action_to_string (action)); + } + + /* success */ + helper->anything_ran = TRUE; + return TRUE; +} + +static gboolean +gs_plugin_loader_app_is_non_wildcard (GsApp *app, gpointer user_data) +{ + return !gs_app_has_quirk (app, GS_APP_QUIRK_IS_WILDCARD); +} + +static gboolean +gs_plugin_loader_run_refine_filter (GsPluginLoaderHelper *helper, + GsAppList *list, + GsPluginRefineFlags refine_flags, + GCancellable *cancellable, + GError **error) +{ + GsPluginLoaderPrivate *priv = gs_plugin_loader_get_instance_private (helper->plugin_loader); + + /* run each plugin */ + for (guint i = 0; i < priv->plugins->len; i++) { + GsPlugin *plugin = g_ptr_array_index (priv->plugins, i); + g_autoptr(GsAppList) app_list = NULL; + + /* run the batched plugin symbol then refine wildcards per-app */ + helper->function_name = "gs_plugin_refine"; + if (!gs_plugin_loader_call_vfunc (helper, plugin, NULL, list, + refine_flags, cancellable, error)) { + return FALSE; + } + + if (gs_plugin_get_symbol (plugin, "gs_plugin_refine_wildcard") != NULL) { + /* use a copy of the list for the loop because a function called + * on the plugin may affect the list which can lead to problems + * (e.g. inserting an app in the list on every call results in + * an infinite loop) */ + app_list = gs_app_list_copy (list); + helper->function_name = "gs_plugin_refine_wildcard"; + + for (guint j = 0; j < gs_app_list_length (app_list); j++) { + GsApp *app = gs_app_list_index (app_list, j); + if (gs_app_has_quirk (app, GS_APP_QUIRK_IS_WILDCARD) && + !gs_plugin_loader_call_vfunc (helper, plugin, app, NULL, + refine_flags, cancellable, error)) { + return FALSE; + } + } + } + + gs_plugin_status_update (plugin, NULL, GS_PLUGIN_STATUS_FINISHED); + } + + + /* filter any wildcard apps left in the list */ + gs_app_list_filter (list, gs_plugin_loader_app_is_non_wildcard, NULL); + return TRUE; +} + +static gboolean +gs_plugin_loader_run_refine_internal (GsPluginLoaderHelper *helper, + GsAppList *list, + GCancellable *cancellable, + GError **error) +{ + /* try to adopt each application with a plugin */ + gs_plugin_loader_run_adopt (helper->plugin_loader, list); + + /* run each plugin */ + if (!gs_plugin_loader_run_refine_filter (helper, list, + GS_PLUGIN_REFINE_FLAGS_DEFAULT, + cancellable, error)) + return FALSE; + + /* ensure these are sorted by score */ + if (gs_plugin_job_has_refine_flags (helper->plugin_job, + GS_PLUGIN_REFINE_FLAGS_REQUIRE_REVIEWS)) { + GPtrArray *reviews; + for (guint i = 0; i < gs_app_list_length (list); i++) { + GsApp *app = gs_app_list_index (list, i); + reviews = gs_app_get_reviews (app); + g_ptr_array_sort (reviews, + gs_plugin_loader_review_score_sort_cb); + } + } + + /* refine addons one layer deep */ + if (gs_plugin_job_has_refine_flags (helper->plugin_job, + GS_PLUGIN_REFINE_FLAGS_REQUIRE_ADDONS)) { + g_autoptr(GsAppList) addons_list = NULL; + gs_plugin_job_remove_refine_flags (helper->plugin_job, + GS_PLUGIN_REFINE_FLAGS_REQUIRE_ADDONS | + GS_PLUGIN_REFINE_FLAGS_REQUIRE_REVIEWS | + GS_PLUGIN_REFINE_FLAGS_REQUIRE_REVIEW_RATINGS); + addons_list = gs_app_list_new (); + for (guint i = 0; i < gs_app_list_length (list); i++) { + GsApp *app = gs_app_list_index (list, i); + GsAppList *addons = gs_app_get_addons (app); + for (guint j = 0; j < gs_app_list_length (addons); j++) { + GsApp *addon = gs_app_list_index (addons, j); + g_debug ("refining app %s addon %s", + gs_app_get_id (app), + gs_app_get_id (addon)); + gs_app_list_add (addons_list, addon); + } + } + if (gs_app_list_length (addons_list) > 0) { + if (!gs_plugin_loader_run_refine_internal (helper, + addons_list, + cancellable, + error)) { + return FALSE; + } + } + } + + /* also do runtime */ + if (gs_plugin_job_has_refine_flags (helper->plugin_job, + GS_PLUGIN_REFINE_FLAGS_REQUIRE_RUNTIME)) { + g_autoptr(GsAppList) list2 = gs_app_list_new (); + for (guint i = 0; i < gs_app_list_length (list); i++) { + GsApp *runtime; + GsApp *app = gs_app_list_index (list, i); + runtime = gs_app_get_runtime (app); + if (runtime != NULL) + gs_app_list_add (list2, runtime); + } + if (gs_app_list_length (list2) > 0) { + if (!gs_plugin_loader_run_refine_internal (helper, + list2, + cancellable, + error)) { + return FALSE; + } + } + } + + /* also do related packages one layer deep */ + if (gs_plugin_job_has_refine_flags (helper->plugin_job, + GS_PLUGIN_REFINE_FLAGS_REQUIRE_RELATED)) { + g_autoptr(GsAppList) related_list = NULL; + gs_plugin_job_remove_refine_flags (helper->plugin_job, + GS_PLUGIN_REFINE_FLAGS_REQUIRE_RELATED); + related_list = gs_app_list_new (); + for (guint i = 0; i < gs_app_list_length (list); i++) { + GsApp *app = gs_app_list_index (list, i); + GsAppList *related = gs_app_get_related (app); + for (guint j = 0; j < gs_app_list_length (related); j++) { + GsApp *app2 = gs_app_list_index (related, j); + g_debug ("refining related: %s[%s]", + gs_app_get_id (app2), + gs_app_get_source_default (app2)); + gs_app_list_add (related_list, app2); + } + } + if (gs_app_list_length (related_list) > 0) { + if (!gs_plugin_loader_run_refine_internal (helper, + related_list, + cancellable, + error)) { + return FALSE; + } + } + } + + /* success */ + return TRUE; +} + +static gboolean +app_thaw_notify_idle (gpointer data) +{ + GsApp *app = GS_APP (data); + g_object_thaw_notify (G_OBJECT (app)); + g_object_unref (app); + return G_SOURCE_REMOVE; +} + +static gboolean +gs_plugin_loader_run_refine (GsPluginLoaderHelper *helper, + GsAppList *list, + GCancellable *cancellable, + GError **error) +{ + gboolean ret; + g_autoptr(GsAppList) freeze_list = NULL; + g_autoptr(GsPluginLoaderHelper) helper2 = NULL; + g_autoptr(GsPluginJob) plugin_job = NULL; + + /* nothing to do */ + if (gs_app_list_length (list) == 0) + return TRUE; + + /* freeze all apps */ + freeze_list = gs_app_list_copy (list); + for (guint i = 0; i < gs_app_list_length (freeze_list); i++) { + GsApp *app = gs_app_list_index (freeze_list, i); + g_object_freeze_notify (G_OBJECT (app)); + } + + /* first pass */ + plugin_job = gs_plugin_job_newv (GS_PLUGIN_ACTION_REFINE, + "list", list, + "refine-flags", gs_plugin_job_get_refine_flags (helper->plugin_job), + NULL); + helper2 = gs_plugin_loader_helper_new (helper->plugin_loader, plugin_job); + helper2->function_name_parent = helper->function_name; + ret = gs_plugin_loader_run_refine_internal (helper2, list, cancellable, error); + if (!ret) + goto out; + + /* remove any addons that have the same source as the parent app */ + for (guint i = 0; i < gs_app_list_length (list); i++) { + g_autoptr(GPtrArray) to_remove = g_ptr_array_new (); + GsApp *app = gs_app_list_index (list, i); + GsAppList *addons = gs_app_get_addons (app); + + /* find any apps with the same source */ + const gchar *pkgname_parent = gs_app_get_source_default (app); + if (pkgname_parent == NULL) + continue; + for (guint j = 0; j < gs_app_list_length (addons); j++) { + GsApp *addon = gs_app_list_index (addons, j); + if (g_strcmp0 (gs_app_get_source_default (addon), + pkgname_parent) == 0) { + g_debug ("%s has the same pkgname of %s as %s", + gs_app_get_unique_id (app), + pkgname_parent, + gs_app_get_unique_id (addon)); + g_ptr_array_add (to_remove, addon); + } + } + + /* remove any addons with the same source */ + for (guint j = 0; j < to_remove->len; j++) { + GsApp *addon = g_ptr_array_index (to_remove, j); + gs_app_remove_addon (app, addon); + } + } + +out: + /* now emit all the changed signals */ + for (guint i = 0; i < gs_app_list_length (freeze_list); i++) { + GsApp *app = gs_app_list_index (freeze_list, i); + g_idle_add (app_thaw_notify_idle, g_object_ref (app)); + } + return ret; +} + +static void +gs_plugin_loader_job_sorted_truncation_again (GsPluginLoaderHelper *helper) +{ + GsAppListSortFunc sort_func; + gpointer sort_func_data; + + /* not valid */ + if (gs_plugin_job_get_list (helper->plugin_job) == NULL) + return; + + /* unset */ + sort_func = gs_plugin_job_get_sort_func (helper->plugin_job); + if (sort_func == NULL) + return; + sort_func_data = gs_plugin_job_get_sort_func_data (helper->plugin_job); + gs_app_list_sort (gs_plugin_job_get_list (helper->plugin_job), sort_func, sort_func_data); +} + +static void +gs_plugin_loader_job_sorted_truncation (GsPluginLoaderHelper *helper) +{ + GsAppListSortFunc sort_func; + guint max_results; + GsAppList *list = gs_plugin_job_get_list (helper->plugin_job); + + /* not valid */ + if (list == NULL) + return; + + /* unset */ + max_results = gs_plugin_job_get_max_results (helper->plugin_job); + if (max_results == 0) + return; + + /* already small enough */ + if (gs_app_list_length (list) <= max_results) + return; + + /* nothing set */ + g_debug ("truncating results to %u from %u", + max_results, gs_app_list_length (list)); + sort_func = gs_plugin_job_get_sort_func (helper->plugin_job); + if (sort_func == NULL) { + GsPluginAction action = gs_plugin_job_get_action (helper->plugin_job); + g_debug ("no ->sort_func() set for %s, using random!", + gs_plugin_action_to_string (action)); + gs_app_list_randomize (list); + } else { + gpointer sort_func_data; + sort_func_data = gs_plugin_job_get_sort_func_data (helper->plugin_job); + gs_app_list_sort (list, sort_func, sort_func_data); + } + gs_app_list_truncate (list, max_results); +} + +static gboolean +gs_plugin_loader_run_results (GsPluginLoaderHelper *helper, + GCancellable *cancellable, + GError **error) +{ + GsPluginLoaderPrivate *priv = gs_plugin_loader_get_instance_private (helper->plugin_loader); +#ifdef HAVE_SYSPROF + gint64 begin_time_nsec G_GNUC_UNUSED = SYSPROF_CAPTURE_CURRENT_TIME; +#endif + + /* run each plugin */ + for (guint i = 0; i < priv->plugins->len; i++) { + GsPlugin *plugin = g_ptr_array_index (priv->plugins, i); + if (g_cancellable_set_error_if_cancelled (cancellable, error)) { + gs_utils_error_convert_gio (error); + return FALSE; + } + if (!gs_plugin_loader_call_vfunc (helper, plugin, NULL, NULL, + GS_PLUGIN_REFINE_FLAGS_DEFAULT, + cancellable, error)) { + return FALSE; + } + gs_plugin_status_update (plugin, NULL, GS_PLUGIN_STATUS_FINISHED); + } + +#ifdef HAVE_SYSPROF + if (priv->sysprof_writer != NULL) { + g_autofree gchar *sysprof_name = NULL; + g_autofree gchar *sysprof_message = NULL; + + sysprof_name = g_strconcat ("run-results:", + gs_plugin_action_to_string (gs_plugin_job_get_action (helper->plugin_job)), + NULL); + sysprof_message = gs_plugin_job_to_string (helper->plugin_job); + sysprof_capture_writer_add_mark (priv->sysprof_writer, + begin_time_nsec, + sched_getcpu (), + getpid (), + SYSPROF_CAPTURE_CURRENT_TIME - begin_time_nsec, + "gnome-software", + sysprof_name, + sysprof_message); + } +#endif /* HAVE_SYSPROF */ + + return TRUE; +} + +static const gchar * +gs_plugin_loader_get_app_str (GsApp *app) +{ + const gchar *id; + + /* first try the actual id */ + id = gs_app_get_unique_id (app); + if (id != NULL) + return id; + + /* then try the source */ + id = gs_app_get_source_default (app); + if (id != NULL) + return id; + + /* lastly try the source id */ + id = gs_app_get_source_id_default (app); + if (id != NULL) + return id; + + /* urmmm */ + return "<invalid>"; +} + +static gboolean +gs_plugin_loader_app_set_prio (GsApp *app, gpointer user_data) +{ + GsPluginLoader *plugin_loader = GS_PLUGIN_LOADER (user_data); + GsPlugin *plugin; + const gchar *tmp; + + /* if set, copy the priority */ + tmp = gs_app_get_management_plugin (app); + if (tmp == NULL) + return TRUE; + plugin = gs_plugin_loader_find_plugin (plugin_loader, tmp); + if (plugin == NULL) + return TRUE; + gs_app_set_priority (app, gs_plugin_get_priority (plugin)); + return TRUE; +} + +static gboolean +gs_plugin_loader_app_is_valid_installed (GsApp *app, gpointer user_data) +{ + /* even without AppData, show things in progress */ + switch (gs_app_get_state (app)) { + case AS_APP_STATE_INSTALLING: + case AS_APP_STATE_REMOVING: + return TRUE; + break; + default: + break; + } + + switch (gs_app_get_kind (app)) { + case AS_APP_KIND_OS_UPGRADE: + case AS_APP_KIND_CODEC: + case AS_APP_KIND_FONT: + g_debug ("app invalid as %s: %s", + as_app_kind_to_string (gs_app_get_kind (app)), + gs_plugin_loader_get_app_str (app)); + return FALSE; + break; + default: + break; + } + + /* sanity check */ + if (!gs_app_is_installed (app)) { + g_autofree gchar *tmp = gs_app_to_string (app); + g_warning ("ignoring non-installed app %s", tmp); + return FALSE; + } + + return TRUE; +} + +static gboolean +gs_plugin_loader_app_is_valid (GsApp *app, gpointer user_data) +{ + GsPluginLoaderHelper *helper = (GsPluginLoaderHelper *) user_data; + + /* never show addons */ + if (gs_app_get_kind (app) == AS_APP_KIND_ADDON) { + g_debug ("app invalid as addon %s", + gs_plugin_loader_get_app_str (app)); + return FALSE; + } + + /* never show CLI apps */ + if (gs_app_get_kind (app) == AS_APP_KIND_CONSOLE) { + g_debug ("app invalid as console %s", + gs_plugin_loader_get_app_str (app)); + return FALSE; + } + + /* don't show unknown state */ + if (gs_app_get_state (app) == AS_APP_STATE_UNKNOWN) { + g_debug ("app invalid as state unknown %s", + gs_plugin_loader_get_app_str (app)); + return FALSE; + } + + /* don't show unconverted unavailables */ + if (gs_app_get_kind (app) == AS_APP_KIND_UNKNOWN && + gs_app_get_state (app) == AS_APP_STATE_UNAVAILABLE) { + g_debug ("app invalid as unconverted unavailable %s", + gs_plugin_loader_get_app_str (app)); + return FALSE; + } + + /* don't show blocklisted apps */ + if (gs_app_has_quirk (app, GS_APP_QUIRK_HIDE_EVERYWHERE)) { + g_debug ("app invalid as blocklisted %s", + gs_plugin_loader_get_app_str (app)); + return FALSE; + } + + /* Don’t show parentally filtered apps unless they’re already + * installed. See the comments in gs-details-page.c for details. */ + if (!gs_app_is_installed (app) && + gs_app_has_quirk (app, GS_APP_QUIRK_PARENTAL_FILTER)) { + g_debug ("app invalid as parentally filtered %s", + gs_plugin_loader_get_app_str (app)); + return FALSE; + } + + /* don't show apps with hide-from-search quirk, unless they are already installed */ + if (!gs_app_is_installed (app) && + gs_app_has_quirk (app, GS_APP_QUIRK_HIDE_FROM_SEARCH)) { + g_debug ("app invalid as hide-from-search quirk set %s", + gs_plugin_loader_get_app_str (app)); + return FALSE; + } + + /* don't show sources */ + if (gs_app_get_kind (app) == AS_APP_KIND_SOURCE) { + g_debug ("app invalid as source %s", + gs_plugin_loader_get_app_str (app)); + return FALSE; + } + + /* don't show unknown kind */ + if (gs_app_get_kind (app) == AS_APP_KIND_UNKNOWN) { + g_debug ("app invalid as kind unknown %s", + gs_plugin_loader_get_app_str (app)); + return FALSE; + } + + /* don't show unconverted packages in the application view */ + if (!gs_plugin_job_has_refine_flags (helper->plugin_job, + GS_PLUGIN_REFINE_FLAGS_ALLOW_PACKAGES) && + (gs_app_get_kind (app) == AS_APP_KIND_GENERIC)) { + g_debug ("app invalid as only a %s: %s", + as_app_kind_to_string (gs_app_get_kind (app)), + gs_plugin_loader_get_app_str (app)); + return FALSE; + } + + /* don't show apps that do not have the required details */ + if (gs_app_get_name (app) == NULL) { + g_debug ("app invalid as no name %s", + gs_plugin_loader_get_app_str (app)); + return FALSE; + } + if (gs_app_get_summary (app) == NULL) { + g_debug ("app invalid as no summary %s", + gs_plugin_loader_get_app_str (app)); + return FALSE; + } + + /* ignore this crazy application */ + if (g_strcmp0 (gs_app_get_id (app), "gnome-system-monitor-kde.desktop") == 0) { + g_debug ("Ignoring KDE version of %s", gs_app_get_id (app)); + return FALSE; + } + return TRUE; +} + +static gboolean +gs_plugin_loader_app_is_valid_updatable (GsApp *app, gpointer user_data) +{ + return gs_plugin_loader_app_is_valid (app, user_data) && + gs_app_is_updatable (app); +} + +static gboolean +gs_plugin_loader_filter_qt_for_gtk (GsApp *app, gpointer user_data) +{ + /* hide the QT versions in preference to the GTK ones */ + if (g_strcmp0 (gs_app_get_id (app), "transmission-qt.desktop") == 0 || + g_strcmp0 (gs_app_get_id (app), "nntpgrab_qt.desktop") == 0 || + g_strcmp0 (gs_app_get_id (app), "gimagereader-qt4.desktop") == 0 || + g_strcmp0 (gs_app_get_id (app), "gimagereader-qt5.desktop") == 0 || + g_strcmp0 (gs_app_get_id (app), "nntpgrab_server_qt.desktop") == 0 || + g_strcmp0 (gs_app_get_id (app), "hotot-qt.desktop") == 0) { + g_debug ("removing QT version of %s", + gs_plugin_loader_get_app_str (app)); + return FALSE; + } + + /* hide the KDE version in preference to the GTK one */ + if (g_strcmp0 (gs_app_get_id (app), "qalculate_kde.desktop") == 0) { + g_debug ("removing KDE version of %s", + gs_plugin_loader_get_app_str (app)); + return FALSE; + } + + /* hide the KDE version in preference to the Qt one */ + if (g_strcmp0 (gs_app_get_id (app), "kid3.desktop") == 0 || + g_strcmp0 (gs_app_get_id (app), "kchmviewer.desktop") == 0) { + g_debug ("removing KDE version of %s", + gs_plugin_loader_get_app_str (app)); + return FALSE; + } + return TRUE; +} + +static gboolean +gs_plugin_loader_app_is_non_compulsory (GsApp *app, gpointer user_data) +{ + return !gs_app_has_quirk (app, GS_APP_QUIRK_COMPULSORY); +} + +static gboolean +gs_plugin_loader_get_app_is_compatible (GsApp *app, gpointer user_data) +{ + GsPluginLoader *plugin_loader = GS_PLUGIN_LOADER (user_data); + GsPluginLoaderPrivate *priv = gs_plugin_loader_get_instance_private (plugin_loader); + const gchar *tmp; + guint i; + + /* search for any compatible projects */ + tmp = gs_app_get_project_group (app); + if (tmp == NULL) + return TRUE; + for (i = 0; priv->compatible_projects[i] != NULL; i++) { + if (g_strcmp0 (tmp, priv->compatible_projects[i]) == 0) + return TRUE; + } + g_debug ("removing incompatible %s from project group %s", + gs_app_get_id (app), gs_app_get_project_group (app)); + return FALSE; +} + +/******************************************************************************/ + +static gboolean +gs_plugin_loader_featured_debug (GsApp *app, gpointer user_data) +{ + if (g_strcmp0 (gs_app_get_id (app), + g_getenv ("GNOME_SOFTWARE_FEATURED")) == 0) + return TRUE; + return FALSE; +} + +static gint +gs_plugin_loader_app_sort_kind_cb (GsApp *app1, GsApp *app2, gpointer user_data) +{ + if (gs_app_get_kind (app1) == AS_APP_KIND_DESKTOP) + return -1; + if (gs_app_get_kind (app2) == AS_APP_KIND_DESKTOP) + return 1; + return 0; +} + +static gint +gs_plugin_loader_app_sort_match_value_cb (GsApp *app1, GsApp *app2, gpointer user_data) +{ + if (gs_app_get_match_value (app1) > gs_app_get_match_value (app2)) + return -1; + if (gs_app_get_match_value (app1) < gs_app_get_match_value (app2)) + return 1; + return 0; +} + +static gint +gs_plugin_loader_app_sort_prio_cb (GsApp *app1, GsApp *app2, gpointer user_data) +{ + return gs_app_compare_priority (app1, app2); +} + +static gint +gs_plugin_loader_app_sort_version_cb (GsApp *app1, GsApp *app2, gpointer user_data) +{ +#if AS_CHECK_VERSION(0,7,15) + return as_utils_vercmp_full (gs_app_get_version (app1), + gs_app_get_version (app2), + AS_VERSION_COMPARE_FLAG_NONE); +#else + return as_utils_vercmp (gs_app_get_version (app1), + gs_app_get_version (app2)); +#endif +} + +/******************************************************************************/ + +/** + * gs_plugin_loader_job_process_finish: + * @plugin_loader: A #GsPluginLoader + * @res: a #GAsyncResult + * @error: A #GError, or %NULL + * + * Return value: (element-type GsApp) (transfer full): A list of applications + **/ +GsAppList * +gs_plugin_loader_job_process_finish (GsPluginLoader *plugin_loader, + GAsyncResult *res, + GError **error) +{ + GTask *task; + GsAppList *list = NULL; + + g_return_val_if_fail (GS_IS_PLUGIN_LOADER (plugin_loader), NULL); + g_return_val_if_fail (G_IS_TASK (res), NULL); + g_return_val_if_fail (g_task_is_valid (res, plugin_loader), NULL); + g_return_val_if_fail (error == NULL || *error == NULL, NULL); + + task = G_TASK (res); + + /* Return cancelled if the task was cancelled and there is no other error set. + * + * This is needed because we set the task `check_cancellable` to FALSE, + * to be able to catch other errors such as timeout, but that means + * g_task_propagate_pointer() will ignore if the task was cancelled and only + * check if there was an error (i.e. g_task_return_*error*). + * + * We only do this if there is no error already set in the task (e.g. + * timeout) because in that case we want to return the existing error. + */ + if (!g_task_had_error (task)) { + GCancellable *cancellable = g_task_get_cancellable (task); + + if (g_cancellable_set_error_if_cancelled (cancellable, error)) { + gs_utils_error_convert_gio (error); + return NULL; + } + } + list = g_task_propagate_pointer (task, error); + gs_utils_error_convert_gio (error); + return list; +} + +/** + * gs_plugin_loader_job_action_finish: + * @plugin_loader: A #GsPluginLoader + * @res: a #GAsyncResult + * @error: A #GError, or %NULL + * + * Return value: success + **/ +gboolean +gs_plugin_loader_job_action_finish (GsPluginLoader *plugin_loader, + GAsyncResult *res, + GError **error) +{ + g_autoptr(GsAppList) list = NULL; + + g_return_val_if_fail (GS_IS_PLUGIN_LOADER (plugin_loader), FALSE); + g_return_val_if_fail (G_IS_TASK (res), FALSE); + g_return_val_if_fail (g_task_is_valid (res, plugin_loader), FALSE); + g_return_val_if_fail (error == NULL || *error == NULL, FALSE); + + list = g_task_propagate_pointer (G_TASK (res), error); + return list != NULL; +} + +/******************************************************************************/ + +static gint +gs_plugin_loader_category_sort_cb (gconstpointer a, gconstpointer b) +{ + GsCategory *cata = GS_CATEGORY (*(GsCategory **) a); + GsCategory *catb = GS_CATEGORY (*(GsCategory **) b); + if (gs_category_get_score (cata) < gs_category_get_score (catb)) + return 1; + if (gs_category_get_score (cata) > gs_category_get_score (catb)) + return -1; + return gs_utils_sort_strcmp (gs_category_get_name (cata), + gs_category_get_name (catb)); +} + +static void +gs_plugin_loader_fix_category_all (GsCategory *category) +{ + GPtrArray *children; + GsCategory *cat_all; + guint i, j; + + /* set correct size */ + cat_all = gs_category_find_child (category, "all"); + if (cat_all == NULL) + return; + gs_category_set_size (cat_all, gs_category_get_size (category)); + + /* add the desktop groups from all children */ + children = gs_category_get_children (category); + for (i = 0; i < children->len; i++) { + GPtrArray *desktop_groups; + GsCategory *child; + + /* ignore the all category */ + child = g_ptr_array_index (children, i); + if (g_strcmp0 (gs_category_get_id (child), "all") == 0) + continue; + + /* add all desktop groups */ + desktop_groups = gs_category_get_desktop_groups (child); + for (j = 0; j < desktop_groups->len; j++) { + const gchar *tmp = g_ptr_array_index (desktop_groups, j); + gs_category_add_desktop_group (cat_all, tmp); + } + } +} + +static void +gs_plugin_loader_job_get_categories_thread_cb (GTask *task, + gpointer object, + gpointer task_data, + GCancellable *cancellable) +{ + GError *error = NULL; + GsPluginLoaderHelper *helper = (GsPluginLoaderHelper *) task_data; +#ifdef HAVE_SYSPROF + GsPluginLoaderPrivate *priv = gs_plugin_loader_get_instance_private (helper->plugin_loader); + gint64 begin_time_nsec G_GNUC_UNUSED = SYSPROF_CAPTURE_CURRENT_TIME; +#endif + + /* run each plugin */ + if (!gs_plugin_loader_run_results (helper, cancellable, &error)) { + g_task_return_error (task, error); + return; + } + + /* make sure 'All' has the right categories */ + for (guint i = 0; i < helper->catlist->len; i++) { + GsCategory *cat = g_ptr_array_index (helper->catlist, i); + gs_plugin_loader_fix_category_all (cat); + } + + /* sort by name */ + g_ptr_array_sort (helper->catlist, gs_plugin_loader_category_sort_cb); + for (guint i = 0; i < helper->catlist->len; i++) { + GsCategory *cat = GS_CATEGORY (g_ptr_array_index (helper->catlist, i)); + gs_category_sort_children (cat); + } + +#ifdef HAVE_SYSPROF + if (priv->sysprof_writer != NULL) { + g_autofree gchar *sysprof_message = gs_plugin_job_to_string (helper->plugin_job); + sysprof_capture_writer_add_mark (priv->sysprof_writer, + begin_time_nsec, + sched_getcpu (), + getpid (), + SYSPROF_CAPTURE_CURRENT_TIME - begin_time_nsec, + "gnome-software", + "get-categories", + sysprof_message); + } +#endif /* HAVE_SYSPROF */ + + /* show elapsed time */ + gs_plugin_loader_job_debug (helper); + + /* success */ + if (helper->catlist->len == 0) + g_task_return_new_error (task, + GS_PLUGIN_ERROR, + GS_PLUGIN_ERROR_NOT_SUPPORTED, + "no categories to show"); + else + g_task_return_pointer (task, g_ptr_array_ref (helper->catlist), (GDestroyNotify) g_ptr_array_unref); +} + +/** + * gs_plugin_loader_job_get_categories_async: + * @plugin_loader: A #GsPluginLoader + * @plugin_job: job to process + * @cancellable: a #GCancellable, or %NULL + * @callback: function to call when complete + * @user_data: user data to pass to @callback + * + * This method calls all plugins that implement the gs_plugin_add_categories() + * function. The plugins return #GsCategory objects. + **/ +void +gs_plugin_loader_job_get_categories_async (GsPluginLoader *plugin_loader, + GsPluginJob *plugin_job, + GCancellable *cancellable, + GAsyncReadyCallback callback, + gpointer user_data) +{ + GsPluginLoaderHelper *helper; + g_autoptr(GTask) task = NULL; + + g_return_if_fail (GS_IS_PLUGIN_LOADER (plugin_loader)); + g_return_if_fail (GS_IS_PLUGIN_JOB (plugin_job)); + g_return_if_fail (cancellable == NULL || G_IS_CANCELLABLE (cancellable)); + + /* save helper */ + helper = gs_plugin_loader_helper_new (plugin_loader, plugin_job); + helper->catlist = g_ptr_array_new_with_free_func ((GDestroyNotify) g_object_unref); + + /* run in a thread */ + task = g_task_new (plugin_loader, cancellable, callback, user_data); + g_task_set_source_tag (task, gs_plugin_loader_job_get_categories_async); + g_task_set_task_data (task, helper, (GDestroyNotify) gs_plugin_loader_helper_free); + g_task_run_in_thread (task, gs_plugin_loader_job_get_categories_thread_cb); +} + +/** + * gs_plugin_loader_job_get_categories_finish: + * @plugin_loader: A #GsPluginLoader + * @res: a #GAsyncResult + * @error: A #GError, or %NULL + * + * Return value: (element-type GsCategory) (transfer full): A list of applications + **/ +GPtrArray * +gs_plugin_loader_job_get_categories_finish (GsPluginLoader *plugin_loader, + GAsyncResult *res, + GError **error) +{ + GPtrArray *array; + + g_return_val_if_fail (GS_IS_PLUGIN_LOADER (plugin_loader), NULL); + g_return_val_if_fail (G_IS_TASK (res), NULL); + g_return_val_if_fail (g_task_is_valid (res, plugin_loader), NULL); + g_return_val_if_fail (error == NULL || *error == NULL, NULL); + + array = g_task_propagate_pointer (G_TASK (res), error); + gs_utils_error_convert_gio (error); + return array; +} + +/******************************************************************************/ + +static gboolean +emit_pending_apps_idle (gpointer loader) +{ + g_signal_emit (loader, signals[SIGNAL_PENDING_APPS_CHANGED], 0); + g_object_unref (loader); + + return G_SOURCE_REMOVE; +} + +static void +gs_plugin_loader_pending_apps_add (GsPluginLoader *plugin_loader, + GsPluginLoaderHelper *helper) +{ + GsAppList *list = gs_plugin_job_get_list (helper->plugin_job); + GsPluginLoaderPrivate *priv = gs_plugin_loader_get_instance_private (plugin_loader); + g_autoptr(GMutexLocker) locker = g_mutex_locker_new (&priv->pending_apps_mutex); + + g_assert (gs_app_list_length (list) > 0); + for (guint i = 0; i < gs_app_list_length (list); i++) { + GsApp *app = gs_app_list_index (list, i); + g_ptr_array_add (priv->pending_apps, g_object_ref (app)); + /* make sure the progress is properly initialized */ + gs_app_set_progress (app, GS_APP_PROGRESS_UNKNOWN); + } + g_idle_add (emit_pending_apps_idle, g_object_ref (plugin_loader)); +} + +static void +gs_plugin_loader_pending_apps_remove (GsPluginLoader *plugin_loader, + GsPluginLoaderHelper *helper) +{ + GsAppList *list = gs_plugin_job_get_list (helper->plugin_job); + GsPluginLoaderPrivate *priv = gs_plugin_loader_get_instance_private (plugin_loader); + g_autoptr(GMutexLocker) locker = g_mutex_locker_new (&priv->pending_apps_mutex); + + g_assert (gs_app_list_length (list) > 0); + for (guint i = 0; i < gs_app_list_length (list); i++) { + GsApp *app = gs_app_list_index (list, i); + g_ptr_array_remove (priv->pending_apps, app); + + /* check the app is not still in an action helper */ + switch (gs_app_get_state (app)) { + case AS_APP_STATE_INSTALLING: + case AS_APP_STATE_REMOVING: + g_warning ("application %s left in %s helper", + gs_app_get_unique_id (app), + as_app_state_to_string (gs_app_get_state (app))); + gs_app_set_state (app, AS_APP_STATE_UNKNOWN); + break; + default: + break; + } + + } + g_idle_add (emit_pending_apps_idle, g_object_ref (plugin_loader)); +} + +static gboolean +load_install_queue (GsPluginLoader *plugin_loader, GError **error) +{ + GsPluginLoaderPrivate *priv = gs_plugin_loader_get_instance_private (plugin_loader); + g_autofree gchar *contents = NULL; + g_autofree gchar *file = NULL; + g_auto(GStrv) names = NULL; + g_autoptr(GsAppList) list = NULL; + + /* load from file */ + file = g_build_filename (g_get_user_data_dir (), + "gnome-software", + "install-queue", + NULL); + if (!g_file_test (file, G_FILE_TEST_EXISTS)) + return TRUE; + g_debug ("loading install queue from %s", file); + if (!g_file_get_contents (file, &contents, NULL, error)) + return FALSE; + + /* add to GsAppList, deduplicating if required */ + list = gs_app_list_new (); + names = g_strsplit (contents, "\n", 0); + for (guint i = 0; names[i] != NULL; i++) { + g_autoptr(GsApp) app = NULL; + if (strlen (names[i]) == 0) + continue; + app = gs_app_new (names[i]); + gs_app_set_state (app, AS_APP_STATE_QUEUED_FOR_INSTALL); + gs_app_list_add (list, app); + } + + /* add to pending list */ + g_mutex_lock (&priv->pending_apps_mutex); + for (guint i = 0; i < gs_app_list_length (list); i++) { + GsApp *app = gs_app_list_index (list, i); + g_debug ("adding pending app %s", gs_app_get_unique_id (app)); + g_ptr_array_add (priv->pending_apps, g_object_ref (app)); + } + g_mutex_unlock (&priv->pending_apps_mutex); + + /* refine */ + if (gs_app_list_length (list) > 0) { + g_autoptr(GsPluginLoaderHelper) helper = NULL; + g_autoptr(GsPluginJob) plugin_job = NULL; + plugin_job = gs_plugin_job_newv (GS_PLUGIN_ACTION_REFINE, NULL); + helper = gs_plugin_loader_helper_new (plugin_loader, plugin_job); + if (!gs_plugin_loader_run_refine (helper, list, NULL, error)) + return FALSE; + } + return TRUE; +} + +static void +save_install_queue (GsPluginLoader *plugin_loader) +{ + GsPluginLoaderPrivate *priv = gs_plugin_loader_get_instance_private (plugin_loader); + GPtrArray *pending_apps; + gboolean ret; + gint i; + g_autoptr(GError) error = NULL; + g_autoptr(GString) s = NULL; + g_autofree gchar *file = NULL; + + s = g_string_new (""); + pending_apps = priv->pending_apps; + g_mutex_lock (&priv->pending_apps_mutex); + for (i = (gint) pending_apps->len - 1; i >= 0; i--) { + GsApp *app; + app = g_ptr_array_index (pending_apps, i); + if (gs_app_get_state (app) == AS_APP_STATE_QUEUED_FOR_INSTALL) { + g_string_append (s, gs_app_get_id (app)); + g_string_append_c (s, '\n'); + } + } + g_mutex_unlock (&priv->pending_apps_mutex); + + /* save file */ + file = g_build_filename (g_get_user_data_dir (), + "gnome-software", + "install-queue", + NULL); + if (!gs_mkdir_parent (file, &error)) { + g_warning ("failed to create dir for %s: %s", + file, error->message); + return; + } + g_debug ("saving install queue to %s", file); + ret = g_file_set_contents (file, s->str, (gssize) s->len, &error); + if (!ret) + g_warning ("failed to save install queue: %s", error->message); +} + +static void +add_app_to_install_queue (GsPluginLoader *plugin_loader, GsApp *app) +{ + GsPluginLoaderPrivate *priv = gs_plugin_loader_get_instance_private (plugin_loader); + GsAppList *addons; + guint i; + guint id; + + /* queue the app itself */ + g_mutex_lock (&priv->pending_apps_mutex); + g_ptr_array_add (priv->pending_apps, g_object_ref (app)); + g_mutex_unlock (&priv->pending_apps_mutex); + + gs_app_set_state (app, AS_APP_STATE_QUEUED_FOR_INSTALL); + id = g_idle_add (emit_pending_apps_idle, g_object_ref (plugin_loader)); + g_source_set_name_by_id (id, "[gnome-software] emit_pending_apps_idle"); + save_install_queue (plugin_loader); + + /* recursively queue any addons */ + addons = gs_app_get_addons (app); + for (i = 0; i < gs_app_list_length (addons); i++) { + GsApp *addon = gs_app_list_index (addons, i); + if (gs_app_get_to_be_installed (addon)) + add_app_to_install_queue (plugin_loader, addon); + } +} + +static gboolean +remove_app_from_install_queue (GsPluginLoader *plugin_loader, GsApp *app) +{ + GsPluginLoaderPrivate *priv = gs_plugin_loader_get_instance_private (plugin_loader); + GsAppList *addons; + gboolean ret; + guint i; + guint id; + + g_mutex_lock (&priv->pending_apps_mutex); + ret = g_ptr_array_remove (priv->pending_apps, app); + g_mutex_unlock (&priv->pending_apps_mutex); + + if (ret) { + gs_app_set_state (app, AS_APP_STATE_AVAILABLE); + id = g_idle_add (emit_pending_apps_idle, g_object_ref (plugin_loader)); + g_source_set_name_by_id (id, "[gnome-software] emit_pending_apps_idle"); + save_install_queue (plugin_loader); + + /* recursively remove any queued addons */ + addons = gs_app_get_addons (app); + for (i = 0; i < gs_app_list_length (addons); i++) { + GsApp *addon = gs_app_list_index (addons, i); + remove_app_from_install_queue (plugin_loader, addon); + } + } + + return ret; +} + +/******************************************************************************/ + +gboolean +gs_plugin_loader_get_allow_updates (GsPluginLoader *plugin_loader) +{ + GsPluginLoaderPrivate *priv = gs_plugin_loader_get_instance_private (plugin_loader); + GHashTableIter iter; + gpointer value; + + /* nothing */ + if (g_hash_table_size (priv->disallow_updates) == 0) + return TRUE; + + /* list */ + g_hash_table_iter_init (&iter, priv->disallow_updates); + while (g_hash_table_iter_next (&iter, NULL, &value)) { + const gchar *reason = value; + g_debug ("managed updates inhibited by %s", reason); + } + return FALSE; +} + +GsAppList * +gs_plugin_loader_get_pending (GsPluginLoader *plugin_loader) +{ + GsPluginLoaderPrivate *priv = gs_plugin_loader_get_instance_private (plugin_loader); + GsAppList *array; + guint i; + + array = gs_app_list_new (); + g_mutex_lock (&priv->pending_apps_mutex); + for (i = 0; i < priv->pending_apps->len; i++) { + GsApp *app = g_ptr_array_index (priv->pending_apps, i); + gs_app_list_add (array, app); + } + g_mutex_unlock (&priv->pending_apps_mutex); + + return array; +} + +gboolean +gs_plugin_loader_get_enabled (GsPluginLoader *plugin_loader, + const gchar *plugin_name) +{ + GsPlugin *plugin; + plugin = gs_plugin_loader_find_plugin (plugin_loader, plugin_name); + if (plugin == NULL) + return FALSE; + return gs_plugin_get_enabled (plugin); +} + +/** + * gs_plugin_loader_get_events: + * @plugin_loader: A #GsPluginLoader + * + * Gets all plugin events, even ones that are not active or visible anymore. + * + * Returns: (transfer container) (element-type GsPluginEvent): events + **/ +GPtrArray * +gs_plugin_loader_get_events (GsPluginLoader *plugin_loader) +{ + GsPluginLoaderPrivate *priv = gs_plugin_loader_get_instance_private (plugin_loader); + GPtrArray *events = g_ptr_array_new_with_free_func ((GDestroyNotify) g_object_unref); + g_autoptr(GMutexLocker) locker = g_mutex_locker_new (&priv->events_by_id_mutex); + GHashTableIter iter; + gpointer key, value; + + /* just add everything */ + g_hash_table_iter_init (&iter, priv->events_by_id); + while (g_hash_table_iter_next (&iter, &key, &value)) { + const gchar *id = key; + GsPluginEvent *event = value; + if (event == NULL) { + g_warning ("failed to get event for '%s'", id); + continue; + } + g_ptr_array_add (events, g_object_ref (event)); + } + return events; +} + +/** + * gs_plugin_loader_get_event_default: + * @plugin_loader: A #GsPluginLoader + * + * Gets an active plugin event where active means that it was not been + * already dismissed by the user. + * + * Returns: (transfer full): a #GsPluginEvent, or %NULL for none + **/ +GsPluginEvent * +gs_plugin_loader_get_event_default (GsPluginLoader *plugin_loader) +{ + GsPluginLoaderPrivate *priv = gs_plugin_loader_get_instance_private (plugin_loader); + g_autoptr(GMutexLocker) locker = g_mutex_locker_new (&priv->events_by_id_mutex); + GHashTableIter iter; + gpointer key, value; + + /* just add everything */ + g_hash_table_iter_init (&iter, priv->events_by_id); + while (g_hash_table_iter_next (&iter, &key, &value)) { + const gchar *id = key; + GsPluginEvent *event = value; + if (event == NULL) { + g_warning ("failed to get event for '%s'", id); + continue; + } + if (!gs_plugin_event_has_flag (event, GS_PLUGIN_EVENT_FLAG_INVALID)) + return g_object_ref (event); + } + return NULL; +} + +/** + * gs_plugin_loader_remove_events: + * @plugin_loader: A #GsPluginLoader + * + * Removes all plugin events from the loader. This function should only be + * called from the self tests. + **/ +void +gs_plugin_loader_remove_events (GsPluginLoader *plugin_loader) +{ + GsPluginLoaderPrivate *priv = gs_plugin_loader_get_instance_private (plugin_loader); + g_autoptr(GMutexLocker) locker = g_mutex_locker_new (&priv->events_by_id_mutex); + g_hash_table_remove_all (priv->events_by_id); +} + +static void +gs_plugin_loader_report_event_cb (GsPlugin *plugin, + GsPluginEvent *event, + GsPluginLoader *plugin_loader) +{ + if (gs_plugin_has_flags (plugin, GS_PLUGIN_FLAGS_INTERACTIVE)) + gs_plugin_event_add_flag (event, GS_PLUGIN_EVENT_FLAG_INTERACTIVE); + gs_plugin_loader_add_event (plugin_loader, event); +} + +static void +gs_plugin_loader_allow_updates_cb (GsPlugin *plugin, + gboolean allow_updates, + GsPluginLoader *plugin_loader) +{ + GsPluginLoaderPrivate *priv = gs_plugin_loader_get_instance_private (plugin_loader); + gboolean changed = FALSE; + + /* plugin now allowing gnome-software to show updates panel */ + if (allow_updates) { + if (g_hash_table_remove (priv->disallow_updates, plugin)) { + g_debug ("plugin %s no longer inhibited managed updates", + gs_plugin_get_name (plugin)); + changed = TRUE; + } + + /* plugin preventing the updates panel from being shown */ + } else { + if (g_hash_table_replace (priv->disallow_updates, + (gpointer) plugin, + (gpointer) gs_plugin_get_name (plugin))) { + g_debug ("plugin %s inhibited managed updates", + gs_plugin_get_name (plugin)); + changed = TRUE; + } + } + + /* notify display layer */ + if (changed) + g_object_notify (G_OBJECT (plugin_loader), "allow-updates"); +} + +static void +gs_plugin_loader_status_changed_cb (GsPlugin *plugin, + GsApp *app, + GsPluginStatus status, + GsPluginLoader *plugin_loader) +{ + GsPluginLoaderPrivate *priv = gs_plugin_loader_get_instance_private (plugin_loader); + + /* nothing specific */ + if (app == NULL || gs_app_get_id (app) == NULL) { + if (priv->global_status_last != status) { + g_debug ("emitting global %s", + gs_plugin_status_to_string (status)); + g_signal_emit (plugin_loader, + signals[SIGNAL_STATUS_CHANGED], + 0, app, status); + priv->global_status_last = status; + } + return; + } + + /* a specific app */ + g_debug ("emitting %s(%s)", + gs_plugin_status_to_string (status), + gs_app_get_id (app)); + g_signal_emit (plugin_loader, + signals[SIGNAL_STATUS_CHANGED], + 0, app, status); +} + +static void +gs_plugin_loader_basic_auth_start_cb (GsPlugin *plugin, + const gchar *remote, + const gchar *realm, + GCallback callback, + gpointer user_data, + GsPluginLoader *plugin_loader) +{ + g_debug ("emitting basic-auth-start %s", realm); + g_signal_emit (plugin_loader, + signals[SIGNAL_BASIC_AUTH_START], 0, + remote, + realm, + callback, + user_data); +} + +static gboolean +gs_plugin_loader_job_actions_changed_delay_cb (gpointer user_data) +{ + GsPluginLoader *plugin_loader = GS_PLUGIN_LOADER (user_data); + GsPluginLoaderPrivate *priv = gs_plugin_loader_get_instance_private (plugin_loader); + + /* notify shells */ + g_debug ("updates-changed"); + g_signal_emit (plugin_loader, signals[SIGNAL_UPDATES_CHANGED], 0); + priv->updates_changed_id = 0; + priv->updates_changed_cnt = 0; + + g_object_unref (plugin_loader); + return FALSE; +} + +static void +gs_plugin_loader_job_actions_changed_cb (GsPlugin *plugin, GsPluginLoader *plugin_loader) +{ + GsPluginLoaderPrivate *priv = gs_plugin_loader_get_instance_private (plugin_loader); + priv->updates_changed_cnt++; +} + +static void +gs_plugin_loader_updates_changed (GsPluginLoader *plugin_loader) +{ + GsPluginLoaderPrivate *priv = gs_plugin_loader_get_instance_private (plugin_loader); + if (priv->updates_changed_id != 0) + return; + priv->updates_changed_id = + g_timeout_add_seconds (GS_PLUGIN_LOADER_UPDATES_CHANGED_DELAY, + gs_plugin_loader_job_actions_changed_delay_cb, + g_object_ref (plugin_loader)); +} + +static gboolean +gs_plugin_loader_reload_delay_cb (gpointer user_data) +{ + GsPluginLoader *plugin_loader = GS_PLUGIN_LOADER (user_data); + GsPluginLoaderPrivate *priv = gs_plugin_loader_get_instance_private (plugin_loader); + + /* notify shells */ + g_debug ("emitting ::reload"); + g_signal_emit (plugin_loader, signals[SIGNAL_RELOAD], 0); + priv->reload_id = 0; + + g_object_unref (plugin_loader); + return FALSE; +} + +static void +gs_plugin_loader_reload_cb (GsPlugin *plugin, + GsPluginLoader *plugin_loader) +{ + GsPluginLoaderPrivate *priv = gs_plugin_loader_get_instance_private (plugin_loader); + if (priv->reload_id != 0) + return; + priv->reload_id = + g_timeout_add_seconds (GS_PLUGIN_LOADER_RELOAD_DELAY, + gs_plugin_loader_reload_delay_cb, + g_object_ref (plugin_loader)); +} + +static void +gs_plugin_loader_open_plugin (GsPluginLoader *plugin_loader, + const gchar *filename) +{ + GsPluginLoaderPrivate *priv = gs_plugin_loader_get_instance_private (plugin_loader); + GsPlugin *plugin; + g_autoptr(GError) error = NULL; + + /* create plugin from file */ + plugin = gs_plugin_create (filename, &error); + if (plugin == NULL) { + g_warning ("Failed to load %s: %s", filename, error->message); + return; + } + g_signal_connect (plugin, "updates-changed", + G_CALLBACK (gs_plugin_loader_job_actions_changed_cb), + plugin_loader); + g_signal_connect (plugin, "reload", + G_CALLBACK (gs_plugin_loader_reload_cb), + plugin_loader); + g_signal_connect (plugin, "status-changed", + G_CALLBACK (gs_plugin_loader_status_changed_cb), + plugin_loader); + g_signal_connect (plugin, "basic-auth-start", + G_CALLBACK (gs_plugin_loader_basic_auth_start_cb), + plugin_loader); + g_signal_connect (plugin, "report-event", + G_CALLBACK (gs_plugin_loader_report_event_cb), + plugin_loader); + g_signal_connect (plugin, "allow-updates", + G_CALLBACK (gs_plugin_loader_allow_updates_cb), + plugin_loader); + gs_plugin_set_soup_session (plugin, priv->soup_session); + gs_plugin_set_locale (plugin, priv->locale); + gs_plugin_set_language (plugin, priv->language); + gs_plugin_set_scale (plugin, gs_plugin_loader_get_scale (plugin_loader)); + gs_plugin_set_network_monitor (plugin, priv->network_monitor); + g_debug ("opened plugin %s: %s", filename, gs_plugin_get_name (plugin)); + + /* add to array */ + g_ptr_array_add (priv->plugins, plugin); +} + +void +gs_plugin_loader_set_scale (GsPluginLoader *plugin_loader, guint scale) +{ + GsPluginLoaderPrivate *priv = gs_plugin_loader_get_instance_private (plugin_loader); + + /* save globally, and update each plugin */ + priv->scale = scale; + for (guint i = 0; i < priv->plugins->len; i++) { + GsPlugin *plugin = g_ptr_array_index (priv->plugins, i); + gs_plugin_set_scale (plugin, scale); + } +} + +guint +gs_plugin_loader_get_scale (GsPluginLoader *plugin_loader) +{ + GsPluginLoaderPrivate *priv = gs_plugin_loader_get_instance_private (plugin_loader); + return priv->scale; +} + +void +gs_plugin_loader_add_location (GsPluginLoader *plugin_loader, const gchar *location) +{ + GsPluginLoaderPrivate *priv = gs_plugin_loader_get_instance_private (plugin_loader); + for (guint i = 0; i < priv->locations->len; i++) { + const gchar *location_tmp = g_ptr_array_index (priv->locations, i); + if (g_strcmp0 (location_tmp, location) == 0) + return; + } + g_info ("adding plugin location %s", location); + g_ptr_array_add (priv->locations, g_strdup (location)); +} + +static gint +gs_plugin_loader_plugin_sort_fn (gconstpointer a, gconstpointer b) +{ + GsPlugin *pa = *((GsPlugin **) a); + GsPlugin *pb = *((GsPlugin **) b); + if (gs_plugin_get_order (pa) < gs_plugin_get_order (pb)) + return -1; + if (gs_plugin_get_order (pa) > gs_plugin_get_order (pb)) + return 1; + return g_strcmp0 (gs_plugin_get_name (pa), gs_plugin_get_name (pb)); +} + +static void +gs_plugin_loader_plugin_dir_changed_cb (GFileMonitor *monitor, + GFile *file, + GFile *other_file, + GFileMonitorEvent event_type, + GsPluginLoader *plugin_loader) +{ + GsPluginLoaderPrivate *priv = gs_plugin_loader_get_instance_private (plugin_loader); + g_autoptr(GsApp) app = NULL; + g_autoptr(GsPluginEvent) event = gs_plugin_event_new (); + g_autoptr(GError) error = NULL; + + /* already triggered */ + if (priv->plugin_dir_dirty) + return; + + /* add app */ + gs_plugin_event_set_action (event, GS_PLUGIN_ACTION_SETUP); + app = gs_plugin_loader_app_create (plugin_loader, + "system/*/*/*/org.gnome.Software.desktop/*"); + if (app != NULL) + gs_plugin_event_set_app (event, app); + + /* add error */ + g_set_error_literal (&error, + GS_PLUGIN_ERROR, + GS_PLUGIN_ERROR_RESTART_REQUIRED, + "A restart is required"); + gs_plugin_event_set_error (event, error); + gs_plugin_loader_add_event (plugin_loader, event); + priv->plugin_dir_dirty = TRUE; +} + +void +gs_plugin_loader_clear_caches (GsPluginLoader *plugin_loader) +{ + GsPluginLoaderPrivate *priv = gs_plugin_loader_get_instance_private (plugin_loader); + for (guint i = 0; i < priv->plugins->len; i++) { + GsPlugin *plugin = g_ptr_array_index (priv->plugins, i); + gs_plugin_cache_invalidate (plugin); + } +} + +/** + * gs_plugin_loader_setup_again: + * @plugin_loader: a #GsPluginLoader + * + * Calls setup on each plugin. This should only be used from the self tests + * and in a controlled way. + */ +void +gs_plugin_loader_setup_again (GsPluginLoader *plugin_loader) +{ + GsPluginLoaderPrivate *priv = gs_plugin_loader_get_instance_private (plugin_loader); + GsPluginAction actions[] = { + GS_PLUGIN_ACTION_DESTROY, + GS_PLUGIN_ACTION_INITIALIZE, + GS_PLUGIN_ACTION_SETUP, + GS_PLUGIN_ACTION_UNKNOWN }; +#ifdef HAVE_SYSPROF + gint64 begin_time_nsec G_GNUC_UNUSED = SYSPROF_CAPTURE_CURRENT_TIME; +#endif + + /* clear global cache */ + gs_plugin_loader_clear_caches (plugin_loader); + + /* remove any events */ + gs_plugin_loader_remove_events (plugin_loader); + + /* call in order */ + for (guint j = 0; actions[j] != GS_PLUGIN_ACTION_UNKNOWN; j++) { + for (guint i = 0; i < priv->plugins->len; i++) { + g_autoptr(GError) error_local = NULL; + g_autoptr(GsPluginLoaderHelper) helper = NULL; + g_autoptr(GsPluginJob) plugin_job = NULL; + GsPlugin *plugin = g_ptr_array_index (priv->plugins, i); + if (!gs_plugin_get_enabled (plugin)) + continue; + + plugin_job = gs_plugin_job_newv (actions[j], NULL); + helper = gs_plugin_loader_helper_new (plugin_loader, plugin_job); + if (!gs_plugin_loader_call_vfunc (helper, plugin, NULL, NULL, + GS_PLUGIN_REFINE_FLAGS_DEFAULT, + NULL, &error_local)) { + g_warning ("resetup of %s failed: %s", + gs_plugin_get_name (plugin), + error_local->message); + break; + } + if (actions[j] == GS_PLUGIN_ACTION_DESTROY) + gs_plugin_clear_data (plugin); + } + } + +#ifdef HAVE_SYSPROF + if (priv->sysprof_writer != NULL) { + sysprof_capture_writer_add_mark (priv->sysprof_writer, + begin_time_nsec, + sched_getcpu (), + getpid (), + SYSPROF_CAPTURE_CURRENT_TIME - begin_time_nsec, + "gnome-software", + "setup-again", + NULL); + } +#endif /* HAVE_SYSPROF */ +} + +static gint +gs_plugin_loader_path_sort_fn (gconstpointer a, gconstpointer b) +{ + const gchar *sa = *((const gchar **) a); + const gchar *sb = *((const gchar **) b); + return g_strcmp0 (sa, sb); +} + +static GPtrArray * +gs_plugin_loader_find_plugins (const gchar *path, GError **error) +{ + const gchar *fn_tmp; + g_autoptr(GPtrArray) fns = g_ptr_array_new_with_free_func (g_free); + g_autoptr(GDir) dir = g_dir_open (path, 0, error); + if (dir == NULL) + return NULL; + while ((fn_tmp = g_dir_read_name (dir)) != NULL) { + if (!g_str_has_suffix (fn_tmp, ".so")) + continue; + g_ptr_array_add (fns, g_build_filename (path, fn_tmp, NULL)); + } + g_ptr_array_sort (fns, gs_plugin_loader_path_sort_fn); + return g_steal_pointer (&fns); +} + +/** + * gs_plugin_loader_setup: + * @plugin_loader: a #GsPluginLoader + * @allowlist: list of plugin names, or %NULL + * @blocklist: list of plugin names, or %NULL + * @cancellable: A #GCancellable, or %NULL + * @error: A #GError, or %NULL + * + * Sets up the plugin loader ready for use. + * + * Returns: %TRUE for success + */ +gboolean +gs_plugin_loader_setup (GsPluginLoader *plugin_loader, + gchar **allowlist, + gchar **blocklist, + GCancellable *cancellable, + GError **error) +{ + GsPluginLoaderPrivate *priv = gs_plugin_loader_get_instance_private (plugin_loader); + const gchar *plugin_name; + gboolean changes; + GPtrArray *deps; + GsPlugin *dep; + GsPlugin *plugin; + guint dep_loop_check = 0; + guint i; + guint j; + g_autoptr(GsPluginLoaderHelper) helper = NULL; + g_autoptr(GsPluginJob) plugin_job = NULL; +#ifdef HAVE_SYSPROF + gint64 begin_time_nsec G_GNUC_UNUSED = SYSPROF_CAPTURE_CURRENT_TIME; +#endif + + /* use the default, but this requires a 'make install' */ + if (priv->locations->len == 0) { + g_autofree gchar *filename = NULL; + filename = g_strdup_printf ("gs-plugins-%s", GS_PLUGIN_API_VERSION); + g_ptr_array_add (priv->locations, g_build_filename (LIBDIR, filename, NULL)); + } + + for (i = 0; i < priv->locations->len; i++) { + GFileMonitor *monitor; + const gchar *location = g_ptr_array_index (priv->locations, i); + g_autoptr(GFile) plugin_dir = g_file_new_for_path (location); + monitor = g_file_monitor_directory (plugin_dir, + G_FILE_MONITOR_NONE, + cancellable, + error); + if (monitor == NULL) + return FALSE; + g_signal_connect (monitor, "changed", + G_CALLBACK (gs_plugin_loader_plugin_dir_changed_cb), plugin_loader); + g_ptr_array_add (priv->file_monitors, monitor); + } + + /* search for plugins */ + for (i = 0; i < priv->locations->len; i++) { + const gchar *location = g_ptr_array_index (priv->locations, i); + g_autoptr(GPtrArray) fns = NULL; + + /* search in the plugin directory for plugins */ + g_debug ("searching for plugins in %s", location); + fns = gs_plugin_loader_find_plugins (location, error); + if (fns == NULL) + return FALSE; + for (j = 0; j < fns->len; j++) { + const gchar *fn = g_ptr_array_index (fns, j); + gs_plugin_loader_open_plugin (plugin_loader, fn); + } + } + + /* optional allowlist */ + if (allowlist != NULL) { + for (i = 0; i < priv->plugins->len; i++) { + gboolean ret; + plugin = g_ptr_array_index (priv->plugins, i); + if (!gs_plugin_get_enabled (plugin)) + continue; + ret = g_strv_contains ((const gchar * const *) allowlist, + gs_plugin_get_name (plugin)); + if (!ret) { + g_debug ("%s not in allowlist, disabling", + gs_plugin_get_name (plugin)); + } + gs_plugin_set_enabled (plugin, ret); + } + } + + /* optional blocklist */ + if (blocklist != NULL) { + for (i = 0; i < priv->plugins->len; i++) { + gboolean ret; + plugin = g_ptr_array_index (priv->plugins, i); + if (!gs_plugin_get_enabled (plugin)) + continue; + ret = g_strv_contains ((const gchar * const *) blocklist, + gs_plugin_get_name (plugin)); + if (ret) + gs_plugin_set_enabled (plugin, FALSE); + } + } + + /* run the plugins */ + plugin_job = gs_plugin_job_newv (GS_PLUGIN_ACTION_INITIALIZE, NULL); + helper = gs_plugin_loader_helper_new (plugin_loader, plugin_job); + if (!gs_plugin_loader_run_results (helper, cancellable, error)) + return FALSE; + + /* order by deps */ + do { + changes = FALSE; + for (i = 0; i < priv->plugins->len; i++) { + plugin = g_ptr_array_index (priv->plugins, i); + deps = gs_plugin_get_rules (plugin, GS_PLUGIN_RULE_RUN_AFTER); + for (j = 0; j < deps->len && !changes; j++) { + plugin_name = g_ptr_array_index (deps, j); + dep = gs_plugin_loader_find_plugin (plugin_loader, + plugin_name); + if (dep == NULL) { + g_debug ("cannot find plugin '%s' " + "requested by '%s'", + plugin_name, + gs_plugin_get_name (plugin)); + continue; + } + if (!gs_plugin_get_enabled (dep)) + continue; + if (gs_plugin_get_order (plugin) <= gs_plugin_get_order (dep)) { + gs_plugin_set_order (plugin, gs_plugin_get_order (dep) + 1); + changes = TRUE; + } + } + } + for (i = 0; i < priv->plugins->len; i++) { + plugin = g_ptr_array_index (priv->plugins, i); + deps = gs_plugin_get_rules (plugin, GS_PLUGIN_RULE_RUN_BEFORE); + for (j = 0; j < deps->len && !changes; j++) { + plugin_name = g_ptr_array_index (deps, j); + dep = gs_plugin_loader_find_plugin (plugin_loader, + plugin_name); + if (dep == NULL) { + g_debug ("cannot find plugin '%s' " + "requested by '%s'", + plugin_name, + gs_plugin_get_name (plugin)); + continue; + } + if (!gs_plugin_get_enabled (dep)) + continue; + if (gs_plugin_get_order (plugin) >= gs_plugin_get_order (dep)) { + gs_plugin_set_order (dep, gs_plugin_get_order (plugin) + 1); + changes = TRUE; + } + } + } + + /* check we're not stuck */ + if (dep_loop_check++ > 100) { + g_set_error (error, + GS_PLUGIN_ERROR, + GS_PLUGIN_ERROR_PLUGIN_DEPSOLVE_FAILED, + "got stuck in dep loop"); + return FALSE; + } + } while (changes); + + /* check for conflicts */ + for (i = 0; i < priv->plugins->len; i++) { + plugin = g_ptr_array_index (priv->plugins, i); + if (!gs_plugin_get_enabled (plugin)) + continue; + deps = gs_plugin_get_rules (plugin, GS_PLUGIN_RULE_CONFLICTS); + for (j = 0; j < deps->len && !changes; j++) { + plugin_name = g_ptr_array_index (deps, j); + dep = gs_plugin_loader_find_plugin (plugin_loader, + plugin_name); + if (dep == NULL) + continue; + if (!gs_plugin_get_enabled (dep)) + continue; + g_debug ("disabling %s as conflicts with %s", + gs_plugin_get_name (dep), + gs_plugin_get_name (plugin)); + gs_plugin_set_enabled (dep, FALSE); + } + } + + /* sort by order */ + g_ptr_array_sort (priv->plugins, + gs_plugin_loader_plugin_sort_fn); + + /* assign priority values */ + do { + changes = FALSE; + for (i = 0; i < priv->plugins->len; i++) { + plugin = g_ptr_array_index (priv->plugins, i); + deps = gs_plugin_get_rules (plugin, GS_PLUGIN_RULE_BETTER_THAN); + for (j = 0; j < deps->len && !changes; j++) { + plugin_name = g_ptr_array_index (deps, j); + dep = gs_plugin_loader_find_plugin (plugin_loader, + plugin_name); + if (dep == NULL) { + g_debug ("cannot find plugin '%s' " + "requested by '%s'", + plugin_name, + gs_plugin_get_name (plugin)); + continue; + } + if (!gs_plugin_get_enabled (dep)) + continue; + if (gs_plugin_get_priority (plugin) <= gs_plugin_get_priority (dep)) { + gs_plugin_set_priority (plugin, gs_plugin_get_priority (dep) + 1); + changes = TRUE; + } + } + } + + /* check we're not stuck */ + if (dep_loop_check++ > 100) { + g_set_error (error, + GS_PLUGIN_ERROR, + GS_PLUGIN_ERROR_PLUGIN_DEPSOLVE_FAILED, + "got stuck in priority loop"); + return FALSE; + } + } while (changes); + + /* run setup */ + gs_plugin_job_set_action (helper->plugin_job, GS_PLUGIN_ACTION_SETUP); + helper->function_name = "gs_plugin_setup"; + for (i = 0; i < priv->plugins->len; i++) { + g_autoptr(GError) error_local = NULL; + plugin = g_ptr_array_index (priv->plugins, i); + if (!gs_plugin_loader_call_vfunc (helper, plugin, NULL, NULL, + GS_PLUGIN_REFINE_FLAGS_DEFAULT, + cancellable, &error_local)) { + g_debug ("disabling %s as setup failed: %s", + gs_plugin_get_name (plugin), + error_local->message); + gs_plugin_set_enabled (plugin, FALSE); + } + } + + /* now we can load the install-queue */ + if (!load_install_queue (plugin_loader, error)) + return FALSE; + +#ifdef HAVE_SYSPROF + if (priv->sysprof_writer != NULL) { + sysprof_capture_writer_add_mark (priv->sysprof_writer, + begin_time_nsec, + sched_getcpu (), + getpid (), + SYSPROF_CAPTURE_CURRENT_TIME - begin_time_nsec, + "gnome-software", + "setup", + NULL); + } +#endif /* HAVE_SYSPROF */ + + return TRUE; +} + +void +gs_plugin_loader_dump_state (GsPluginLoader *plugin_loader) +{ + GsPluginLoaderPrivate *priv = gs_plugin_loader_get_instance_private (plugin_loader); + g_autoptr(GString) str_enabled = g_string_new (NULL); + g_autoptr(GString) str_disabled = g_string_new (NULL); + + /* print what the priorities are if verbose */ + for (guint i = 0; i < priv->plugins->len; i++) { + GsPlugin *plugin = g_ptr_array_index (priv->plugins, i); + GString *str = gs_plugin_get_enabled (plugin) ? str_enabled : str_disabled; + g_string_append_printf (str, "%s, ", gs_plugin_get_name (plugin)); + g_debug ("[%s]\t%u\t->\t%s", + gs_plugin_get_enabled (plugin) ? "enabled" : "disabld", + gs_plugin_get_order (plugin), + gs_plugin_get_name (plugin)); + } + if (str_enabled->len > 2) + g_string_truncate (str_enabled, str_enabled->len - 2); + if (str_disabled->len > 2) + g_string_truncate (str_disabled, str_disabled->len - 2); + g_info ("enabled plugins: %s", str_enabled->str); + g_info ("disabled plugins: %s", str_disabled->str); +} + +static void +gs_plugin_loader_get_property (GObject *object, guint prop_id, + GValue *value, GParamSpec *pspec) +{ + GsPluginLoader *plugin_loader = GS_PLUGIN_LOADER (object); + GsPluginLoaderPrivate *priv = gs_plugin_loader_get_instance_private (plugin_loader); + + switch (prop_id) { + case PROP_EVENTS: + g_value_set_pointer (value, priv->events_by_id); + break; + case PROP_ALLOW_UPDATES: + g_value_set_boolean (value, gs_plugin_loader_get_allow_updates (plugin_loader)); + break; + case PROP_NETWORK_AVAILABLE: + g_value_set_boolean (value, gs_plugin_loader_get_network_available (plugin_loader)); + break; + case PROP_NETWORK_METERED: + g_value_set_boolean (value, gs_plugin_loader_get_network_metered (plugin_loader)); + break; + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); + break; + } +} + +static void +gs_plugin_loader_set_property (GObject *object, guint prop_id, + const GValue *value, GParamSpec *pspec) +{ + switch (prop_id) { + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); + break; + } +} + +static void +gs_plugin_loader_dispose (GObject *object) +{ + GsPluginLoader *plugin_loader = GS_PLUGIN_LOADER (object); + GsPluginLoaderPrivate *priv = gs_plugin_loader_get_instance_private (plugin_loader); + + if (priv->plugins != NULL) { + g_autoptr(GsPluginLoaderHelper) helper = NULL; + g_autoptr(GsPluginJob) plugin_job = NULL; + plugin_job = gs_plugin_job_newv (GS_PLUGIN_ACTION_DESTROY, NULL); + helper = gs_plugin_loader_helper_new (plugin_loader, plugin_job); + gs_plugin_loader_run_results (helper, NULL, NULL); + g_clear_pointer (&priv->plugins, g_ptr_array_unref); + } + if (priv->updates_changed_id != 0) { + g_source_remove (priv->updates_changed_id); + priv->updates_changed_id = 0; + } + if (priv->network_changed_handler != 0) { + g_signal_handler_disconnect (priv->network_monitor, + priv->network_changed_handler); + priv->network_changed_handler = 0; + } + if (priv->network_available_notify_handler != 0) { + g_signal_handler_disconnect (priv->network_monitor, + priv->network_available_notify_handler); + priv->network_available_notify_handler = 0; + } + if (priv->network_metered_notify_handler != 0) { + g_signal_handler_disconnect (priv->network_monitor, + priv->network_metered_notify_handler); + priv->network_metered_notify_handler = 0; + } + if (priv->queued_ops_pool != NULL) { + /* stop accepting more requests and wait until any currently + * running ones are finished */ + g_thread_pool_free (priv->queued_ops_pool, TRUE, TRUE); + priv->queued_ops_pool = NULL; + } + g_clear_object (&priv->network_monitor); + g_clear_object (&priv->soup_session); + g_clear_object (&priv->settings); + g_clear_pointer (&priv->pending_apps, g_ptr_array_unref); +#ifdef HAVE_SYSPROF + g_clear_pointer (&priv->sysprof_writer, sysprof_capture_writer_unref); +#endif + + G_OBJECT_CLASS (gs_plugin_loader_parent_class)->dispose (object); +} + +static void +gs_plugin_loader_finalize (GObject *object) +{ + GsPluginLoader *plugin_loader = GS_PLUGIN_LOADER (object); + GsPluginLoaderPrivate *priv = gs_plugin_loader_get_instance_private (plugin_loader); + + g_strfreev (priv->compatible_projects); + g_ptr_array_unref (priv->locations); + g_free (priv->locale); + g_free (priv->language); + g_ptr_array_unref (priv->file_monitors); + g_hash_table_unref (priv->events_by_id); + g_hash_table_unref (priv->disallow_updates); + + g_mutex_clear (&priv->pending_apps_mutex); + g_mutex_clear (&priv->events_by_id_mutex); + + G_OBJECT_CLASS (gs_plugin_loader_parent_class)->finalize (object); +} + +static void +gs_plugin_loader_class_init (GsPluginLoaderClass *klass) +{ + GParamSpec *pspec; + GObjectClass *object_class = G_OBJECT_CLASS (klass); + + object_class->get_property = gs_plugin_loader_get_property; + object_class->set_property = gs_plugin_loader_set_property; + object_class->dispose = gs_plugin_loader_dispose; + object_class->finalize = gs_plugin_loader_finalize; + + pspec = g_param_spec_string ("events", NULL, NULL, + NULL, + G_PARAM_READABLE); + g_object_class_install_property (object_class, PROP_EVENTS, pspec); + + pspec = g_param_spec_boolean ("allow-updates", NULL, NULL, + TRUE, + G_PARAM_READABLE); + g_object_class_install_property (object_class, PROP_ALLOW_UPDATES, pspec); + + pspec = g_param_spec_boolean ("network-available", NULL, NULL, + FALSE, + G_PARAM_READABLE); + g_object_class_install_property (object_class, PROP_NETWORK_AVAILABLE, pspec); + + pspec = g_param_spec_boolean ("network-metered", NULL, NULL, + FALSE, + G_PARAM_READABLE); + g_object_class_install_property (object_class, PROP_NETWORK_METERED, pspec); + + signals [SIGNAL_STATUS_CHANGED] = + g_signal_new ("status-changed", + G_TYPE_FROM_CLASS (object_class), G_SIGNAL_RUN_LAST, + G_STRUCT_OFFSET (GsPluginLoaderClass, status_changed), + NULL, NULL, g_cclosure_marshal_generic, + G_TYPE_NONE, 2, G_TYPE_POINTER, G_TYPE_UINT); + signals [SIGNAL_PENDING_APPS_CHANGED] = + g_signal_new ("pending-apps-changed", + G_TYPE_FROM_CLASS (object_class), G_SIGNAL_RUN_LAST, + G_STRUCT_OFFSET (GsPluginLoaderClass, pending_apps_changed), + NULL, NULL, g_cclosure_marshal_VOID__VOID, + G_TYPE_NONE, 0); + signals [SIGNAL_UPDATES_CHANGED] = + g_signal_new ("updates-changed", + G_TYPE_FROM_CLASS (object_class), G_SIGNAL_RUN_LAST, + G_STRUCT_OFFSET (GsPluginLoaderClass, updates_changed), + NULL, NULL, g_cclosure_marshal_VOID__VOID, + G_TYPE_NONE, 0); + signals [SIGNAL_RELOAD] = + g_signal_new ("reload", + G_TYPE_FROM_CLASS (object_class), G_SIGNAL_RUN_LAST, + G_STRUCT_OFFSET (GsPluginLoaderClass, reload), + NULL, NULL, g_cclosure_marshal_VOID__VOID, + G_TYPE_NONE, 0); + signals [SIGNAL_BASIC_AUTH_START] = + g_signal_new ("basic-auth-start", + G_TYPE_FROM_CLASS (object_class), G_SIGNAL_RUN_LAST, + G_STRUCT_OFFSET (GsPluginLoaderClass, basic_auth_start), + NULL, NULL, g_cclosure_marshal_generic, + G_TYPE_NONE, 4, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_POINTER, G_TYPE_POINTER); +} + +static void +gs_plugin_loader_allow_updates_recheck (GsPluginLoader *plugin_loader) +{ + GsPluginLoaderPrivate *priv = gs_plugin_loader_get_instance_private (plugin_loader); + if (g_settings_get_boolean (priv->settings, "allow-updates")) { + g_hash_table_remove (priv->disallow_updates, plugin_loader); + } else { + g_hash_table_insert (priv->disallow_updates, + (gpointer) plugin_loader, + (gpointer) "GSettings"); + } +} + +static void +gs_plugin_loader_settings_changed_cb (GSettings *settings, + const gchar *key, + GsPluginLoader *plugin_loader) +{ + if (g_strcmp0 (key, "allow-updates") == 0) + gs_plugin_loader_allow_updates_recheck (plugin_loader); +} + +static gint +get_max_parallel_ops (void) +{ + guint mem_total = gs_utils_get_memory_total (); + if (mem_total == 0) + return 8; + /* allow 1 op per GB of memory */ + return (gint) MAX (round((gdouble) mem_total / 1024), 1.0); +} + +static void +gs_plugin_loader_init (GsPluginLoader *plugin_loader) +{ + GsPluginLoaderPrivate *priv = gs_plugin_loader_get_instance_private (plugin_loader); + const gchar *tmp; + gchar *match; + gchar **projects; + guint i; + +#ifdef HAVE_SYSPROF + priv->sysprof_writer = sysprof_capture_writer_new_from_env (0); +#endif /* HAVE_SYSPROF */ + + priv->scale = 1; + priv->plugins = g_ptr_array_new_with_free_func ((GDestroyNotify) g_object_unref); + priv->pending_apps = g_ptr_array_new_with_free_func ((GFreeFunc) g_object_unref); + priv->queued_ops_pool = g_thread_pool_new (gs_plugin_loader_process_in_thread_pool_cb, + NULL, + get_max_parallel_ops (), + FALSE, + NULL); + priv->file_monitors = g_ptr_array_new_with_free_func ((GFreeFunc) g_object_unref); + priv->locations = g_ptr_array_new_with_free_func (g_free); + priv->settings = g_settings_new ("org.gnome.software"); + g_signal_connect (priv->settings, "changed", + G_CALLBACK (gs_plugin_loader_settings_changed_cb), plugin_loader); + priv->events_by_id = g_hash_table_new_full ((GHashFunc) as_utils_unique_id_hash, + (GEqualFunc) as_utils_unique_id_equal, + g_free, + (GDestroyNotify) g_object_unref); + + /* share a soup session (also disable the double-compression) */ + priv->soup_session = soup_session_new_with_options (SOUP_SESSION_USER_AGENT, gs_user_agent (), + SOUP_SESSION_TIMEOUT, 10, + NULL); + + /* get the locale */ + tmp = g_getenv ("GS_SELF_TEST_LOCALE"); + if (tmp != NULL) { + g_debug ("using self test locale of %s", tmp); + priv->locale = g_strdup (tmp); + } else { + priv->locale = g_strdup (setlocale (LC_MESSAGES, NULL)); + } + + /* the settings key sets the initial override */ + priv->disallow_updates = g_hash_table_new (g_direct_hash, g_direct_equal); + gs_plugin_loader_allow_updates_recheck (plugin_loader); + + /* get the language from the locale (i.e. strip the territory, codeset + * and modifier) */ + priv->language = g_strdup (priv->locale); + match = strpbrk (priv->language, "._@"); + if (match != NULL) + *match = '\0'; + + g_debug ("Using locale = %s, language = %s", priv->locale, priv->language); + + g_mutex_init (&priv->pending_apps_mutex); + g_mutex_init (&priv->events_by_id_mutex); + + /* monitor the network as the many UI operations need the network */ + gs_plugin_loader_monitor_network (plugin_loader); + + /* by default we only show project-less apps or compatible projects */ + tmp = g_getenv ("GNOME_SOFTWARE_COMPATIBLE_PROJECTS"); + if (tmp == NULL) { + projects = g_settings_get_strv (priv->settings, + "compatible-projects"); + } else { + projects = g_strsplit (tmp, ",", -1); + } + for (i = 0; projects[i] != NULL; i++) + g_debug ("compatible-project: %s", projects[i]); + priv->compatible_projects = projects; +} + +/** + * gs_plugin_loader_new: + * + * Return value: a new GsPluginLoader object. + **/ +GsPluginLoader * +gs_plugin_loader_new (void) +{ + GsPluginLoader *plugin_loader; + plugin_loader = g_object_new (GS_TYPE_PLUGIN_LOADER, NULL); + return GS_PLUGIN_LOADER (plugin_loader); +} + +static void +gs_plugin_loader_app_installed_cb (GObject *source, + GAsyncResult *res, + gpointer user_data) +{ + GsPluginLoader *plugin_loader = GS_PLUGIN_LOADER (source); + gboolean ret; + g_autoptr(GError) error = NULL; + g_autoptr(GsApp) app = GS_APP (user_data); + + ret = gs_plugin_loader_job_action_finish (plugin_loader, + res, + &error); + if (!ret) { + remove_app_from_install_queue (plugin_loader, app); + g_warning ("failed to install %s: %s", + gs_app_get_unique_id (app), error->message); + } +} + +gboolean +gs_plugin_loader_get_network_available (GsPluginLoader *plugin_loader) +{ + GsPluginLoaderPrivate *priv = gs_plugin_loader_get_instance_private (plugin_loader); + if (priv->network_monitor == NULL) { + g_debug ("no network monitor, so returning network-available=TRUE"); + return TRUE; + } + return g_network_monitor_get_network_available (priv->network_monitor); +} + +gboolean +gs_plugin_loader_get_network_metered (GsPluginLoader *plugin_loader) +{ + GsPluginLoaderPrivate *priv = gs_plugin_loader_get_instance_private (plugin_loader); + if (priv->network_monitor == NULL) { + g_debug ("no network monitor, so returning network-metered=FALSE"); + return FALSE; + } + return g_network_monitor_get_network_metered (priv->network_monitor); +} + +static void +gs_plugin_loader_network_changed_cb (GNetworkMonitor *monitor, + gboolean available, + GsPluginLoader *plugin_loader) +{ + GsPluginLoaderPrivate *priv = gs_plugin_loader_get_instance_private (plugin_loader); + gboolean metered = g_network_monitor_get_network_metered (priv->network_monitor); + + g_debug ("network status change: %s [%s]", + available ? "online" : "offline", + metered ? "metered" : "unmetered"); + + g_object_notify (G_OBJECT (plugin_loader), "network-available"); + g_object_notify (G_OBJECT (plugin_loader), "network-metered"); + + if (available && !metered) { + g_autoptr(GsAppList) queue = NULL; + g_mutex_lock (&priv->pending_apps_mutex); + queue = gs_app_list_new (); + for (guint i = 0; i < priv->pending_apps->len; i++) { + GsApp *app = g_ptr_array_index (priv->pending_apps, i); + if (gs_app_get_state (app) == AS_APP_STATE_QUEUED_FOR_INSTALL) + gs_app_list_add (queue, app); + } + g_mutex_unlock (&priv->pending_apps_mutex); + for (guint i = 0; i < gs_app_list_length (queue); i++) { + GsApp *app = gs_app_list_index (queue, i); + g_autoptr(GsPluginJob) plugin_job = NULL; + plugin_job = gs_plugin_job_newv (GS_PLUGIN_ACTION_INSTALL, + "app", app, + NULL); + gs_plugin_loader_job_process_async (plugin_loader, plugin_job, + NULL, + gs_plugin_loader_app_installed_cb, + g_object_ref (app)); + } + } +} + +static void +gs_plugin_loader_network_available_notify_cb (GObject *obj, + GParamSpec *pspec, + gpointer user_data) +{ + GNetworkMonitor *monitor = G_NETWORK_MONITOR (obj); + GsPluginLoader *plugin_loader = GS_PLUGIN_LOADER (user_data); + + gs_plugin_loader_network_changed_cb (monitor, g_network_monitor_get_network_available (monitor), plugin_loader); +} + +static void +gs_plugin_loader_network_metered_notify_cb (GObject *obj, + GParamSpec *pspec, + gpointer user_data) +{ + GNetworkMonitor *monitor = G_NETWORK_MONITOR (obj); + GsPluginLoader *plugin_loader = GS_PLUGIN_LOADER (user_data); + + gs_plugin_loader_network_changed_cb (monitor, g_network_monitor_get_network_available (monitor), plugin_loader); +} + +static void +gs_plugin_loader_monitor_network (GsPluginLoader *plugin_loader) +{ + GsPluginLoaderPrivate *priv = gs_plugin_loader_get_instance_private (plugin_loader); + GNetworkMonitor *network_monitor; + + network_monitor = g_network_monitor_get_default (); + if (network_monitor == NULL || priv->network_changed_handler != 0) + return; + priv->network_monitor = g_object_ref (network_monitor); + + priv->network_changed_handler = + g_signal_connect (priv->network_monitor, "network-changed", + G_CALLBACK (gs_plugin_loader_network_changed_cb), plugin_loader); + priv->network_available_notify_handler = + g_signal_connect (priv->network_monitor, "notify::network-available", + G_CALLBACK (gs_plugin_loader_network_available_notify_cb), plugin_loader); + priv->network_metered_notify_handler = + g_signal_connect (priv->network_monitor, "notify::network-metered", + G_CALLBACK (gs_plugin_loader_network_metered_notify_cb), plugin_loader); + + gs_plugin_loader_network_changed_cb (priv->network_monitor, + g_network_monitor_get_network_available (priv->network_monitor), + plugin_loader); +} + +/******************************************************************************/ + +static AsIcon * +_gs_app_get_icon_by_kind (GsApp *app, AsIconKind kind) +{ + GPtrArray *icons = gs_app_get_icons (app); + guint i; + for (i = 0; i < icons->len; i++) { + AsIcon *ic = g_ptr_array_index (icons, i); + if (as_icon_get_kind (ic) == kind) + return ic; + } + return NULL; +} + +static void +generic_update_cancelled_cb (GCancellable *cancellable, gpointer data) +{ + GCancellable *app_cancellable = G_CANCELLABLE (data); + g_cancellable_cancel (app_cancellable); +} + +static gboolean +gs_plugin_loader_generic_update (GsPluginLoader *plugin_loader, + GsPluginLoaderHelper *helper, + GCancellable *cancellable, + GError **error) +{ + GsPluginLoaderPrivate *priv = gs_plugin_loader_get_instance_private (plugin_loader); + guint cancel_handler_id = 0; + GsAppList *list; + + /* run each plugin, per-app version */ + list = gs_plugin_job_get_list (helper->plugin_job); + for (guint i = 0; i < priv->plugins->len; i++) { + GsPluginActionFunc plugin_app_func = NULL; + GsPlugin *plugin = g_ptr_array_index (priv->plugins, i); + if (g_cancellable_set_error_if_cancelled (cancellable, error)) { + gs_utils_error_convert_gio (error); + return FALSE; + } + plugin_app_func = gs_plugin_get_symbol (plugin, helper->function_name); + if (plugin_app_func == NULL) + continue; + + /* for each app */ + for (guint j = 0; j < gs_app_list_length (list); j++) { + GCancellable *app_cancellable; + GsApp *app = gs_app_list_index (list, j); + gboolean ret; + g_autoptr(GError) error_local = NULL; + + /* if the whole operation should be cancelled */ + if (g_cancellable_set_error_if_cancelled (cancellable, error)) + return FALSE; + + /* already installed? */ + if (gs_app_get_state (app) == AS_APP_STATE_INSTALLED) + continue; + + /* make sure that the app update is cancelled when the whole op is cancelled */ + app_cancellable = gs_app_get_cancellable (app); + cancel_handler_id = g_cancellable_connect (cancellable, + G_CALLBACK (generic_update_cancelled_cb), + g_object_ref (app_cancellable), + g_object_unref); + + gs_plugin_job_set_app (helper->plugin_job, app); + ret = plugin_app_func (plugin, app, app_cancellable, &error_local); + g_cancellable_disconnect (cancellable, cancel_handler_id); + + if (!ret) { + if (!gs_plugin_error_handle_failure (helper, + plugin, + error_local, + error)) { + return FALSE; + } + } + } + helper->anything_ran = TRUE; + gs_plugin_status_update (plugin, NULL, GS_PLUGIN_STATUS_FINISHED); + } + + gs_utils_set_online_updates_timestamp (priv->settings); + return TRUE; +} + +static void +gs_plugin_loader_process_thread_cb (GTask *task, + gpointer object, + gpointer task_data, + GCancellable *cancellable) +{ + GError *error = NULL; + GsPluginLoaderHelper *helper = (GsPluginLoaderHelper *) task_data; + GsAppListFilterFlags dedupe_flags; + GsAppList *list = gs_plugin_job_get_list (helper->plugin_job); + GsPluginAction action = gs_plugin_job_get_action (helper->plugin_job); + GsPluginLoader *plugin_loader = GS_PLUGIN_LOADER (object); + GsPluginLoaderPrivate *priv = gs_plugin_loader_get_instance_private (plugin_loader); + GsPluginRefineFlags filter_flags; + GsPluginRefineFlags refine_flags; + gboolean add_to_pending_array = FALSE; + guint max_results; + GsAppListSortFunc sort_func; +#ifdef HAVE_SYSPROF + gint64 begin_time_nsec G_GNUC_UNUSED = SYSPROF_CAPTURE_CURRENT_TIME; +#endif + + /* these change the pending count on the installed panel */ + switch (action) { + case GS_PLUGIN_ACTION_INSTALL: + case GS_PLUGIN_ACTION_REMOVE: + add_to_pending_array = TRUE; + break; + default: + break; + } + + /* add to pending list */ + if (add_to_pending_array) + gs_plugin_loader_pending_apps_add (plugin_loader, helper); + + /* run each plugin */ + if (action != GS_PLUGIN_ACTION_REFINE) { + if (!gs_plugin_loader_run_results (helper, cancellable, &error)) { + if (add_to_pending_array) { + gs_app_set_state_recover (gs_plugin_job_get_app (helper->plugin_job)); + gs_plugin_loader_pending_apps_remove (plugin_loader, helper); + } + gs_utils_error_convert_gio (&error); + g_task_return_error (task, error); + return; + } + } + + /* run per-app version */ + if (action == GS_PLUGIN_ACTION_UPDATE) { + helper->function_name = "gs_plugin_update_app"; + if (!gs_plugin_loader_generic_update (plugin_loader, helper, + cancellable, &error)) { + gs_utils_error_convert_gio (&error); + g_task_return_error (task, error); + return; + } + } else if (action == GS_PLUGIN_ACTION_DOWNLOAD) { + helper->function_name = "gs_plugin_download_app"; + if (!gs_plugin_loader_generic_update (plugin_loader, helper, + cancellable, &error)) { + gs_utils_error_convert_gio (&error); + g_task_return_error (task, error); + return; + } + } + + if (action == GS_PLUGIN_ACTION_UPGRADE_TRIGGER) + gs_utils_set_online_updates_timestamp (priv->settings); + + /* remove from pending list */ + if (add_to_pending_array) + gs_plugin_loader_pending_apps_remove (plugin_loader, helper); + + /* some functions are really required for proper operation */ + switch (action) { + case GS_PLUGIN_ACTION_DESTROY: + case GS_PLUGIN_ACTION_GET_INSTALLED: + case GS_PLUGIN_ACTION_GET_UPDATES: + case GS_PLUGIN_ACTION_INITIALIZE: + case GS_PLUGIN_ACTION_INSTALL: + case GS_PLUGIN_ACTION_DOWNLOAD: + case GS_PLUGIN_ACTION_LAUNCH: + case GS_PLUGIN_ACTION_REFRESH: + case GS_PLUGIN_ACTION_REMOVE: + case GS_PLUGIN_ACTION_SEARCH: + case GS_PLUGIN_ACTION_SETUP: + case GS_PLUGIN_ACTION_UPDATE: + if (!helper->anything_ran) { + g_set_error (&error, + GS_PLUGIN_ERROR, + GS_PLUGIN_ERROR_NOT_SUPPORTED, + "no plugin could handle %s", + gs_plugin_action_to_string (action)); + g_task_return_error (task, error); + return; + } + break; + case GS_PLUGIN_ACTION_REFINE: + break; + default: + if (!helper->anything_ran) { + g_debug ("no plugin could handle %s", + gs_plugin_action_to_string (action)); + } + break; + } + + /* unstage addons */ + if (add_to_pending_array) { + GsAppList *addons; + addons = gs_app_get_addons (gs_plugin_job_get_app (helper->plugin_job)); + for (guint i = 0; i < gs_app_list_length (addons); i++) { + GsApp *addon = gs_app_list_index (addons, i); + if (gs_app_get_to_be_installed (addon)) + gs_app_set_to_be_installed (addon, FALSE); + } + } + + /* modify the local app */ + switch (action) { + case GS_PLUGIN_ACTION_REVIEW_SUBMIT: + gs_app_add_review (gs_plugin_job_get_app (helper->plugin_job), gs_plugin_job_get_review (helper->plugin_job)); + break; + case GS_PLUGIN_ACTION_REVIEW_REMOVE: + gs_app_remove_review (gs_plugin_job_get_app (helper->plugin_job), gs_plugin_job_get_review (helper->plugin_job)); + break; + default: + break; + } + + /* refine with enough data so that the sort_func in + * gs_plugin_loader_job_sorted_truncation() can do what it needs */ + filter_flags = gs_plugin_job_get_filter_flags (helper->plugin_job); + max_results = gs_plugin_job_get_max_results (helper->plugin_job); + sort_func = gs_plugin_job_get_sort_func (helper->plugin_job); + if (filter_flags > 0 && max_results > 0 && sort_func != NULL) { + g_autoptr(GsPluginLoaderHelper) helper2 = NULL; + g_autoptr(GsPluginJob) plugin_job = NULL; + plugin_job = gs_plugin_job_newv (GS_PLUGIN_ACTION_REFINE, + "list", list, + "refine-flags", filter_flags, + NULL); + helper2 = gs_plugin_loader_helper_new (helper->plugin_loader, plugin_job); + helper2->function_name_parent = helper->function_name; + g_debug ("running filter flags with early refine"); + if (!gs_plugin_loader_run_refine_filter (helper2, list, + filter_flags, + cancellable, &error)) { + gs_utils_error_convert_gio (&error); + g_task_return_error (task, error); + return; + } + } + + /* filter to reduce to a sane set */ + gs_plugin_loader_job_sorted_truncation (helper); + + /* set the local file on any of the returned results */ + switch (action) { + case GS_PLUGIN_ACTION_FILE_TO_APP: + for (guint j = 0; j < gs_app_list_length (list); j++) { + GsApp *app = gs_app_list_index (list, j); + if (gs_app_get_local_file (app) == NULL) + gs_app_set_local_file (app, gs_plugin_job_get_file (helper->plugin_job)); + } + default: + break; + } + + /* pick up new source id */ + switch (action) { + case GS_PLUGIN_ACTION_INSTALL: + case GS_PLUGIN_ACTION_REMOVE: + gs_plugin_job_add_refine_flags (helper->plugin_job, + GS_PLUGIN_REFINE_FLAGS_REQUIRE_ORIGIN | + GS_PLUGIN_REFINE_FLAGS_REQUIRE_SETUP_ACTION); + break; + default: + break; + } + + /* run refine() on each one if required */ + if (gs_plugin_job_get_refine_flags (helper->plugin_job) != 0) { + if (!gs_plugin_loader_run_refine (helper, list, cancellable, &error)) { + gs_utils_error_convert_gio (&error); + g_task_return_error (task, error); + return; + } + } else { + g_debug ("no refine flags set for transaction"); + } + + /* check the local files have an icon set */ + switch (action) { + case GS_PLUGIN_ACTION_URL_TO_APP: + case GS_PLUGIN_ACTION_FILE_TO_APP: + for (guint j = 0; j < gs_app_list_length (list); j++) { + GsApp *app = gs_app_list_index (list, j); + if (_gs_app_get_icon_by_kind (app, AS_ICON_KIND_STOCK) == NULL && + _gs_app_get_icon_by_kind (app, AS_ICON_KIND_LOCAL) == NULL && + _gs_app_get_icon_by_kind (app, AS_ICON_KIND_CACHED) == NULL) { + g_autoptr(AsIcon) ic = as_icon_new (); + as_icon_set_kind (ic, AS_ICON_KIND_STOCK); + if (gs_app_has_quirk (app, GS_APP_QUIRK_HAS_SOURCE)) + as_icon_set_name (ic, "x-package-repository"); + else + as_icon_set_name (ic, "application-x-executable"); + gs_app_add_icon (app, ic); + } + } + + /* run refine() on each one again to pick up any icons */ + refine_flags = gs_plugin_job_get_refine_flags (helper->plugin_job); + gs_plugin_job_set_refine_flags (helper->plugin_job, + GS_PLUGIN_REFINE_FLAGS_REQUIRE_ICON); + if (!gs_plugin_loader_run_refine (helper, list, cancellable, &error)) { + gs_utils_error_convert_gio (&error); + g_task_return_error (task, error); + return; + } + /* restore the refine flags so that gs_app_list_filter sees the right thing */ + gs_plugin_job_set_refine_flags (helper->plugin_job, refine_flags); + break; + default: + break; + } + + /* filter package list */ + switch (action) { + case GS_PLUGIN_ACTION_URL_TO_APP: + gs_app_list_filter (list, gs_plugin_loader_app_is_valid, helper); + break; + case GS_PLUGIN_ACTION_SEARCH: + case GS_PLUGIN_ACTION_SEARCH_FILES: + case GS_PLUGIN_ACTION_SEARCH_PROVIDES: + case GS_PLUGIN_ACTION_GET_ALTERNATES: + gs_app_list_filter (list, gs_plugin_loader_app_is_valid, helper); + gs_app_list_filter (list, gs_plugin_loader_filter_qt_for_gtk, NULL); + gs_app_list_filter (list, gs_plugin_loader_get_app_is_compatible, plugin_loader); + break; + case GS_PLUGIN_ACTION_GET_CATEGORY_APPS: + gs_app_list_filter (list, gs_plugin_loader_app_is_valid, helper); + gs_app_list_filter (list, gs_plugin_loader_filter_qt_for_gtk, NULL); + gs_app_list_filter (list, gs_plugin_loader_get_app_is_compatible, plugin_loader); + break; + case GS_PLUGIN_ACTION_GET_INSTALLED: + gs_app_list_filter (list, gs_plugin_loader_app_is_valid, helper); + gs_app_list_filter (list, gs_plugin_loader_app_is_valid_installed, helper); + break; + case GS_PLUGIN_ACTION_GET_FEATURED: + if (g_getenv ("GNOME_SOFTWARE_FEATURED") != NULL) { + gs_app_list_filter (list, gs_plugin_loader_featured_debug, NULL); + } else { + gs_app_list_filter (list, gs_plugin_loader_app_is_valid, helper); + gs_app_list_filter (list, gs_plugin_loader_get_app_is_compatible, plugin_loader); + } + break; + case GS_PLUGIN_ACTION_GET_UPDATES: + gs_app_list_filter (list, gs_plugin_loader_app_is_valid_updatable, helper); + break; + case GS_PLUGIN_ACTION_GET_RECENT: + gs_app_list_filter (list, gs_plugin_loader_app_is_non_compulsory, NULL); + gs_app_list_filter (list, gs_plugin_loader_app_is_valid, helper); + gs_app_list_filter (list, gs_plugin_loader_filter_qt_for_gtk, NULL); + gs_app_list_filter (list, gs_plugin_loader_get_app_is_compatible, plugin_loader); + break; + case GS_PLUGIN_ACTION_REFINE: + gs_app_list_filter (list, gs_plugin_loader_app_is_valid, helper); + break; + case GS_PLUGIN_ACTION_GET_POPULAR: + gs_app_list_filter (list, gs_plugin_loader_app_is_valid, helper); + gs_app_list_filter (list, gs_plugin_loader_filter_qt_for_gtk, NULL); + gs_app_list_filter (list, gs_plugin_loader_get_app_is_compatible, plugin_loader); + break; + default: + break; + } + + /* only allow one result */ + if (action == GS_PLUGIN_ACTION_URL_TO_APP || + action == GS_PLUGIN_ACTION_FILE_TO_APP) { + if (gs_app_list_length (list) == 0) { + g_autofree gchar *str = gs_plugin_job_to_string (helper->plugin_job); + g_autoptr(GError) error_local = NULL; + g_autoptr(GsPluginEvent) event = NULL; + g_set_error (&error_local, + GS_PLUGIN_ERROR, + GS_PLUGIN_ERROR_NOT_SUPPORTED, + "no application was created for %s", str); + event = gs_plugin_job_to_failed_event (helper->plugin_job, error_local); + gs_plugin_loader_add_event (plugin_loader, event); + g_task_return_error (task, g_steal_pointer (&error_local)); + return; + } + if (gs_app_list_length (list) > 1) { + g_autofree gchar *str = gs_plugin_job_to_string (helper->plugin_job); + g_debug ("more than one application was created for %s", str); + } + } + + /* filter duplicates with priority, taking into account the source name + * & version, so we combine available updates with the installed app */ + gs_app_list_filter (list, gs_plugin_loader_app_set_prio, plugin_loader); + dedupe_flags = gs_plugin_job_get_dedupe_flags (helper->plugin_job); + if (dedupe_flags != GS_APP_LIST_FILTER_FLAG_NONE) + gs_app_list_filter_duplicates (list, dedupe_flags); + + /* sort these again as the refine may have added useful metadata */ + gs_plugin_loader_job_sorted_truncation_again (helper); + + /* if the plugin used updates-changed actually schedule it now */ + if (priv->updates_changed_cnt > 0) + gs_plugin_loader_updates_changed (plugin_loader); + +#ifdef HAVE_SYSPROF + if (priv->sysprof_writer != NULL) { + g_autofree gchar *sysprof_name = g_strconcat ("process-thread:", gs_plugin_action_to_string (action), NULL); + g_autofree gchar *sysprof_message = gs_plugin_job_to_string (helper->plugin_job); + sysprof_capture_writer_add_mark (priv->sysprof_writer, + begin_time_nsec, + sched_getcpu (), + getpid (), + SYSPROF_CAPTURE_CURRENT_TIME - begin_time_nsec, + "gnome-software", + sysprof_name, + sysprof_message); + } +#endif /* HAVE_SYSPROF */ + + /* show elapsed time */ + gs_plugin_loader_job_debug (helper); + + /* success */ + g_task_return_pointer (task, g_object_ref (list), (GDestroyNotify) g_object_unref); +} + +static void +gs_plugin_loader_process_in_thread_pool_cb (gpointer data, + gpointer user_data) +{ + GTask *task = data; + gpointer source_object = g_task_get_source_object (task); + gpointer task_data = g_task_get_task_data (task); + GCancellable *cancellable = g_task_get_cancellable (task); + + gs_ioprio_init (); + + gs_plugin_loader_process_thread_cb (task, source_object, task_data, cancellable); + g_object_unref (task); +} + +static gboolean +gs_plugin_loader_job_timeout_cb (gpointer user_data) +{ + GsPluginLoaderHelper *helper = (GsPluginLoaderHelper *) user_data; + + /* call the cancellable */ + g_debug ("cancelling job %s as it took longer than %u seconds", + helper->function_name, + gs_plugin_job_get_timeout (helper->plugin_job)); + g_cancellable_cancel (helper->cancellable); + + /* failed */ + helper->timeout_triggered = TRUE; + helper->timeout_id = 0; + return G_SOURCE_REMOVE; +} + +static void +gs_plugin_loader_cancelled_cb (GCancellable *cancellable, GsPluginLoaderHelper *helper) +{ + /* just proxy this forward */ + g_debug ("Cancelling job with cancellable %p", helper->cancellable); + g_cancellable_cancel (helper->cancellable); +} + +static void +gs_plugin_loader_schedule_task (GsPluginLoader *plugin_loader, + GTask *task) +{ + GsPluginLoaderHelper *helper = g_task_get_task_data (task); + GsPluginLoaderPrivate *priv = gs_plugin_loader_get_instance_private (plugin_loader); + GsApp *app = gs_plugin_job_get_app (helper->plugin_job); + + if (app != NULL) { + /* set the pending-action to the app */ + GsPluginAction action = gs_plugin_job_get_action (helper->plugin_job); + gs_app_set_pending_action (app, action); + } + g_thread_pool_push (priv->queued_ops_pool, g_object_ref (task), NULL); +} + +/** + * gs_plugin_loader_job_process_async: + * @plugin_loader: A #GsPluginLoader + * @plugin_job: job to process + * @cancellable: a #GCancellable, or %NULL + * @callback: function to call when complete + * @user_data: user data to pass to @callback + * + * This method calls all plugins. + **/ +void +gs_plugin_loader_job_process_async (GsPluginLoader *plugin_loader, + GsPluginJob *plugin_job, + GCancellable *cancellable, + GAsyncReadyCallback callback, + gpointer user_data) +{ + GsPluginAction action; + GsPluginLoaderHelper *helper; + GsPluginLoaderPrivate *priv = gs_plugin_loader_get_instance_private (plugin_loader); + g_autoptr(GTask) task = NULL; + g_autoptr(GCancellable) cancellable_job = g_cancellable_new (); +#if GLIB_CHECK_VERSION(2, 60, 0) + g_autofree gchar *task_name = NULL; +#endif + + g_return_if_fail (GS_IS_PLUGIN_LOADER (plugin_loader)); + g_return_if_fail (GS_IS_PLUGIN_JOB (plugin_job)); + g_return_if_fail (cancellable == NULL || G_IS_CANCELLABLE (cancellable)); + + action = gs_plugin_job_get_action (plugin_job); +#if GLIB_CHECK_VERSION(2, 60, 0) + task_name = g_strdup_printf ("%s %s", G_STRFUNC, gs_plugin_action_to_string (action)); +#endif + + /* check job has valid action */ + if (action == GS_PLUGIN_ACTION_UNKNOWN) { + g_autofree gchar *job_str = gs_plugin_job_to_string (plugin_job); + task = g_task_new (plugin_loader, cancellable_job, callback, user_data); +#if GLIB_CHECK_VERSION(2, 60, 0) + g_task_set_name (task, task_name); +#endif + g_task_return_new_error (task, + GS_PLUGIN_ERROR, + GS_PLUGIN_ERROR_NOT_SUPPORTED, + "job has no valid action: %s", job_str); + return; + } + + /* deal with the install queue */ + if (action == GS_PLUGIN_ACTION_REMOVE) { + if (remove_app_from_install_queue (plugin_loader, gs_plugin_job_get_app (plugin_job))) { + GsAppList *list = gs_plugin_job_get_list (plugin_job); + task = g_task_new (plugin_loader, cancellable, callback, user_data); +#if GLIB_CHECK_VERSION(2, 60, 0) + g_task_set_name (task, task_name); +#endif + g_task_return_pointer (task, g_object_ref (list), (GDestroyNotify) g_object_unref); + return; + } + } + + /* hardcoded, so resolve a set list */ + if (action == GS_PLUGIN_ACTION_GET_POPULAR) { + g_auto(GStrv) apps = NULL; + if (g_getenv ("GNOME_SOFTWARE_POPULAR") != NULL) { + apps = g_strsplit (g_getenv ("GNOME_SOFTWARE_POPULAR"), ",", 0); + } else { + apps = g_settings_get_strv (priv->settings, "popular-overrides"); + } + if (apps != NULL && g_strv_length (apps) > 0) { + GsAppList *list = gs_plugin_job_get_list (plugin_job); + for (guint i = 0; apps[i] != NULL; i++) { + g_autoptr(GsApp) app = gs_app_new (apps[i]); + gs_app_add_quirk (app, GS_APP_QUIRK_IS_WILDCARD); + gs_app_list_add (list, app); + } + gs_plugin_job_set_action (plugin_job, GS_PLUGIN_ACTION_REFINE); + } + } + + /* FIXME: the plugins should specify this, rather than hardcoding */ + if (gs_plugin_job_has_refine_flags (plugin_job, + GS_PLUGIN_REFINE_FLAGS_REQUIRE_KEY_COLORS)) { + gs_plugin_job_add_refine_flags (plugin_job, + GS_PLUGIN_REFINE_FLAGS_REQUIRE_ICON); + } + if (gs_plugin_job_has_refine_flags (plugin_job, + GS_PLUGIN_REFINE_FLAGS_REQUIRE_ORIGIN_UI)) { + gs_plugin_job_add_refine_flags (plugin_job, + GS_PLUGIN_REFINE_FLAGS_REQUIRE_ORIGIN); + } + if (gs_plugin_job_has_refine_flags (plugin_job, + GS_PLUGIN_REFINE_FLAGS_REQUIRE_MENU_PATH)) { + gs_plugin_job_add_refine_flags (plugin_job, + GS_PLUGIN_REFINE_FLAGS_REQUIRE_CATEGORIES); + } + if (gs_plugin_job_has_refine_flags (plugin_job, + GS_PLUGIN_REFINE_FLAGS_REQUIRE_ORIGIN_HOSTNAME)) { + gs_plugin_job_add_refine_flags (plugin_job, + GS_PLUGIN_REFINE_FLAGS_REQUIRE_ORIGIN); + } + if (gs_plugin_job_has_refine_flags (plugin_job, + GS_PLUGIN_REFINE_FLAGS_REQUIRE_SIZE)) { + gs_plugin_job_add_refine_flags (plugin_job, + GS_PLUGIN_REFINE_FLAGS_REQUIRE_RUNTIME); + } + + /* FIXME: this is probably a bug */ + if (action == GS_PLUGIN_ACTION_GET_DISTRO_UPDATES || + action == GS_PLUGIN_ACTION_GET_SOURCES) { + gs_plugin_job_add_refine_flags (plugin_job, + GS_PLUGIN_REFINE_FLAGS_REQUIRE_SETUP_ACTION); + } + + /* get alternates is unusual in that it needs an app input and a list + * output -- so undo the helpful app add in gs_plugin_job_set_app() */ + if (action == GS_PLUGIN_ACTION_GET_ALTERNATES) { + GsAppList *list = gs_plugin_job_get_list (plugin_job); + gs_app_list_remove_all (list); + } + + /* check required args */ + task = g_task_new (plugin_loader, cancellable_job, callback, user_data); +#if GLIB_CHECK_VERSION(2, 60, 0) + g_task_set_name (task, task_name); +#endif + + switch (action) { + case GS_PLUGIN_ACTION_SEARCH: + case GS_PLUGIN_ACTION_SEARCH_FILES: + case GS_PLUGIN_ACTION_SEARCH_PROVIDES: + case GS_PLUGIN_ACTION_URL_TO_APP: + if (gs_plugin_job_get_search (plugin_job) == NULL) { + g_task_return_new_error (task, + GS_PLUGIN_ERROR, + GS_PLUGIN_ERROR_NOT_SUPPORTED, + "no valid search terms"); + return; + } + break; + case GS_PLUGIN_ACTION_REVIEW_SUBMIT: + case GS_PLUGIN_ACTION_REVIEW_UPVOTE: + case GS_PLUGIN_ACTION_REVIEW_DOWNVOTE: + case GS_PLUGIN_ACTION_REVIEW_REPORT: + case GS_PLUGIN_ACTION_REVIEW_REMOVE: + case GS_PLUGIN_ACTION_REVIEW_DISMISS: + if (gs_plugin_job_get_review (plugin_job) == NULL) { + g_task_return_new_error (task, + GS_PLUGIN_ERROR, + GS_PLUGIN_ERROR_NOT_SUPPORTED, + "no valid review object"); + return; + } + break; + default: + break; + } + + /* sorting fallbacks */ + switch (action) { + case GS_PLUGIN_ACTION_SEARCH: + if (gs_plugin_job_get_sort_func (plugin_job) == NULL) { + gs_plugin_job_set_sort_func (plugin_job, + gs_plugin_loader_app_sort_match_value_cb); + } + break; + case GS_PLUGIN_ACTION_GET_RECENT: + if (gs_plugin_job_get_sort_func (plugin_job) == NULL) { + gs_plugin_job_set_sort_func (plugin_job, + gs_plugin_loader_app_sort_kind_cb); + } + break; + case GS_PLUGIN_ACTION_GET_CATEGORY_APPS: + if (gs_plugin_job_get_sort_func (plugin_job) == NULL) { + gs_plugin_job_set_sort_func (plugin_job, + gs_plugin_loader_app_sort_name_cb); + } + break; + case GS_PLUGIN_ACTION_GET_ALTERNATES: + if (gs_plugin_job_get_sort_func (plugin_job) == NULL) { + gs_plugin_job_set_sort_func (plugin_job, + gs_plugin_loader_app_sort_prio_cb); + } + break; + case GS_PLUGIN_ACTION_GET_DISTRO_UPDATES: + if (gs_plugin_job_get_sort_func (plugin_job) == NULL) { + gs_plugin_job_set_sort_func (plugin_job, + gs_plugin_loader_app_sort_version_cb); + } + break; + default: + break; + } + + /* save helper */ + helper = gs_plugin_loader_helper_new (plugin_loader, plugin_job); + g_task_set_task_data (task, helper, (GDestroyNotify) gs_plugin_loader_helper_free); + + /* let the task cancel itself */ + g_task_set_check_cancellable (task, FALSE); + g_task_set_return_on_cancel (task, FALSE); + + /* pre-tokenize search */ + if (action == GS_PLUGIN_ACTION_SEARCH) { + const gchar *search = gs_plugin_job_get_search (plugin_job); + helper->tokens = as_utils_search_tokenize (search); + if (helper->tokens == NULL) { + g_task_return_new_error (task, + GS_PLUGIN_ERROR, + GS_PLUGIN_ERROR_NOT_SUPPORTED, + "failed to tokenize %s", search); + return; + } + } + + /* jobs always have a valid cancellable, so proxy the caller */ + helper->cancellable = g_object_ref (cancellable_job); + g_debug ("Chaining cancellation from %p to %p", cancellable, cancellable_job); + if (cancellable != NULL) { + helper->cancellable_caller = g_object_ref (cancellable); + helper->cancellable_id = + g_cancellable_connect (helper->cancellable_caller, + G_CALLBACK (gs_plugin_loader_cancelled_cb), + helper, NULL); + } + + /* set up a hang handler */ + switch (action) { + case GS_PLUGIN_ACTION_GET_ALTERNATES: + case GS_PLUGIN_ACTION_GET_CATEGORY_APPS: + case GS_PLUGIN_ACTION_GET_FEATURED: + case GS_PLUGIN_ACTION_GET_INSTALLED: + case GS_PLUGIN_ACTION_GET_POPULAR: + case GS_PLUGIN_ACTION_GET_RECENT: + case GS_PLUGIN_ACTION_SEARCH: + case GS_PLUGIN_ACTION_SEARCH_FILES: + case GS_PLUGIN_ACTION_SEARCH_PROVIDES: + helper->timeout_id = + g_timeout_add_seconds (gs_plugin_job_get_timeout (plugin_job), + gs_plugin_loader_job_timeout_cb, + helper); + break; + default: + break; + } + + switch (action) { + case GS_PLUGIN_ACTION_INSTALL: + case GS_PLUGIN_ACTION_UPDATE: + case GS_PLUGIN_ACTION_UPGRADE_DOWNLOAD: + /* these actions must be performed by the thread pool because we + * want to limit the number of them running in parallel */ + gs_plugin_loader_schedule_task (plugin_loader, task); + return; + default: + break; + } + + /* run in a thread */ + g_task_run_in_thread (task, gs_plugin_loader_process_thread_cb); +} + +/******************************************************************************/ + +/** + * gs_plugin_loader_get_plugin_supported: + * @plugin_loader: A #GsPluginLoader + * @function_name: a function name + * + * This function returns TRUE if the symbol is found in any enabled plugin. + */ +gboolean +gs_plugin_loader_get_plugin_supported (GsPluginLoader *plugin_loader, + const gchar *function_name) +{ + GsPluginLoaderPrivate *priv = gs_plugin_loader_get_instance_private (plugin_loader); + for (guint i = 0; i < priv->plugins->len; i++) { + GsPlugin *plugin = g_ptr_array_index (priv->plugins, i); + if (gs_plugin_get_symbol (plugin, function_name) != NULL) + return TRUE; + } + return FALSE; +} + +/** + * gs_plugin_loader_app_create: + * @plugin_loader: a #GsPluginLoader + * @unique_id: a unique_id + * + * Returns an application from the global cache, creating if required. + * + * Returns: (transfer full): a #GsApp + **/ +GsApp * +gs_plugin_loader_app_create (GsPluginLoader *plugin_loader, const gchar *unique_id) +{ + g_autoptr(GError) error = NULL; + g_autoptr(GsApp) app = NULL; + g_autoptr(GsAppList) list = gs_app_list_new (); + g_autoptr(GsPluginJob) plugin_job = NULL; + g_autoptr(GsPluginLoaderHelper) helper = NULL; + + /* use the plugin loader to convert a wildcard app*/ + app = gs_app_new (NULL); + gs_app_add_quirk (app, GS_APP_QUIRK_IS_WILDCARD); + gs_app_set_from_unique_id (app, unique_id); + gs_app_list_add (list, app); + plugin_job = gs_plugin_job_newv (GS_PLUGIN_ACTION_REFINE, NULL); + helper = gs_plugin_loader_helper_new (plugin_loader, plugin_job); + if (!gs_plugin_loader_run_refine (helper, list, NULL, &error)) { + g_warning ("%s", error->message); + return NULL; + } + + /* return the matching GsApp */ + for (guint i = 0; i < gs_app_list_length (list); i++) { + GsApp *app_tmp = gs_app_list_index (list, i); + if (g_strcmp0 (unique_id, gs_app_get_unique_id (app_tmp)) == 0) + return g_object_ref (app_tmp); + } + + /* return the first returned app that's not a wildcard */ + for (guint i = 0; i < gs_app_list_length (list); i++) { + GsApp *app_tmp = gs_app_list_index (list, i); + if (!gs_app_has_quirk (app_tmp, GS_APP_QUIRK_IS_WILDCARD)) { + g_debug ("returning imperfect match: %s != %s", + unique_id, gs_app_get_unique_id (app_tmp)); + return g_object_ref (app_tmp); + } + } + + /* does not exist */ + g_warning ("failed to create an app for %s", unique_id); + return NULL; +} + +/** + * gs_plugin_loader_get_system_app: + * @plugin_loader: a #GsPluginLoader + * + * Returns the application that represents the currently installed OS. + * + * Returns: (transfer full): a #GsApp + **/ +GsApp * +gs_plugin_loader_get_system_app (GsPluginLoader *plugin_loader) +{ + return gs_plugin_loader_app_create (plugin_loader, "*/*/*/*/system/*"); +} + +/** + * gs_plugin_loader_set_max_parallel_ops: + * @plugin_loader: a #GsPluginLoader + * @max_ops: the maximum number of parallel operations + * + * Sets the number of maximum number of queued operations (install/update/upgrade-download) + * to be processed at a time. If @max_ops is 0, then it will set the default maximum number. + */ +void +gs_plugin_loader_set_max_parallel_ops (GsPluginLoader *plugin_loader, + guint max_ops) +{ + g_autoptr(GError) error = NULL; + GsPluginLoaderPrivate *priv = gs_plugin_loader_get_instance_private (plugin_loader); + if (max_ops == 0) + max_ops = get_max_parallel_ops (); + if (!g_thread_pool_set_max_threads (priv->queued_ops_pool, max_ops, &error)) + g_warning ("Failed to set the maximum number of ops in parallel: %s", + error->message); +} + +const gchar * +gs_plugin_loader_get_locale (GsPluginLoader *plugin_loader) +{ + GsPluginLoaderPrivate *priv = gs_plugin_loader_get_instance_private (plugin_loader); + return priv->locale; +} |