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; }