static void find_channel_and_update (GObject *source_object, GAsyncResult *res, gpointer user_data)
{
gchar **values;
GtkTreeModel *model;
GtkTreeIter iter;
TrackerSparqlCursor *cursor;
GError *error;
error = NULL;
cursor = tracker_sparql_connection_query_finish (TRACKER_SPARQL_CONNECTION (source_object), res, &error);
if (error != NULL) {
g_warning ("Unable to update channel: %s", error->message);
g_error_free (error);
return;
}
model = user_data;
while (tracker_sparql_cursor_next (cursor, NULL, NULL)) {
if (retrive_row_by_id (model, tracker_sparql_cursor_get_string (cursor, 0, NULL), &iter) == TRUE) {
gtk_list_store_set (GTK_LIST_STORE (model), &iter,
PREDICATE_NAME, tracker_sparql_cursor_get_string (cursor, 1, NULL),
PREDICATE_DOWNLOAD, tracker_sparql_cursor_get_boolean (cursor, 2),
PREDICATE_DOWNPATH, tracker_sparql_cursor_get_string (cursor, 3, NULL),
PREDICATE_MAXSIZE, tracker_sparql_cursor_get_double (cursor, 4),
PREDICATE_EXPIRY, tracker_sparql_cursor_get_double (cursor, 5),
6, FALSE, -1);
}
}
}
static void
handle_channel_deletes (ReaderEngine *engine,
gint sub)
{
gchar *query;
const gchar *subject;
GtkTreeIter *iter;
TrackerSparqlCursor *cursor;
ReaderEnginePrivate *priv;
priv = reader_engine_get_instance_private (engine);
query = g_strdup_printf ("SELECT tracker:uri(%d) {}", sub);
cursor = tracker_sparql_connection_query (priv->tracker, query, NULL, NULL);
tracker_sparql_cursor_next (cursor, NULL, NULL);
subject = tracker_sparql_cursor_get_string (cursor, 0, NULL);
if (find_in_model (GTK_TREE_MODEL (priv->data), GD_MAIN_COLUMN_ID, subject, &iter)) {
remove_channel_data (GTK_TREE_MODEL (priv->data), iter);
gtk_list_store_remove (priv->data, iter);
gtk_tree_iter_free (iter);
}
g_free (query);
g_object_unref (cursor);
}
static void
decorator_query_remaining_items_cb (GObject *object,
GAsyncResult *result,
gpointer user_data)
{
TrackerDecorator *decorator = user_data;
TrackerDecoratorPrivate *priv;
TrackerSparqlCursor *cursor;
GError *error = NULL;
cursor = tracker_sparql_connection_query_finish (TRACKER_SPARQL_CONNECTION (object),
result, &error);
priv = decorator->priv;
priv->querying = FALSE;
if (error || !tracker_sparql_cursor_next (cursor, NULL, &error)) {
decorator_notify_task_error (decorator, error);
g_error_free (error);
return;
}
priv->n_remaining_items = g_queue_get_length (&priv->item_cache) +
tracker_sparql_cursor_get_integer (cursor, 0);
g_object_unref (cursor);
g_debug ("Found %ld items to extract", priv->n_remaining_items);
if (priv->n_remaining_items > 0)
decorator_cache_next_items (decorator);
else
decorator_finish (decorator);
}
void QGalleryTrackerResultSetPrivate::run()
{
iCache.values.clear();
GError *error = 0;
if (TrackerSparqlCursor *cursor = tracker_sparql_connection_query(
connection, sparql.toUtf8(), 0, &error)) {
const QVariant variant;
while (tracker_sparql_cursor_next(cursor, 0, 0)) {
const int rowWidth = qMin(tableWidth, tracker_sparql_cursor_get_n_columns(cursor));
int i = 0;
for (; i < rowWidth; ++i) {
iCache.values.append(valueColumns.at(i)->toVariant(cursor, i));
}
for (; i < tableWidth; ++i)
iCache.values.append(variant);
}
g_object_unref(G_OBJECT(cursor));
} else {
queryError = QDocumentGallery::FilterError;
queryErrorString = QString::fromUtf8(error->message);
g_error_free(error);
}
iCache.count = iCache.values.count() / tableWidth;
synchronize();
}
static void fill_model_with_channels (GObject *source_object, GAsyncResult *res, gpointer user_data)
{
int i;
GtkWidget *dialog;
GtkListStore *list;
TrackerSparqlCursor *cursor;
GError *error;
error = NULL;
cursor = tracker_sparql_connection_query_finish (TRACKER_SPARQL_CONNECTION (source_object), res, &error);
if (error != NULL) {
dialog = gtk_message_dialog_new (NULL, GTK_DIALOG_MODAL, GTK_MESSAGE_ERROR, GTK_BUTTONS_CLOSE, "Unable to fetch data about current feeds:\n%s", error->message);
gtk_message_dialog_format_secondary_text (GTK_MESSAGE_DIALOG (dialog), "Is Tracker running?");
gtk_dialog_run (GTK_DIALOG (dialog));
gtk_widget_destroy (dialog);
g_error_free (error);
return;
}
list = user_data;
while (tracker_sparql_cursor_next (cursor, NULL, NULL)) {
gtk_list_store_insert_with_values (list, NULL, G_MAXINT,
PREDICATE_SUBJECT, tracker_sparql_cursor_get_string (cursor, 0, NULL),
PREDICATE_NAME, tracker_sparql_cursor_get_string (cursor, 1, NULL),
PREDICATE_DOWNLOAD, tracker_sparql_cursor_get_boolean (cursor, 2),
PREDICATE_DOWNPATH, tracker_sparql_cursor_get_string (cursor, 3, NULL),
PREDICATE_MAXSIZE, tracker_sparql_cursor_get_double (cursor, 4),
PREDICATE_EXPIRY, tracker_sparql_cursor_get_double (cursor, 5),
6, FALSE, -1);
}
}
static void
pass_channels (ReaderEngine *engine,
TrackerSparqlCursor *cursor)
{
const gchar *subject;
const gchar *title;
const gchar *url;
gint64 unread;
GtkTreeModel *model;
GtkTreeIter *iter;
GtkTreeIter iter2;
GtkTreeStore *items_model;
GdkPixbuf *icon;
ReaderEnginePrivate *priv;
if (cursor != NULL) {
priv = reader_engine_get_instance_private (engine);
model = GTK_TREE_MODEL (priv->data);
while (tracker_sparql_cursor_next (cursor, NULL, NULL)) {
subject = tracker_sparql_cursor_get_string (cursor, 0, NULL);
title = tracker_sparql_cursor_get_string (cursor, 1, NULL);
unread = tracker_sparql_cursor_get_integer (cursor, 2);
url = tracker_sparql_cursor_get_string (cursor, 4, NULL);
if (find_in_model (model, GD_MAIN_COLUMN_ID, subject, &iter)) {
gtk_list_store_set (GTK_LIST_STORE (model), iter,
GD_MAIN_COLUMN_PRIMARY_TEXT, title,
EXTRA_COLUMN_UNREADS, unread, -1);
gtk_tree_iter_free (iter);
}
else {
items_model = gtk_tree_store_new (ITEM_COLUMN_LAST,
G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING,
G_TYPE_STRING, G_TYPE_POINTER, G_TYPE_INT, G_TYPE_STRING);
g_signal_connect (items_model, "row-changed", G_CALLBACK (model_item_changed), engine);
icon = get_icon_for_channel (tracker_sparql_cursor_get_string (cursor, 3, NULL));
gtk_list_store_append (GTK_LIST_STORE (model), &iter2);
gtk_list_store_set (GTK_LIST_STORE (model), &iter2,
GD_MAIN_COLUMN_ID, subject,
GD_MAIN_COLUMN_PRIMARY_TEXT, title,
GD_MAIN_COLUMN_ICON, icon,
EXTRA_COLUMN_UNREADS, unread,
EXTRA_COLUMN_URL, url,
EXTRA_COLUMN_FEEDS_MODEL, items_model, -1);
}
collect_items (engine, subject, NULL);
}
g_object_unref (cursor);
}
}
static gchar *
get_class_from_prefix (TrackerSparqlConnection *connection,
const gchar *prefix)
{
GError *error = NULL;
TrackerSparqlCursor *cursor;
const gchar *query;
gchar *found = NULL;
query = "SELECT ?prefix ?ns "
"WHERE {"
" ?ns a tracker:Namespace ;"
" tracker:prefix ?prefix "
"}";
/* We have namespace prefix, get full name */
cursor = tracker_sparql_connection_query (connection, query, NULL, &error);
if (error) {
g_printerr ("%s, %s\n",
_("Could not get namespace prefixes"),
error->message);
g_error_free (error);
return NULL;
}
if (!cursor) {
g_printerr ("%s\n",
_("No namespace prefixes were found"));
return NULL;
}
while (tracker_sparql_cursor_next (cursor, NULL, NULL) && !found) {
const gchar *class_prefix, *class_name;
class_prefix = tracker_sparql_cursor_get_string (cursor, 0, NULL);
class_name = tracker_sparql_cursor_get_string (cursor, 1, NULL);
if (strcmp (class_prefix, prefix) == 0) {
found = g_strdup (class_name);
}
}
g_object_unref (cursor);
return found;
}
static void
item_warn (TrackerSparqlConnection *conn,
gint id,
const gchar *sparql,
const GError *error)
{
TrackerSparqlCursor *cursor;
const gchar *elem;
gchar *query;
query = g_strdup_printf ("SELECT COALESCE (nie:url (?u), ?u) {"
" ?u a rdfs:Resource. "
" FILTER (tracker:id (?u) = %d)"
"}", id);
cursor = tracker_sparql_connection_query (conn, query, NULL, NULL);
g_free (query);
g_debug ("--8<------------------------------");
g_debug ("The information relevant for a bug report is between "
"the dotted lines");
if (cursor &&
tracker_sparql_cursor_next (cursor, NULL, NULL)) {
elem = tracker_sparql_cursor_get_string (cursor, 0, NULL);
g_warning ("Could not insert metadata for item \"%s\": %s",
elem, error->message);
} else {
g_warning ("Could not insert metadata for item with ID %d: %s",
id, error->message);
}
g_warning ("If the error above is recurrent for the same item/ID, "
"consider running \"%s\" in the terminal with the "
"TRACKER_VERBOSITY=3 environment variable, and filing a "
"bug with the additional information", g_get_prgname ());
g_debug ("Sparql was:\n%s", sparql);
g_debug ("NOTE: The information above may contain data you "
"consider sensitive. Feel free to edit it out, but please "
"keep it as unmodified as you possibly can.");
g_debug ("------------------------------>8--");
g_clear_object (&cursor);
}
static void
pass_items (ReaderEngine *engine,
TrackerSparqlCursor *cursor)
{
gboolean blocked;
const gchar *channel_id;
const gchar *item_id;
GtkTreeIter iter;
GtkTreeModel *model;
GDateTime *date;
if (cursor != NULL) {
while (tracker_sparql_cursor_next (cursor, NULL, NULL)) {
channel_id = tracker_sparql_cursor_get_string (cursor, 0, NULL);
model = reader_engine_get_items_model (engine, channel_id);
if (model == NULL)
continue;
item_id = tracker_sparql_cursor_get_string (cursor, 1, NULL);
date = item_cursor_to_time (cursor);
if (dispose_item_in_model (model, item_id, date, &iter) == FALSE) {
g_signal_handlers_block_by_func (model, G_CALLBACK (model_item_changed), engine);
blocked = TRUE;
}
else {
blocked = FALSE;
}
gtk_tree_store_set (GTK_TREE_STORE (model), &iter,
ITEM_COLUMN_ID, item_id,
ITEM_COLUMN_TITLE, tracker_sparql_cursor_get_string (cursor, 2, NULL),
ITEM_COLUMN_URL, tracker_sparql_cursor_get_string (cursor, 3, NULL),
ITEM_COLUMN_TIME, date,
ITEM_COLUMN_CONTENTS, tracker_sparql_cursor_get_string (cursor, 5, NULL),
ITEM_COLUMN_READ, tracker_sparql_cursor_get_boolean (cursor, 4) ? READ_FONT_WEIGHT : UNREAD_FONT_WEIGHT, -1);
if (blocked == TRUE)
g_signal_handlers_unblock_by_func (model, G_CALLBACK (model_item_changed), engine);
}
g_object_unref (cursor);
}
}
bool QTrackerDirectSyncResult::next()
{
if (!cursor) {
// The cursor may have been unreferenced because the connection was deleted
// and now the user is calling next(), so set the row here
updatePos(QSparql::AfterLastRow);
return false;
}
GError * error = 0;
const gboolean active = tracker_sparql_cursor_next(cursor, 0, &error);
// if this is an ask query, get the result
if (isBool() && active && tracker_sparql_cursor_get_value_type(cursor, 0) == TRACKER_SPARQL_VALUE_TYPE_BOOLEAN) {
const gboolean value = tracker_sparql_cursor_get_boolean(cursor, 0);
setBoolValue(value != FALSE);
}
if (error) {
setLastError(QSparqlError(QString::fromUtf8(error->message),
errorCodeToType(error->code),
error->code));
g_error_free(error);
qWarning() << "QTrackerDirectSyncResult:" << lastError() << query();
g_object_unref(cursor);
cursor = 0;
return false;
}
if (!active) {
g_object_unref(cursor);
cursor = 0;
updatePos(QSparql::AfterLastRow);
return false;
}
const int oldPos = pos();
if (oldPos == QSparql::BeforeFirstRow)
updatePos(0);
else
updatePos(oldPos + 1);
return true;
}
static void
handle_channel_inserts (ReaderEngine *engine,
gint sub)
{
gchar *query;
const gchar *subject;
TrackerSparqlCursor *cursor;
ReaderEnginePrivate *priv;
priv = reader_engine_get_instance_private (engine);
query = g_strdup_printf ("SELECT tracker:uri(%d) {}", sub);
cursor = tracker_sparql_connection_query (priv->tracker, query, NULL, NULL);
tracker_sparql_cursor_next (cursor, NULL, NULL);
subject = tracker_sparql_cursor_get_string (cursor, 0, NULL);
collect_channels (engine, subject);
g_free (query);
g_object_unref (cursor);
}
static void
decorator_cache_items_cb (GObject *object,
GAsyncResult *result,
gpointer user_data)
{
TrackerDecorator *decorator = user_data;
TrackerDecoratorPrivate *priv;
TrackerSparqlConnection *conn;
TrackerSparqlCursor *cursor;
TrackerDecoratorInfo *info;
GError *error = NULL;
conn = TRACKER_SPARQL_CONNECTION (object);
cursor = tracker_sparql_connection_query_finish (conn, result, &error);
priv = decorator->priv;
priv->querying = FALSE;
if (error) {
decorator_notify_task_error (decorator, error);
g_error_free (error);
} else {
while (tracker_sparql_cursor_next (cursor, NULL, NULL)) {
info = tracker_decorator_info_new (decorator, cursor);
g_queue_push_tail (&priv->item_cache, info);
}
}
if (!g_queue_is_empty (&priv->item_cache) && !priv->processing) {
decorator_start (decorator);
} else if (g_queue_is_empty (&priv->item_cache) && priv->processing) {
decorator_finish (decorator);
}
decorator_pair_tasks (decorator);
g_object_unref (cursor);
}
int
main (int argc, char **argv)
{
TrackerSparqlConnection *connection;
TrackerSparqlCursor *cursor;
GOptionContext *context;
GError *error = NULL;
setlocale (LC_ALL, "");
bindtextdomain (GETTEXT_PACKAGE, LOCALEDIR);
bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8");
textdomain (GETTEXT_PACKAGE);
/* Translators: this messagge will apper immediately after the */
/* usage string - Usage: COMMAND [OPTION]... <THIS_MESSAGE> */
context = g_option_context_new (_(" - Show statistics for all Nepomuk defined ontology classes"));
g_option_context_add_main_entries (context, entries, NULL);
g_option_context_parse (context, &argc, &argv, NULL);
if (print_version) {
g_print ("\n" ABOUT "\n" LICENSE "\n");
g_option_context_free (context);
return EXIT_SUCCESS;
}
/* We use search terms on ALL ontologies not just common ones */
if (terms && g_strv_length (terms) > 0) {
show_all = TRUE;
}
g_option_context_free (context);
connection = tracker_sparql_connection_get (NULL, &error);
if (!connection) {
g_printerr ("%s: %s\n",
_("Could not establish a connection to Tracker"),
error ? error->message : _("No error given"));
g_clear_error (&error);
return EXIT_FAILURE;
}
cursor = tracker_sparql_connection_statistics (connection, NULL, &error);
if (error) {
g_printerr ("%s, %s\n",
_("Could not get Tracker statistics"),
error->message);
g_error_free (error);
return EXIT_FAILURE;
}
if (!cursor) {
g_print ("%s\n", _("No statistics available"));
} else {
GString *output;
output = g_string_new ("");
if (!show_all) {
get_common_rdf_types ();
}
while (tracker_sparql_cursor_next (cursor, NULL, NULL)) {
const gchar *rdf_type;
const gchar *rdf_type_count;
rdf_type = tracker_sparql_cursor_get_string (cursor, 0, NULL);
rdf_type_count = tracker_sparql_cursor_get_string (cursor, 1, NULL);
if (!show_all && !g_hash_table_contains (common_rdf_types, rdf_type)) {
continue;
}
if (terms) {
gint i, n_terms;
gboolean show_rdf_type = FALSE;
n_terms = g_strv_length (terms);
for (i = 0;
i < n_terms && !show_rdf_type;
i++) {
show_rdf_type = g_str_match_string (terms[i], rdf_type, TRUE);
}
if (!show_rdf_type) {
continue;
}
}
g_string_append_printf (output,
" %s = %s\n",
rdf_type,
rdf_type_count);
}
if (output->len > 0) {
/* To translators: This is to say there are no
* statistics found. We use a "Statistics:
* None" with multiple print statements */
g_string_prepend (output, "\n");
g_string_prepend (output, _("Statistics:"));
} else {
g_string_append_printf (output,
" %s\n", _("None"));
}
g_print ("%s\n", output->str);
g_string_free (output, TRUE);
if (common_rdf_types) {
g_hash_table_unref (common_rdf_types);
}
g_object_unref (cursor);
}
g_object_unref (connection);
return EXIT_SUCCESS;
}
GHashTable *
tracker_sparql_get_prefixes (void)
{
TrackerSparqlConnection *connection;
TrackerSparqlCursor *cursor;
GError *error = NULL;
GHashTable *retval;
const gchar *query;
connection = tracker_sparql_connection_get (NULL, &error);
if (!connection) {
g_printerr ("%s: %s\n",
_("Could not establish a connection to Tracker"),
error ? error->message : _("No error given"));
g_clear_error (&error);
return NULL;
}
retval = g_hash_table_new_full (g_str_hash,
g_str_equal,
g_free,
g_free);
/* FIXME: Would like to get this in the same SPARQL that we
* use to get the info, but doesn't seem possible at the
* moment with the limited string manipulation features we
* support in SPARQL.
*/
query = "SELECT ?ns ?prefix "
"WHERE {"
" ?ns a tracker:Namespace ;"
" tracker:prefix ?prefix "
"}";
cursor = tracker_sparql_connection_query (connection, query, NULL, &error);
g_object_unref (connection);
if (error) {
g_printerr ("%s, %s\n",
_("Unable to retrieve namespace prefixes"),
error->message);
g_error_free (error);
return retval;
}
if (!cursor) {
g_printerr ("%s\n", _("No namespace prefixes were returned"));
return retval;
}
while (tracker_sparql_cursor_next (cursor, NULL, NULL)) {
const gchar *key, *value;
key = tracker_sparql_cursor_get_string (cursor, 0, NULL);
value = tracker_sparql_cursor_get_string (cursor, 1, NULL);
if (!key || !value) {
continue;
}
g_hash_table_insert (retval,
g_strndup (key, strlen (key) - 1),
g_strdup (value));
}
if (cursor) {
g_object_unref (cursor);
}
return retval;
}
static void
on_query_finished (GObject *source_object,
GAsyncResult *res,
gpointer user_data)
{
GError *error = NULL;
TrackerSparqlCursor *cursor = NULL;
GDir *dir = NULL;
GHashTable *table = NULL;
const gchar *name;
gchar *dirname = NULL;
GList *to_remove = NULL;
cursor = tracker_sparql_connection_query_finish (TRACKER_SPARQL_CONNECTION (source_object),
res,
&error);
if (error) {
goto on_error;
}
dirname = g_build_filename (g_get_user_cache_dir (),
"media-art",
NULL);
if (!g_file_test (dirname, G_FILE_TEST_EXISTS)) {
/* Ignore this and just quit the function */
goto on_error;
}
dir = g_dir_open (dirname, 0, &error);
if (error) {
goto on_error;
}
table = g_hash_table_new_full (g_str_hash,
g_str_equal,
(GDestroyNotify) g_free,
(GDestroyNotify) NULL);
while (tracker_sparql_cursor_next (cursor, NULL, NULL)) {
gchar *target = NULL, *album_path = NULL;
const gchar *album, *artist;
album = tracker_sparql_cursor_get_string (cursor, 0, NULL);
artist = tracker_sparql_cursor_get_value_type (cursor, 1) != TRACKER_SPARQL_VALUE_TYPE_UNBOUND ? tracker_sparql_cursor_get_string (cursor, 1, NULL) : NULL;
/* The get_path API does stripping itself */
media_art_get_path (artist,
album,
"album", NULL,
&target, NULL);
g_hash_table_replace (table, target, target);
/* Also add the file to which the symlinks are made */
media_art_get_path (NULL,
album,
"album", NULL,
&album_path, NULL);
g_hash_table_replace (table, album_path, album_path);
}
/* Perhaps we should have an internal list of media art files that we made,
* instead of going over all the media art (which could also have been made
* by other softwares) */
for (name = g_dir_read_name (dir); name != NULL; name = g_dir_read_name (dir)) {
gpointer value;
gchar *full;
full = g_build_filename (dirname, name, NULL);
value = g_hash_table_lookup (table, full);
if (!value) {
g_message ("Removing media-art file %s: no album exists that has "
"any songs for this media-art cache", name);
to_remove = g_list_prepend (to_remove, (gpointer) full);
} else {
g_free (full);
}
}
g_list_foreach (to_remove, (GFunc) g_unlink, NULL);
g_list_foreach (to_remove, (GFunc) g_free, NULL);
g_list_free (to_remove);
on_error:
g_free (dirname);
if (table) {
g_hash_table_unref (table);
}
if (cursor) {
g_object_unref (cursor);
}
if (dir) {
g_dir_close (dir);
}
if (error) {
g_critical ("Error running cleanup of media-art: %s",
error->message ? error->message : "No error given");
g_error_free (error);
}
}
static gboolean tracker_bus_fd_cursor_real_next_async_co (TrackerBusFdCursorNextAsyncData* _data_) {
#line 122 "/home/martyn/Source/checkout/gnome/tracker/src/libtracker-bus/tracker-bus-fd-cursor.vala"
switch (_data_->_state_) {
#line 122 "/home/martyn/Source/checkout/gnome/tracker/src/libtracker-bus/tracker-bus-fd-cursor.vala"
case 0:
#line 575 "tracker-bus-fd-cursor.c"
goto _state_0;
default:
#line 122 "/home/martyn/Source/checkout/gnome/tracker/src/libtracker-bus/tracker-bus-fd-cursor.vala"
g_assert_not_reached ();
#line 580 "tracker-bus-fd-cursor.c"
}
_state_0:
#line 124 "/home/martyn/Source/checkout/gnome/tracker/src/libtracker-bus/tracker-bus-fd-cursor.vala"
_data_->_tmp1_ = NULL;
#line 124 "/home/martyn/Source/checkout/gnome/tracker/src/libtracker-bus/tracker-bus-fd-cursor.vala"
_data_->_tmp1_ = _data_->cancellable;
#line 124 "/home/martyn/Source/checkout/gnome/tracker/src/libtracker-bus/tracker-bus-fd-cursor.vala"
_data_->_tmp2_ = FALSE;
#line 124 "/home/martyn/Source/checkout/gnome/tracker/src/libtracker-bus/tracker-bus-fd-cursor.vala"
_data_->_tmp2_ = tracker_sparql_cursor_next ((TrackerSparqlCursor*) _data_->self, _data_->_tmp1_, &_data_->_inner_error_);
#line 124 "/home/martyn/Source/checkout/gnome/tracker/src/libtracker-bus/tracker-bus-fd-cursor.vala"
_data_->_tmp0_ = _data_->_tmp2_;
#line 124 "/home/martyn/Source/checkout/gnome/tracker/src/libtracker-bus/tracker-bus-fd-cursor.vala"
if (G_UNLIKELY (_data_->_inner_error_ != NULL)) {
#line 124 "/home/martyn/Source/checkout/gnome/tracker/src/libtracker-bus/tracker-bus-fd-cursor.vala"
g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
#line 124 "/home/martyn/Source/checkout/gnome/tracker/src/libtracker-bus/tracker-bus-fd-cursor.vala"
g_error_free (_data_->_inner_error_);
#line 124 "/home/martyn/Source/checkout/gnome/tracker/src/libtracker-bus/tracker-bus-fd-cursor.vala"
if (_data_->_state_ == 0) {
#line 124 "/home/martyn/Source/checkout/gnome/tracker/src/libtracker-bus/tracker-bus-fd-cursor.vala"
g_simple_async_result_complete_in_idle (_data_->_async_result);
#line 603 "tracker-bus-fd-cursor.c"
} else {
#line 124 "/home/martyn/Source/checkout/gnome/tracker/src/libtracker-bus/tracker-bus-fd-cursor.vala"
g_simple_async_result_complete (_data_->_async_result);
#line 607 "tracker-bus-fd-cursor.c"
}
#line 124 "/home/martyn/Source/checkout/gnome/tracker/src/libtracker-bus/tracker-bus-fd-cursor.vala"
g_object_unref (_data_->_async_result);
#line 124 "/home/martyn/Source/checkout/gnome/tracker/src/libtracker-bus/tracker-bus-fd-cursor.vala"
return FALSE;
#line 613 "tracker-bus-fd-cursor.c"
}
#line 124 "/home/martyn/Source/checkout/gnome/tracker/src/libtracker-bus/tracker-bus-fd-cursor.vala"
_data_->result = _data_->_tmp0_;
#line 124 "/home/martyn/Source/checkout/gnome/tracker/src/libtracker-bus/tracker-bus-fd-cursor.vala"
if (_data_->_state_ == 0) {
#line 124 "/home/martyn/Source/checkout/gnome/tracker/src/libtracker-bus/tracker-bus-fd-cursor.vala"
g_simple_async_result_complete_in_idle (_data_->_async_result);
#line 621 "tracker-bus-fd-cursor.c"
} else {
#line 124 "/home/martyn/Source/checkout/gnome/tracker/src/libtracker-bus/tracker-bus-fd-cursor.vala"
g_simple_async_result_complete (_data_->_async_result);
#line 625 "tracker-bus-fd-cursor.c"
}
#line 124 "/home/martyn/Source/checkout/gnome/tracker/src/libtracker-bus/tracker-bus-fd-cursor.vala"
g_object_unref (_data_->_async_result);
#line 124 "/home/martyn/Source/checkout/gnome/tracker/src/libtracker-bus/tracker-bus-fd-cursor.vala"
return FALSE;
#line 122 "/home/martyn/Source/checkout/gnome/tracker/src/libtracker-bus/tracker-bus-fd-cursor.vala"
if (_data_->_state_ == 0) {
#line 122 "/home/martyn/Source/checkout/gnome/tracker/src/libtracker-bus/tracker-bus-fd-cursor.vala"
g_simple_async_result_complete_in_idle (_data_->_async_result);
#line 635 "tracker-bus-fd-cursor.c"
} else {
#line 122 "/home/martyn/Source/checkout/gnome/tracker/src/libtracker-bus/tracker-bus-fd-cursor.vala"
g_simple_async_result_complete (_data_->_async_result);
#line 639 "tracker-bus-fd-cursor.c"
}
#line 122 "/home/martyn/Source/checkout/gnome/tracker/src/libtracker-bus/tracker-bus-fd-cursor.vala"
g_object_unref (_data_->_async_result);
#line 122 "/home/martyn/Source/checkout/gnome/tracker/src/libtracker-bus/tracker-bus-fd-cursor.vala"
return FALSE;
#line 645 "tracker-bus-fd-cursor.c"
}
static int
get_file_and_folder_count (int *files,
int *folders)
{
TrackerSparqlConnection *connection;
TrackerSparqlCursor *cursor;
GError *error = NULL;
connection = tracker_sparql_connection_get (NULL, &error);
if (files) {
*files = 0;
}
if (folders) {
*folders = 0;
}
if (!connection) {
g_printerr ("%s: %s\n",
_("Could not establish a connection to Tracker"),
error ? error->message : _("No error given"));
g_clear_error (&error);
return EXIT_FAILURE;
}
if (files) {
const gchar query[] =
"\nSELECT COUNT(?file) "
"\nWHERE { "
"\n ?file a nfo:FileDataObject ;"
"\n tracker:available true ."
"\n FILTER (?file != nfo:Folder) "
"\n}";
cursor = tracker_sparql_connection_query (connection, query, NULL, &error);
if (error || !tracker_sparql_cursor_next (cursor, NULL, NULL)) {
g_printerr ("%s, %s\n",
_("Could not get basic status for Tracker"),
error->message);
g_error_free (error);
return EXIT_FAILURE;
}
*files = tracker_sparql_cursor_get_integer (cursor, 0);
g_object_unref (cursor);
}
if (folders) {
const gchar query[] =
"\nSELECT COUNT(?folders)"
"\nWHERE { "
"\n ?folders a nfo:Folder ;"
"\n tracker:available true ."
"\n}";
cursor = tracker_sparql_connection_query (connection, query, NULL, &error);
if (error || !tracker_sparql_cursor_next (cursor, NULL, NULL)) {
g_printerr ("%s, %s\n",
_("Could not get basic status for Tracker"),
error->message);
g_error_free (error);
return EXIT_FAILURE;
}
*folders = tracker_sparql_cursor_get_integer (cursor, 0);
g_object_unref (cursor);
}
g_object_unref (connection);
return EXIT_SUCCESS;
}
static int
collect_debug (void)
{
/* What to collect?
* This is based on information usually requested from maintainers to users.
*
* 1. Package details, e.g. version.
* 2. Disk size, space left, type (SSD/etc)
* 3. Size of dataset (tracker-stats), size of databases
* 4. Current configuration (libtracker-fts, tracker-miner-fs, tracker-extract)
* All txt files in ~/.cache/
* 5. Statistics about data (tracker-stats)
*/
GDir *d;
gchar *data_dir;
gchar *str;
data_dir = g_build_filename (g_get_user_cache_dir (), "tracker", NULL);
/* 1. Package details, e.g. version. */
g_print ("[Package Details]\n");
g_print ("%s: " PACKAGE_VERSION "\n", _("Version"));
g_print ("\n\n");
/* 2. Disk size, space left, type (SSD/etc) */
guint64 remaining_bytes;
gdouble remaining;
g_print ("[%s]\n", _("Disk Information"));
remaining_bytes = tracker_file_system_get_remaining_space (data_dir);
str = g_format_size (remaining_bytes);
remaining = tracker_file_system_get_remaining_space_percentage (data_dir);
g_print ("%s: %s (%3.2lf%%)\n",
_("Remaining space on database partition"),
str,
remaining);
g_free (str);
g_print ("\n\n");
/* 3. Size of dataset (tracker-stats), size of databases */
g_print ("[%s]\n", _("Data Set"));
for (d = g_dir_open (data_dir, 0, NULL); d != NULL;) {
const gchar *f;
gchar *path;
goffset size;
f = g_dir_read_name (d);
if (!f) {
break;
}
if (g_str_has_suffix (f, ".txt")) {
continue;
}
path = g_build_filename (data_dir, f, NULL);
size = tracker_file_get_size (path);
str = g_format_size (size);
g_print ("%s\n%s\n\n", path, str);
g_free (str);
g_free (path);
}
g_dir_close (d);
g_print ("\n");
/* 4. Current configuration (libtracker-fts, tracker-miner-fs, tracker-extract)
* All txt files in ~/.cache/
*/
GSList *all, *l;
g_print ("[%s]\n", _("Configuration"));
all = tracker_gsettings_get_all (NULL);
if (all) {
for (l = all; l; l = l->next) {
ComponentGSettings *c = l->data;
gchar **keys, **p;
if (!c) {
continue;
}
keys = g_settings_list_keys (c->settings);
for (p = keys; p && *p; p++) {
GVariant *v;
gchar *printed;
v = g_settings_get_value (c->settings, *p);
printed = g_variant_print (v, FALSE);
g_print ("%s.%s: %s\n", c->name, *p, printed);
g_free (printed);
g_variant_unref (v);
}
}
tracker_gsettings_free (all);
} else {
g_print ("** %s **\n", _("No configuration was found"));
}
g_print ("\n\n");
g_print ("[%s]\n", _("States"));
for (d = g_dir_open (data_dir, 0, NULL); d != NULL;) {
const gchar *f;
gchar *path;
gchar *content = NULL;
f = g_dir_read_name (d);
if (!f) {
break;
}
if (!g_str_has_suffix (f, ".txt")) {
continue;
}
path = g_build_filename (data_dir, f, NULL);
if (g_file_get_contents (path, &content, NULL, NULL)) {
/* Special case last-index.txt which is time() dump to file */
if (g_str_has_suffix (path, "last-crawl.txt")) {
guint64 then, now;
now = (guint64) time (NULL);
then = g_ascii_strtoull (content, NULL, 10);
str = tracker_seconds_to_string (now - then, FALSE);
g_print ("%s\n%s (%s)\n\n", path, content, str);
} else {
g_print ("%s\n%s\n\n", path, content);
}
g_free (content);
}
g_free (path);
}
g_dir_close (d);
g_print ("\n");
/* 5. Statistics about data (tracker-stats) */
TrackerSparqlConnection *connection;
GError *error = NULL;
g_print ("[%s]\n", _("Data Statistics"));
connection = tracker_sparql_connection_get (NULL, &error);
if (!connection) {
g_print ("** %s, %s **\n",
_("No connection available"),
error ? error->message : _("No error given"));
g_clear_error (&error);
} else {
TrackerSparqlCursor *cursor;
cursor = tracker_sparql_connection_statistics (connection, NULL, &error);
if (error) {
g_print ("** %s, %s **\n",
_("Could not get statistics"),
error ? error->message : _("No error given"));
g_error_free (error);
} else {
if (!cursor) {
g_print ("** %s **\n",
_("No statistics were available"));
} else {
gint count = 0;
while (tracker_sparql_cursor_next (cursor, NULL, NULL)) {
g_print ("%s: %s\n",
tracker_sparql_cursor_get_string (cursor, 0, NULL),
tracker_sparql_cursor_get_string (cursor, 1, NULL));
count++;
}
if (count == 0) {
g_print ("%s\n",
_("Database is currently empty"));
}
g_object_unref (cursor);
}
}
}
g_object_unref (connection);
g_print ("\n\n");
g_print ("\n");
g_free (data_dir);
return EXIT_SUCCESS;
}
static int
status_stat (void)
{
TrackerSparqlConnection *connection;
TrackerSparqlCursor *cursor;
GError *error = NULL;
connection = tracker_sparql_connection_get (NULL, &error);
if (!connection) {
g_printerr ("%s: %s\n",
_("Could not establish a connection to Tracker"),
error ? error->message : _("No error given"));
g_clear_error (&error);
return EXIT_FAILURE;
}
cursor = tracker_sparql_connection_statistics (connection, NULL, &error);
g_object_unref (connection);
if (error) {
g_printerr ("%s, %s\n",
_("Could not get Tracker statistics"),
error->message);
g_error_free (error);
return EXIT_FAILURE;
}
/* We use search terms on ALL ontologies not just common ones */
if (terms && g_strv_length (terms) > 0) {
show_all = TRUE;
}
if (!cursor) {
g_print ("%s\n", _("No statistics available"));
} else {
GString *output;
output = g_string_new ("");
if (!show_all) {
get_common_rdf_types ();
}
while (tracker_sparql_cursor_next (cursor, NULL, NULL)) {
const gchar *rdf_type;
const gchar *rdf_type_count;
rdf_type = tracker_sparql_cursor_get_string (cursor, 0, NULL);
rdf_type_count = tracker_sparql_cursor_get_string (cursor, 1, NULL);
if (!show_all && !g_hash_table_contains (common_rdf_types, rdf_type)) {
continue;
}
if (terms) {
gint i, n_terms;
gboolean show_rdf_type = FALSE;
n_terms = g_strv_length (terms);
for (i = 0;
i < n_terms && !show_rdf_type;
i++) {
show_rdf_type = g_str_match_string (terms[i], rdf_type, TRUE);
}
if (!show_rdf_type) {
continue;
}
}
g_string_append_printf (output,
" %s = %s\n",
rdf_type,
rdf_type_count);
}
if (output->len > 0) {
/* To translators: This is to say there are no
* statistics found. We use a "Statistics:
* None" with multiple print statements */
g_string_prepend (output, "\n");
g_string_prepend (output, _("Statistics:"));
} else {
g_string_append_printf (output,
" %s\n", _("None"));
}
g_print ("%s\n", output->str);
g_string_free (output, TRUE);
if (common_rdf_types) {
g_hash_table_unref (common_rdf_types);
}
g_object_unref (cursor);
}
return EXIT_SUCCESS;
}
