string config_handler::get_config_file() { if( config_file == "" ) { if( get_config_file_path() != "" ) config_file += get_config_file_path(); else config_file += utils::get_base_dir(); if( get_config_file_name() != "" ) config_file += get_config_file_name(); else config_file += "config"; // TODO - make default } return config_file; }
static svn_error_t * test_has_section_case_sensitive(const svn_test_opts_t *opts, apr_pool_t *pool) { svn_config_t *cfg; const char *cfg_file; SVN_ERR(get_config_file_path(&cfg_file, opts, pool)); SVN_ERR(svn_config_read3(&cfg, cfg_file, TRUE, TRUE, FALSE, pool)); if (! svn_config_has_section(cfg, "section1")) return fail(pool, "Failed to find section1"); if (svn_config_has_section(cfg, "SECTION1")) return fail(pool, "Returned true on missing section"); if (! svn_config_has_section(cfg, "UpperCaseSection")) return fail(pool, "Failed to find UpperCaseSection"); if (svn_config_has_section(cfg, "uppercasesection")) return fail(pool, "Returned true on missing section"); if (svn_config_has_section(cfg, "notthere")) return fail(pool, "Returned true on missing section"); return SVN_NO_ERROR; }
static svn_error_t * test_read_only_mode(const svn_test_opts_t *opts, apr_pool_t *pool) { svn_config_t *cfg; svn_config_t *cfg2; const char *cfg_file; SVN_ERR(get_config_file_path(&cfg_file, opts, pool)); SVN_ERR(svn_config_read3(&cfg, cfg_file, TRUE, TRUE, FALSE, pool)); /* setting CFG to r/o mode shall toggle the r/o mode and expand values */ SVN_TEST_ASSERT(!svn_config__is_read_only(cfg)); SVN_TEST_ASSERT(!svn_config__is_expanded(cfg, "section1", "i")); svn_config__set_read_only(cfg, pool); SVN_TEST_ASSERT(svn_config__is_read_only(cfg)); SVN_TEST_ASSERT(svn_config__is_expanded(cfg, "section1", "i")); /* copies should be r/w with values */ SVN_ERR(svn_config_dup(&cfg2, cfg, pool)); SVN_TEST_ASSERT(!svn_config__is_read_only(cfg2)); return SVN_NO_ERROR; }
static svn_error_t * test_expand(const svn_test_opts_t *opts, apr_pool_t *pool) { svn_config_t *cfg; const char *cfg_file, *val; SVN_ERR(get_config_file_path(&cfg_file, opts, pool)); SVN_ERR(svn_config_read3(&cfg, cfg_file, TRUE, TRUE, FALSE, pool)); /* Get expanded "g" which requires expanding "c". */ svn_config_get(cfg, &val, "section1", "g", NULL); /* Get expanded "c". */ svn_config_get(cfg, &val, "section1", "c", NULL); /* With pool debugging enabled this ensures that the expanded value of "c" was not created in a temporary pool when expanding "g". */ SVN_TEST_STRING_ASSERT(val, "bar"); /* Get expanded "j" and "k" which have cyclic definitions. * They must return empty values. */ svn_config_get(cfg, &val, "section1", "j", NULL); SVN_TEST_STRING_ASSERT(val, ""); svn_config_get(cfg, &val, "section1", "k", NULL); SVN_TEST_STRING_ASSERT(val, ""); /* Get expanded "l" which depends on a cyclic definition. * So, it also considered "undefined" and will be normalized to "". */ svn_config_get(cfg, &val, "section1", "l", NULL); SVN_TEST_STRING_ASSERT(val, ""); return SVN_NO_ERROR; }
static svn_error_t * test_boolean_retrieval(const svn_test_opts_t *opts, apr_pool_t *pool) { svn_config_t *cfg; int i; const char *cfg_file; SVN_ERR(get_config_file_path(&cfg_file, opts, pool)); SVN_ERR(svn_config_read3(&cfg, cfg_file, TRUE, FALSE, FALSE, pool)); for (i = 0; true_keys[i] != NULL; i++) { svn_boolean_t value; SVN_ERR(svn_config_get_bool(cfg, &value, "booleans", true_keys[i], FALSE)); if (!value) return fail(pool, "Value of option '%s' is not true", true_keys[i]); } for (i = 0; false_keys[i] != NULL; i++) { svn_boolean_t value; SVN_ERR(svn_config_get_bool(cfg, &value, "booleans", false_keys[i], TRUE)); if (value) return fail(pool, "Value of option '%s' is not true", false_keys[i]); } { svn_error_t *err; svn_boolean_t value; svn_error_clear((err = svn_config_get_bool(cfg, &value, "booleans", "bad_true", TRUE))); if (!err) return fail(pool, "No error on bad truth value"); svn_error_clear((err = svn_config_get_bool(cfg, &value, "booleans", "bad_false", FALSE))); if (!err) return fail(pool, "No error on bad truth value"); } { svn_boolean_t value; SVN_ERR(svn_config_get_server_setting_bool(cfg, &value, "server group", "setting", FALSE)); if (value) return svn_error_create(SVN_ERR_TEST_FAILED, SVN_NO_ERROR, "Expected a svn_config_get_server_setting_bool()" "to return FALSE, but it returned TRUE"); } return SVN_NO_ERROR; }
/* Display the path of the default configuration file when `-p` is not used */ void display_default_config_file (void) { char *path = get_config_file_path (); if (!path) { fprintf (stdout, "No default config file found.\n"); fprintf (stdout, "You may specify one with `-p /path/goaccess.conf`\n"); } else { fprintf (stdout, "%s\n", path); free (path); } }
/* Display the path of the default configuration file when `-p` is not used */ void display_default_config_file (void) { char *path = get_config_file_path (); if (!path) { fprintf (stdout, "%s\n", ERR_NODEF_CONF_FILE); fprintf (stdout, "%s `-p /path/goaccess.conf`\n", ERR_NODEF_CONF_FILE_DESC); } else { fprintf (stdout, "%s\n", path); free (path); } }
void config_handler::print() { // // Display internal settings set from reading steering // string mn = "print:"; string def = "<default>"; int w1=30; //arbitrary spacing size that makes formatting look pretty for data names int w2=30; //arbitrary spacing size that makes formatting look pretty for data options cout<<cn<<mn<<" >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>" <<"\n"<<setw(w1)<<"DEBUG: " <<setw(w2)<<(debug? "ON":"OFF") <<"\n"<<setw(w1)<<"RUN IN BACKGROUND: " <<setw(w2)<<(get_background()? "ON":"OFF") <<"\n"<<setw(w1)<<"SIMULATION: " <<setw(w2)<<(get_simulate()? "ON":"OFF") <<"\n"<<setw(w1)<<"FILTER FIRST: " <<setw(w2)<<(get_filter()? "ON":"OFF") <<"\n"<<setw(w1)<<"SAVE RECORDINGS: " <<setw(w2)<<(get_save_rec()? "ON":"OFF") <<"\n"<<setw(w1)<<"HUMAN READABLE OUTPUT: " <<setw(w2)<<(get_output_formatted()? "ON":"OFF") <<"\n"<<setw(w1)<<"Output Type ID: " <<setw(w2)<<"\""<<get_output_type_id()<<"\"" <<"\n"<<setw(w1)<<"RPi Latitude: " <<setw(w2)<<"\""<<get_latitude()<<"\"" <<"\n"<<setw(w1)<<"RPi Longitude: " <<setw(w2)<<"\""<<get_longitude()<<"\"" <<"\n"<<setw(w1)<<"RPi ID: " <<setw(w2)<<"\""<<get_rpid()<<"\"" <<"\n"<<setw(w1)<<"Simulation Data Dir: " <<setw(w2)<<"\""<<get_simulate_dir()<<"\"" <<"\n"<<setw(w1)<<"Config Path: " <<setw(w2)<<"\""<<get_config_file_path()<<"\"" <<"\n"<<setw(w1)<<"Config Name: " <<setw(w2)<<"\""<<get_config_file_name()<<"\"" <<"\n"<<setw(w1)<<"Config File: " <<setw(w2)<<"\""<<get_config_file()<<"\"" <<"\n"<<setw(w1)<<"Final Feature Format: " <<setw(w2)<<"\""<<get_final_feature_format()<<"\"" <<"\n"<<setw(w1)<<"Filter Vector Path: " <<setw(w2)<<"\""<<get_fv_filter_path()<<"\"" <<"\n"<<setw(w1)<<"Filter Vector Name: " <<setw(w2)<<"\""<<get_fv_filter_name()<<"\"" <<"\n"<<setw(w1)<<"Filter Vector File: " <<setw(w2)<<"\""<<get_fv_filter()<<"\"" <<"\n"<<setw(w1)<<"Feature Vector Path: " <<setw(w2)<<"\""<<get_fv_file_path()<<"\"" <<"\n"<<setw(w1)<<"Feature Vector Name: " <<setw(w2)<<"\""<<get_fv_file_name()<<"\"" <<"\n"<<setw(w1)<<"Feature Vector File: " <<setw(w2)<<"\""<<get_fv_file()<<"\"" <<"\n"<<setw(w1)<<"Analysis File(s) Path: " <<setw(w2)<<"\""<<get_analysis_location()<<"\"" <<"\n"<<setw(w1)<<"Data File(s) Path: " <<setw(w2)<<"\""<<get_data_location()<<"\"" <<"\n"<<setw(w1)<<"Media Location File Path: " <<setw(w2)<<"\""<<get_media_location()<<"\"" <<"\n"<<setw(w1)<<"Recording Extention: " <<setw(w2)<<"\""<<get_rec_extention()<<"\"" <<"\n"<<setw(w1)<<"Recording File Name Prefix: " <<setw(w2)<<"\""<<get_rec_file_name_prefix()<<"\"" <<"\n"<<setw(w1)<<"Recording Rate: " <<setw(w2)<<"\""<<get_samp_rate()<<"\"" <<"\n"<<setw(w1)<<"Recording Duration: " <<setw(w2)<<"\""<<get_rec_duration()<<"\"" <<"\n"<<setw(w1)<<"Recording Number: " <<setw(w2)<<"\""<<get_rec_number()<<"\""<<endl; cout<<cn<<mn<<" <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<"<<endl; return; }
static svn_error_t * test_text_retrieval(const svn_test_opts_t *opts, apr_pool_t *pool) { svn_config_t *cfg; int i; const char *cfg_file; SVN_ERR(get_config_file_path(&cfg_file, opts, pool)); SVN_ERR(svn_config_read3(&cfg, cfg_file, TRUE, FALSE, FALSE, pool)); /* Test values retrieved from our ConfigParser instance against values retrieved using svn_config. */ for (i = 0; config_keys[i] != NULL; i++) { const char *key, *py_val, *c_val; key = config_keys[i]; py_val = config_values[i]; svn_config_get(cfg, &c_val, "section1", key, "default value"); #if 0 printf("Testing expected value '%s' against '%s' for " "option '%s'\n", py_val, c_val, key); #endif /* Fail iff one value is null, or the strings don't match. */ if ((c_val == NULL) != (py_val == NULL) || (c_val != NULL && py_val != NULL && strcmp(c_val, py_val) != 0)) return fail(pool, "Expected value '%s' not equal to '%s' for " "option '%s'", py_val, c_val, key); } { const char *value = svn_config_get_server_setting(cfg, "server group", "setting", "default"); if (value == NULL || strcmp(value, "default") != 0) return svn_error_create(SVN_ERR_TEST_FAILED, SVN_NO_ERROR, "Expected a svn_config_get_server_setting()" "to return 'default'"); } return SVN_NO_ERROR; }
void remember_no_welcome_screen_option() { // enable no_welcome_screen option in command line options config file! char* cfg_file_path = get_config_file_path(); FILE* gtypistrc = fopen(cfg_file_path, "a+"); if (gtypistrc == NULL) { fatal_error( _("Error reading/writing config file!"), NULL ); } int no_welcome_screen_option_found = FALSE; size_t len = 0; char* line = NULL; while (getline(&line, &len, gtypistrc) != -1) { /* remove control chars (newline, CR) at end of line */ int idx = len; while (idx >= 0 && line[idx] < 0x20) { line[idx] = '\0'; idx--; } if (strcmp(line, "no-welcome-screen") == 0) { no_welcome_screen_option_found = TRUE; } } if (!no_welcome_screen_option_found) { /* append "no-welcome-screen" option */ fprintf(gtypistrc, "no-welcome-screen\n"); } fclose(gtypistrc); if (line) { free(line); line = NULL; } free(cfg_file_path); }
static svn_error_t * test_stream_interface(const svn_test_opts_t *opts, apr_pool_t *pool) { svn_config_t *cfg; const char *cfg_file; svn_stream_t *stream; SVN_ERR(get_config_file_path(&cfg_file, opts, pool)); SVN_ERR(svn_stream_open_readonly(&stream, cfg_file, pool, pool)); SVN_ERR(svn_config_parse(&cfg, stream, TRUE, TRUE, pool)); /* nominal test to make sure cfg is populated with something since * svn_config_parse will happily return an empty cfg if the stream is * empty. */ if (! svn_config_has_section(cfg, "section1")) return fail(pool, "Failed to find section1"); return SVN_NO_ERROR; }
config_handler::config_handler( string fpath, string fname = "" ) { string mn = "config_handler:"; cout<<mn<<" Constructor started for file \""<<fname<<"\"."<<endl; debug = true; init(); if( fpath == "" ) fpath = utils::get_home_dir(); if( fname == "" ) utils::get_base( fpath ); if( fname == "" ) fname = "cirainbow.conf"; // make sure default or custom config file is found // User coice, home directory "cirainbow.conf", local directory "sound_settings.conf" if( utils::is_file_readable( utils::pathify(fpath) + fname ) == false ) { cout<<cn<<mn<<" Initial config file not accesable at: \""<<utils::pathify(fpath)+fname<<"\"."<<endl; fpath = utils::get_base_dir(); fname = "sound_settings.conf"; } //cout<<cn<<mn<<" Config file here: \""<<utils::pathify(fpath)+fname<<"\"."<<endl; //TEST //exit( 0 ); //TEST set_config_file_path( fpath ); set_config_file_name( fname ); string configFile = get_config_file_path() + get_config_file_name(); set_config_file( configFile ); cout<<cn<<mn<<" Config file here: \""<<get_config_file()<<"\"."<<endl; read_config( configFile ); cout<<cn<<mn<<" Constructor finished for file \""<<fname<<"\"."<<endl; }
static svn_error_t * test_has_option_case_sensitive(const svn_test_opts_t *opts, apr_pool_t *pool) { svn_config_t *cfg; const char *cfg_file; apr_int64_t value; int i; static struct test_dataset { const char *option; apr_int64_t value; } const test_data[] = { { "a", 1 }, { "A", 2 }, { "B", 3 }, { "b", 4 } }; static const int test_data_size = sizeof(test_data)/sizeof(*test_data); SVN_ERR(get_config_file_path(&cfg_file, opts, pool)); SVN_ERR(svn_config_read3(&cfg, cfg_file, TRUE, TRUE, TRUE, pool)); for (i = 0; i < test_data_size; ++i) { SVN_ERR(svn_config_get_int64(cfg, &value, "case-sensitive-option", test_data[i].option, -1)); if (test_data[i].value != value) return fail(pool, apr_psprintf(pool, "case-sensitive-option.%s != %" APR_INT64_T_FMT" but %"APR_INT64_T_FMT, test_data[i].option, test_data[i].value, value)); } return SVN_NO_ERROR; }
static svn_error_t * test_expand(const svn_test_opts_t *opts, apr_pool_t *pool) { svn_config_t *cfg; const char *cfg_file, *val; SVN_ERR(get_config_file_path(&cfg_file, opts, pool)); SVN_ERR(svn_config_read3(&cfg, cfg_file, TRUE, TRUE, FALSE, pool)); /* Get expanded "g" which requires expanding "c". */ svn_config_get(cfg, &val, "section1", "g", NULL); /* Get expanded "c". */ svn_config_get(cfg, &val, "section1", "c", NULL); /* With pool debugging enabled this ensures that the expanded value of "c" was not created in a temporary pool when expanding "g". */ SVN_TEST_STRING_ASSERT(val, "bar"); return SVN_NO_ERROR; }
/* This only supports migrating from v0.5's config file */ gboolean migrate_config(gmpv_handle *ctx) { gchar *config_file = get_config_file_path(); gboolean result = FALSE; if(g_file_test(config_file, G_FILE_TEST_EXISTS)) { const gchar *key_list[] = { "csd-enable", "dark-theme-enable", "mpv-input-config-enable", "mpv-config-enable", "mpv-input-config-file", "mpv-config-file", "mpv-options", NULL }; GSettingsBackend *backend; GSettings *keyfile_settings; GSettings *default_settings; const gchar **iter; backend = g_keyfile_settings_backend_new ( config_file, "/org/gnome-mpv/gnome-mpv/", "main" ); keyfile_settings = g_settings_new_with_backend( CONFIG_ROOT, backend ); default_settings = g_settings_new(CONFIG_ROOT); iter = key_list; while(*iter) { GVariant *value; value = g_settings_get_value(keyfile_settings, *iter); g_settings_set_value(default_settings, *iter, value); iter++; g_variant_unref(value); } g_object_unref(backend); g_object_unref(keyfile_settings); g_object_unref(default_settings); /* Rename the old config file */ gchar *backup_config_file = g_strconcat( config_file, ".bak", NULL ); GFile *src = g_file_new_for_path(config_file); GFile *dest = g_file_new_for_path(backup_config_file); result = g_file_move( src, dest, G_FILE_COPY_NONE, NULL, NULL, NULL, NULL ); g_free(backup_config_file); g_object_unref(src); g_object_unref(dest); } g_free(config_file); return result; }
/* parses configuration file to feed getopt_long */ int parse_conf_file (int *argc, char ***argv) { char line[MAX_LINE_CONF + 1]; char *path = NULL, *val, *opt, *p; FILE *file; int i; size_t idx; /* assumes program name is on argv[0], though, it is not guaranteed */ append_to_argv (&nargc, &nargv, xstrdup ((char *) *argv[0])); /* determine which config file to open, default or custom */ path = get_config_file_path (); if (path == NULL) return ENOENT; /* could not open conf file, if so prompt conf dialog */ if ((file = fopen (path, "r")) == NULL) { free (path); return ENOENT; } while (fgets (line, sizeof line, file) != NULL) { if (line[0] == '\n' || line[0] == '\r' || line[0] == '#') continue; /* key */ idx = strcspn (line, " \t"); if (strlen (line) == idx) FATAL ("Malformed config key at line: %s", line); line[idx] = '\0'; /* make old config options backwards compatible by * substituting underscores with dashes */ while ((p = strpbrk (line, "_")) != NULL) *p = '-'; /* Ignore the following options when reading the config file */ if (in_ignore_cmd_opts (line)) continue; /* value */ val = line + (idx + 1); idx = strspn (val, " \t"); if (strlen (line) == idx) FATAL ("Malformed config value at line: %s", line); val = val + idx; val = trim_str (val); if (strcmp ("false", val) == 0) continue; /* set it as command line options */ opt = xmalloc (snprintf (NULL, 0, "--%s", line) + 1); sprintf (opt, "--%s", line); append_to_argv (&nargc, &nargv, opt); if (strcmp ("true", val) != 0) append_to_argv (&nargc, &nargv, xstrdup (val)); } /* give priority to command line arguments */ for (i = 1; i < *argc; i++) append_to_argv (&nargc, &nargv, xstrdup ((char *) (*argv)[i])); *argc = nargc; *argv = (char **) nargv; fclose (file); if (conf.iconfigfile == NULL) conf.iconfigfile = xstrdup (path); free (path); return 0; }
static void app_startup_handler(GApplication *app, gpointer data) { gmpv_handle *ctx = data; const gchar *vid_area_style = ".gmpv-vid-area{background-color: black}"; GSettingsBackend *config_backend; GtkCssProvider *style_provider; gboolean css_loaded; gboolean use_opengl; gboolean config_migrated; gboolean mpvinput_enable; gboolean csd_enable; gboolean dark_theme_enable; gchar *config_file; gchar *mpvinput; setlocale(LC_NUMERIC, "C"); g_set_application_name(_("GNOME MPV")); gtk_window_set_default_icon_name(ICON_NAME); bindtextdomain(GETTEXT_PACKAGE, PACKAGE_LOCALEDIR); bind_textdomain_codeset(GETTEXT_PACKAGE, "UTF-8"); textdomain(GETTEXT_PACKAGE); config_file = get_config_file_path(); config_backend = g_keyfile_settings_backend_new ( config_file, CONFIG_ROOT_PATH, CONFIG_ROOT_GROUP ); use_opengl = get_use_opengl(); ctx->mpv_ctx = mpv_create(); ctx->files = NULL; ctx->opengl_ctx = NULL; ctx->opengl_ready = FALSE; ctx->paused = TRUE; ctx->loaded = FALSE; ctx->new_file = TRUE; ctx->sub_visible = TRUE; ctx->init_load = TRUE; ctx->playlist_move_dest = -1; ctx->log_level_list = NULL; ctx->keybind_list = NULL; ctx->config = g_settings_new_with_backend(APP_ID, config_backend); ctx->app = GTK_APPLICATION(app); ctx->gui = MAIN_WINDOW(main_window_new(ctx->app, use_opengl)); ctx->fs_control = NULL; ctx->playlist_store = PLAYLIST_WIDGET(ctx->gui->playlist)->list_store; config_migrated = migrate_config(ctx); style_provider = gtk_css_provider_new(); css_loaded = gtk_css_provider_load_from_data (style_provider, vid_area_style, -1, NULL); if(!css_loaded) { g_warning ("Failed to apply background color css"); } gtk_style_context_add_provider_for_screen ( gtk_window_get_screen(GTK_WINDOW(ctx->gui)), GTK_STYLE_PROVIDER(style_provider), GTK_STYLE_PROVIDER_PRIORITY_APPLICATION ); g_object_unref(style_provider); csd_enable = g_settings_get_boolean (ctx->config, "csd-enable"); dark_theme_enable = g_settings_get_boolean (ctx->config, "dark-theme-enable"); mpvinput_enable = g_settings_get_boolean (ctx->config, "mpv-input-config-enable"); mpvinput = g_settings_get_string (ctx->config, "mpv-input-config-file"); if(csd_enable) { gtk_application_set_app_menu (ctx->app, G_MENU_MODEL(build_app_menu())); main_window_enable_csd(ctx->gui); } else { gtk_application_set_app_menu (ctx->app, NULL); gtk_application_set_menubar (ctx->app, G_MENU_MODEL(build_full_menu())); } gtk_widget_show_all(GTK_WIDGET(ctx->gui)); if(csd_enable) { control_box_set_fullscreen_btn_visible (CONTROL_BOX(ctx->gui->control_box), FALSE); } control_box_set_chapter_enabled (CONTROL_BOX(ctx->gui->control_box), FALSE); if(!main_window_get_use_opengl(ctx->gui)) { ctx->vid_area_wid = get_xid(ctx->gui->vid_area); } g_assert( main_window_get_use_opengl(ctx->gui) || ctx->vid_area_wid != -1 ); main_window_load_state(ctx->gui); setup_accelerators(ctx); setup_dnd_targets(ctx); actionctl_map_actions(ctx); connect_signals(ctx); load_keybind(ctx, mpvinput_enable?mpvinput:NULL, FALSE); mpris_init(ctx); media_keys_init(ctx); g_object_set( ctx->gui->settings, "gtk-application-prefer-dark-theme", dark_theme_enable, NULL ); g_timeout_add( SEEK_BAR_UPDATE_INTERVAL, (GSourceFunc)update_seek_bar, ctx ); if(config_migrated) { GtkWidget *dialog = gtk_message_dialog_new ( GTK_WINDOW(ctx->gui), GTK_DIALOG_DESTROY_WITH_PARENT, GTK_MESSAGE_INFO, GTK_BUTTONS_OK, _("Your configuration file has been " "moved to the new location at %s."), config_file ); gtk_dialog_run(GTK_DIALOG(dialog)); gtk_widget_destroy(dialog); } g_free(config_file); g_free(mpvinput); }
int main (int argc, char **argv) { g_autoptr(EosUpdater) proxy = NULL; g_autoptr(GError) error = NULL; guint update_interval_days, randomized_delay_days; g_autoptr(GOptionContext) context = NULL; GOptionEntry entries[] = { { "force-update", 0, 0, G_OPTION_ARG_NONE, &force_update, "Force an update", NULL }, { "from-volume", 0, 0, G_OPTION_ARG_STRING, &volume_path, "Poll for updates from the volume", "PATH" }, { NULL } }; GBusType bus_type = G_BUS_TYPE_SYSTEM; gint dbus_timeout; setlocale (LC_ALL, ""); context = g_option_context_new ("— Endless OS Automatic Updater"); g_option_context_add_main_entries (context, entries, NULL); g_option_context_set_summary (context, "Automatically poll for, fetch and apply " "updates in the background. This drives the " "state changes in the eos-updater service."); if (!g_option_context_parse (context, &argc, &argv, &error)) { warning (EOS_UPDATER_INVALID_ARGS_MSGID, "Error parsing command line arguments: %s", error->message); return EXIT_INVALID_ARGUMENTS; } if (!read_config_file (get_config_file_path (), &update_interval_days, &randomized_delay_days)) return EXIT_BAD_CONFIGURATION; if (volume_path == NULL && !is_online ()) return EXIT_OK; /* Always force an update if running with --from-volume; it doesn’t make * sense not to. */ if (volume_path != NULL) force_update = TRUE; if (!force_update) { if (!is_time_to_update (update_interval_days, randomized_delay_days)) { info (EOS_UPDATER_NOT_TIME_MSGID, "Less than %s since last update. Exiting", INTERVAL_KEY); return EXIT_OK; } } main_loop = g_main_loop_new (NULL, FALSE); if (should_listen_on_session_bus ()) bus_type = G_BUS_TYPE_SESSION; proxy = eos_updater_proxy_new_for_bus_sync (bus_type, G_DBUS_PROXY_FLAGS_NONE, "com.endlessm.Updater", "/com/endlessm/Updater", NULL, &error); if (error) { warning (EOS_UPDATER_DAEMON_ERROR_MSGID, "Error getting EOS updater object: %s", error->message); should_exit_failure = TRUE; goto out; } dbus_timeout = get_dbus_timeout (); g_dbus_proxy_set_default_timeout (G_DBUS_PROXY (proxy), dbus_timeout); g_signal_connect (proxy, "notify::state", G_CALLBACK (on_state_changed_notify), NULL); g_signal_connect (proxy, "notify::g-name-owner", (GCallback) on_name_owner_changed, NULL); g_idle_add (initial_poll_idle_func, proxy); g_main_loop_run (main_loop); out: g_main_loop_unref (main_loop); g_free (volume_path); if (should_exit_failure) /* All paths setting this print an error message */ return EXIT_FAILED; /* Update the stamp file since all configured steps have succeeded. */ update_stamp_file ((guint64) g_get_real_time () / G_USEC_PER_SEC, update_interval_days, randomized_delay_days); info (EOS_UPDATER_SUCCESS_MSGID, "Updater finished successfully"); return EXIT_OK; }
void config_handler::init() { // const std::string MyClass::valid = "something else again"; const string DEF_CONFIG_NAME = "cirainbow.conf"; const string DEF_FILTER_NAME = "featureplan_filter"; const string DEF_FEATURE_NAME = "featureplan"; const string DEF_REC_PREFIX = "rec_"; const string DEF_REC_EXT = ".wav"; const string DEF_FINAL_FORMAT = "WRAPPED"; const string DEF_LAT = "0.0000 N"; const string DEF_LON = "0.0000 W"; const string DEF_RPID = "-1"; const int DEF_SOUND_ID = 0; // TODO - What should this be by default? const string DEF_DATA_DIR = "data/"; const string DEF_ANALYSIS_DIR = "analysis/"; const string DEF_MEDIA_DIR = "media/"; cn = " config_handler::"; set_config_file_path ( utils::get_home_dir() ); set_config_file_name ( DEF_CONFIG_NAME ); // TODO - make hardcoded elsewhere set_config_file ( get_config_file_path() + get_config_file_name() ); set_fv_filter_path ( utils::get_base_dir() ); set_fv_filter_name ( DEF_FILTER_NAME ); set_fv_filter ( get_fv_filter_path() + get_fv_filter_name() ); set_fv_file_path ( utils::get_base_dir() ); set_fv_file_name ( DEF_FEATURE_NAME ); set_fv_file ( get_fv_file_path() + get_fv_file_name() ); // set_data_location ( utils::get_base_dir() + DEF_DATA_DIR ); //TODO - make hardcoded elsewhere // set_analysis_location ( utils::get_base_dir() + DEF_ANALYSIS_DIR ); // TODO - make hardcoded elsewhere set_data_location ( utils::get_home_dir() + DEF_DATA_DIR ); set_analysis_location ( utils::get_base_dir() + DEF_ANALYSIS_DIR ); set_rec_file_name_prefix( DEF_REC_PREFIX ); // TODO - make hardcoded elsewhere set_media_location ( get_data_location() + DEF_MEDIA_DIR ); // TODO - make hardcoded elsewhere set_rec_extention ( DEF_REC_EXT ); // TODO - make hardcoded elsewhere set_samp_rate ( -1 ); set_rec_number ( -1 ); set_rec_duration ( -1 ); set_latitude( DEF_LAT ); // TODO - make hardcoded elsewhere set_longitude( DEF_LON ); // TODO - make hardcoded elsewhere set_rpid( DEF_RPID ); set_final_feature_format( DEF_FINAL_FORMAT ); //Foramts: WRAPPED, FILES set_output_type_id( DEF_SOUND_ID ); //Numeric represetning the type of data this is. TODO - WHAT SHOULD THIS BE? set_simulate( false ); //simulate a run (dont actually do one). set_simulate_dir( "" ); //default sim data dir set_background( false ); //run in forground by default set_filter( false ); //filtering is ONLY done if requested set_analysis( false ); //feature extraction only done if user wants it set_save_rec( true ); //Always save recordings by default set_output_formatted( true ); //It makes sense to always format output return; }