summaryrefslogtreecommitdiffstats
path: root/src/nautilus-search-engine-simple.c
diff options
context:
space:
mode:
Diffstat (limited to '')
-rw-r--r--src/nautilus-search-engine-simple.c614
1 files changed, 614 insertions, 0 deletions
diff --git a/src/nautilus-search-engine-simple.c b/src/nautilus-search-engine-simple.c
new file mode 100644
index 0000000..4fa1a07
--- /dev/null
+++ b/src/nautilus-search-engine-simple.c
@@ -0,0 +1,614 @@
+/*
+ * Copyright (C) 2005 Red Hat, Inc
+ *
+ * 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: Alexander Larsson <alexl@redhat.com>
+ *
+ */
+
+#include <config.h>
+#include "nautilus-search-engine-simple.h"
+
+#include "nautilus-search-engine-private.h"
+#include "nautilus-search-hit.h"
+#include "nautilus-search-provider.h"
+#include "nautilus-ui-utilities.h"
+#define DEBUG_FLAG NAUTILUS_DEBUG_SEARCH
+#include "nautilus-debug.h"
+
+#include <string.h>
+#include <glib.h>
+#include <gio/gio.h>
+
+#define BATCH_SIZE 500
+
+enum
+{
+ PROP_0,
+ PROP_RUNNING,
+ NUM_PROPERTIES
+};
+
+typedef struct
+{
+ NautilusSearchEngineSimple *engine;
+ GCancellable *cancellable;
+
+ GPtrArray *mime_types;
+ GList *found_list;
+
+ GQueue *directories; /* GFiles */
+
+ GHashTable *visited;
+
+ gint n_processed_files;
+ GList *hits;
+
+ NautilusQuery *query;
+
+ gint processing_id;
+ GMutex idle_mutex;
+ /* The following data can be accessed from different threads
+ * and needs to lock the mutex
+ */
+ GQueue *idle_queue;
+ gboolean finished;
+} SearchThreadData;
+
+
+struct _NautilusSearchEngineSimple
+{
+ GObject parent_instance;
+ NautilusQuery *query;
+
+ SearchThreadData *active_search;
+};
+
+static void nautilus_search_provider_init (NautilusSearchProviderInterface *iface);
+
+G_DEFINE_TYPE_WITH_CODE (NautilusSearchEngineSimple,
+ nautilus_search_engine_simple,
+ G_TYPE_OBJECT,
+ G_IMPLEMENT_INTERFACE (NAUTILUS_TYPE_SEARCH_PROVIDER,
+ nautilus_search_provider_init))
+
+static void
+finalize (GObject *object)
+{
+ NautilusSearchEngineSimple *simple = NAUTILUS_SEARCH_ENGINE_SIMPLE (object);
+ g_clear_object (&simple->query);
+
+ G_OBJECT_CLASS (nautilus_search_engine_simple_parent_class)->finalize (object);
+}
+
+static SearchThreadData *
+search_thread_data_new (NautilusSearchEngineSimple *engine,
+ NautilusQuery *query)
+{
+ SearchThreadData *data;
+ GFile *location;
+
+ data = g_new0 (SearchThreadData, 1);
+
+ data->engine = g_object_ref (engine);
+ data->directories = g_queue_new ();
+ data->visited = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, NULL);
+ data->query = g_object_ref (query);
+
+ location = nautilus_query_get_location (query);
+
+ g_queue_push_tail (data->directories, location);
+ data->mime_types = nautilus_query_get_mime_types (query);
+
+ data->cancellable = g_cancellable_new ();
+
+ g_mutex_init (&data->idle_mutex);
+ data->idle_queue = g_queue_new ();
+
+ return data;
+}
+
+static void
+search_thread_data_free (SearchThreadData *data)
+{
+ GList *hits;
+
+ g_queue_foreach (data->directories,
+ (GFunc) g_object_unref, NULL);
+ g_queue_free (data->directories);
+ g_hash_table_destroy (data->visited);
+ g_object_unref (data->cancellable);
+ g_object_unref (data->query);
+ g_clear_pointer (&data->mime_types, g_ptr_array_unref);
+ g_list_free_full (data->hits, g_object_unref);
+ g_object_unref (data->engine);
+ g_mutex_clear (&data->idle_mutex);
+
+ while ((hits = g_queue_pop_head (data->idle_queue)))
+ {
+ g_list_free_full (hits, g_object_unref);
+ }
+ g_queue_free (data->idle_queue);
+
+ g_free (data);
+}
+
+static gboolean
+search_thread_done (SearchThreadData *data)
+{
+ NautilusSearchEngineSimple *engine = data->engine;
+
+ if (g_cancellable_is_cancelled (data->cancellable))
+ {
+ DEBUG ("Simple engine finished and cancelled");
+ }
+ else
+ {
+ DEBUG ("Simple engine finished");
+ }
+ engine->active_search = NULL;
+ nautilus_search_provider_finished (NAUTILUS_SEARCH_PROVIDER (engine),
+ NAUTILUS_SEARCH_PROVIDER_STATUS_NORMAL);
+
+ g_object_notify (G_OBJECT (engine), "running");
+
+ search_thread_data_free (data);
+
+ return G_SOURCE_REMOVE;
+}
+
+static void
+search_thread_process_hits_idle (SearchThreadData *data,
+ GList *hits)
+{
+ if (!g_cancellable_is_cancelled (data->cancellable))
+ {
+ DEBUG ("Simple engine add hits");
+ nautilus_search_provider_hits_added (NAUTILUS_SEARCH_PROVIDER (data->engine),
+ hits);
+ }
+}
+
+static gboolean
+search_thread_process_idle (gpointer user_data)
+{
+ SearchThreadData *thread_data;
+ GList *hits;
+
+ thread_data = user_data;
+
+ g_mutex_lock (&thread_data->idle_mutex);
+ hits = g_queue_pop_head (thread_data->idle_queue);
+ /* Even if the cancellable is cancelled, we need to make sure the search
+ * thread has aknowledge it, and therefore not using the thread data after
+ * freeing it. The search thread will mark as finished whenever the search
+ * is finished or cancelled.
+ * Nonetheless, we should stop yielding results if the search was cancelled
+ */
+ if (thread_data->finished)
+ {
+ if (hits == NULL || g_cancellable_is_cancelled (thread_data->cancellable))
+ {
+ g_mutex_unlock (&thread_data->idle_mutex);
+
+ if (hits)
+ {
+ g_list_free_full (hits, g_object_unref);
+ }
+ search_thread_done (thread_data);
+
+ return G_SOURCE_REMOVE;
+ }
+ }
+
+ g_mutex_unlock (&thread_data->idle_mutex);
+
+ if (hits)
+ {
+ search_thread_process_hits_idle (thread_data, hits);
+ g_list_free_full (hits, g_object_unref);
+ }
+
+ return G_SOURCE_CONTINUE;
+}
+
+static void
+finish_search_thread (SearchThreadData *thread_data)
+{
+ g_mutex_lock (&thread_data->idle_mutex);
+ thread_data->finished = TRUE;
+ g_mutex_unlock (&thread_data->idle_mutex);
+
+ /* If no results were processed, direclty finish the search, in the main
+ * thread.
+ */
+ if (thread_data->processing_id == 0)
+ {
+ g_idle_add (G_SOURCE_FUNC (search_thread_done), thread_data);
+ }
+}
+
+static void
+process_batch_in_idle (SearchThreadData *thread_data,
+ GList *hits)
+{
+ g_return_if_fail (hits != NULL);
+
+ g_mutex_lock (&thread_data->idle_mutex);
+ g_queue_push_tail (thread_data->idle_queue, hits);
+ g_mutex_unlock (&thread_data->idle_mutex);
+
+ if (thread_data->processing_id == 0)
+ {
+ thread_data->processing_id = g_idle_add (search_thread_process_idle, thread_data);
+ }
+}
+
+static void
+send_batch_in_idle (SearchThreadData *thread_data)
+{
+ thread_data->n_processed_files = 0;
+
+ if (thread_data->hits)
+ {
+ process_batch_in_idle (thread_data, thread_data->hits);
+ }
+ thread_data->hits = NULL;
+}
+
+#define STD_ATTRIBUTES \
+ G_FILE_ATTRIBUTE_STANDARD_NAME "," \
+ G_FILE_ATTRIBUTE_STANDARD_DISPLAY_NAME "," \
+ G_FILE_ATTRIBUTE_STANDARD_IS_BACKUP "," \
+ G_FILE_ATTRIBUTE_STANDARD_IS_HIDDEN "," \
+ G_FILE_ATTRIBUTE_STANDARD_TYPE "," \
+ G_FILE_ATTRIBUTE_TIME_MODIFIED "," \
+ G_FILE_ATTRIBUTE_TIME_ACCESS "," \
+ G_FILE_ATTRIBUTE_TIME_CREATED "," \
+ G_FILE_ATTRIBUTE_ID_FILE
+
+static void
+visit_directory (GFile *dir,
+ SearchThreadData *data)
+{
+ g_autoptr (GPtrArray) date_range = NULL;
+ NautilusQuerySearchType type;
+ NautilusQueryRecursive recursive;
+ GFileEnumerator *enumerator;
+ GFileInfo *info;
+ GFile *child;
+ const char *mime_type, *display_name;
+ gdouble match;
+ gboolean is_hidden, found;
+ const char *id;
+ gboolean visited;
+ GDateTime *initial_date;
+ GDateTime *end_date;
+ gchar *uri;
+
+ enumerator = g_file_enumerate_children (dir,
+ data->mime_types->len > 0 ?
+ STD_ATTRIBUTES ","
+ G_FILE_ATTRIBUTE_STANDARD_CONTENT_TYPE
+ :
+ STD_ATTRIBUTES
+ ,
+ G_FILE_QUERY_INFO_NOFOLLOW_SYMLINKS,
+ data->cancellable, NULL);
+
+ if (enumerator == NULL)
+ {
+ return;
+ }
+
+ type = nautilus_query_get_search_type (data->query);
+ recursive = nautilus_query_get_recursive (data->query);
+ date_range = nautilus_query_get_date_range (data->query);
+
+ while ((info = g_file_enumerator_next_file (enumerator, data->cancellable, NULL)) != NULL)
+ {
+ g_autoptr (GDateTime) mtime = NULL;
+ g_autoptr (GDateTime) atime = NULL;
+ g_autoptr (GDateTime) ctime = NULL;
+
+ display_name = g_file_info_get_display_name (info);
+ if (display_name == NULL)
+ {
+ goto next;
+ }
+
+ is_hidden = g_file_info_get_is_hidden (info) || g_file_info_get_is_backup (info);
+ if (is_hidden && !nautilus_query_get_show_hidden_files (data->query))
+ {
+ goto next;
+ }
+
+ child = g_file_get_child (dir, g_file_info_get_name (info));
+ match = nautilus_query_matches_string (data->query, display_name);
+ found = (match > -1);
+
+ if (found && data->mime_types->len > 0)
+ {
+ mime_type = g_file_info_get_content_type (info);
+ found = FALSE;
+
+ for (gint i = 0; i < data->mime_types->len; i++)
+ {
+ if (g_content_type_is_a (mime_type, g_ptr_array_index (data->mime_types, i)))
+ {
+ found = TRUE;
+ break;
+ }
+ }
+ }
+
+ mtime = g_file_info_get_modification_date_time (info);
+ atime = g_file_info_get_access_date_time (info);
+ ctime = g_file_info_get_creation_date_time (info);
+
+ if (found && date_range != NULL)
+ {
+ GDateTime *target_date;
+
+ initial_date = g_ptr_array_index (date_range, 0);
+ end_date = g_ptr_array_index (date_range, 1);
+
+ switch (type)
+ {
+ case NAUTILUS_QUERY_SEARCH_TYPE_LAST_ACCESS:
+ {
+ target_date = atime;
+ }
+ break;
+
+ case NAUTILUS_QUERY_SEARCH_TYPE_LAST_MODIFIED:
+ {
+ target_date = mtime;
+ }
+ break;
+
+ case NAUTILUS_QUERY_SEARCH_TYPE_CREATED:
+ {
+ target_date = ctime;
+ }
+ break;
+
+ default:
+ {
+ target_date = NULL;
+ }
+ }
+
+ found = nautilus_date_time_is_between_dates (target_date,
+ initial_date,
+ end_date);
+ }
+
+ if (found)
+ {
+ NautilusSearchHit *hit;
+
+ uri = g_file_get_uri (child);
+ hit = nautilus_search_hit_new (uri);
+ g_free (uri);
+ nautilus_search_hit_set_fts_rank (hit, match);
+ nautilus_search_hit_set_modification_time (hit, mtime);
+ nautilus_search_hit_set_access_time (hit, atime);
+ nautilus_search_hit_set_creation_time (hit, ctime);
+
+ data->hits = g_list_prepend (data->hits, hit);
+ }
+
+ data->n_processed_files++;
+ if (data->n_processed_files > BATCH_SIZE)
+ {
+ send_batch_in_idle (data);
+ }
+
+ if (recursive != NAUTILUS_QUERY_RECURSIVE_NEVER &&
+ g_file_info_get_file_type (info) == G_FILE_TYPE_DIRECTORY &&
+ is_recursive_search (NAUTILUS_SEARCH_ENGINE_TYPE_NON_INDEXED,
+ recursive, child))
+ {
+ id = g_file_info_get_attribute_string (info, G_FILE_ATTRIBUTE_ID_FILE);
+ visited = FALSE;
+ if (id)
+ {
+ if (g_hash_table_lookup_extended (data->visited,
+ id, NULL, NULL))
+ {
+ visited = TRUE;
+ }
+ else
+ {
+ g_hash_table_insert (data->visited, g_strdup (id), NULL);
+ }
+ }
+
+ if (!visited)
+ {
+ g_queue_push_tail (data->directories, g_object_ref (child));
+ }
+ }
+
+ g_object_unref (child);
+next:
+ g_object_unref (info);
+ }
+
+ g_object_unref (enumerator);
+}
+
+
+static gpointer
+search_thread_func (gpointer user_data)
+{
+ SearchThreadData *data;
+ GFile *dir;
+ GFileInfo *info;
+ const char *id;
+
+ data = user_data;
+
+ /* Insert id for toplevel directory into visited */
+ dir = g_queue_peek_head (data->directories);
+ info = g_file_query_info (dir, G_FILE_ATTRIBUTE_ID_FILE, 0, data->cancellable, NULL);
+ if (info)
+ {
+ id = g_file_info_get_attribute_string (info, G_FILE_ATTRIBUTE_ID_FILE);
+ if (id)
+ {
+ g_hash_table_insert (data->visited, g_strdup (id), NULL);
+ }
+ g_object_unref (info);
+ }
+
+ while (!g_cancellable_is_cancelled (data->cancellable) &&
+ (dir = g_queue_pop_head (data->directories)) != NULL)
+ {
+ visit_directory (dir, data);
+ g_object_unref (dir);
+ }
+
+ if (!g_cancellable_is_cancelled (data->cancellable))
+ {
+ send_batch_in_idle (data);
+ }
+
+ finish_search_thread (data);
+
+ return NULL;
+}
+
+static void
+nautilus_search_engine_simple_start (NautilusSearchProvider *provider)
+{
+ NautilusSearchEngineSimple *simple;
+ SearchThreadData *data;
+ GThread *thread;
+
+ simple = NAUTILUS_SEARCH_ENGINE_SIMPLE (provider);
+
+ if (simple->active_search != NULL)
+ {
+ return;
+ }
+
+ DEBUG ("Simple engine start");
+
+ data = search_thread_data_new (simple, simple->query);
+
+ thread = g_thread_new ("nautilus-search-simple", search_thread_func, data);
+ simple->active_search = data;
+
+ g_object_notify (G_OBJECT (provider), "running");
+
+ g_thread_unref (thread);
+}
+
+static void
+nautilus_search_engine_simple_stop (NautilusSearchProvider *provider)
+{
+ NautilusSearchEngineSimple *simple = NAUTILUS_SEARCH_ENGINE_SIMPLE (provider);
+
+ if (simple->active_search != NULL)
+ {
+ DEBUG ("Simple engine stop");
+ g_cancellable_cancel (simple->active_search->cancellable);
+ }
+}
+
+static void
+nautilus_search_engine_simple_set_query (NautilusSearchProvider *provider,
+ NautilusQuery *query)
+{
+ NautilusSearchEngineSimple *simple = NAUTILUS_SEARCH_ENGINE_SIMPLE (provider);
+
+ g_clear_object (&simple->query);
+
+ simple->query = g_object_ref (query);
+}
+
+static gboolean
+nautilus_search_engine_simple_is_running (NautilusSearchProvider *provider)
+{
+ NautilusSearchEngineSimple *simple;
+
+ simple = NAUTILUS_SEARCH_ENGINE_SIMPLE (provider);
+
+ return simple->active_search != NULL;
+}
+
+static void
+nautilus_search_engine_simple_get_property (GObject *object,
+ guint arg_id,
+ GValue *value,
+ GParamSpec *pspec)
+{
+ NautilusSearchEngineSimple *engine = NAUTILUS_SEARCH_ENGINE_SIMPLE (object);
+
+ switch (arg_id)
+ {
+ case PROP_RUNNING:
+ {
+ g_value_set_boolean (value, nautilus_search_engine_simple_is_running (NAUTILUS_SEARCH_PROVIDER (engine)));
+ }
+ break;
+ }
+}
+
+static void
+nautilus_search_provider_init (NautilusSearchProviderInterface *iface)
+{
+ iface->set_query = nautilus_search_engine_simple_set_query;
+ iface->start = nautilus_search_engine_simple_start;
+ iface->stop = nautilus_search_engine_simple_stop;
+ iface->is_running = nautilus_search_engine_simple_is_running;
+}
+
+static void
+nautilus_search_engine_simple_class_init (NautilusSearchEngineSimpleClass *class)
+{
+ GObjectClass *gobject_class;
+
+ gobject_class = G_OBJECT_CLASS (class);
+ gobject_class->finalize = finalize;
+ gobject_class->get_property = nautilus_search_engine_simple_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_simple_init (NautilusSearchEngineSimple *engine)
+{
+ engine->query = NULL;
+ engine->active_search = NULL;
+}
+
+NautilusSearchEngineSimple *
+nautilus_search_engine_simple_new (void)
+{
+ NautilusSearchEngineSimple *engine;
+
+ engine = g_object_new (NAUTILUS_TYPE_SEARCH_ENGINE_SIMPLE, NULL);
+
+ return engine;
+}