[tracker/tracker-0.10] Rewrite of tracker-writeback



commit 60b9af1e643eb86e6c60b402b6d4e9639d30f6fd
Author: Philip Van Hoof <philip codeminded be>
Date:   Wed Jul 13 16:37:44 2011 +0200

    Rewrite of tracker-writeback

 data/dbus/Makefile.am                              |   39 +-
 data/dbus/tracker-writeback.xml                    |   23 +-
 src/tracker-writeback/Makefile.am                  |   51 +-
 src/tracker-writeback/tracker-main.c               |  128 +---
 src/tracker-writeback/tracker-writeback-consumer.c |  456 -----------
 src/tracker-writeback/tracker-writeback-consumer.h |   57 --
 .../tracker-writeback-dispatcher.c                 |  418 ----------
 .../tracker-writeback-dispatcher.h                 |   59 --
 src/tracker-writeback/tracker-writeback-file.h     |    2 +-
 src/tracker-writeback/tracker-writeback-module.c   |   40 +
 src/tracker-writeback/tracker-writeback-module.h   |   35 +-
 src/tracker-writeback/tracker-writeback.c          |  823 +++++++++++++++++++-
 src/tracker-writeback/tracker-writeback.h          |   58 +-
 13 files changed, 971 insertions(+), 1218 deletions(-)
---
diff --git a/data/dbus/Makefile.am b/data/dbus/Makefile.am
index 4549048..a809137 100644
--- a/data/dbus/Makefile.am
+++ b/data/dbus/Makefile.am
@@ -2,39 +2,42 @@ include $(top_srcdir)/Makefile.decl
 
 configdir = $(datadir)/tracker
 
-config_DATA =                                          \
-	tracker-backup.xml                             \
-	tracker-extract.xml                            \
-	tracker-miner.xml                              \
-	tracker-miner-web.xml                          \
-	tracker-resources.xml                          \
-	tracker-statistics.xml                         \
-	tracker-writeback.xml                          \
+config_DATA = \
+	tracker-backup.xml \
+	tracker-extract.xml \
+	tracker-miner.xml \
+	tracker-miner-web.xml \
+	tracker-resources.xml \
+	tracker-statistics.xml \
+	tracker-writeback.xml \
 	tracker-status.xml
 
-config_noinst =                                        \
+config_noinst = \
 	tracker-miner-files-index.xml
 
 # Services
-service_in_files =                                     \
-	org.freedesktop.Tracker1.service.in            \
+service_in_files = \
+	org.freedesktop.Tracker1.service.in \
 	org.freedesktop.Tracker1.Miner.Applications.service.in \
 	org.freedesktop.Tracker1.Miner.EMails.service.in \
 	org.freedesktop.Tracker1.Miner.Files.service.in \
 	org.freedesktop.Tracker1.Miner.Flickr.service.in \
 	org.freedesktop.Tracker1.Miner.RSS.service.in  \
-	org.freedesktop.Tracker1.Extract.service.in
+	org.freedesktop.Tracker1.Extract.service.in \
+	org.freedesktop.Tracker1.Writeback.service.in
 
 %.service: %.service.in
 	@sed -e "s|@libexecdir[ ]|${libexecdir}|" $< > $@
 
 # Services
 servicedir = $(DBUS_SERVICES_DIR)
-service_DATA =                                         \
-	org.freedesktop.Tracker1.service               \
+service_DATA = \
+	org.freedesktop.Tracker1.service \
 	org.freedesktop.Tracker1.Miner.Applications.service \
 	org.freedesktop.Tracker1.Miner.Files.service   \
-	org.freedesktop.Tracker1.Extract.service
+	org.freedesktop.Tracker1.Extract.service \
+	org.freedesktop.Tracker1.Writeback.service
+
 
 if HAVE_TRACKER_MINER_EVOLUTION
 service_DATA += org.freedesktop.Tracker1.Miner.EMails.service
@@ -49,9 +52,9 @@ service_DATA += org.freedesktop.Tracker1.Miner.Flickr.service
 endif
 
 
-EXTRA_DIST =                                           \
-	$(service_in_files)                            \
-	$(config_DATA)                                 \
+EXTRA_DIST = \
+	$(service_in_files) \
+	$(config_DATA) \
 	$(config_noinst)
 
 CLEANFILES = $(service_DATA)
diff --git a/data/dbus/tracker-writeback.xml b/data/dbus/tracker-writeback.xml
index e67cf70..71e09f5 100644
--- a/data/dbus/tracker-writeback.xml
+++ b/data/dbus/tracker-writeback.xml
@@ -1,8 +1,27 @@
 <?xml version="1.0" encoding="UTF-8"?>
 
+<!--
+<busconfig>
+    <policy context="default">
+      <deny send_interface="org.freedesktop.Tracker1.Indexer"/>
+      <allow send_destination="org.freedesktop.Tracker1"/>
+    </policy>
+</busconfig>
+-->
+
 <node name="/">
   <interface name="org.freedesktop.Tracker1.Writeback">
-    <annotation name="org.freedesktop.DBus.GLib.CSymbol" value="tracker_writeback_dbus"/>
-
+    <method name="GetPid">
+      <annotation name="org.freedesktop.DBus.GLib.Async" value="true"/>
+      <arg type="i" name="value" direction="out" />
+    </method>
+    <method name='PerformWriteback'>"
+      <arg type='s' name='uri' direction='in' />"
+      <arg type='as' name='rdf_types' direction='in' />"
+      <arg type='aas' name='results' direction='in' />"
+    </method>"
+    <method name='CancelTasks'>"
+      <arg type='as' name='uri' direction='in' />"
+    </method>"
   </interface>
 </node>
diff --git a/src/tracker-writeback/Makefile.am b/src/tracker-writeback/Makefile.am
index f0d0f7c..f459ed8 100644
--- a/src/tracker-writeback/Makefile.am
+++ b/src/tracker-writeback/Makefile.am
@@ -10,7 +10,9 @@ AM_CPPFLAGS =                                          \
 	-DLOCALEDIR=\""$(localedir)"\"                 \
 	-DMODULESDIR=\"$(modulesdir)\"                 \
 	-DWRITEBACK_MODULES_DIR=\""$(modulesdir)"\"    \
-	$(TRACKER_WRITEBACK_CFLAGS)
+	$(TRACKER_WRITEBACK_CFLAGS)                    \
+	$(LIBTRACKER_MINER_CFLAGS)
+
 
 modules_LTLIBRARIES =
 
@@ -44,36 +46,31 @@ endif
 #
 libexec_PROGRAMS = tracker-writeback
 
