static void
shell_prefs_init (void)
{
ShellGlobal *global = shell_global_get ();
GSettings *settings = shell_global_get_overrides_settings (global);
char **keys, **k, *schema_id;
if (!settings)
return;
g_object_get (G_OBJECT (settings), "schema-id", &schema_id, NULL);
keys = g_settings_list_keys (settings);
for (keys = k = g_settings_list_keys (settings); *k; k++)
meta_prefs_override_preference_schema (*k, schema_id);
g_strfreev (keys);
g_free (schema_id);
}
bool
nsGSettingsCollection::KeyExists(const nsACString& aKey)
{
if (!mKeys)
mKeys = g_settings_list_keys(mSettings);
for (PRUint32 i = 0; mKeys[i] != NULL; i++) {
if (aKey.Equals(mKeys[i]))
return PR_TRUE;
}
return PR_FALSE;
}
QStringList QGSettings::keys() const
{
Q_D(const QGSettings);
QStringList result;
if (!d->valid)
return result;
gchar **keys = g_settings_list_keys(d->settings);
for (int i = 0; keys[i]; i++)
result.append(Utils::toCamelCase(keys[i]));
g_strfreev(keys);
return result;
}
static void
nemo_fr_instance_init (NemoFr *fr)
{
GSettings *settings = g_settings_new ("org.nemo.preferences");
gchar **keys = g_settings_list_keys (settings);
int i;
for (i = 0; i < g_strv_length (keys); i++) {
if (g_strcmp0 (keys[i], "context-menus-show-all-actions")) {
always_show_extract_to = g_settings_get_boolean (settings, "context-menus-show-all-actions");
break;
}
}
g_strfreev (keys);
g_object_unref (settings);
}
static gboolean gnc_gsettings_is_valid_key(GSettings *settings, const gchar *key)
{
gchar **keys = NULL;
gint i = 0;
gboolean found = FALSE;
#ifdef HAVE_GLIB_2_46
GSettingsSchema *schema;
#endif
// Check if the key is valid key within settings
if (!G_IS_SETTINGS(settings))
return FALSE;
#ifdef HAVE_GLIB_2_46
g_object_get (settings, "settings-schema", &schema, NULL);
if (!schema)
return FALSE;
#endif
// Get list of keys
#ifdef HAVE_GLIB_2_46
keys = g_settings_schema_list_keys(schema);
#else
keys = g_settings_list_keys(settings);
#endif
while (keys && keys[i])
{
if (!g_strcmp0(key, keys[i]))
{
found = TRUE;
break;
}
i++;
}
// Free keys
g_strfreev(keys);
return found;
}
void
gnc_gsettings_reset_schema (const gchar *schema_str)
{
gchar **keys;
gint counter = 0;
#ifdef HAVE_GLIB_2_46
GSettingsSchema *schema;
#endif
GSettings *settings = gnc_gsettings_get_settings_ptr (schema_str);
if (!settings)
return;
#ifdef HAVE_GLIB_2_46
g_object_get (settings, "settings-schema", &schema, NULL);
if (!schema)
return;
keys = g_settings_schema_list_keys (schema);
#else
keys = g_settings_list_keys (settings);
#endif
if (!keys)
return;
while (keys[counter])
{
gnc_gsettings_reset (schema_str, keys[counter]);
counter++;
}
g_strfreev (keys);
}
static GSettings *
get_system_settings (void)
{
GSettings *settings;
gchar **keys;
gchar **k;
/* FIXME: we need to bind system settings instead of user but
* that's currently impossible, not implemented yet.
* Hence, reset to system default values.
*/
/* TODO: Ideally we would like to bind some other key, screensaver-specific. */
settings = g_settings_new ("org.gnome.desktop.background");
g_settings_delay (settings);
keys = g_settings_list_keys (settings);
for (k = keys; *k; k++) {
g_settings_reset (settings, *k);
}
g_strfreev (keys);
return settings;
}
static NimfSettingsPage *
nimf_settings_page_new (NimfSettings *nsettings,
const gchar *schema_id)
{
NimfSettingsPage *page;
GSettingsSchema *schema;
GList *key_list = NULL;
gchar **keys;
GList *l;
gint i;
page = g_slice_new0 (NimfSettingsPage);
page->gsettings = g_settings_new (schema_id);
page->label = nimf_settings_page_build_label (page, schema_id);
page->box = gtk_box_new (GTK_ORIENTATION_VERTICAL, 15);
page->page_keys = g_ptr_array_new_with_free_func ((GDestroyNotify) nimf_settings_page_key_free);
#if GTK_CHECK_VERSION (3, 12, 0)
gtk_widget_set_margin_start (page->box, 15);
gtk_widget_set_margin_end (page->box, 15);
#else
gtk_widget_set_margin_left (page->box, 15);
gtk_widget_set_margin_right (page->box, 15);
#endif
gtk_widget_set_margin_top (page->box, 15);
gtk_widget_set_margin_bottom (page->box, 15);
schema = g_settings_schema_source_lookup (nsettings->schema_source,
schema_id, TRUE);
#if GLIB_CHECK_VERSION (2, 46, 0)
keys = g_settings_schema_list_keys (schema);
#else
keys = g_settings_list_keys (page->gsettings);
#endif
for (i = 0; keys[i] != NULL; i++)
key_list = g_list_prepend (key_list, keys[i]);
key_list = g_list_sort (key_list, (GCompareFunc) on_comparison);
for (i = 0, l = key_list; l != NULL; l = l->next, i++)
{
GVariant *variant;
GSettingsSchemaKey *schema_key = NULL;
NimfSettingsPageKey *page_key;
const GVariantType *type;
const gchar *key;
const gchar *summary;
const gchar *desc;
key = l->data;
if (g_str_has_prefix (key, "hidden-"))
continue;
variant = g_settings_get_value (page->gsettings, key);
type = g_variant_get_type (variant);
schema_key = g_settings_schema_get_key (schema, key);
summary = g_settings_schema_key_get_summary (schema_key);
desc = g_settings_schema_key_get_description (schema_key);
page_key = nimf_settings_page_key_new (page->gsettings, key, summary, desc);
g_ptr_array_add (page->page_keys, page_key);
if (g_variant_type_equal (type, G_VARIANT_TYPE_BOOLEAN))
{
GtkWidget *item;
item = nimf_settings_page_key_build_boolean (page_key);
gtk_box_pack_start (GTK_BOX (page->box), item, FALSE, FALSE, 0);
}
else if (g_variant_type_equal (type, G_VARIANT_TYPE_STRING))
{
GtkWidget *item;
item = nimf_settings_page_key_build_string (page_key, schema_id, key_list);
gtk_box_pack_start (GTK_BOX (page->box), item, FALSE, FALSE, 0);
}
else if (g_variant_type_equal (type, G_VARIANT_TYPE_STRING_ARRAY))
{
GtkWidget *item;
item = nimf_settings_page_key_build_string_array (page_key);
gtk_box_pack_start (GTK_BOX (page->box), item, FALSE, FALSE, 0);
}
else
g_error (G_STRLOC ": %s: not supported variant type: \"%s\"",
G_STRFUNC, (gchar *) type);
g_settings_schema_key_unref (schema_key);
g_variant_unref (variant);
}
g_strfreev (keys);
g_list_free (key_list);
g_settings_schema_unref (schema);
return page;
}
static gboolean
panel_layout_append_self_check (GSettings *settings,
PanelLayoutKeyDefinition *key_definitions,
int key_definitions_len,
GError **error)
{
char **settings_keys = NULL;
int i, j;
/* Don't do those checks twice; we use a static array with a boolean
* for each set of key definitions we might want to check, and mark the
* booleans to TRUE once we've entered this function once for a set. */
static gboolean self_check_done[2] = {FALSE, FALSE};
g_assert (key_definitions == panel_layout_toplevel_keys ||
key_definitions == panel_layout_object_keys);
if (key_definitions == panel_layout_toplevel_keys) {
if (self_check_done[0])
return TRUE;
else
self_check_done[0] = TRUE;
}
if (key_definitions == panel_layout_object_keys) {
if (self_check_done[1])
return TRUE;
else
self_check_done[1] = TRUE;
}
/* End hacky way of avoiding double-checks */
g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
settings_keys = g_settings_list_keys (settings);
for (i = 0; settings_keys[i] != NULL; i++) {
gboolean found = FALSE;
for (j = 0; j < key_definitions_len; j++) {
if (g_strcmp0 (settings_keys[i],
key_definitions[j].name) == 0) {
found = TRUE;
break;
}
}
if (!found) {
g_set_error (error, PANEL_LAYOUT_ERROR, 0,
"Mismatch between keys defined in schema and keys known to consort-panel ('%s' is not known)",
settings_keys[i]);
g_strfreev (settings_keys);
return FALSE;
}
}
g_strfreev (settings_keys);
if (i != key_definitions_len) {
g_set_error (error, PANEL_LAYOUT_ERROR, 0,
"Mismatch between keys defined in schema and keys known to consort-panel (%d keys in schema, %d keys known to consort-panel)",
i, j);
return FALSE;
}
return TRUE;
}
gint
tracker_control_general_run (void)
{
GError *error = NULL;
GSList *pids;
GSList *l;
gchar *str;
gpointer verbosity_type_enum_class_pointer = NULL;
TrackerVerbosity set_log_verbosity_value = TRACKER_VERBOSITY_ERRORS;
/* Constraints */
if (kill_option != TERM_NONE && terminate_option != TERM_NONE) {
g_printerr ("%s\n",
_("You can not use the --kill and --terminate arguments together"));
return EXIT_FAILURE;
}
if ((hard_reset || soft_reset) && terminate_option != TERM_NONE) {
g_printerr ("%s\n",
_("You can not use the --terminate with --hard-reset or --soft-reset, --kill is implied"));
return EXIT_FAILURE;
}
if (hard_reset && soft_reset) {
g_printerr ("%s\n",
_("You can not use the --hard-reset and --soft-reset arguments together"));
return EXIT_FAILURE;
}
if (get_log_verbosity && set_log_verbosity) {
g_printerr ("%s\n",
_("You can not use the --get-logging and --set-logging arguments together"));
return EXIT_FAILURE;
}
if (set_log_verbosity) {
if (g_ascii_strcasecmp (set_log_verbosity, "debug") == 0) {
set_log_verbosity_value = TRACKER_VERBOSITY_DEBUG;
} else if (g_ascii_strcasecmp (set_log_verbosity, "detailed") == 0) {
set_log_verbosity_value = TRACKER_VERBOSITY_DETAILED;
} else if (g_ascii_strcasecmp (set_log_verbosity, "minimal") == 0) {
set_log_verbosity_value = TRACKER_VERBOSITY_MINIMAL;
} else if (g_ascii_strcasecmp (set_log_verbosity, "errors") == 0) {
set_log_verbosity_value = TRACKER_VERBOSITY_ERRORS;
} else {
g_printerr ("%s\n",
_("Invalid log verbosity, try 'debug', 'detailed', 'minimal' or 'errors'"));
return EXIT_FAILURE;
}
}
if (hard_reset || soft_reset) {
/* Imply --kill */
kill_option = TERM_ALL;
}
if (get_log_verbosity || set_log_verbosity) {
GType etype;
/* Since we don't reference this enum anywhere, we do
* it here to make sure it exists when we call
* g_type_class_peek(). This wouldn't be necessary if
* it was a param in a GObject for example.
*
* This does mean that we are leaking by 1 reference
* here and should clean it up, but it doesn't grow so
* this is acceptable.
*/
etype = tracker_verbosity_get_type ();
verbosity_type_enum_class_pointer = g_type_class_ref (etype);
}
/* Unless we are stopping processes or listing processes,
* don't iterate them.
*/
if (kill_option != TERM_NONE ||
terminate_option != TERM_NONE ||
list_processes) {
guint32 own_pid;
guint32 own_uid;
gchar *own_pid_str;
pids = get_pids ();
str = g_strdup_printf (g_dngettext (NULL,
"Found %d PID…",
"Found %d PIDs…",
g_slist_length (pids)),
g_slist_length (pids));
g_print ("%s\n", str);
g_free (str);
/* Establish own uid/pid */
own_pid = (guint32) getpid ();
own_pid_str = g_strdup_printf ("%d", own_pid);
own_uid = get_uid_for_pid (own_pid_str, NULL);
g_free (own_pid_str);
for (l = pids; l; l = l->next) {
GError *error = NULL;
gchar *filename;
gchar *contents = NULL;
gchar **strv;
guint uid;
uid = get_uid_for_pid (l->data, &filename);
/* Stat the file and make sure current user == file owner */
if (uid != own_uid) {
continue;
}
/* Get contents to determine basename */
if (!g_file_get_contents (filename, &contents, NULL, &error)) {
str = g_strdup_printf (_("Could not open '%s'"), filename);
g_printerr ("%s, %s\n",
str,
error ? error->message : _("no error given"));
g_free (str);
g_clear_error (&error);
g_free (contents);
g_free (filename);
continue;
}
strv = g_strsplit (contents, "^@", 2);
if (strv && strv[0]) {
gchar *basename;
basename = g_path_get_basename (strv[0]);
if ((g_str_has_prefix (basename, "tracker") == TRUE ||
g_str_has_prefix (basename, "lt-tracker") == TRUE) &&
g_str_has_suffix (basename, "-control") == FALSE &&
g_str_has_suffix (basename, "-status-icon") == FALSE) {
pid_t pid;
pid = atoi (l->data);
str = g_strdup_printf (_("Found process ID %d for '%s'"), pid, basename);
g_print ("%s\n", str);
g_free (str);
if (terminate_option != TERM_NONE) {
if ((terminate_option == TERM_STORE &&
!g_str_has_suffix (basename, "tracker-store")) ||
(terminate_option == TERM_MINERS &&
!strstr (basename, "tracker-miner"))) {
continue;
}
if (kill (pid, SIGTERM) == -1) {
const gchar *errstr = g_strerror (errno);
str = g_strdup_printf (_("Could not terminate process %d"), pid);
g_printerr (" %s, %s\n",
str,
errstr ? errstr : _("no error given"));
g_free (str);
} else {
str = g_strdup_printf (_("Terminated process %d"), pid);
g_print (" %s\n", str);
g_free (str);
}
} else if (kill_option != TERM_NONE) {
if ((kill_option == TERM_STORE &&
!g_str_has_suffix (basename, "tracker-store")) ||
(kill_option == TERM_MINERS &&
!strstr (basename, "tracker-miner"))) {
continue;
}
if (kill (pid, SIGKILL) == -1) {
const gchar *errstr = g_strerror (errno);
str = g_strdup_printf (_("Could not kill process %d"), pid);
g_printerr (" %s, %s\n",
str,
errstr ? errstr : _("no error given"));
g_free (str);
} else {
str = g_strdup_printf (_("Killed process %d"), pid);
g_print (" %s\n", str);
g_free (str);
}
}
}
g_free (basename);
}
g_strfreev (strv);
g_free (contents);
g_free (filename);
}
g_slist_foreach (pids, (GFunc) g_free, NULL);
g_slist_free (pids);
/* If we just wanted to list processes, all done */
if (list_processes &&
terminate_option == TERM_NONE &&
kill_option == TERM_NONE) {
return EXIT_SUCCESS;
}
}
if (hard_reset || soft_reset) {
guint log_handler_id;
#ifndef DISABLE_JOURNAL
gchar *rotate_to;
TrackerDBConfig *db_config;
gsize chunk_size;
gint chunk_size_mb;
#endif /* DISABLE_JOURNAL */
/* Set log handler for library messages */
log_handler_id = g_log_set_handler (NULL,
G_LOG_LEVEL_MASK | G_LOG_FLAG_FATAL,
log_handler,
NULL);
g_log_set_default_handler (log_handler, NULL);
#ifndef DISABLE_JOURNAL
db_config = tracker_db_config_new ();
chunk_size_mb = tracker_db_config_get_journal_chunk_size (db_config);
chunk_size = (gsize) ((gsize) chunk_size_mb * (gsize) 1024 * (gsize) 1024);
rotate_to = tracker_db_config_get_journal_rotate_destination (db_config);
/* This call is needed to set the journal's filename */
tracker_db_journal_set_rotating ((chunk_size_mb != -1),
chunk_size, rotate_to);
g_free (rotate_to);
g_object_unref (db_config);
#endif /* DISABLE_JOURNAL */
/* Clean up (select_cache_size and update_cache_size don't matter here) */
if (!tracker_db_manager_init (TRACKER_DB_MANAGER_REMOVE_ALL,
NULL,
FALSE,
FALSE,
100,
100,
NULL,
NULL,
NULL,
&error)) {
g_message ("Error initializing database: %s", error->message);
g_free (error);
return EXIT_FAILURE;
}
#ifndef DISABLE_JOURNAL
tracker_db_journal_init (NULL, FALSE, NULL);
#endif /* DISABLE_JOURNAL */
tracker_db_manager_remove_all (hard_reset);
tracker_db_manager_shutdown ();
#ifndef DISABLE_JOURNAL
tracker_db_journal_shutdown (NULL);
#endif /* DISABLE_JOURNAL */
/* Unset log handler */
g_log_remove_handler (NULL, log_handler_id);
}
if (remove_config) {
GMainLoop *main_loop;
GFile *file;
TrackerCrawler *crawler;
const gchar *suffix = ".cfg";
const gchar *home_conf_dir;
gchar *path;
GSList *all, *l;
crawler = tracker_crawler_new ();
main_loop = g_main_loop_new (NULL, FALSE);
g_signal_connect (crawler, "check-file",
G_CALLBACK (crawler_check_file_cb),
&suffix);
g_signal_connect (crawler, "finished",
G_CALLBACK (crawler_finished_cb),
main_loop);
/* Go through service files */
/* Check the default XDG_DATA_HOME location */
home_conf_dir = g_getenv ("XDG_CONFIG_HOME");
if (home_conf_dir && tracker_path_has_write_access_or_was_created (home_conf_dir)) {
path = g_build_path (G_DIR_SEPARATOR_S, home_conf_dir, "tracker", NULL);
} else {
home_conf_dir = g_getenv ("HOME");
if (!home_conf_dir || !tracker_path_has_write_access_or_was_created (home_conf_dir)) {
home_conf_dir = g_get_home_dir ();
}
path = g_build_path (G_DIR_SEPARATOR_S, home_conf_dir, ".config", "tracker", NULL);
}
file = g_file_new_for_path (path);
g_free (path);
g_print ("%s\n", _("Removing configuration files…"));
tracker_crawler_start (crawler, file, FALSE);
g_object_unref (file);
g_main_loop_run (main_loop);
g_object_unref (crawler);
g_print ("%s\n", _("Resetting existing configuration…"));
all = tracker_gsettings_get_all (NULL);
if (!all) {
return EXIT_FAILURE;
}
for (l = all; l; l = l->next) {
ComponentGSettings *c = l->data;
gchar **keys, **p;
if (!c) {
continue;
}
g_print (" %s\n", c->name);
keys = g_settings_list_keys (c->settings);
for (p = keys; p && *p; p++) {
g_print (" %s\n", *p);
g_settings_reset (c->settings, *p);
}
if (keys) {
g_strfreev (keys);
}
g_settings_apply (c->settings);
}
tracker_gsettings_free (all);
}
/* Deal with logging changes AFTER the config may have been
* reset, this way users can actually use --remove-config with
* the --set-logging switch.
*/
if (get_log_verbosity) {
GSList *all;
gint longest = 0;
all = tracker_gsettings_get_all (&longest);
if (!all) {
return EXIT_FAILURE;
}
g_print ("%s:\n", _("Components"));
tracker_gsettings_print_verbosity (all, longest, TRUE);
g_print ("\n");
/* Miners */
g_print ("%s (%s):\n",
_("Miners"),
_("Only those with config listed"));
tracker_gsettings_print_verbosity (all, longest, FALSE);
g_print ("\n");
tracker_gsettings_free (all);
}
if (set_log_verbosity) {
GSList *all;
gchar *str;
gint longest = 0;
all = tracker_gsettings_get_all (&longest);
if (!all) {
return EXIT_FAILURE;
}
str = g_strdup_printf (_("Setting log verbosity for all components to '%s'…"), set_log_verbosity);
g_print ("%s\n", str);
g_print ("\n");
g_free (str);
tracker_gsettings_set_all (all, set_log_verbosity_value);
tracker_gsettings_free (all);
/* We free to make sure we get new settings and that
* they're saved properly.
*/
all = tracker_gsettings_get_all (&longest);
if (!all) {
return EXIT_FAILURE;
}
g_print ("%s:\n", _("Components"));
tracker_gsettings_print_verbosity (all, longest, TRUE);
g_print ("\n");
/* Miners */
g_print ("%s (%s):\n",
_("Miners"),
_("Only those with config listed"));
tracker_gsettings_print_verbosity (all, longest, FALSE);
g_print ("\n");
tracker_gsettings_free (all);
}
if (verbosity_type_enum_class_pointer) {
g_type_class_unref (verbosity_type_enum_class_pointer);
}
if (start) {
TrackerMinerManager *manager;
GSList *miners, *l;
if (hard_reset || soft_reset) {
g_print ("%s\n", _("Waiting one second before starting miners…"));
/* Give a second's grace to avoid race conditions */
g_usleep (G_USEC_PER_SEC);
}
g_print ("%s\n", _("Starting miners…"));
/* Auto-start the miners here */
manager = tracker_miner_manager_new_full (TRUE, &error);
if (!manager) {
g_printerr (_("Could not start miners, manager could not be created, %s"),
error ? error->message : "unknown error");
g_printerr ("\n");
g_clear_error (&error);
return EXIT_FAILURE;
}
miners = tracker_miner_manager_get_available (manager);
/* Get the status of all miners, this will start all
* miners not already running.
*/
for (l = miners; l; l = l->next) {
const gchar *display_name;
gdouble progress = 0.0;
display_name = tracker_miner_manager_get_display_name (manager, l->data);
if (!tracker_miner_manager_get_status (manager,
l->data,
NULL,
&progress,
NULL)) {
g_printerr (" ✗ %s (%s)\n",
display_name,
_("perhaps a disabled plugin?"));
} else {
g_print (" ✓ %s\n",
display_name);
}
g_free (l->data);
}
g_slist_free (miners);
g_object_unref (manager);
}
if (backup) {
GDBusConnection *connection;
GDBusProxy *proxy;
GError *error = NULL;
GVariant *v;
gchar *uri;
uri = get_uri_from_arg (backup);
g_print ("%s\n", _("Backing up database"));
g_print (" %s\n", uri);
connection = g_bus_get_sync (G_BUS_TYPE_SESSION, NULL, &error);
if (!connection) {
g_critical ("Could not connect to the D-Bus session bus, %s",
error ? error->message : "no error given.");
g_clear_error (&error);
g_free (uri);
return EXIT_FAILURE;
}
proxy = g_dbus_proxy_new_sync (connection,
G_DBUS_PROXY_FLAGS_NONE,
NULL,
"org.freedesktop.Tracker1",
"/org/freedesktop/Tracker1/Backup",
"org.freedesktop.Tracker1.Backup",
NULL,
&error);
if (error) {
g_critical ("Could not create proxy on the D-Bus session bus, %s",
error ? error->message : "no error given.");
g_clear_error (&error);
g_free (uri);
return EXIT_FAILURE;
}
/* Backup/Restore can take some time */
g_dbus_proxy_set_default_timeout (proxy, G_MAXINT);
v = g_dbus_proxy_call_sync (proxy,
"Save",
g_variant_new ("(s)", uri),
G_DBUS_CALL_FLAGS_NONE,
-1,
NULL,
&error);
if (proxy) {
g_object_unref (proxy);
}
if (error) {
g_critical ("Could not backup database, %s",
error ? error->message : "no error given.");
g_clear_error (&error);
g_free (uri);
return EXIT_FAILURE;
}
if (v) {
g_variant_unref (v);
}
g_free (uri);
}
if (restore) {
GDBusConnection *connection;
GDBusProxy *proxy;
GError *error = NULL;
GVariant *v;
gchar *uri;
uri = get_uri_from_arg (restore);
g_print ("%s\n", _("Restoring database from backup"));
g_print (" %s\n", uri);
connection = g_bus_get_sync (G_BUS_TYPE_SESSION, NULL, &error);
if (!connection) {
g_critical ("Could not connect to the D-Bus session bus, %s",
error ? error->message : "no error given.");
g_clear_error (&error);
g_free (uri);
return EXIT_FAILURE;
}
proxy = g_dbus_proxy_new_sync (connection,
G_DBUS_PROXY_FLAGS_NONE,
NULL,
"org.freedesktop.Tracker1",
"/org/freedesktop/Tracker1/Backup",
"org.freedesktop.Tracker1.Backup",
NULL,
&error);
if (error) {
g_critical ("Could not create proxy on the D-Bus session bus, %s",
error ? error->message : "no error given.");
g_clear_error (&error);
g_free (uri);
return EXIT_FAILURE;
}
/* Backup/Restore can take some time */
g_dbus_proxy_set_default_timeout (proxy, G_MAXINT);
v = g_dbus_proxy_call_sync (proxy,
"Restore",
g_variant_new ("(s)", uri),
G_DBUS_CALL_FLAGS_NONE,
-1,
NULL,
&error);
if (proxy) {
g_object_unref (proxy);
}
if (error) {
g_critical ("Could not restore database, %s",
error ? error->message : "no error given.");
g_clear_error (&error);
g_free (uri);
return EXIT_FAILURE;
}
if (v) {
g_variant_unref (v);
}
g_free (uri);
}
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 gboolean
check_gsettings_condition (NemoAction *action, const gchar *condition)
{
gchar **split = g_strsplit (condition, " ", 6);
gint len = g_strv_length (split);
if (len != 6 &&
len != 3) {
g_strfreev (split);
return FALSE;
}
if (g_strcmp0 (split[0], "gsettings") != 0) {
g_strfreev (split);
return FALSE;
}
if (len == 6 &&
(!g_variant_type_string_is_valid (split[GSETTINGS_TYPE_INDEX]) ||
!operator_is_valid (split[GSETTINGS_OP_INDEX]))) {
g_printerr ("Nemo Action: Either gsettings variant type (%s) or operator (%s) is invalid.\n",
split[GSETTINGS_TYPE_INDEX], split[GSETTINGS_OP_INDEX]);
g_strfreev (split);
return FALSE;
}
GSettingsSchemaSource *schema_source;
gboolean ret = FALSE;
const GVariantType *target_type;
if (len == 3) {
target_type = G_VARIANT_TYPE_BOOLEAN;
} else {
target_type = G_VARIANT_TYPE (split[GSETTINGS_TYPE_INDEX]);
}
schema_source = g_settings_schema_source_get_default();
if (g_settings_schema_source_lookup (schema_source, split[GSETTINGS_SCHEMA_INDEX], TRUE)) {
GSettings *s = g_settings_new (split[GSETTINGS_SCHEMA_INDEX]);
gchar **keys = g_settings_list_keys (s);
gint i;
for (i = 0; i < g_strv_length (keys); i++) {
if (len == 3) {
if (g_strcmp0 (keys[i], split[GSETTINGS_KEY_INDEX]) == 0) {
GVariant *setting_var = g_settings_get_value (s, split[GSETTINGS_KEY_INDEX]);
const GVariantType *setting_type = g_variant_get_type (setting_var);
if (g_variant_type_equal (setting_type, target_type))
ret = g_variant_get_boolean (setting_var);
g_variant_unref (setting_var);
}
} else {
if (g_strcmp0 (keys[i], split[GSETTINGS_KEY_INDEX]) == 0) {
GVariant *setting_var = g_settings_get_value (s, split[GSETTINGS_KEY_INDEX]);
const GVariantType *setting_type = g_variant_get_type (setting_var);
if (g_variant_type_equal (setting_type, target_type)) {
GVariant *target_var = g_variant_parse (target_type,
split[GSETTINGS_VAL_INDEX],
NULL, NULL, NULL);
if (target_var != NULL) {
gint vector = g_variant_compare (setting_var, target_var);
ret = try_vector (split[GSETTINGS_OP_INDEX], vector);
g_variant_unref (target_var);
} else {
g_printerr ("Nemo Action: gsettings value could not be parsed into a valid GVariant\n");
}
}
g_variant_unref (setting_var);
}
}
}
g_strfreev (keys);
g_object_unref (s);
g_strfreev (split);
return ret;
} else {
g_strfreev (split);
return FALSE;
}
}
static gint
reset_run (void)
{
GError *error = NULL;
if (hard_reset && soft_reset) {
g_printerr ("%s\n",
_("You can not use the --hard and --soft arguments together"));
return EXIT_FAILURE;
}
/* KILL processes first... */
if (hard_reset || soft_reset) {
tracker_process_stop (TRACKER_PROCESS_TYPE_NONE, TRACKER_PROCESS_TYPE_ALL);
}
if (hard_reset || soft_reset) {
guint log_handler_id;
#ifndef DISABLE_JOURNAL
gchar *rotate_to;
TrackerDBConfig *db_config;
gsize chunk_size;
gint chunk_size_mb;
#endif /* DISABLE_JOURNAL */
/* Set log handler for library messages */
log_handler_id = g_log_set_handler (NULL,
G_LOG_LEVEL_MASK | G_LOG_FLAG_FATAL,
log_handler,
NULL);
g_log_set_default_handler (log_handler, NULL);
#ifndef DISABLE_JOURNAL
db_config = tracker_db_config_new ();
chunk_size_mb = tracker_db_config_get_journal_chunk_size (db_config);
chunk_size = (gsize) ((gsize) chunk_size_mb * (gsize) 1024 * (gsize) 1024);
rotate_to = tracker_db_config_get_journal_rotate_destination (db_config);
/* This call is needed to set the journal's filename */
tracker_db_journal_set_rotating ((chunk_size_mb != -1),
chunk_size, rotate_to);
g_free (rotate_to);
g_object_unref (db_config);
#endif /* DISABLE_JOURNAL */
/* Clean up (select_cache_size and update_cache_size don't matter here) */
if (!tracker_db_manager_init (TRACKER_DB_MANAGER_REMOVE_ALL,
NULL,
FALSE,
FALSE,
100,
100,
NULL,
NULL,
NULL,
&error)) {
g_message ("Error initializing database: %s", error->message);
g_free (error);
return EXIT_FAILURE;
}
#ifndef DISABLE_JOURNAL
tracker_db_journal_init (NULL, FALSE, NULL);
#endif /* DISABLE_JOURNAL */
tracker_db_manager_remove_all (hard_reset);
tracker_db_manager_shutdown ();
#ifndef DISABLE_JOURNAL
tracker_db_journal_shutdown (NULL);
#endif /* DISABLE_JOURNAL */
/* Unset log handler */
g_log_remove_handler (NULL, log_handler_id);
if (!remove_config) {
return EXIT_SUCCESS;
}
}
if (remove_config) {
GFile *file;
const gchar *home_conf_dir;
gchar *path;
GSList *all, *l;
/* Check the default XDG_DATA_HOME location */
home_conf_dir = g_getenv ("XDG_CONFIG_HOME");
if (home_conf_dir && tracker_path_has_write_access_or_was_created (home_conf_dir)) {
path = g_build_path (G_DIR_SEPARATOR_S, home_conf_dir, "tracker", NULL);
} else {
home_conf_dir = g_getenv ("HOME");
if (!home_conf_dir || !tracker_path_has_write_access_or_was_created (home_conf_dir)) {
home_conf_dir = g_get_home_dir ();
}
path = g_build_path (G_DIR_SEPARATOR_S, home_conf_dir, ".config", "tracker", NULL);
}
file = g_file_new_for_path (path);
g_free (path);
g_print ("%s\n", _("Removing configuration files…"));
directory_foreach (file, ".cfg", (GFunc) delete_file, NULL);
g_object_unref (file);
g_print ("%s\n", _("Resetting existing configuration…"));
all = tracker_gsettings_get_all (NULL);
if (!all) {
return EXIT_FAILURE;
}
for (l = all; l; l = l->next) {
ComponentGSettings *c = l->data;
gchar **keys, **p;
if (!c) {
continue;
}
g_print (" %s\n", c->name);
keys = g_settings_list_keys (c->settings);
for (p = keys; p && *p; p++) {
g_print (" %s\n", *p);
g_settings_reset (c->settings, *p);
}
if (keys) {
g_strfreev (keys);
}
g_settings_apply (c->settings);
}
g_settings_sync ();
tracker_gsettings_free (all);
return EXIT_SUCCESS;
}
/* All known options have their own exit points */
g_warn_if_reached ();
return EXIT_FAILURE;
}
gboolean ug_settings_safe_get_boolean (const gchar* key, gboolean _default_) {
gboolean result = FALSE;
GSettings* _tmp0_;
GSettings* gsettings;
GSettings* _tmp1_;
gchar** _tmp2_;
gchar** _tmp3_ = NULL;
gchar** keys;
gint keys_length1;
gint _keys_size_;
gchar** _tmp4_;
gint _tmp4__length1;
gboolean _tmp11_;
g_return_val_if_fail (key != NULL, FALSE);
_tmp0_ = g_settings_new (UG_SETTINGS_SCHEMA);
gsettings = _tmp0_;
_tmp1_ = gsettings;
_tmp3_ = _tmp2_ = g_settings_list_keys (_tmp1_);
keys = _tmp3_;
keys_length1 = _vala_array_length (_tmp2_);
_keys_size_ = keys_length1;
_tmp4_ = keys;
_tmp4__length1 = keys_length1;
{
gchar** k_collection = NULL;
gint k_collection_length1 = 0;
gint _k_collection_size_ = 0;
gint k_it = 0;
k_collection = _tmp4_;
k_collection_length1 = _tmp4__length1;
for (k_it = 0; k_it < _tmp4__length1; k_it = k_it + 1) {
gchar* _tmp5_;
gchar* k = NULL;
_tmp5_ = g_strdup (k_collection[k_it]);
k = _tmp5_;
{
const gchar* _tmp6_;
const gchar* _tmp7_;
_tmp6_ = k;
_tmp7_ = key;
if (g_strcmp0 (_tmp6_, _tmp7_) == 0) {
GSettings* _tmp8_;
const gchar* _tmp9_;
gboolean _tmp10_ = FALSE;
_tmp8_ = gsettings;
_tmp9_ = key;
_tmp10_ = g_settings_get_boolean (_tmp8_, _tmp9_);
result = _tmp10_;
_g_free0 (k);
keys = (_vala_array_free (keys, keys_length1, (GDestroyNotify) g_free), NULL);
_g_object_unref0 (gsettings);
return result;
}
_g_free0 (k);
}
}
}
_tmp11_ = _default_;
result = _tmp11_;
keys = (_vala_array_free (keys, keys_length1, (GDestroyNotify) g_free), NULL);
_g_object_unref0 (gsettings);
return result;
}