static void
load_running_miners_only (TrackerMinerManager *manager)
{
TrackerMinerManagerPrivate *priv;
GSList *running, *l;
gint prefix_len;
priv = TRACKER_MINER_MANAGER_GET_PRIVATE (manager);
running = tracker_miner_manager_get_running (manager);
prefix_len = strlen (TRACKER_MINER_DBUS_NAME_PREFIX);
for (l = running; l; l = l->next) {
MinerData *data;
const gchar *dbus_name;
gchar *p;
dbus_name = l->data;
data = g_slice_new0 (MinerData);
data->dbus_path = g_strdup_printf ("/%s", dbus_name);
p = data->dbus_path;
while ((p = strchr (p, '.')) != NULL) {
*p++ = '/';
}
data->dbus_name = l->data;
data->display_name = g_strdup (dbus_name + prefix_len);
data->description = g_strdup (data->display_name);
priv->miners = g_list_prepend (priv->miners, data);
}
g_slist_free (running);
}
static gboolean
crawler_check_file_cb (TrackerCrawler *crawler,
GFile *file,
gpointer user_data)
{
TrackerMinerManager *manager;
TrackerMinerManagerPrivate *priv;
GKeyFile *key_file;
gchar *path, *dbus_path, *dbus_name, *display_name, *description;
GError *error = NULL;
MinerData *data;
manager = user_data;
path = g_file_get_path (file);
priv = TRACKER_MINER_MANAGER_GET_PRIVATE (manager);
if (!g_str_has_suffix (path, ".desktop")) {
return FALSE;
}
key_file = g_key_file_new ();
g_key_file_load_from_file (key_file, path, G_KEY_FILE_NONE, &error);
if (error) {
g_warning ("Error parsing miner .desktop file: %s", error->message);
g_error_free (error);
g_key_file_free (key_file);
return FALSE;
}
dbus_path = g_key_file_get_string (key_file, DESKTOP_ENTRY_GROUP, DBUS_PATH_KEY, NULL);
dbus_name = g_key_file_get_string (key_file, DESKTOP_ENTRY_GROUP, DBUS_NAME_KEY, NULL);
display_name = g_key_file_get_locale_string (key_file, DESKTOP_ENTRY_GROUP, DISPLAY_NAME_KEY, NULL, NULL);
if (!dbus_path || !dbus_name || !display_name) {
g_warning ("Essential data (DBusPath, DBusName or Name) are missing in miner .desktop file");
g_key_file_free (key_file);
g_free (dbus_path);
g_free (display_name);
g_free (dbus_name);
return FALSE;
}
description = g_key_file_get_locale_string (key_file, DESKTOP_ENTRY_GROUP, DESCRIPTION_KEY, NULL, NULL);
data = g_slice_new0 (MinerData);
data->dbus_path = dbus_path;
data->dbus_name = dbus_name;
data->display_name = display_name;
data->description = description;
priv->miners = g_list_prepend (priv->miners, data);
g_key_file_free (key_file);
g_free (path);
return TRUE;
}
/**
* tracker_miner_manager_get_running:
* @manager: a #trackerMinerManager
*
* Returns a list of references for all active miners. Active miners
* are miners which are running within a process.
*
* Returns: (transfer full) (element-type utf8) (nullable): a #GSList which
* must be freed with g_slist_free() and all contained data with g_free().
* Otherwise %NULL is returned if there are no miners.
*
* Since: 0.8
**/
GSList *
tracker_miner_manager_get_running (TrackerMinerManager *manager)
{
TrackerMinerManagerPrivate *priv;
GSList *list = NULL;
GError *error = NULL;
GVariant *v;
GVariantIter *iter;
const gchar *str = NULL;
g_return_val_if_fail (TRACKER_IS_MINER_MANAGER (manager), NULL);
priv = TRACKER_MINER_MANAGER_GET_PRIVATE (manager);
if (!priv->connection) {
return NULL;
}
v = g_dbus_connection_call_sync (priv->connection,
"org.freedesktop.DBus",
"/org/freedesktop/DBus",
"org.freedesktop.DBus",
"ListNames",
NULL,
G_VARIANT_TYPE ("(as)"),
G_DBUS_CALL_FLAGS_NONE,
-1,
NULL,
&error);
if (error) {
g_critical ("Could not get a list of names registered on the session bus, %s",
error ? error->message : "no error given");
g_clear_error (&error);
return NULL;
}
g_variant_get (v, "(as)", &iter);
while (g_variant_iter_loop (iter, "&s", &str)) {
if (!g_str_has_prefix (str, TRACKER_MINER_DBUS_NAME_PREFIX)) {
continue;
}
/* Special case miner-fs which has
* additional D-Bus interface.
*/
if (strcmp (str, "org.freedesktop.Tracker1.Miner.Files.Index") == 0) {
continue;
}
list = g_slist_prepend (list, g_strdup (str));
}
g_variant_iter_free (iter);
g_variant_unref (v);
list = g_slist_reverse (list);
return list;
}
static GDBusProxy *
find_miner_proxy (TrackerMinerManager *manager,
const gchar *name,
gboolean try_suffix)
{
TrackerMinerManagerPrivate *priv;
GHashTableIter iter;
gpointer key, value;
priv = TRACKER_MINER_MANAGER_GET_PRIVATE (manager);
g_hash_table_iter_init (&iter, priv->miner_proxies);
while (g_hash_table_iter_next (&iter, &key, &value)) {
if (g_strcmp0 (name, (gchar *) value) == 0) {
return key;
}
if (try_suffix) {
if (g_str_has_suffix (value, name)) {
return key;
}
}
}
return NULL;
}
/**
* tracker_miner_manager_index_file:
* @manager: a #TrackerMinerManager
* @file: a URL valid in GIO of a file to give to the miner for processing
* @error: (out callee-allocates) (transfer full) (allow-none): return location for errors
*
* Tells the filesystem miner to index the @file.
*
* On failure @error will be set.
*
* Returns: %TRUE on success, otherwise %FALSE.
*
* Since: 0.10
**/
gboolean
tracker_miner_manager_index_file (TrackerMinerManager *manager,
GFile *file,
GError **error)
{
TrackerMinerManagerPrivate *priv;
gchar *uri;
GVariant *v;
GError *new_error = NULL;
g_return_val_if_fail (TRACKER_IS_MINER_MANAGER (manager), FALSE);
g_return_val_if_fail (G_IS_FILE (file), FALSE);
if (!g_file_query_exists (file, NULL)) {
g_set_error_literal (error,
TRACKER_MINER_MANAGER_ERROR,
TRACKER_MINER_MANAGER_ERROR_NOENT,
"File or directory does not exist");
return FALSE;
}
if (!tracker_miner_manager_is_active (manager,
"org.freedesktop.Tracker1.Miner.Files")) {
g_set_error_literal (error,
TRACKER_MINER_MANAGER_ERROR,
TRACKER_MINER_MANAGER_ERROR_NOT_AVAILABLE,
"Filesystem miner is not active");
return FALSE;
}
priv = TRACKER_MINER_MANAGER_GET_PRIVATE (manager);
uri = g_file_get_uri (file);
v = g_dbus_connection_call_sync (priv->connection,
"org.freedesktop.Tracker1.Miner.Files.Index",
"/org/freedesktop/Tracker1/Miner/Files/Index",
"org.freedesktop.Tracker1.Miner.Files.Index",
"IndexFile",
g_variant_new ("(s)", uri),
NULL,
G_DBUS_CALL_FLAGS_NONE,
-1,
NULL,
&new_error);
g_free (uri);
if (new_error) {
g_propagate_error (error, new_error);
return FALSE;
}
g_variant_unref (v);
return FALSE;
}
static void
tracker_miner_manager_init (TrackerMinerManager *manager)
{
TrackerMinerManagerPrivate *priv;
priv = TRACKER_MINER_MANAGER_GET_PRIVATE (manager);
priv->miner_proxies = g_hash_table_new_full (NULL, NULL,
(GDestroyNotify) g_object_unref,
(GDestroyNotify) g_free);
}
/**
* tracker_miner_manager_get_available:
* @manager: a #TrackerMinerManager
*
* Returns a list of references for all available miners. Available
* miners are miners which may or may not be running in a process at
* the current time.
*
* Returns: (transfer full) (element-type utf8) (nullable): a #GSList which
* must be freed with g_slist_free() and all contained data with g_free().
* Otherwise %NULL is returned if there are no miners.
*
* Since: 0.8
**/
GSList *
tracker_miner_manager_get_available (TrackerMinerManager *manager)
{
TrackerMinerManagerPrivate *priv;
GSList *list = NULL;
GList *m;
priv = TRACKER_MINER_MANAGER_GET_PRIVATE (manager);
for (m = priv->miners; m; m = m->next) {
MinerData *data = m->data;
list = g_slist_prepend (list, g_strdup (data->dbus_name));
}
return g_slist_reverse (list);
}
static void
miner_manager_finalize (GObject *object)
{
TrackerMinerManagerPrivate *priv;
priv = TRACKER_MINER_MANAGER_GET_PRIVATE (object);
if (priv->connection) {
g_object_unref (priv->connection);
}
g_list_foreach (priv->miners, (GFunc) miner_data_free, NULL);
g_list_free (priv->miners);
g_hash_table_unref (priv->miner_proxies);
G_OBJECT_CLASS (tracker_miner_manager_parent_class)->finalize (object);
}
/**
* tracker_miner_manager_reindex_by_mimetype:
* @manager: a #TrackerMinerManager
* @mimetypes: (in): an array of mimetypes (E.G. "text/plain"). All items
* with a mimetype in that list will be reindexed.
* @error: (out callee-allocates) (transfer full) (allow-none): return location for errors
*
* Tells the filesystem miner to reindex any file with a mimetype in
* the @mimetypes list.
*
* On failure @error will be set.
*
* Returns: %TRUE on success, otherwise %FALSE.
*
* Since: 0.10
**/
gboolean
tracker_miner_manager_reindex_by_mimetype (TrackerMinerManager *manager,
const GStrv mimetypes,
GError **error)
{
TrackerMinerManagerPrivate *priv;
GVariant *v;
GError *new_error = NULL;
g_return_val_if_fail (TRACKER_IS_MINER_MANAGER (manager), FALSE);
g_return_val_if_fail (mimetypes != NULL, FALSE);
if (!tracker_miner_manager_is_active (manager,
"org.freedesktop.Tracker1.Miner.Files")) {
g_set_error_literal (error,
TRACKER_MINER_MANAGER_ERROR,
TRACKER_MINER_MANAGER_ERROR_NOT_AVAILABLE,
"Filesystem miner is not active");
return FALSE;
}
priv = TRACKER_MINER_MANAGER_GET_PRIVATE (manager);
v = g_dbus_connection_call_sync (priv->connection,
"org.freedesktop.Tracker1.Miner.Files.Index",
"/org/freedesktop/Tracker1/Miner/Files/Index",
"org.freedesktop.Tracker1.Miner.Files.Index",
"ReindexMimeTypes",
g_variant_new ("(^as)", mimetypes),
NULL,
G_DBUS_CALL_FLAGS_NONE,
-1,
NULL,
&new_error);
if (new_error) {
g_propagate_error (error, new_error);
return FALSE;
}
g_variant_unref (v);
return FALSE;
}
static void
miner_manager_get_property (GObject *object,
guint prop_id,
GValue *value,
GParamSpec *pspec)
{
TrackerMinerManager *manager;
TrackerMinerManagerPrivate *priv;
manager = TRACKER_MINER_MANAGER (object);
priv = TRACKER_MINER_MANAGER_GET_PRIVATE (manager);
switch (prop_id) {
case PROP_AUTO_START:
g_value_set_boolean (value, priv->auto_start);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
/**
* tracker_miner_manager_get_description:
* @manager: a #TrackerMinerManager
* @miner: miner reference
*
* Returns the description for the given @miner.
*
* Returns: (transfer none): A string which should not be freed or %NULL if none is specified.
*
* Since: 0.8
**/
const gchar *
tracker_miner_manager_get_description (TrackerMinerManager *manager,
const gchar *miner)
{
TrackerMinerManagerPrivate *priv;
GList *m;
g_return_val_if_fail (TRACKER_IS_MINER_MANAGER (manager), NULL);
g_return_val_if_fail (miner != NULL, NULL);
priv = TRACKER_MINER_MANAGER_GET_PRIVATE (manager);
for (m = priv->miners; m; m = m->next) {
MinerData *data = m->data;
if (strcmp (miner, data->dbus_name) == 0) {
return data->description;
}
}
return NULL;
}
/**
* tracker_miner_manager_is_active:
* @manager: a #TrackerMinerManager
* @miner: miner reference
*
* Returns the miner's current activity.
*
* Returns: %TRUE if the @miner is active, otherwise %FALSE.
*
* Since: 0.8
**/
gboolean
tracker_miner_manager_is_active (TrackerMinerManager *manager,
const gchar *miner)
{
TrackerMinerManagerPrivate *priv;
GError *error = NULL;
gboolean active = FALSE;
GVariant *v;
g_return_val_if_fail (TRACKER_IS_MINER_MANAGER (manager), FALSE);
g_return_val_if_fail (miner != NULL, FALSE);
priv = TRACKER_MINER_MANAGER_GET_PRIVATE (manager);
v = g_dbus_connection_call_sync (priv->connection,
"org.freedesktop.DBus",
"/org/freedesktop/DBus",
"org.freedesktop.DBus",
"NameHasOwner",
g_variant_new ("(s)", miner),
(GVariantType *) "(b)",
G_DBUS_CALL_FLAGS_NONE,
-1,
NULL,
&error);
if (error) {
g_critical ("Could not check whether miner '%s' is currently active: %s",
miner, error ? error->message : "no error given");
g_error_free (error);
return FALSE;
}
g_variant_get (v, "(b)", &active);
g_variant_unref (v);
return active;
}
static gboolean
miner_manager_initable_init (GInitable *initable,
GCancellable *cancellable,
GError **error)
{
TrackerMinerManager *manager;
GError *inner_error = NULL;
TrackerMinerManagerPrivate *priv;
GList *m;
manager = TRACKER_MINER_MANAGER (initable);
priv = TRACKER_MINER_MANAGER_GET_PRIVATE (manager);
priv->connection = g_bus_get_sync (TRACKER_IPC_BUS, NULL, &inner_error);
if (!priv->connection) {
g_propagate_error (error, inner_error);
return FALSE;
}
initialize_miners_data (manager);
for (m = priv->miners; m; m = m->next) {
GDBusProxy *proxy;
MinerData *data;
data = m->data;
data->connection = g_object_ref (priv->connection);
data->manager = G_OBJECT (manager);
g_object_weak_ref (data->manager, data_manager_weak_notify, data);
proxy = g_dbus_proxy_new_sync (priv->connection,
(priv->auto_start ?
G_DBUS_PROXY_FLAGS_NONE :
G_DBUS_PROXY_FLAGS_DO_NOT_AUTO_START),
NULL,
data->dbus_name,
data->dbus_path,
TRACKER_MINER_DBUS_INTERFACE,
NULL,
&inner_error);
/* This error shouldn't be considered fatal */
if (inner_error) {
g_critical ("Could not create proxy on the D-Bus session bus, %s",
inner_error ? inner_error->message : "no error given.");
g_clear_error (&inner_error);
continue;
}
data->progress_signal = g_dbus_connection_signal_subscribe (priv->connection,
data->dbus_name,
TRACKER_MINER_DBUS_INTERFACE,
"Progress",
data->dbus_path,
NULL,
G_DBUS_SIGNAL_FLAGS_NONE,
miner_progress_changed,
data,
NULL);
data->paused_signal = g_dbus_connection_signal_subscribe (priv->connection,
data->dbus_name,
TRACKER_MINER_DBUS_INTERFACE,
"Paused",
data->dbus_path,
NULL,
G_DBUS_SIGNAL_FLAGS_NONE,
miner_paused,
data,
NULL);
data->resumed_signal = g_dbus_connection_signal_subscribe (priv->connection,
data->dbus_name,
TRACKER_MINER_DBUS_INTERFACE,
"Resumed",
data->dbus_path,
NULL,
G_DBUS_SIGNAL_FLAGS_NONE,
miner_resumed,
data,
NULL);
g_hash_table_insert (priv->miner_proxies, proxy, g_strdup (data->dbus_name));
data->watch_name_id = g_bus_watch_name (TRACKER_IPC_BUS,
data->dbus_name,
G_BUS_NAME_WATCHER_FLAGS_NONE,
miner_appears,
miner_disappears,
data,
NULL);
}
return TRUE;
}