-tracker_writeback_SOURCES =                            \
-	$(marshal_sources)                             \
-	$(dbus_sources)                                \
-	tracker-config.c                               \
-	tracker-config.h                               \
-	tracker-writeback-consumer.c                   \
-	tracker-writeback-consumer.h                   \
-	tracker-writeback-dbus.h                       \
-	tracker-writeback-dispatcher.c                 \
-	tracker-writeback-dispatcher.h                 \
-	tracker-writeback-file.c                       \
-	tracker-writeback-file.h                       \
-	tracker-writeback-module.c                     \
-	tracker-writeback-module.h                     \
-	tracker-writeback.c                            \
-	tracker-writeback.h                            \
+tracker_writeback_SOURCES = \
+	$(marshal_sources) \
+	$(dbus_sources) \
+	tracker-config.c \
+	tracker-config.h \
+	tracker-writeback-dbus.h \
+	tracker-writeback-file.c \
+	tracker-writeback-file.h \
+	tracker-writeback-module.c \
+	tracker-writeback-module.h \
+	tracker-writeback.c \
+	tracker-writeback.h \
 	tracker-main.c
 
-tracker_writeback_LDADD =                              \
+tracker_writeback_LDADD = \
 	$(top_builddir)/src/libtracker-sparql-backend/libtracker-sparql- TRACKER_API_VERSION@.la \
 	$(top_builddir)/src/libtracker-miner/libtracker-miner- TRACKER_API_VERSION@.la \
 	$(top_builddir)/src/libtracker-common/libtracker-common.la \
-	$(BUILD_LIBS)                                  \
-	$(TRACKER_WRITEBACK_LIBS)
+	$(BUILD_LIBS) \
+	$(TRACKER_WRITEBACK_LIBS) \
+	$(LIBTRACKER_MINER_LIBS)
 
-dbus_sources =                                         \
-	tracker-writeback-glue.h
 
-marshal_sources =                                      \
-	tracker-marshal.h                              \
+marshal_sources = \
+	tracker-marshal.h \
 	tracker-marshal.c
 
 tracker-marshal.h: tracker-marshal.list
@@ -83,11 +80,7 @@ tracker-marshal.c: tracker-marshal.list
 	$(AM_V_GEN)echo "#include \"tracker-marshal.h\"" > $@ && \
 		$(GLIB_GENMARSHAL) $< --prefix=tracker_marshal --body >> $@
 
-%-glue.h: $(top_srcdir)/data/dbus/%.xml
-	$(AM_V_GEN)$(DBUSBINDINGTOOL) --mode=glib-server --output=$@ --prefix=$(subst -,_,$*) $^
-
-BUILT_SOURCES =                                        \
-	$(dbus_sources)                                \
+BUILT_SOURCES = \
 	$(marshal_sources)
 
 CLEANFILES = $(BUILT_SOURCES)
diff --git a/src/tracker-writeback/tracker-main.c b/src/tracker-writeback/tracker-main.c
index a42226d..f42fa69 100644
--- a/src/tracker-writeback/tracker-main.c
+++ b/src/tracker-writeback/tracker-main.c
@@ -28,8 +28,7 @@
 
 #include <libtracker-common/tracker-log.h>
 
-#include "tracker-writeback-dispatcher.h"
-#include "tracker-writeback-consumer.h"
+#include "tracker-writeback.h"
 #include "tracker-config.h"
 
 #define ABOUT	  \
@@ -58,93 +57,6 @@ static GOptionEntry  entries[] = {
 	{ NULL }
 };
 
-typedef struct {
-	gint    subject;
-	GArray *rdf_types;
-} WritebackData;
-
-static TrackerWritebackConsumer *consumer = NULL;
-static TrackerWritebackDispatcher *dispatcher = NULL;
-static GMainContext *dispatcher_context = NULL;
-
-static WritebackData *
-writeback_data_new (gint    subject,
-                    GArray *rdf_types)
-{
-	WritebackData *data;
-	guint i;
-
-	data = g_slice_new (WritebackData);
-	data->subject = subject;
-
-	data->rdf_types = g_array_sized_new (FALSE, FALSE, sizeof (gint), rdf_types->len);
-
-	for (i = 0; i < rdf_types->len; i++) {
-		gint id = g_array_index (rdf_types, gint, i);
-		g_array_append_val (data->rdf_types, id);
-	}
-
-	return data;
-}
-
-static void
-writeback_data_free (WritebackData *data)
-{
-	g_array_free (data->rdf_types, TRUE);
-	g_slice_free (WritebackData, data);
-}
-
-/* This function will be executed in the main thread */
-static gboolean
-on_writeback_idle_cb (gpointer user_data)
-{
-	WritebackData *data = user_data;
-
-	g_message ("Main thread (%p) got signaled of writeback petition", g_thread_self ());
-
-	tracker_writeback_consumer_add_subject (consumer, data->subject, data->rdf_types);
-
-	writeback_data_free (data);
-
-	return FALSE;
-}
-
-/* This callback run in the dispatcher thread */
-static void
-on_writeback_cb (TrackerWritebackDispatcher *dispatcher,
-                 gint                        subject,
-                 GArray                     *rdf_types)
-{
-	WritebackData *data;
-
-	g_message ("Got writeback petition on thread '%p' for subject '%d'",
-	           g_thread_self (), subject);
-
-	data = writeback_data_new (subject, rdf_types);
-	g_idle_add_full (G_PRIORITY_HIGH_IDLE,
-	                 on_writeback_idle_cb,
-	                 data, NULL);
-}
-
-static gpointer
-dispatcher_thread_func (gpointer data)
-{
-	GMainLoop *loop;
-
-	g_message ("DBus Dispatcher thread created: %p", g_thread_self ());
-
-	g_signal_connect (dispatcher, "writeback",
-	                  G_CALLBACK (on_writeback_cb), NULL);
-
-	loop = g_main_loop_new (dispatcher_context, FALSE);
-	g_main_loop_run (loop);
-
-	g_object_unref (dispatcher);
-	g_main_loop_unref (loop);
-	g_main_context_unref (dispatcher_context);
-
-	return NULL;
-}
 
 static void
 sanity_check_option_values (TrackerConfig *config)
