Adding upstream version 43.2.upstream/43.2upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 627 insertions, 0 deletions

diff --git a/src/nautilus-search-engine-tracker.c b/src/nautilus-search-engine-tracker.c
new file mode 100644
index 0000000..b4ae92a
--- /dev/null
+++ b/src/nautilus-search-engine-tracker.c
@@ -0,0 +1,627 @@
+/*
+ * Copyright (C) 2005 Mr Jamie McCracken
+ *
+ * Nautilus is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * Nautilus is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public
+ * License along with this program; see the file COPYING.  If not,
+ * see <http://www.gnu.org/licenses/>.
+ *
+ * Author: Jamie McCracken <jamiemcc@gnome.org>
+ *
+ */
+
+#include <config.h>
+#include "nautilus-search-engine-tracker.h"
+
+#include "nautilus-search-engine-private.h"
+#include "nautilus-search-hit.h"
+#include "nautilus-search-provider.h"
+#include "nautilus-tracker-utilities.h"
+#define DEBUG_FLAG NAUTILUS_DEBUG_SEARCH
+#include "nautilus-debug.h"
+
+#include <string.h>
+#include <gio/gio.h>
+#include <libtracker-sparql/tracker-sparql.h>
+
+struct _NautilusSearchEngineTracker
+{
+    GObject parent_instance;
+
+    TrackerSparqlConnection *connection;
+    NautilusQuery *query;
+
+    gboolean query_pending;
+    GQueue *hits_pending;
+
+    gboolean recursive;
+    gboolean fts_enabled;
+
+    GCancellable *cancellable;
+};
+
+enum
+{
+    PROP_0,
+    PROP_RUNNING,
+    LAST_PROP
+};
+
+static void nautilus_search_provider_init (NautilusSearchProviderInterface *iface);
+
+G_DEFINE_TYPE_WITH_CODE (NautilusSearchEngineTracker,
+                         nautilus_search_engine_tracker,
+                         G_TYPE_OBJECT,
+                         G_IMPLEMENT_INTERFACE (NAUTILUS_TYPE_SEARCH_PROVIDER,
+                                                nautilus_search_provider_init))
+
+static void
+finalize (GObject *object)
+{
+    NautilusSearchEngineTracker *tracker;
+
+    tracker = NAUTILUS_SEARCH_ENGINE_TRACKER (object);
+
+    if (tracker->cancellable)
+    {
+        g_cancellable_cancel (tracker->cancellable);
+        g_clear_object (&tracker->cancellable);
+    }
+
+    g_clear_object (&tracker->query);
+    g_queue_free_full (tracker->hits_pending, g_object_unref);
+    /* This is a singleton, no need to unref. */
+    tracker->connection = NULL;
+
+    G_OBJECT_CLASS (nautilus_search_engine_tracker_parent_class)->finalize (object);
+}
+
+#define BATCH_SIZE 100
+
+static void
+check_pending_hits (NautilusSearchEngineTracker *tracker,
+                    gboolean                     force_send)
+{
+    GList *hits = NULL;
+    NautilusSearchHit *hit;
+
+    DEBUG ("Tracker engine add hits");
+
+    if (!force_send &&
+        g_queue_get_length (tracker->hits_pending) < BATCH_SIZE)
+    {
+        return;
+    }
+
+    while ((hit = g_queue_pop_head (tracker->hits_pending)))
+    {
+        hits = g_list_prepend (hits, hit);
+    }
+
+    nautilus_search_provider_hits_added (NAUTILUS_SEARCH_PROVIDER (tracker), hits);
+    g_list_free_full (hits, g_object_unref);
+}
+
+static void
+search_finished (NautilusSearchEngineTracker *tracker,
+                 GError                      *error)
+{
+    DEBUG ("Tracker engine finished");
+
+    if (error == NULL)
+    {
+        check_pending_hits (tracker, TRUE);
+    }
+    else
+    {
+        g_queue_foreach (tracker->hits_pending, (GFunc) g_object_unref, NULL);
+        g_queue_clear (tracker->hits_pending);
+    }
+
+    tracker->query_pending = FALSE;
+
+    g_object_notify (G_OBJECT (tracker), "running");
+
+    if (error && !g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED))
+    {
+        DEBUG ("Tracker engine error %s", error->message);
+        nautilus_search_provider_error (NAUTILUS_SEARCH_PROVIDER (tracker), error->message);
+    }
+    else
+    {
+        nautilus_search_provider_finished (NAUTILUS_SEARCH_PROVIDER (tracker),
+                                           NAUTILUS_SEARCH_PROVIDER_STATUS_NORMAL);
+        if (g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED))
+        {
+            DEBUG ("Tracker engine finished and cancelled");
+        }
+        else
+        {
+            DEBUG ("Tracker engine finished correctly");
+        }
+    }
+
+    g_object_unref (tracker);
+}
+
+static void cursor_callback (GObject      *object,
+                             GAsyncResult *result,
+                             gpointer      user_data);
+
+static void
+cursor_next (NautilusSearchEngineTracker *tracker,
+             TrackerSparqlCursor         *cursor)
+{
+    tracker_sparql_cursor_next_async (cursor,
+                                      tracker->cancellable,
+                                      cursor_callback,
+                                      tracker);
+}
+
+static void
+cursor_callback (GObject      *object,
+                 GAsyncResult *result,
+                 gpointer      user_data)
+{
+    NautilusSearchEngineTracker *tracker;
+    GError *error = NULL;
+    TrackerSparqlCursor *cursor;
+    NautilusSearchHit *hit;
+    const char *uri;
+    const char *mtime_str;
+    const char *atime_str;
+    const char *ctime_str;
+    const gchar *snippet;
+    GTimeVal tv;
+    gdouble rank, match;
+    gboolean success;
+    gchar *basename;
+
+    tracker = NAUTILUS_SEARCH_ENGINE_TRACKER (user_data);
+
+    cursor = TRACKER_SPARQL_CURSOR (object);
+    success = tracker_sparql_cursor_next_finish (cursor, result, &error);
+
+    if (!success)
+    {
+        search_finished (tracker, error);
+
+        g_clear_error (&error);
+        g_clear_object (&cursor);
+
+        return;
+    }
+
+    /* We iterate result by result, not n at a time. */
+    uri = tracker_sparql_cursor_get_string (cursor, 0, NULL);
+    rank = tracker_sparql_cursor_get_double (cursor, 1);
+    mtime_str = tracker_sparql_cursor_get_string (cursor, 2, NULL);
+    ctime_str = tracker_sparql_cursor_get_string (cursor, 3, NULL);
+    atime_str = tracker_sparql_cursor_get_string (cursor, 4, NULL);
+    basename = g_path_get_basename (uri);
+
+    hit = nautilus_search_hit_new (uri);
+    match = nautilus_query_matches_string (tracker->query, basename);
+    nautilus_search_hit_set_fts_rank (hit, rank + match);
+    g_free (basename);
+
+    if (tracker->fts_enabled)
+    {
+        snippet = tracker_sparql_cursor_get_string (cursor, 5, NULL);
+        if (snippet != NULL)
+        {
+            g_autofree gchar *escaped = NULL;
+            g_autoptr (GString) buffer = NULL;
+            /* Escape for markup, before adding our own markup. */
+            escaped = g_markup_escape_text (snippet, -1);
+            buffer = g_string_new (escaped);
+            g_string_replace (buffer, "_NAUTILUS_SNIPPET_DELIM_START_", "<b>", 0);
+            g_string_replace (buffer, "_NAUTILUS_SNIPPET_DELIM_END_", "</b>", 0);
+
+            nautilus_search_hit_set_fts_snippet (hit, buffer->str);
+        }
+    }
+
+    if (g_time_val_from_iso8601 (mtime_str, &tv))
+    {
+        GDateTime *date;
+        date = g_date_time_new_from_timeval_local (&tv);
+        nautilus_search_hit_set_modification_time (hit, date);
+        g_date_time_unref (date);
+    }
+    else
+    {
+        g_warning ("unable to parse mtime: %s", mtime_str);
+    }
+    if (g_time_val_from_iso8601 (atime_str, &tv))
+    {
+        GDateTime *date;
+        date = g_date_time_new_from_timeval_local (&tv);
+        nautilus_search_hit_set_access_time (hit, date);
+        g_date_time_unref (date);
+    }
+    else
+    {
+        g_warning ("unable to parse atime: %s", atime_str);
+    }
+    if (g_time_val_from_iso8601 (ctime_str, &tv))
+    {
+        GDateTime *date;
+        date = g_date_time_new_from_timeval_local (&tv);
+        nautilus_search_hit_set_creation_time (hit, date);
+        g_date_time_unref (date);
+    }
+    else
+    {
+        g_warning ("unable to parse ctime: %s", ctime_str);
+    }
+
+    g_queue_push_head (tracker->hits_pending, hit);
+    check_pending_hits (tracker, FALSE);
+
+    /* Get next */
+    cursor_next (tracker, cursor);
+}
+
+static void
+query_callback (GObject      *object,
+                GAsyncResult *result,
+                gpointer      user_data)
+{
+    NautilusSearchEngineTracker *tracker;
+    TrackerSparqlConnection *connection;
+    TrackerSparqlCursor *cursor;
+    GError *error = NULL;
+
+    tracker = NAUTILUS_SEARCH_ENGINE_TRACKER (user_data);
+
+    connection = TRACKER_SPARQL_CONNECTION (object);
+    cursor = tracker_sparql_connection_query_finish (connection,
+                                                     result,
+                                                     &error);
+
+    if (error != NULL)
+    {
+        search_finished (tracker, error);
+        g_error_free (error);
+    }
+    else
+    {
+        cursor_next (tracker, cursor);
+    }
+}
+
+static gboolean
+search_finished_idle (gpointer user_data)
+{
+    NautilusSearchEngineTracker *tracker = user_data;
+
+    DEBUG ("Tracker engine finished idle");
+
+    search_finished (tracker, NULL);
+
+    return FALSE;
+}
+
+/* This is used to compensate rank if fts:rank is not set (resp. fts:match is
+ * not used). The value was determined experimentally. I am convinced that
+ * fts:rank is currently always set to 5.0 in case of filename match.
+ */
+#define FILENAME_RANK "5.0"
+
+static void
+nautilus_search_engine_tracker_start (NautilusSearchProvider *provider)
+{
+    NautilusSearchEngineTracker *tracker;
+    gchar *query_text, *search_text, *location_uri, *downcase;
+    GFile *location;
+    GString *sparql;
+    g_autoptr (GPtrArray) mimetypes = NULL;
+    GPtrArray *date_range;
+
+    tracker = NAUTILUS_SEARCH_ENGINE_TRACKER (provider);
+
+    if (tracker->query_pending)
+    {
+        return;
+    }
+
+    DEBUG ("Tracker engine start");
+    g_object_ref (tracker);
+    tracker->query_pending = TRUE;
+
+    g_object_notify (G_OBJECT (provider), "running");
+
+    if (tracker->connection == NULL)
+    {
+        g_idle_add (search_finished_idle, provider);
+        return;
+    }
+
+    tracker->fts_enabled = nautilus_query_get_search_content (tracker->query);
+
+    query_text = nautilus_query_get_text (tracker->query);
+    downcase = g_utf8_strdown (query_text, -1);
+    search_text = tracker_sparql_escape_string (downcase);
+    g_free (query_text);
+    g_free (downcase);
+
+    location = nautilus_query_get_location (tracker->query);
+    location_uri = location ? g_file_get_uri (location) : NULL;
+    mimetypes = nautilus_query_get_mime_types (tracker->query);
+
+    sparql = g_string_new ("SELECT DISTINCT"
+                           " ?url"
+                           " xsd:double(COALESCE(?rank2, ?rank1)) AS ?rank"
+                           " nfo:fileLastModified(?file)"
+                           " nfo:fileCreated(?file)"
+                           " nfo:fileLastAccessed(?file)");
+
+    if (tracker->fts_enabled && *search_text)
+    {
+        g_string_append (sparql,
+                         "fts:snippet(?content,"
+                         "            '_NAUTILUS_SNIPPET_DELIM_START_',"
+                         "            '_NAUTILUS_SNIPPET_DELIM_END_', "
+                         "            '…',"
+                         "            20)");
+    }
+
+    g_string_append (sparql, "FROM tracker:FileSystem ");
+
+    if (tracker->fts_enabled)
+    {
+        g_string_append (sparql, "FROM tracker:Documents ");
+    }
+
+    g_string_append (sparql,
+                     "\nWHERE {"
+                     "  ?file a nfo:FileDataObject;"
+                     "  nfo:fileLastModified ?mtime;"
+                     "  nfo:fileLastAccessed ?atime;"
+                     "  nie:dataSource/tracker:available true;"
+                     "  nie:url ?url."
+                     "  OPTIONAL { ?file nfo:fileCreated ?ctime.}");
+
+    if (mimetypes->len > 0)
+    {
+        g_string_append (sparql,
+                         "  ?content nie:isStoredAs ?file;"
+                         "    nie:mimeType ?mime");
+    }
+
+    if (tracker->fts_enabled && *search_text)
+    {
+        /* Use fts:match only for content search to not lose some filename results due to stop words. */
+        g_string_append_printf (sparql,
+                                " { "
+                                " ?content nie:isStoredAs ?file ."
+                                " ?content fts:match \"%s*\" ."
+                                " BIND(fts:rank(?content) AS ?rank1) ."
+                                " } UNION",
+                                search_text);
+    }
+
+    g_string_append_printf (sparql,
+                            " {"
+                            " ?file nfo:fileName ?filename ."
+                            " FILTER(fn:contains(fn:lower-case(?filename), '%s')) ."
+                            " BIND(" FILENAME_RANK " AS ?rank2) ."
+                            " }",
+                            search_text);
+
+    g_string_append_printf (sparql, " . FILTER( ");
+
+    if (!tracker->recursive)
+    {
+        g_string_append_printf (sparql, "tracker:uri-is-parent('%s', ?url)", location_uri);
+    }
+    else
+    {
+        /* STRSTARTS is faster than tracker:uri-is-descendant().
+         * See https://gitlab.gnome.org/GNOME/tracker/-/issues/243
+         */
+        g_string_append_printf (sparql, "STRSTARTS(?url, '%s/')", location_uri);
+    }
+
+    date_range = nautilus_query_get_date_range (tracker->query);
+    if (date_range)
+    {
+        NautilusQuerySearchType type;
+        gchar *initial_date_format;
+        gchar *end_date_format;
+        GDateTime *initial_date;
+        GDateTime *end_date;
+        GDateTime *shifted_end_date;
+
+        initial_date = g_ptr_array_index (date_range, 0);
+        end_date = g_ptr_array_index (date_range, 1);
+        /* As we do for other searches, we want to make the end date inclusive.
+         * For that, add a day to it */
+        shifted_end_date = g_date_time_add_days (end_date, 1);
+
+        type = nautilus_query_get_search_type (tracker->query);
+        initial_date_format = g_date_time_format_iso8601 (initial_date);
+        end_date_format = g_date_time_format_iso8601 (shifted_end_date);
+
+        g_string_append (sparql, " && ");
+
+        if (type == NAUTILUS_QUERY_SEARCH_TYPE_LAST_ACCESS)
+        {
+            g_string_append_printf (sparql, "?atime >= \"%s\"^^xsd:dateTime", initial_date_format);
+            g_string_append_printf (sparql, " && ?atime <= \"%s\"^^xsd:dateTime", end_date_format);
+        }
+        else if (type == NAUTILUS_QUERY_SEARCH_TYPE_LAST_MODIFIED)
+        {
+            g_string_append_printf (sparql, "?mtime >= \"%s\"^^xsd:dateTime", initial_date_format);
+            g_string_append_printf (sparql, " && ?mtime <= \"%s\"^^xsd:dateTime", end_date_format);
+        }
+        else
+        {
+            g_string_append_printf (sparql, "?ctime >= \"%s\"^^xsd:dateTime", initial_date_format);
+            g_string_append_printf (sparql, " && ?ctime <= \"%s\"^^xsd:dateTime", end_date_format);
+        }
+
+
+        g_free (initial_date_format);
+        g_free (end_date_format);
+        g_ptr_array_unref (date_range);
+    }
+
+    if (mimetypes->len > 0)
+    {
+        g_string_append (sparql, " && (");
+
+        for (gint i = 0; i < mimetypes->len; i++)
+        {
+            if (i != 0)
+            {
+                g_string_append (sparql, " || ");
+            }
+
+            g_string_append_printf (sparql, "fn:contains(?mime, '%s')",
+                                    (gchar *) g_ptr_array_index (mimetypes, i));
+        }
+        g_string_append (sparql, ")\n");
+    }
+
+    g_string_append (sparql, ")} ORDER BY DESC (?rank)");
+
+    tracker->cancellable = g_cancellable_new ();
+    tracker_sparql_connection_query_async (tracker->connection,
+                                           sparql->str,
+                                           tracker->cancellable,
+                                           query_callback,
+                                           tracker);
+    g_string_free (sparql, TRUE);
+
+    g_free (search_text);
+    g_free (location_uri);
+    g_object_unref (location);
+}
+
+static void
+nautilus_search_engine_tracker_stop (NautilusSearchProvider *provider)
+{
+    NautilusSearchEngineTracker *tracker;
+
+    tracker = NAUTILUS_SEARCH_ENGINE_TRACKER (provider);
+
+    if (tracker->query_pending)
+    {
+        DEBUG ("Tracker engine stop");
+        g_cancellable_cancel (tracker->cancellable);
+        g_clear_object (&tracker->cancellable);
+        tracker->query_pending = FALSE;
+
+        g_object_notify (G_OBJECT (provider), "running");
+    }
+}
+
+static void
+nautilus_search_engine_tracker_set_query (NautilusSearchProvider *provider,
+                                          NautilusQuery          *query)
+{
+    g_autoptr (GFile) location = NULL;
+    NautilusSearchEngineTracker *tracker;
+
+    tracker = NAUTILUS_SEARCH_ENGINE_TRACKER (provider);
+    location = nautilus_query_get_location (query);
+
+    g_clear_object (&tracker->query);
+
+    tracker->query = g_object_ref (query);
+    tracker->recursive = is_recursive_search (NAUTILUS_SEARCH_ENGINE_TYPE_INDEXED,
+                                              nautilus_query_get_recursive (query),
+                                              location);
+}
+
+static gboolean
+nautilus_search_engine_tracker_is_running (NautilusSearchProvider *provider)
+{
+    NautilusSearchEngineTracker *tracker;
+
+    tracker = NAUTILUS_SEARCH_ENGINE_TRACKER (provider);
+
+    return tracker->query_pending;
+}
+
+static void
+nautilus_search_provider_init (NautilusSearchProviderInterface *iface)
+{
+    iface->set_query = nautilus_search_engine_tracker_set_query;
+    iface->start = nautilus_search_engine_tracker_start;
+    iface->stop = nautilus_search_engine_tracker_stop;
+    iface->is_running = nautilus_search_engine_tracker_is_running;
+}
+
+static void
+nautilus_search_engine_tracker_get_property (GObject    *object,
+                                             guint       prop_id,
+                                             GValue     *value,
+                                             GParamSpec *pspec)
+{
+    NautilusSearchProvider *self = NAUTILUS_SEARCH_PROVIDER (object);
+
+    switch (prop_id)
+    {
+        case PROP_RUNNING:
+        {
+            g_value_set_boolean (value, nautilus_search_engine_tracker_is_running (self));
+        }
+        break;
+
+        default:
+        {
+            G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+        }
+    }
+}
+
+static void
+nautilus_search_engine_tracker_class_init (NautilusSearchEngineTrackerClass *class)
+{
+    GObjectClass *gobject_class;
+
+    gobject_class = G_OBJECT_CLASS (class);
+    gobject_class->finalize = finalize;
+    gobject_class->get_property = nautilus_search_engine_tracker_get_property;
+
+    /**
+     * NautilusSearchEngine::running:
+     *
+     * Whether the search engine is running a search.
+     */
+    g_object_class_override_property (gobject_class, PROP_RUNNING, "running");
+}
+
+static void
+nautilus_search_engine_tracker_init (NautilusSearchEngineTracker *engine)
+{
+    GError *error = NULL;
+
+    engine->hits_pending = g_queue_new ();
+
+    engine->connection = nautilus_tracker_get_miner_fs_connection (&error);
+    if (error)
+    {
+        g_warning ("Could not establish a connection to Tracker: %s", error->message);
+        g_error_free (error);
+    }
+}
+
+
+NautilusSearchEngineTracker *
+nautilus_search_engine_tracker_new (void)
+{
+    return g_object_new (NAUTILUS_TYPE_SEARCH_ENGINE_TRACKER, NULL);
+}