@@ -159,13 +71,13 @@ main (int   argc,
       char *argv[])
 {
 	TrackerConfig *config;
+	TrackerController *controller;
 	GOptionContext *context;
 	GMainLoop *loop;
 	GError *error = NULL;
 	gchar *log_filename;
 
 	g_thread_init (NULL);
-	dbus_g_thread_init ();
 
 	g_type_init ();
 
@@ -204,38 +116,14 @@ main (int   argc,
 
 	sanity_check_option_values (config);
 
+#warning todo here
 
-	consumer = tracker_writeback_consumer_new (&error);
+	// get correct value from config here
+	controller = tracker_controller_new (9999, &error);
 
 	if (error) {
-		g_critical ("Error creating consumer: %s", error->message);
+		g_critical ("Error creating controller: %s", error->message);
 		g_error_free (error);
-
-		return EXIT_FAILURE;
-	}
-
-	/* Create dispatcher thread data here, GType
-	 * initialization for boxed types don't seem
-	 * to be threadsafe, this is troublesome with
-	 * signals initialization. */
-
-	dispatcher_context = g_main_context_new ();
-	dispatcher = tracker_writeback_dispatcher_new (dispatcher_context,
-	                                               &error);
-
-	if (error) {
-		g_critical ("Error creating dispatcher: %s", error->message);
-		g_error_free (error);
-
-		return EXIT_FAILURE;
-	}
-
-	g_thread_create (dispatcher_thread_func, dispatcher, FALSE, &error);
-
-	if (error) {
-		g_critical ("Error creating dispatcher thread: %s", error->message);
-		g_error_free (error);
-
 		return EXIT_FAILURE;
 	}
 
@@ -244,9 +132,11 @@ main (int   argc,
 	loop = g_main_loop_new (NULL, FALSE);
 	g_main_loop_run (loop);
 
+
 	tracker_log_shutdown ();
 
-	g_object_unref (consumer);
+	g_object_unref (controller);
+
 	g_main_loop_unref (loop);
 
 	g_object_unref (config);
diff --git a/src/tracker-writeback/tracker-writeback-file.h b/src/tracker-writeback/tracker-writeback-file.h
index c3ffbc3..9b81813 100644
--- a/src/tracker-writeback/tracker-writeback-file.h
+++ b/src/tracker-writeback/tracker-writeback-file.h
@@ -22,7 +22,7 @@
 
 #include <gio/gio.h>
 
-#include "tracker-writeback.h"
+#include "tracker-writeback-module.h"
 
 G_BEGIN_DECLS
 
diff --git a/src/tracker-writeback/tracker-writeback-module.c b/src/tracker-writeback/tracker-writeback-module.c
index b45847e..4ebf731 100644
--- a/src/tracker-writeback/tracker-writeback-module.c
+++ b/src/tracker-writeback/tracker-writeback-module.c
@@ -23,11 +23,16 @@
 
 #include "tracker-writeback-module.h"
 
+static TrackerMinerManager *manager = NULL;
+
 static gboolean writeback_module_load   (GTypeModule *module);
 static void     writeback_module_unload (GTypeModule *module);
 
 G_DEFINE_TYPE (TrackerWritebackModule, tracker_writeback_module, G_TYPE_TYPE_MODULE)
 
+G_DEFINE_ABSTRACT_TYPE (TrackerWriteback, tracker_writeback, G_TYPE_OBJECT)
+
+
 static void
 tracker_writeback_module_class_init (TrackerWritebackModuleClass *klass)
 {
@@ -162,3 +167,38 @@ tracker_writeback_module_get_rdf_types (TrackerWritebackModule *module)
 {
 	return (module->get_rdf_types) ();
 }
+
+static void
+tracker_writeback_class_init (TrackerWritebackClass *klass)
+{
+}
+
+static void
+tracker_writeback_init (TrackerWriteback *writeback)
+{
+}
+
+gboolean
+tracker_writeback_update_metadata (TrackerWriteback        *writeback,
+                                   GPtrArray               *values,
+                                   TrackerSparqlConnection *connection)
+{
+	g_return_val_if_fail (TRACKER_IS_WRITEBACK (writeback), FALSE);
+	g_return_val_if_fail (values != NULL, FALSE);
+
+	if (TRACKER_WRITEBACK_GET_CLASS (writeback)->update_metadata) {
+		return TRACKER_WRITEBACK_GET_CLASS (writeback)->update_metadata (writeback, values, connection);
+	}
+
+	return FALSE;
+}
+
+TrackerMinerManager*
+tracker_writeback_get_miner_manager (void)
+{
+	if (!manager) {
+		manager = tracker_miner_manager_new ();
+	}
+
+	return manager;
+}
diff --git a/src/tracker-writeback/tracker-writeback-module.h b/src/tracker-writeback/tracker-writeback-module.h
index be023a6..b8038a2 100644
--- a/src/tracker-writeback/tracker-writeback-module.h
+++ b/src/tracker-writeback/tracker-writeback-module.h
@@ -23,16 +23,38 @@
 #include <glib.h>
 #include <glib-object.h>
 
-#include "tracker-writeback.h"
+#include <libtracker-miner/tracker-miner.h>
+#include <libtracker-sparql/tracker-sparql.h>
 
 G_BEGIN_DECLS
 
 #define TRACKER_TYPE_WRITEBACK_MODULE    (tracker_writeback_module_get_type ())
 #define TRACKER_WRITEBACK_MODULE(module) (G_TYPE_CHECK_INSTANCE_CAST ((module), TRACKER_TYPE_WRITEBACK_MODULE, TrackerWritebackModule))
 
+#define TRACKER_TYPE_WRITEBACK         (tracker_writeback_get_type())
+#define TRACKER_WRITEBACK(o)           (G_TYPE_CHECK_INSTANCE_CAST ((o), TRACKER_TYPE_WRITEBACK, TrackerWriteback))
+#define TRACKER_WRITEBACK_CLASS(c)     (G_TYPE_CHECK_CLASS_CAST ((c), TRACKER_TYPE_WRITEBACK, TrackerWritebackClass))
+#define TRACKER_IS_WRITEBACK(o)        (G_TYPE_CHECK_INSTANCE_TYPE ((o), TRACKER_TYPE_WRITEBACK))
+#define TRACKER_IS_WRITEBACK_CLASS(c)  (G_TYPE_CHECK_CLASS_TYPE ((c),  TRACKER_TYPE_WRITEBACK))
+#define TRACKER_WRITEBACK_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), TRACKER_TYPE_WRITEBACK, TrackerWritebackClass))
+
+typedef struct TrackerWriteback TrackerWriteback;
+typedef struct TrackerWritebackClass TrackerWritebackClass;
 typedef struct TrackerWritebackModule TrackerWritebackModule;
 typedef struct TrackerWritebackModuleClass TrackerWritebackModuleClass;
 
+struct TrackerWriteback {
+	GObject parent_instance;
+};
+
+struct TrackerWritebackClass {
+	GObjectClass parent_class;
+
+	gboolean (* update_metadata) (TrackerWriteback        *writeback,
+	                              GPtrArray               *values,
+	                              TrackerSparqlConnection *connection);
+};
+
 struct TrackerWritebackModule {
 	GTypeModule parent_instance;
 
@@ -47,6 +69,17 @@ struct TrackerWritebackModuleClass {
 	GTypeModuleClass parent_class;
 };
 
+
+GType                   tracker_writeback_get_type          (void) G_GNUC_CONST;
+gboolean                tracker_writeback_update_metadata   (TrackerWriteback        *writeback,
+                                                             GPtrArray               *values,
+                                                             TrackerSparqlConnection *connection);
+TrackerMinerManager*    tracker_writeback_get_miner_manager (void);
+
+/* Entry functions to be defined by modules */
+TrackerWriteback *      writeback_module_create             (GTypeModule             *module);
+const gchar * const *   writeback_module_get_rdf_types      (void);
+
 GType                   tracker_writeback_module_get_type      (void) G_GNUC_CONST;
 
 TrackerWritebackModule *tracker_writeback_module_get           (const gchar            *name);
diff --git a/src/tracker-writeback/tracker-writeback.c b/src/tracker-writeback/tracker-writeback.c
index 6b26733..67cb160 100644
--- a/src/tracker-writeback/tracker-writeback.c
+++ b/src/tracker-writeback/tracker-writeback.c
@@ -1,61 +1,834 @@
 /*
- * Copyright (C) 2009, Nokia <ivan frade nokia com>
+ * Copyright (C) 2011, Nokia <ivan frade nokia com>
  *
  * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public
+ * modify it under the terms of the GNU Lesser General Public
  * License as published by the Free Software Foundation; either
- * version 2 of the License, or (at your option) any later version.
+ * version 2.1 of the License, or (at your option) any later version.
  *
  * This library 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.
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.	 See the GNU
+ * Lesser General Public License for more details.
  *
- * You should have received a copy of the GNU General Public
+ * You should have received a copy of the GNU Lesser General Public
  * License along with this library; if not, write to the
  * Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA  02110-1301, USA.
  */
 
-#include "config.h"
-
 #include "tracker-writeback.h"
+#include "tracker-writeback-module.h"
+
+#include <libtracker-common/tracker-common.h>
+#include <libtracker-miner/tracker-miner.h>
+#include <libtracker-sparql/tracker-sparql.h>
+
+#include <gio/gio.h>
+
+#ifdef STAYALIVE_ENABLE_TRACE
+#warning Stayalive traces enabled
+#endif /* STAYALIVE_ENABLE_TRACE */
+
+#define THREAD_ENABLE_TRACE
+
+#ifdef THREAD_ENABLE_TRACE
+#warning Controller thread traces enabled
+#endif /* THREAD_ENABLE_TRACE */
+
+typedef struct {
+	GMainContext *context;
+	GMainLoop *main_loop;
+
+	TrackerStorage *storage;
+
+	GDBusConnection *d_connection;
+	GDBusNodeInfo *introspection_data;
+	guint registration_id;
+	guint bus_name_id;
+
+	GList *ongoing_tasks;
+
+	guint shutdown_timeout;
+	GSource *shutdown_source;
+
+	GCond *initialization_cond;
+	GMutex *initialization_mutex;
+	GError *initialization_error;
+
+	guint initialized : 1;
+
+	GHashTable *modules;
+	TrackerSparqlConnection *connection;
+} TrackerControllerPrivate;
+
+typedef struct {
+	TrackerController *controller;
+	GCancellable *cancellable;
+	GDBusMethodInvocation *invocation;
+	TrackerDBusRequest *request;
+	gchar *subject;
+	GPtrArray *results;
+} WritebackData;
+
+#define TRACKER_WRITEBACK_SERVICE   "org.freedesktop.Tracker1.Writeback"
+#define TRACKER_WRITEBACK_PATH      "/org/freedesktop/Tracker1/Writeback"
+#define TRACKER_WRITEBACK_INTERFACE "org.freedesktop.Tracker1.Writeback"
 
-G_DEFINE_ABSTRACT_TYPE (TrackerWriteback, tracker_writeback, G_TYPE_OBJECT)
+static const gchar *introspection_xml =
+	"<node>"
+	"  <interface name='org.freedesktop.Tracker1.Writeback'>"
+	"    <method name='GetPid'>"
+	"      <arg type='i' name='value' direction='out' />"
+	"    </method>"
+	"    <method name='PerformWriteback'>"
+	"      <arg type='s' name='uri' direction='in' />"
+	"      <arg type='as' name='rdf_types' direction='in' />"
+	"      <arg type='aas' name='results' direction='in' />"
+	"    </method>"
+	"    <method name='CancelTasks'>"
+	"      <arg type='as' name='uri' direction='in' />"
+	"    </method>"
+	"  </interface>"
+	"</node>";
 
-static TrackerMinerManager *manager = NULL;
+enum {
+	PROP_0,
+	PROP_SHUTDOWN_TIMEOUT,
+};
+
+static void     tracker_controller_initable_iface_init  (GInitableIface     *iface);
+static gboolean tracker_controller_dbus_start           (TrackerController  *controller,
+                                                         GError            **error);
+static void     tracker_controller_dbus_stop            (TrackerController  *controller);
+static gboolean tracker_controller_start                (TrackerController  *controller,
+                                                         GError            **error);
+
+G_DEFINE_TYPE_WITH_CODE (TrackerController, tracker_controller, G_TYPE_OBJECT,
+                         G_IMPLEMENT_INTERFACE (G_TYPE_INITABLE,
+                                                tracker_controller_initable_iface_init));
+
+static gboolean
+tracker_controller_initable_init (GInitable     *initable,
+                                  GCancellable  *cancellable,
+                                  GError       **error)
+{
+	return tracker_controller_start (TRACKER_CONTROLLER (initable), error);
+}
+
+static void
+tracker_controller_initable_iface_init (GInitableIface *iface)
+{
+	iface->init = tracker_controller_initable_init;
+}
 
 static void
-tracker_writeback_class_init (TrackerWritebackClass *klass)
+tracker_controller_finalize (GObject *object)
 {
+	TrackerControllerPrivate *priv;
+	TrackerController *controller;
+
+	controller = TRACKER_CONTROLLER (object);
+	priv = controller->priv;
+
+	if (priv->shutdown_source) {
+		g_source_destroy (priv->shutdown_source);
+		priv->shutdown_source = NULL;
+	}
+
+	tracker_controller_dbus_stop (controller);
+
+	g_object_unref (priv->storage);
+	g_hash_table_unref (priv->modules);
+
+	g_main_loop_unref (priv->main_loop);
+	g_main_context_unref (priv->context);
+
+	g_cond_free (priv->initialization_cond);
+	g_mutex_free (priv->initialization_mutex);
+
+	G_OBJECT_CLASS (tracker_controller_parent_class)->finalize (object);
 }
 
 static void
-tracker_writeback_init (TrackerWriteback *writeback)
+tracker_controller_get_property (GObject    *object,
+                                 guint       param_id,
+                                 GValue     *value,
+                                 GParamSpec *pspec)
 {
+	TrackerControllerPrivate *priv = TRACKER_CONTROLLER (object)->priv;
+
+	switch (param_id) {
+	case PROP_SHUTDOWN_TIMEOUT:
+		g_value_set_uint (value, priv->shutdown_timeout);
+		break;
+	}
 }
 
-gboolean
-tracker_writeback_update_metadata (TrackerWriteback        *writeback,
-                                   GPtrArray               *values,
-                                   TrackerSparqlConnection *connection)
+static void
+tracker_controller_set_property (GObject      *object,
+                                 guint         param_id,
+                                 const GValue *value,
+                                 GParamSpec   *pspec)
 {
-	g_return_val_if_fail (TRACKER_IS_WRITEBACK (writeback), FALSE);
-	g_return_val_if_fail (values != NULL, FALSE);
+	TrackerControllerPrivate *priv = TRACKER_CONTROLLER (object)->priv;
 
-	if (TRACKER_WRITEBACK_GET_CLASS (writeback)->update_metadata) {
-		return TRACKER_WRITEBACK_GET_CLASS (writeback)->update_metadata (writeback, values, connection);
+	switch (param_id) {
+	case PROP_SHUTDOWN_TIMEOUT:
+		priv->shutdown_timeout = g_value_get_uint (value);
+		break;
 	}
+}
+
+static void
+tracker_controller_class_init (TrackerControllerClass *klass)
+{
+	GObjectClass *object_class = G_OBJECT_CLASS (klass);
+
+	object_class->finalize = tracker_controller_finalize;
+	object_class->get_property = tracker_controller_get_property;
+	object_class->set_property = tracker_controller_set_property;
+
+	g_object_class_install_property (object_class,
+	                                 PROP_SHUTDOWN_TIMEOUT,
+	                                 g_param_spec_uint ("shutdown-timeout",
+	                                                    "Shutdown timeout",
+	                                                    "Shutdown timeout, 0 to disable",
+	                                                    0, 1000, 0,
+	                                                    G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY));
+
+	g_type_class_add_private (object_class, sizeof (TrackerControllerPrivate));
+}
+
+static WritebackData *
+writeback_data_new (TrackerController     *controller,
+                    const gchar           *subject,
+                    GPtrArray             *results,
+                    GDBusMethodInvocation *invocation,
+                    TrackerDBusRequest    *request)
+{
+	WritebackData *data;
+
+	data = g_slice_new (WritebackData);
+	data->cancellable = g_cancellable_new ();
+	data->controller = controller;
+	data->subject = g_strdup (subject);
+	data->results = g_ptr_array_ref (results);
+	data->invocation = invocation;
+	data->request = request;
+
+	return data;
+}
+
+static void
+writeback_data_free (WritebackData *data)
+{
+	/* We rely on data->invocation being freed through
+	 * the g_dbus_method_invocation_return_* methods
+	 */
+	g_free (data->subject);
+	g_ptr_array_unref (data->results);
+	g_object_unref (data->cancellable);
+	g_slice_free (WritebackData, data);
+}
+
+static void
+cancel_tasks_in_file (TrackerController *controller,
+                      GFile             *file)
+{
+/*
+	TrackerControllerPrivate *priv;
+	GList *elem;
+
+	priv = controller->priv;
+
+	for (elem = priv->ongoing_tasks; elem; elem = elem->next) {
+		GetMetadataData *data;
+		GFile *task_file;
+
+		data = elem->data;
+
+#warning todo here
+		// todo: the GFile holds the nie:url, not the subject, so this wont work
+
+		task_file = g_file_new_for_uri (data->subject);
+
+		if (g_file_equal (task_file, file) ||
+		    g_file_has_prefix (task_file, file)) {
+			/ Mount path contains one of the files being processed /
+			if (!elem->next) {
+				* The last element in the list is
+				 * the one currently being processed,
+				 * so exit abruptly.
+				 *
+				g_message ("Cancelled task ('%s') is currently being processed, quitting",
+				           data->uri);
+				_exit (0);
+			} else {
+				g_message ("Cancelling not yet processed task ('%s')",
+				           data->uri);
+				g_cancellable_cancel (data->cancellable);
+			}
+		}
+
+		g_object_unref (task_file);
+	} */
+}
+
+static void
+mount_point_removed_cb (TrackerStorage *storage,
+                        const gchar    *uuid,
+                        const gchar    *mount_point,
+                        gpointer        user_data)
+{
+	GFile *mount_file;
+
+	mount_file = g_file_new_for_path (mount_point);
+	cancel_tasks_in_file (TRACKER_CONTROLLER (user_data), mount_file);
+	g_object_unref (mount_file);
+}
+
+static gboolean
+reset_shutdown_timeout_cb (gpointer user_data)
+{
+	TrackerControllerPrivate *priv;
+
+#ifdef STAYALIVE_ENABLE_TRACE
+	g_debug ("Stayalive --- time has expired");
+#endif /* STAYALIVE_ENABLE_TRACE */
+
+	g_message ("Shutting down due to no activity");
+
+	priv = TRACKER_CONTROLLER (user_data)->priv;
+	g_main_loop_quit (priv->main_loop);
 
 	return FALSE;
 }
 
-TrackerMinerManager*
-tracker_writeback_get_miner_manager (void)
+static void
+reset_shutdown_timeout (TrackerController *controller)
+{
+	TrackerControllerPrivate *priv;
+	GSource *source;
+
+	priv = controller->priv;
+
+	if (priv->shutdown_timeout == 0) {
+		return;
+	}
+
+#ifdef STAYALIVE_ENABLE_TRACE
+	g_debug ("Stayalive --- (Re)setting timeout");
+#endif /* STAYALIVE_ENABLE_TRACE */
+
+	if (priv->shutdown_source) {
+		g_source_destroy (priv->shutdown_source);
+		priv->shutdown_source = NULL;
+	}
+
+	source = g_timeout_source_new_seconds (priv->shutdown_timeout);
+	g_source_set_callback (source,
+	                       reset_shutdown_timeout_cb,
+	                       controller, NULL);
+
+	g_source_attach (source, priv->context);
+	priv->shutdown_source = source;
+}
+
+static void
+tracker_controller_init (TrackerController *controller)
+{
+	TrackerControllerPrivate *priv;
+
+	priv = controller->priv = G_TYPE_INSTANCE_GET_PRIVATE (controller,
+	                                                       TRACKER_TYPE_CONTROLLER,
+	                                                       TrackerControllerPrivate);
+
+	priv->context = g_main_context_new ();
+	priv->main_loop = g_main_loop_new (priv->context, FALSE);
+
+	priv->storage = tracker_storage_new ();
+	g_signal_connect (priv->storage, "mount-point-removed",
+	                  G_CALLBACK (mount_point_removed_cb), controller);
+
+	priv->initialization_cond = g_cond_new ();
+	priv->initialization_mutex = g_mutex_new ();
+}
+
+static void
+handle_method_call_get_pid (TrackerController     *controller,
+                            GDBusMethodInvocation *invocation,
+                            GVariant              *parameters)
+{
+	TrackerDBusRequest *request;
+	pid_t value;
+
+	request = tracker_g_dbus_request_begin (invocation,
+	                                        "%s()",
+	                                        __FUNCTION__);
+
+	reset_shutdown_timeout (controller);
+	value = getpid ();
+	tracker_dbus_request_debug (request,
+	                            "PID is %d",
+	                            value);
+
+	tracker_dbus_request_end (request, NULL);
+
+	g_dbus_method_invocation_return_value (invocation,
+	                                       g_variant_new ("(i)", (gint) value));
+}
+
+static void
+perform_writeback_cb (GObject      *object,
+                      GAsyncResult *res,
+                      gpointer      user_data)
+{
+	TrackerControllerPrivate *priv;
+	WritebackData *data;
+
+	data = user_data;
+	priv = data->controller->priv;
+	priv->ongoing_tasks = g_list_remove (priv->ongoing_tasks, data);
+//	info = g_simple_async_result_get_op_res_gpointer (G_SIMPLE_ASYNC_RESULT (res));
+
+//	if (info) {
+	if (TRUE) {
+		g_dbus_method_invocation_return_value (data->invocation, NULL);
+
+		tracker_dbus_request_end (data->request, NULL);
+	} else {
+		GError *error = NULL;
+
+#ifdef THREAD_ENABLE_TRACE
+		g_debug ("Thread:%p (Controller) --> Got error back",
+		         g_thread_self ());
+#endif /* THREAD_ENABLE_TRACE */
+
+		g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (res), &error);
+		tracker_dbus_request_end (data->request, error);
+		g_dbus_method_invocation_return_gerror (data->invocation, error);
+		g_error_free (error);
+	}
+
+	writeback_data_free (data);
+}
+
+static gboolean
+sparql_rdf_types_match (const gchar * const *module_types,
+                        const gchar * const *rdf_types)
+{
+	guint n;
+
+	for (n = 0; rdf_types[n] != NULL; n++) {
+		guint i;
+
+		for (i = 0; module_types[i] != NULL; i++) {
+			if (g_strcmp0 (module_types[i], rdf_types[n]) == 0) {
+				return TRUE;
+			}
+		}
+	}
+
+	return FALSE;
+}
+
+static void
+handle_method_call_perform_writeback (TrackerController     *controller,
+                                      GDBusMethodInvocation *invocation,
+                                      GVariant              *parameters)
+{
+	TrackerControllerPrivate *priv;
+	WritebackData *data;
+	TrackerDBusRequest *request;
+	const gchar *subject;
+	GPtrArray *results = NULL;
+	GHashTableIter iter;
+	gpointer key, value;
+	GVariantIter *iter1, *iter2, *iter3;
+	GArray *rdf_types_array;
+	GStrv rdf_types;
+	gchar *rdf_type = NULL;
+
+	priv = controller->priv;
+
+	results = g_ptr_array_new_with_free_func ((GDestroyNotify) g_strfreev);
+	g_variant_get (parameters, "(&sasaas)", &subject, &iter1, &iter2);
+
+	rdf_types_array = g_array_new (TRUE, TRUE, sizeof (gchar *));
+	while (g_variant_iter_loop (iter1, "&s", &rdf_type)) {
+		g_array_append_val (rdf_types_array, rdf_type);
+	}
+
+	rdf_types = (GStrv) rdf_types_array->data;
+	g_array_free (rdf_types_array, FALSE);
+
+	while (g_variant_iter_loop (iter2, "as", &iter3)) {
+		GArray *row_array = g_array_new (TRUE, TRUE, sizeof (gchar *));
+		gchar *cell = NULL;
+
+		while (g_variant_iter_loop (iter3, "&s", &cell)) {
+			g_array_append_val (row_array, cell);
+		}
+
+		g_ptr_array_add (results, row_array->data);
+		g_array_free (row_array, FALSE);
+	}
+
+	g_variant_iter_free (iter1);
+	g_variant_iter_free (iter2);
+
+	reset_shutdown_timeout (controller);
+	request = tracker_dbus_request_begin (NULL, "%s (%s)", __FUNCTION__, subject);
+
+	g_hash_table_iter_init (&iter, priv->modules);
+
+	data = writeback_data_new (controller, subject, results, invocation, request);
+
+	while (g_hash_table_iter_next (&iter, &key, &value)) {
+		TrackerWritebackModule *module;
+		const gchar * const *module_types;
+
+		module = value;
+		module_types = tracker_writeback_module_get_rdf_types (module);
+
+		if (sparql_rdf_types_match (module_types, (const gchar * const *) rdf_types)) {
+			TrackerWriteback *writeback;
+
+			g_message ("  Updating metadata for subject:'%s' using module:'%s'",
+			           subject,
+			           module->name);
+
+			writeback = tracker_writeback_module_create (module);
+
+#warning todo here
+			// todo: make this really async using ie. g_io_scheduler_push_job
+			tracker_writeback_update_metadata (writeback, results, priv->connection);
+			g_object_unref (writeback);
+		}
+	}
+
+	priv->ongoing_tasks = g_list_prepend (priv->ongoing_tasks, data);
+
+	// todo: make this really async
+	perform_writeback_cb (NULL, NULL, data);
+
+	g_free (rdf_types);
+}
+
+static void
+handle_method_call_cancel_tasks (TrackerController     *controller,
+                                 GDBusMethodInvocation *invocation,
+                                 GVariant              *parameters)
+{
+	TrackerDBusRequest *request;
+	gchar **uris;
+	gint i;
+
+#ifdef THREAD_ENABLE_TRACE
+	g_debug ("Thread:%p (Controller) --> Got Tasks cancellation request",
+		 g_thread_self ());
+#endif /* THREAD_ENABLE_TRACE */
+
+
+	g_variant_get (parameters, "(^as)", &uris);
+
+	request = tracker_dbus_request_begin (NULL, "%s (%s, ...)", __FUNCTION__, uris[0]);
+
+	for (i = 0; uris[i] != NULL; i++) {
+		GFile *file;
+
+		file = g_file_new_for_uri (uris[i]);
+		cancel_tasks_in_file (controller, file);
+		g_object_unref (file);
+	}
+
+	g_strfreev (uris);
+	tracker_dbus_request_end (request, NULL);
+	g_dbus_method_invocation_return_value (invocation, NULL);
+}
+
+static void
+handle_method_call (GDBusConnection       *connection,
+                    const gchar           *sender,
+                    const gchar           *object_path,
+                    const gchar           *interface_name,
+                    const gchar           *method_name,
+                    GVariant              *parameters,
+                    GDBusMethodInvocation *invocation,
+                    gpointer               user_data)
+{
+	TrackerController *controller = user_data;
+
+	if (g_strcmp0 (method_name, "GetPid") == 0) {
+		handle_method_call_get_pid (controller, invocation, parameters);
+	} else if (g_strcmp0 (method_name, "PerformWriteback") == 0) {
+		handle_method_call_perform_writeback (controller, invocation, parameters);
+	} else if (g_strcmp0 (method_name, "CancelTasks") == 0) {
+		handle_method_call_cancel_tasks (controller, invocation, parameters);
+	} else {
+		g_warning ("Unknown method '%s' called", method_name);
+	}
+}
+
+static void
+controller_notify_main_thread (TrackerController *controller,
+                               GError            *error)
+{
+	TrackerControllerPrivate *priv;
+
+	priv = controller->priv;
+
+	g_mutex_lock (priv->initialization_mutex);
+
+	priv->initialized = TRUE;
+	priv->initialization_error = error;
+
+	/* Notify about the initialization */
+	g_cond_signal (priv->initialization_cond);
+
+	g_mutex_unlock (priv->initialization_mutex);
+}
+
+static void
+bus_name_acquired_cb (GDBusConnection *connection,
+                      const gchar     *name,
+                      gpointer         user_data)
+{
+	controller_notify_main_thread (TRACKER_CONTROLLER (user_data), NULL);
+}
+
+static void
+bus_name_vanished_cb (GDBusConnection *connection,
+                      const gchar     *name,
+                      gpointer         user_data)
+{
+	TrackerController *controller;
+	TrackerControllerPrivate *priv;
+
+	controller = user_data;
+	priv = controller->priv;
+
+	if (!priv->initialized) {
+		GError *error;
+
+		error = g_error_new_literal (TRACKER_DBUS_ERROR, 0,
+		                             "Could not acquire bus name, "
+		                             "perhaps it's already taken?");
+		controller_notify_main_thread (controller, error);
+	} else {
+		/* We're already in control of the program
+		 * lifetime, so just quit the mainloop
+		 */
+		g_main_loop_quit (priv->main_loop);
+	}
+}
+
+static gboolean
+tracker_controller_dbus_start (TrackerController   *controller,
+                               GError             **error)
 {
-	if (!manager) {
-		manager = tracker_miner_manager_new ();
+	TrackerControllerPrivate *priv;
+	GError *err = NULL;
+	GDBusInterfaceVTable interface_vtable = {
+		handle_method_call,
+		NULL, NULL
+	};
+
+	priv = controller->priv;
+
+	priv->connection = tracker_sparql_connection_get (NULL, &err);
+
+	if (!priv->connection) {
+		g_propagate_error (error, err);
+		return FALSE;
 	}
 
-	return manager;
+	priv->d_connection = g_bus_get_sync (G_BUS_TYPE_SESSION, NULL, &err);
+
+	if (!priv->d_connection) {
+		g_propagate_error (error, err);
+		return FALSE;
+	}
+
+	priv->introspection_data = g_dbus_node_info_new_for_xml (introspection_xml, &err);
+	if (!priv->introspection_data) {
+		g_propagate_error (error, err);
+		return FALSE;
+	}
+
+	g_message ("Registering D-Bus object...");
+	g_message ("  Path:'" TRACKER_WRITEBACK_PATH "'");
+	g_message ("  Object Type:'%s'", G_OBJECT_TYPE_NAME (controller));
+
+	priv->bus_name_id =
+		g_bus_own_name_on_connection (priv->d_connection,
+		                              TRACKER_WRITEBACK_SERVICE,
+		                              G_BUS_NAME_OWNER_FLAGS_NONE,
+		                              bus_name_acquired_cb,
+		                              bus_name_vanished_cb,
+		                              controller, NULL);
+
+	priv->registration_id =
+		g_dbus_connection_register_object (priv->d_connection,
+		                                   TRACKER_WRITEBACK_PATH,
+		                                   priv->introspection_data->interfaces[0],
+		                                   &interface_vtable,
+		                                   controller,
+		                                   NULL,
+		                                   &err);
+
+	if (err) {
+		g_propagate_error (error, err);
+		return FALSE;
+	}
+
+	return TRUE;
+}
+
+static void
+tracker_controller_dbus_stop (TrackerController *controller)
+{
+	TrackerControllerPrivate *priv;
+
+	priv = controller->priv;
+
+	if (priv->registration_id != 0) {
+		g_dbus_connection_unregister_object (priv->d_connection,
+		                                     priv->registration_id);
+	}
+
+	if (priv->bus_name_id != 0) {
+		g_bus_unown_name (priv->bus_name_id);
+	}
+
+	if (priv->introspection_data) {
+		g_dbus_node_info_unref (priv->introspection_data);
+	}
+
+	if (priv->d_connection) {
+		g_object_unref (priv->d_connection);
+	}
+
+	if (priv->connection) {
+		g_object_unref (priv->connection);
+	}
+}
+
+TrackerController *
+tracker_controller_new (guint             shutdown_timeout,
+                        GError          **error)
+{
+	return g_initable_new (TRACKER_TYPE_CONTROLLER,
+	                       NULL, error,
+	                       "shutdown-timeout", shutdown_timeout,
+	                       NULL);
+}
+
+static gpointer
+tracker_controller_thread_func (gpointer user_data)
+{
+	TrackerController *controller;
+	TrackerControllerPrivate *priv;
+	GError *error = NULL;
+
+#ifdef THREAD_ENABLE_TRACE
+	g_debug ("Thread:%p (Controller) --- Created, dispatching...",
+	         g_thread_self ());
+#endif /* THREAD_ENABLE_TRACE */
+
+	controller = user_data;
+	priv = controller->priv;
+	g_main_context_push_thread_default (priv->context);
+
+	reset_shutdown_timeout (controller);
+
+	if (!tracker_controller_dbus_start (controller, &error)) {
+		/* Error has been filled in, so we return
+		 * in this thread. The main thread will be
+		 * notified about the error and exit.
+		 */
+		controller_notify_main_thread (controller, error);
+		return NULL;
+	}
+
+	g_main_loop_run (priv->main_loop);
+
+#ifdef THREAD_ENABLE_TRACE
+	g_debug ("Thread:%p (Controller) --- Shutting down...",
+	         g_thread_self ());
+#endif /* THREAD_ENABLE_TRACE */
+
+	g_object_unref (controller);
+
+	/* This is where we exit, be it
+	 * either through umount events on monitored
+	 * files' volumes or the timeout being reached
+	 */
+	exit (0);
+	return NULL;
+}
+
+static gboolean
+tracker_controller_start (TrackerController  *controller,
+                          GError            **error)
+{
+	TrackerControllerPrivate *priv;
+	GList *modules;
+
+	priv = controller->priv;
+
+	priv->modules = g_hash_table_new_full (g_str_hash,
+	                                       g_str_equal,
+	                                       (GDestroyNotify) g_free,
+	                                       NULL);
+
+	modules = tracker_writeback_modules_list ();
+
+	while (modules) {
+		TrackerWritebackModule *module;
+		const gchar *path;
+
+		path = modules->data;
+		module = tracker_writeback_module_get (path);
+
+		if (module) {
+			g_hash_table_insert (priv->modules, g_strdup (path), module);
+		}
+
+		modules = modules->next;
+	}
+
+	if (!g_thread_create (tracker_controller_thread_func,
+	                      controller, FALSE, error)) {
+		return FALSE;
+	}
+
+
+#ifdef THREAD_ENABLE_TRACE
+	g_debug ("Thread:%p (Controller) --- Waiting for controller thread to initialize...",
+	         g_thread_self ());
+#endif /* THREAD_ENABLE_TRACE */
+
+	/* Wait for the controller thread to notify initialization */
+	g_mutex_lock (priv->initialization_mutex);
+
+	while (!priv->initialized) {
+		g_cond_wait (priv->initialization_cond, priv->initialization_mutex);
+	}
+
+	g_mutex_unlock (priv->initialization_mutex);
+
+	/* If there was any error resulting from initialization, propagate it */
+	if (priv->initialization_error != NULL) {
+		g_propagate_error (error, priv->initialization_error);
+		return FALSE;
+	}
+
+#ifdef THREAD_ENABLE_TRACE
+	g_debug ("Thread:%p (Controller) --- Initialized",
+	         g_thread_self ());
+#endif /* THREAD_ENABLE_TRACE */
+
+	return TRUE;
 }
diff --git a/src/tracker-writeback/tracker-writeback.h b/src/tracker-writeback/tracker-writeback.h
index c56d85e..371a947 100644
--- a/src/tracker-writeback/tracker-writeback.h
+++ b/src/tracker-writeback/tracker-writeback.h
@@ -1,64 +1,56 @@
 /*
- * Copyright (C) 2009, Nokia <ivan frade nokia com>
+ * Copyright (C) 2011, Nokia <ivan frade nokia com>
  *
  * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public
+ * modify it under the terms of the GNU Lesser General Public
  * License as published by the Free Software Foundation; either
- * version 2 of the License, or (at your option) any later version.
+ * version 2.1 of the License, or (at your option) any later version.
  *
  * This library 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.
+ * Lesser General Public License for more details.
  *
- * You should have received a copy of the GNU General Public
+ * You should have received a copy of the GNU Lesser General Public
  * License along with this library; if not, write to the
  * Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA  02110-1301, USA.
  */
 
-#ifndef __TRACKER_WRITEBACK_WRITEBACK_H__
-#define __TRACKER_WRITEBACK_WRITEBACK_H__
+#ifndef __TRACKER_CONTROLLER_H__
+#define __TRACKER_CONTROLLER_H__
 
-#include <glib-object.h>
+#include <gio/gio.h>
 
-#include <libtracker-miner/tracker-miner.h>
-#include <libtracker-sparql/tracker-sparql.h>
+/* Not needed, but for now this keeps #include API backward compatible */
+#include "tracker-writeback-module.h"
 
 G_BEGIN_DECLS
 
-#define TRACKER_TYPE_WRITEBACK         (tracker_writeback_get_type())
-#define TRACKER_WRITEBACK(o)           (G_TYPE_CHECK_INSTANCE_CAST ((o), TRACKER_TYPE_WRITEBACK, TrackerWriteback))
-#define TRACKER_WRITEBACK_CLASS(c)     (G_TYPE_CHECK_CLASS_CAST ((c), TRACKER_TYPE_WRITEBACK, TrackerWritebackClass))
-#define TRACKER_IS_WRITEBACK(o)        (G_TYPE_CHECK_INSTANCE_TYPE ((o), TRACKER_TYPE_WRITEBACK))
-#define TRACKER_IS_WRITEBACK_CLASS(c)  (G_TYPE_CHECK_CLASS_TYPE ((c),  TRACKER_TYPE_WRITEBACK))
-#define TRACKER_WRITEBACK_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), TRACKER_TYPE_WRITEBACK, TrackerWritebackClass))
+#define TRACKER_TYPE_CONTROLLER         (tracker_controller_get_type ())
+#define TRACKER_CONTROLLER(o)           (G_TYPE_CHECK_INSTANCE_CAST ((o), TRACKER_TYPE_CONTROLLER, TrackerController))
+#define TRACKER_CONTROLLER_CLASS(c)     (G_TYPE_CHECK_CLASS_CAST ((c), TRACKER_TYPE_CONTROLLER, TrackerControllerClass))
+#define TRACKER_IS_CONTROLLER(o)        (G_TYPE_CHECK_INSTANCE_TYPE ((o), TRACKER_TYPE_CONTROLLER))
+#define TRACKER_IS_CONTROLLER_CLASS(c)  (G_TYPE_CHECK_CLASS_TYPE ((c), TRACKER_TYPE_CONTROLLER))
+#define TRACKER_CONTROLLER_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), TRACKER_TYPE_CONTROLLER, TrackerControllerClass))
 
-typedef struct TrackerWriteback TrackerWriteback;
-typedef struct TrackerWritebackClass TrackerWritebackClass;
+typedef struct TrackerController TrackerController;
+typedef struct TrackerControllerClass TrackerControllerClass;
 
-struct TrackerWriteback {
+struct TrackerController {
 	GObject parent_instance;
+	gpointer priv;
 };
 
-struct TrackerWritebackClass {
+struct TrackerControllerClass {
 	GObjectClass parent_class;
-
-	gboolean (* update_metadata) (TrackerWriteback        *writeback,
-	                              GPtrArray               *values,
-	                              TrackerSparqlConnection *connection);
 };
 
-GType                tracker_writeback_get_type          (void) G_GNUC_CONST;
-gboolean             tracker_writeback_update_metadata   (TrackerWriteback        *writeback,
-                                                          GPtrArray               *values,
-                                                          TrackerSparqlConnection *connection);
-TrackerMinerManager* tracker_writeback_get_miner_manager (void);
+GType               tracker_controller_get_type (void) G_GNUC_CONST;
 
-/* Entry functions to be defined by modules */
-TrackerWriteback *   writeback_module_create             (GTypeModule             *module);
-const gchar * const *writeback_module_get_rdf_types      (void);
+TrackerController * tracker_controller_new   (guint               shutdown_timeout,
+                                              GError            **error);
 
 G_END_DECLS
 
-#endif /* __TRACKER_WRITEBACK_WRITEBACK_H__ */
+#endif /* __TRACKER_CONTROLLER_H__ */



[Date Prev][Date Next]   [Thread Prev][Thread Next]   [Thread Index] [Date Index] [Author Index]