static gboolean
process_arguments (int *argc, char ***argv,
GError **error)
{
GOptionContext *context;
gboolean ret;
GOptionGroup *group;
group = g_option_group_new (NULL, /* name */
NULL, /* description */
NULL, /* help_description */
NULL, /* user_data */
NULL /* destroy notify */);
g_option_group_add_entries (group, options);
context = g_option_context_new ("- A server for practicing a "
"foreign language");
g_option_context_set_main_group (context, group);
ret = g_option_context_parse (context, argc, argv, error);
g_option_context_free (context);
if (ret && *argc > 1)
{
g_set_error (error, G_OPTION_ERROR, G_OPTION_ERROR_UNKNOWN_OPTION,
"Unknown option '%s'", (* argv)[1]);
ret = FALSE;
}
return ret;
}
int
main( int argc, char *argv[] )
{
GOptionContext *context;
GOptionGroup *main_group;
GError *error = NULL;
if( VIPS_INIT( argv[0] ) )
vips_error_exit( "unable to start VIPS" );
textdomain( GETTEXT_PACKAGE );
setlocale( LC_ALL, "" );
context = g_option_context_new( _( "- introspect" ) );
main_group = g_option_group_new( NULL, NULL, NULL, NULL, NULL );
g_option_group_add_entries( main_group, main_option );
vips_add_option_entries( main_group );
g_option_group_set_translation_domain( main_group, GETTEXT_PACKAGE );
g_option_context_set_main_group( context, main_group );
if( !g_option_context_parse( context, &argc, &argv, &error ) ) {
if( error ) {
fprintf( stderr, "%s\n", error->message );
g_error_free( error );
}
vips_error_exit( "try \"%s --help\"", g_get_prgname() );
}
g_option_context_free( context );
#ifdef DEBUG
/* For debugging it's handy to have a copy of the input file.
*/
if( main_option_introspect_dump ) {
char **args;
char *cmd;
args = g_strsplit( main_option_introspect_dump, ",", 2 );
cmd = g_strdup_printf( "cp %s ~/functions.txt", args[0]);
printf( "introspect: running '%s'\n", cmd );
system( cmd );
g_free( cmd );
}
#endif /*DEBUG*/
if( main_option_introspect_dump &&
!g_irepository_dump( main_option_introspect_dump, &error ) ) {
if( error ) {
fprintf( stderr, "%s\n", error->message );
g_error_free( error );
}
vips_error_exit( "unable to dump introspection" );
}
vips_shutdown();
return( 0 );
}
void
mu_config_show_help (MuConfigCmd cmd)
{
GOptionContext *ctx;
GOptionGroup *group;
char *cleanhelp;
g_return_if_fail (mu_config_cmd_is_valid(cmd));
ctx = g_option_context_new ("");
g_option_context_set_main_group (ctx, config_options_group_mu());
group = get_option_group (cmd);
if (group)
g_option_context_add_group (ctx, group);
g_option_context_set_description (ctx,
get_help_string (cmd, TRUE));
cleanhelp = massage_help
(g_option_context_get_help (ctx, TRUE, group));
g_print ("usage:\n\t%s\n%s",
get_help_string (cmd, FALSE), cleanhelp);
g_free (cleanhelp);
}
/**
* gdict_debug_init:
* @argc: FIXME
* @argv: FIXME
*
* FIXME
*
* Since: 0.12
*/
void
gdict_debug_init (gint *argc,
gchar ***argv)
{
GOptionContext *option_context;
GOptionGroup *gdict_group;
GError *error = NULL;
if (gdict_is_initialized)
return;
option_context = g_option_context_new (NULL);
g_option_context_set_ignore_unknown_options (option_context, TRUE);
g_option_context_set_help_enabled (option_context, FALSE);
gdict_group = gdict_get_option_group ();
g_option_context_set_main_group (option_context, gdict_group);
if (!g_option_context_parse (option_context, argc, argv, &error))
{
g_warning ("%s", error->message);
g_error_free (error);
}
g_option_context_free (option_context);
}
static gboolean
tf_graphite_parse_command_line_arguments(TFGraphiteState *self, gint *argc, gchar ***argv, LogTemplate *parent)
{
GOptionContext *ctx;
GOptionGroup *og;
TFGraphiteArgumentsUserData userdata;
gboolean success;
GError *error = NULL;
GOptionEntry graphite_options[] = {
{ "timestamp", 't', 0, G_OPTION_ARG_CALLBACK, tf_graphite_set_timestamp, NULL, NULL },
{ NULL },
};
userdata.state = self;
userdata.cfg = parent->cfg;
ctx = g_option_context_new ("graphite-options");
og = g_option_group_new (NULL, NULL, NULL, &userdata, NULL);
g_option_group_add_entries(og, graphite_options);
g_option_context_set_main_group(ctx, og);
g_option_context_set_ignore_unknown_options(ctx, TRUE);
success = g_option_context_parse (ctx, argc, argv, &error);
g_option_context_free (ctx);
return success;
}
/**
* Main function for command-line filter utility.
*/
int main(int argc, char *argv[])
{
#ifndef HAVE_G_OPTION_GROUP
printf("Need GLib >= 2.6\n");
#else
GError *error;
GOptionContext *context;
char inFilename[FLEN_FILENAME], outFilename[FLEN_FILENAME];
oi_fits inData, outData;
int status;
/* Parse command-line */
error = NULL;
context =
g_option_context_new("INFILE OUTFILE - write filtered dataset to new file");
g_option_context_set_main_group(context, get_oi_filter_option_group());
g_option_context_parse(context, &argc, &argv, &error);
if(error != NULL) {
printf("Error parsing command-line options: %s\n", error->message);
g_error_free(error);
exit(2); /* standard unix behaviour */
}
if(argc != 3) {
printf("Wrong number of command-line arguments\n"
"Enter '%s --help' for usage information\n", argv[0]);
exit(2);
}
g_strlcpy(inFilename, argv[1], FLEN_FILENAME);
g_strlcpy(outFilename, argv[2], FLEN_FILENAME);
/* Read FITS file */
status = 0;
read_oi_fits(inFilename, &inData, &status);
if(status) goto except;
/* Display summary info */
printf("=== INPUT DATA: ===\n");
print_oi_fits_summary(&inData);
printf("=== Applying filter: ===\n");
print_oi_filter(get_user_oi_filter());
/* Apply filter */
apply_user_oi_filter(&inData, &outData);
printf("--> OUTPUT DATA: ===\n");
print_oi_fits_summary(&outData);
/* Write out filtered data */
write_oi_fits(outFilename, outData, &status);
if(status) goto except;
free_oi_fits(&inData);
free_oi_fits(&outData);
g_option_context_free(context);
exit(EXIT_SUCCESS);
except:
exit(EXIT_FAILURE);
#endif /* #ifndef HAVE_G_OPTION_GROUP */
}
static gboolean
parse_params (int *argcp, char ***argvp, GError **err)
{
GOptionContext *context;
GOptionGroup *group;
gboolean rv;
context = g_option_context_new("- mu general options");
g_option_context_set_help_enabled (context, TRUE);
err = NULL;
rv = TRUE;
g_option_context_set_main_group(context,
config_options_group_mu());
switch (MU_CONFIG.cmd) {
case MU_CONFIG_CMD_NONE: show_usage(); break;
case MU_CONFIG_CMD_HELP:
/* 'help' is special; sucks in the options of the
* command after it */
rv = g_option_context_parse (context, argcp, argvp, err) &&
cmd_help ();
break;
default:
group = get_option_group (MU_CONFIG.cmd);
if (group)
g_option_context_add_group(context, group);
rv = g_option_context_parse (context, argcp, argvp, err);
}
g_option_context_free (context);
return rv ? TRUE : FALSE;
}
void
gegl_init (gint *argc,
gchar ***argv)
{
GOptionContext *context;
GError *error = NULL;
static gboolean initialized = FALSE;
if (initialized)
return;
initialized = TRUE;
context = g_option_context_new (NULL);
g_option_context_set_ignore_unknown_options (context, TRUE);
g_option_context_set_help_enabled (context, FALSE);
g_option_context_set_main_group (context, gegl_get_option_group ());
if (!g_option_context_parse (context, argc, argv, &error))
{
g_warning ("%s", error->message);
g_error_free (error);
}
g_option_context_free (context);
}
static gboolean
parse_params (int *argcp, char ***argvp)
{
GError *err;
GOptionContext *context;
gboolean rv;
context = g_option_context_new("- mu general options");
g_option_context_set_main_group(context, config_options_group_mu());
g_option_context_set_help_enabled (context, TRUE);
err = NULL;
/* help is special */
if (MU_CONFIG.cmd == MU_CONFIG_CMD_HELP) {
rv = g_option_context_parse (context, argcp, argvp, &err) &&
init_cmd_help (&err);
} else {
GOptionGroup *group;
group = get_option_group (MU_CONFIG.cmd);
if (group)
g_option_context_add_group(context, group);
rv = g_option_context_parse (context, argcp, argvp, &err);
}
g_option_context_free (context);
if (!rv) {
g_printerr ("mu: error in options: %s\n",
err ? err->message : "?");
g_clear_error (&err);
return FALSE;
}
return TRUE;
}
/**
* gdk_parse_args:
* @argc: the number of command line arguments.
* @argv: (inout) (array length=argc): the array of command line arguments.
*
* Parse command line arguments, and store for future
* use by calls to gdk_display_open().
*
* Any arguments used by GDK are removed from the array and @argc and @argv are
* updated accordingly.
*
* You shouldn’t call this function explicitly if you are using
* gtk_init(), gtk_init_check(), gdk_init(), or gdk_init_check().
*
* Since: 2.2
**/
void
gdk_parse_args (int *argc,
char ***argv)
{
GOptionContext *option_context;
GOptionGroup *option_group;
GError *error = NULL;
if (gdk_initialized)
return;
gdk_pre_parse ();
option_context = g_option_context_new (NULL);
g_option_context_set_ignore_unknown_options (option_context, TRUE);
g_option_context_set_help_enabled (option_context, FALSE);
option_group = g_option_group_new (NULL, NULL, NULL, NULL, NULL);
g_option_context_set_main_group (option_context, option_group);
g_option_group_add_entries (option_group, gdk_args);
if (!g_option_context_parse (option_context, argc, argv, &error))
{
g_warning ("%s", error->message);
g_error_free (error);
}
g_option_context_free (option_context);
GDK_NOTE (MISC, g_message ("progname: \"%s\"", g_get_prgname ()));
}
static CoglBool
process_arguments (int *argc, char ***argv,
GError **error)
{
GOptionContext *context;
CoglBool ret;
GOptionGroup *group;
group = g_option_group_new (NULL, /* name */
NULL, /* description */
NULL, /* help_description */
NULL, /* user_data */
NULL /* destroy notify */);
g_option_group_add_entries (group, options);
context = g_option_context_new ("- An example Wayland compositor using Cogl");
g_option_context_set_main_group (context, group);
ret = g_option_context_parse (context, argc, argv, error);
g_option_context_free (context);
if (ret && *argc > 1)
{
g_set_error (error, G_OPTION_ERROR, G_OPTION_ERROR_UNKNOWN_OPTION,
"Unknown option '%s'", (* argv)[1]);
ret = FALSE;
}
return ret;
}
void tg_option_tests()
{
GOptionContext *context;
GOptionContext *context1;//for testing set main group
GOptionContext *context2;//for testing add group
gboolean retval;
GError *error = NULL;
gchar **argv;
int argc;
gchar **argv1;
int argc1;
GOptionEntry entries [] =
{ { "test", 0, 0, G_OPTION_ARG_INT, &arg_test1_int, "test_description", "test_arg" },
{ NULL } };
GOptionEntry entries1 [] =
{ { "try", 0, 0, G_OPTION_ARG_INT, &arg_test1_int, "try_description", "try_arg" },
{ NULL } };
GOptionEntry entries2 [] =
{ { "again", 0, 0, G_OPTION_ARG_INT, &arg_test1_int, "again_description", "again_arg" },
{ NULL } };
GOptionGroup *main_group;
context = g_option_context_new (NULL);
context1 = g_option_context_new (NULL);
context2 = g_option_context_new (NULL);
g_option_context_add_main_entries (context, entries, NULL);
g_option_context_add_main_entries (context2, entries, NULL);
main_group = g_option_context_get_main_group (context);
//Testing g_option_context_set_main_group with another context-context1
g_option_group_add_entries (main_group,entries1);
g_option_context_set_main_group(context1,main_group);
//Testing g_option_context_set_help_enabled
//and g_option_context_get_help_enabled
//and g_option_context_get_ignore_unknown_options
g_option_context_set_help_enabled(context,TRUE);
g_assert(g_option_context_get_help_enabled(context));
g_assert(!g_option_context_get_ignore_unknown_options(context));
/* Now try parsing on context1*/
argv = split_string ("program --try 20 --try 30", &argc);
retval = g_option_context_parse (context1, &argc, &argv, &error);
g_assert (retval);
/* Last arg specified is the one that should be stored */
g_assert (arg_test1_int == 30);
g_option_group_set_error_hook (main_group, error_func);
argv = split_string ("program --none 20 --none 30", &argc);
retval = g_option_context_parse (context1, &argc, &argv, &error);
g_strfreev (argv);
g_option_context_free (context);
}
int main (int argc, char* argv[])
{
const UgOptionEntry* uoentry;
UgDataset* dataset;
UgetCommon* common;
UgPlugin* plugin;
GOptionContext* context;
GOptionGroup* group;
GError* error = NULL;
#ifdef _WIN32 // curl_global_init() will do this
WSADATA WSAData;
WSAStartup (MAKEWORD (2, 2), &WSAData);
#endif
uglib_init ();
// parse command-line options
context = g_option_context_new ("[URL]");
group = g_option_group_new (NULL, NULL, NULL, NULL, NULL);
uoentry = ug_option_get_main_entry ();
g_option_group_add_entries (group, uoentry->entry);
g_option_context_set_main_group (context, group);
if (g_option_context_parse (context, &argc, &argv, &error) == FALSE) {
g_print ("Option parsing failed : %s\n", error->message);
exit (EXIT_FAILURE); // EXIT_FAILURE == 1
}
// get URL from remained arguments
if (argc == 1) {
g_print ("%s", g_option_context_get_help (context, TRUE, NULL));
exit (EXIT_FAILURE); // EXIT_FAILURE == 1
}
dataset = ug_dataset_new ();
ug_option_entry_get (uoentry, dataset);
common = ug_dataset_realloc (dataset, UgetCommonInfo, 0);
common->url = g_strdup (argv[1]);
plugin = ug_plugin_new_by_data (dataset);
ug_dataset_unref (dataset);
if (plugin) {
ug_plugin_set_state (plugin, UG_STATE_ACTIVE);
while (ug_plugin_dispatch (plugin, plugin_callback, NULL))
ug_plugin_delay (plugin, 1000);
ug_plugin_unref (plugin);
}
uglib_finalize ();
#ifdef _WIN32
WSACleanup ();
#endif
return EXIT_SUCCESS; // EXIT_SUCCESS == 0
}
int main(int argc, char *argv[])
{
GError *error = NULL;
GOptionContext *context;
signal(SIGINT, signal_handler);
/* parse opts */
context = g_option_context_new(NULL);
g_option_context_set_summary(context, "A Spice client used for testing and measurements.");
g_option_context_set_description(context, "Report bugs to " PACKAGE_BUGREPORT ".");
g_option_context_set_main_group(context, spice_cmdline_get_option_group());
g_option_context_add_main_entries(context, app_entries, NULL);
if (!g_option_context_parse (context, &argc, &argv, &error)) {
g_print("option parsing failed: %s\n", error->message);
exit(1);
}
if (version) {
g_print("spicy-stats " PACKAGE_VERSION "\n");
exit(0);
}
mainloop = g_main_loop_new(NULL, false);
session = spice_session_new();
g_signal_connect(session, "channel-new",
G_CALLBACK(channel_new), NULL);
spice_cmdline_session_setup(session);
if (!spice_session_connect(session)) {
fprintf(stderr, "spice_session_connect failed\n");
exit(1);
}
g_main_loop_run(mainloop);
{
GList *iter, *list = spice_session_get_channels(session);
gulong total_read_bytes;
gint channel_type;
printf("total bytes read:\n");
for (iter = list ; iter ; iter = iter->next) {
g_object_get(iter->data,
"total-read-bytes", &total_read_bytes,
"channel-type", &channel_type,
NULL);
printf("%s: %lu\n",
spice_channel_type_to_string(channel_type),
total_read_bytes);
}
g_list_free(list);
}
return 0;
}
static gboolean
parse_cmdline (struct config *cfg, gint *argc, gchar **argv[], GError **error)
{
GOptionContext *context;
GOptionEntry entries[] =
{
{ "category", 'c', 0, G_OPTION_ARG_CALLBACK, cmdline_category,
"Set the item's category;\n\t\t"
"CATEGORY must be app, comm, system or hardware", "CATEGORY" },
{ "title", 't', 0, G_OPTION_ARG_STRING, &cfg->title,
"Set TITLE as the item's title", "TITLE" },
{ "status", 's', 0, G_OPTION_ARG_CALLBACK, cmdline_status,
"Set the item's status;\n\t\t"
"STATUS must be active, passive or attention", "STATUS" },
{ "icon", 'i', 0, G_OPTION_ARG_CALLBACK, cmdline_icon_name,
"Use NAME as icon name for (main) icon", "NAME" },
{ "pixbuf", 'I', 0, G_OPTION_ARG_CALLBACK, cmdline_icon_pixbuf,
"Load FILE as icon for (main) icon", "FILE" },
{ "attention-icon", 'a', 0, G_OPTION_ARG_CALLBACK, cmdline_icon_name,
"Use NAME as icon name for attention icon", "NAME" },
{ "attention-pixbuf", 'A', 0, G_OPTION_ARG_CALLBACK, cmdline_icon_pixbuf,
"Load FILE as icon for attention icon", "FILE" },
{ "overlay-icon", 'o', 0, G_OPTION_ARG_CALLBACK, cmdline_icon_name,
"Use NAME as icon name for overlay icon", "NAME" },
{ "overlay-pixbuf", 'O', 0, G_OPTION_ARG_CALLBACK, cmdline_icon_pixbuf,
"Load FILE as icon for overlay icon", "FILE" },
{ "tooltip-icon", 'l', 0, G_OPTION_ARG_CALLBACK, cmdline_icon_name,
"Use NAME as icon name for tooltip icon", "NAME" },
{ "tooltip-pixbuf", 'L', 0, G_OPTION_ARG_CALLBACK, cmdline_icon_pixbuf,
"Load FILE as icon for tooltip icon", "FILE" },
{ "tooltip", 'T', 0, G_OPTION_ARG_STRING, &cfg->tooltip_title,
"Set TITLE as title of the item's tooltip", "TITLE" },
{ "tooltip-body", 'b', 0, G_OPTION_ARG_STRING, &cfg->tooltip_body,
"Set TEXT as body of the item's tooltip", "TEXT" },
{ "item-is-menu", 'M', 0, G_OPTION_ARG_NONE, &cfg->item_is_menu,
"Whether the item only supports context menu or not", NULL},
#ifdef USE_DBUSMENU
{ "dbus-menu", 'm', 0, G_OPTION_ARG_NONE, &cfg->menu,
"Whether menu should be exposed via dbusmenu or not", NULL },
#endif
{ NULL }
};
GOptionGroup *group;
context = g_option_context_new ("");
group = g_option_group_new ("example", "example", "app options", cfg, NULL);
g_option_group_add_entries (group, entries);
g_option_context_set_main_group (context, group);
if (!g_option_context_parse (context, argc, argv, error))
return FALSE;
return TRUE;
}
static gboolean
parse_params (int *argcp, char ***argvp, GError **err)
{
GOptionContext *context;
GOptionGroup *group;
gboolean rv;
context = g_option_context_new("- mu general options");
g_option_context_set_help_enabled (context, TRUE);
rv = TRUE;
g_option_context_set_main_group(context,
config_options_group_mu());
g_option_context_set_ignore_unknown_options (context, FALSE);
switch (MU_CONFIG.cmd) {
case MU_CONFIG_CMD_NONE:
show_usage();
break;
case MU_CONFIG_CMD_HELP:
/* 'help' is special; sucks in the options of the
* command after it */
rv = g_option_context_parse (context, argcp, argvp, err) &&
cmd_help ();
break;
case MU_CONFIG_CMD_SCRIPT:
/* all unknown commands are passed to 'script' */
g_option_context_set_ignore_unknown_options (context, TRUE);
group = get_option_group (MU_CONFIG.cmd);
g_option_context_add_group (context, group);
rv = g_option_context_parse (context, argcp, argvp, err);
MU_CONFIG.script = g_strdup (MU_CONFIG.cmdstr);
/* argvp contains the script parameters */
MU_CONFIG.script_params = (const char**)&((*argvp)[1]);
break;
default:
group = get_option_group (MU_CONFIG.cmd);
if (group)
g_option_context_add_group (context, group);
rv = g_option_context_parse (context, argcp, argvp, err);
break;
}
g_option_context_free (context);
return rv ? TRUE : FALSE;
}
static gboolean
process_options (Opts *opts, int *argcp, char ***argvp, GError **err)
{
gboolean rv;
GOptionContext *octx;
octx = g_option_context_new ("- ttx options");
g_option_context_set_main_group (octx, get_option_group(opts));
rv = g_option_context_parse (octx, argcp, argvp, err);
g_option_context_free (octx);
return rv;
}
int
main (int argc, char *argv[])
{
GOptionContext *option_context;
GOptionGroup *option_group;
GError *error = NULL;
g_type_init ();
option_group = g_option_group_new ("ephy-profile-migrator",
N_("Epiphany profile migrator"),
N_("Epiphany profile migrator options"),
NULL, NULL);
g_option_group_set_translation_domain (option_group, GETTEXT_PACKAGE);
g_option_group_add_entries (option_group, option_entries);
option_context = g_option_context_new ("");
g_option_context_set_main_group (option_context, option_group);
if (!g_option_context_parse (option_context, &argc, &argv, &error)) {
g_print ("Failed to parse arguments: %s\n", error->message);
g_error_free (error);
g_option_context_free (option_context);
return 1;
}
g_option_context_free (option_context);
ephy_debug_init ();
if (!ephy_file_helpers_init (NULL, EPHY_FILE_HELPERS_NONE, NULL)) {
LOG ("Something wrong happened with ephy_file_helpers_init()");
return -1;
}
return ephy_migrator () ? 0 : 1;
}
static gboolean
process_arguments (int *argc,
char ***argv,
GError **error)
{
GOptionContext *context;
gboolean ret;
GOptionGroup *group;
group = g_option_group_new (NULL, /* name */
NULL, /* description */
NULL, /* help_description */
NULL, /* user_data */
NULL /* destroy notify */);
g_option_group_add_entries (group, options);
context = g_option_context_new ("- Verifies a signed data file "
"with the given key");
g_option_context_set_main_group (context, group);
ret = g_option_context_parse (context, argc, argv, error);
g_option_context_free (context);
if (ret)
{
if (*argc > 1)
{
g_set_error (error, G_OPTION_ERROR, G_OPTION_ERROR_UNKNOWN_OPTION,
"Unknown option '%s'", (* argv)[1]);
ret = FALSE;
}
else if (option_data_file == NULL || option_data_file == NULL)
{
g_set_error (error, G_OPTION_ERROR, G_OPTION_ERROR_BAD_VALUE,
"The -k and -d options are required. See --help");
ret = FALSE;
}
}
return ret;
}
static gboolean
init_cmd_help (GError **err)
{
MuConfigCmd cmd;
GOptionContext *ctx;
GOptionGroup *group;
char *cleanhelp;
if (!MU_CONFIG.params ||
!MU_CONFIG.params[0] || !MU_CONFIG.params[1] ||
MU_CONFIG.params[2])
goto errexit;
cmd = cmd_from_string (MU_CONFIG.params[1]);
if (cmd == MU_CONFIG_CMD_UNKNOWN)
goto errexit;
ctx = g_option_context_new ("");
g_option_context_set_main_group
(ctx, config_options_group_mu());
group = get_option_group (cmd);
if (group)
g_option_context_add_group (ctx, group);
g_option_context_set_description (ctx, cmd_help (cmd, TRUE));
cleanhelp = massage_help
(g_option_context_get_help (ctx, TRUE, group));
g_print ("Usage:\n\t%s\n%s",
cmd_help (cmd, FALSE), cleanhelp);
g_free (cleanhelp);
return TRUE;
errexit:
mu_util_g_set_error (err, MU_ERROR_IN_PARAMETERS,
"usage: mu help <command>");
return FALSE;
}
static gboolean
parse_params (MuConfig *opts, int *argcp, char ***argvp)
{
GError *err = NULL;
GOptionContext *context;
gboolean rv;
context = g_option_context_new("- mu general option");
g_option_context_set_main_group(context,
config_options_group_mu(opts));
add_context_group (context, opts);
rv = g_option_context_parse (context, argcp, argvp, &err);
g_option_context_free (context);
if (!rv) {
g_printerr ("mu: error in options: %s\n", err->message);
g_error_free (err);
return FALSE;
}
return TRUE;
}
int main(int argc, char *argv[]){
GError *error = NULL;
GOptionContext *context;
context = g_option_context_new("glib option test");
GOptionGroup *main_group = g_option_group_new("main",
"Main options",
"Main options",
NULL, NULL);
g_option_group_add_entries(main_group, common_entries);
g_option_context_set_main_group(context, main_group);
if (!g_option_context_parse(context, &argc, &argv, &error)){
g_print ("option parsing failed: %s, try --help\n", error->message);
exit (EXIT_FAILURE);
}
MYSQL *conn;
conn = create_main_connection();
start_dump(conn);
g_option_context_free(context);
return 0;
}
/**
* gegl_init:
* @argc: a pointer to the number of command line arguments.
* @argv: a pointer to the array of command line arguments.
*
* Call this function before using any other GEGL functions. It will initialize
* everything needed to operate GEGL and parses some standard command line
* options. @argc and @argv are adjusted accordingly so your own code will
* never see those standard arguments.
*
* Note that there is an alternative ways to initialize GEGL: if you are
* calling g_option_context_parse() with the option group returned by
* gegl_get_option_group(), you don't have to call gegl_init().
**/
void
gegl_init (gint *argc,
gchar ***argv)
{
GOptionContext *context;
GError *error = NULL;
if (config)
return;
/* If any command-line actions are ever added to GEGL, then the commented
* out code below should be used. Until then, we simply call the parse hook
* directly.
*/
#if 0
gegl_post_parse_hook (NULL, NULL, NULL, NULL);
#else
context = g_option_context_new (NULL);
g_option_context_set_ignore_unknown_options (context, TRUE);
g_option_context_set_help_enabled (context, FALSE);
g_option_context_set_main_group (context, gegl_get_option_group ());
if (!g_option_context_parse (context, argc, argv, &error))
{
g_warning ("%s", error->message);
g_error_free (error);
}
g_option_context_free (context);
#endif
/* Not the best place for this ... better to put it in post_parse and just
* save argv[0] here.
*/
vips_init (*argv[0]);
}
SSVCommandLine *
ssv_command_line_new (gint *argc, gchar ***argv)
{
SSVCommandLine *self = g_new (SSVCommandLine, 1);
// Initialize the contents of the structure we will parse into with
// default or empty values. IMPROVEME: this notion of the default
// cache directory is manually synced with some code in main().
self->cache_dir = g_string_new (getenv ("HOME"));
g_string_append (self->cache_dir, "/.ssv_cache");
const gint default_max_cache_size = 400;
self->max_cache_size = default_max_cache_size;
self->pixmaps = pix_maps_spec_new ();
// If sigmas is negative, we will try to linearly map the whole range.
const gdouble default_sigmas = 2.0;
self->sigmas = default_sigmas;
self->images = g_ptr_array_new ();
self->x_offsets = g_array_new (FALSE, FALSE, sizeof (gint));
self->y_offsets = g_array_new (FALSE, FALSE, sizeof (gint));
gchar *analysis_program = NULL; // We'll copy into GString in self later.
self->async_analysis = FALSE;
const gint default_analysis_tile_size = 51;
self->analysis_tile_size = default_analysis_tile_size;
const gint option_type_count = 8;
// List of uptions (+1 for the 'option' which handles the arguments,
// +1 for the one with NULL for its long_name which terminated the
// list).
GOptionEntry *entries = g_new (GOptionEntry, option_type_count + 1 + 1);
// Place for the parser to store the cache directory option argument
// value. It looks like the option parser automagicly allocates
// this.
gchar *cache_dir = NULL;
// Place for the parser to store the image file names.
gchar **image_names = NULL;
// Entry strings, including documentation that gets printed by
// --help (make sure it still looks good after changes).
// IMPROVEME: there are little bits in these documentation strings
// that at the moment need to be manually kept in sync with the
// defaults and such.
entries[0].long_name = "cache-dir";
entries[0].short_name = 'c';
entries[0].flags = 0;
entries[0].arg = G_OPTION_ARG_FILENAME;
entries[0].arg_data = &cache_dir;
entries[0].description
= "\n Directory to use for pyramid cache (defualt: ~/.ssv_cache)\n";
entries[0].arg_description = "DIRECTORY";
entries[1].long_name = "max-cache-size";
entries[1].short_name = 'm';
entries[1].flags = 0;
entries[1].arg = G_OPTION_ARG_INT;
entries[1].arg_data = &(self->max_cache_size);
entries[1].description
= (
"\n Maximum cache size, in megabytes. Old (unused) entries start\n"
" getting deleted when the cache gets this big. Default is 400.\n");
entries[1].arg_description = "SIZE";
entries[2].long_name = "pixmap";
entries[2].short_name = 'p';
entries[2].flags = 0;
entries[2].arg = G_OPTION_ARG_CALLBACK;
entries[2].arg_data = parse_pixmap;
entries[2].description
= (
"\n Pixel remap specification of the form \"[a,b],c\". Pixels in the \n"
" range [a,b] (values of \"nan\" or \"inf\" are allowed) are not \n"
" considerd when computing the image statistics used to map the image \n"
" into the representable range of pixel values, and are always \n"
" represented visually as if they have value c. Note that pixel maps\n"
" have no effect at all on pixel information, tile analysis, etc.: they\n"
" only affect how the image data is rendered\n");
entries[2].arg_description = "SPEC";
entries[3].long_name = "sigmas";
entries[3].short_name = 's';
entries[3].flags = 0;
entries[3].arg = G_OPTION_ARG_DOUBLE;
entries[3].arg_data = &(self->sigmas);
entries[3].description
= (
"\n When displaying data, map values within SIGMAS standard deviations\n"
" of the mean linearly into the displayable range of values, and clamp\n"
" values outside this region to the endpoints of the displayable range.\n"
" Note that sufficiently huge or special pixel values will still require\n"
" the use of pixel maps (see --pixmap option description). The default\n"
" value is 2.0. If SIGMAS is negative, the whole range of pixel values\n"
" present in the data will be mapped linearly into the displayable\n"
" range.\n");
entries[3].arg_description = "SIGMAS";
entries[4].long_name = "offset";
entries[4].short_name = 'o';
entries[4].flags = 0;
entries[4].arg = G_OPTION_ARG_CALLBACK;
entries[4].arg_data = parse_offset;
entries[4].description
= (
"\n Image offset specification of the form \"a,b\" where a is \n"
" counted in whole image pixels rightward and b downward from the top \n"
" left corner of the first image argument. The first occurence of this \n"
" option specifies the offset of the top left corner of the second \n"
" image, the second occurence the offset of the third image, etc. \n"
" If any occurences of this option appear in an invocation, the correct \n"
" number (i.e. one less than the number of images) must be supplied.\n");
entries[4].arg_description = "SPEC";
entries[5].long_name = "analysis-program";
entries[5].short_name = 'a';
entries[5].flags = 0;
entries[5].arg = G_OPTION_ARG_STRING;
entries[5].arg_data = &analysis_program;
entries[5].description
= (
"\n Program to run when 'a' key is pressed. The program is invoked \n"
" with the following command line arguments:\n"
"\n"
" tile_count total number of image tiles to be passed\n"
" base_name image file base name\n"
" tile_width width of tile in pixels\n"
" tile_height height of tile in pixels\n"
" tile_file_name name of file containing tile data\n"
"\n"
" where arguments 2 through 5 in the above list are repeated tile_count\n"
" times. The tile_width and tile_height arguments are generally equal to\n"
" the value specified with the --analysis-tile-size option, but may be\n"
" smaller (or even zero) if the cursor was near or off the edge of the\n"
" image when analysis was requested. The tile_file_name is the name of a\n"
" file containing the tile data in big endian form. It's probably\n"
" easiest to use the float_image_new_from_file method with these\n"
" arguments. The base_name argument might be useful if metadata needs to\n"
" be used or the analysis region needs to be grown algorithmicly.\n");
entries[5].arg_description = "PROGRAM";
entries[6].long_name = "async-analysis";
entries[6].short_name = 0;
entries[6].flags = 0;
entries[6].arg = G_OPTION_ARG_NONE;
entries[6].arg_data = &(self->async_analysis);
entries[6].description
= (
"\n Run the analysis program asynchronously (i.e. in background,\n"
" without waiting for it to complete.\n");
entries[6].arg_description = ""; // Doesn't take an argument.
entries[7].long_name = "analysis-tile-size";
entries[7].short_name = 0;
entries[7].flags = 0;
entries[7].arg = G_OPTION_ARG_INT;
entries[7].arg_data = &(self->analysis_tile_size);
entries[7].description
= (
"\n Dimensions of (square) tiles to analyze (must be odd). The default\n"
" size is 51.\n");
entries[7].arg_description = "TILE_SIZE";
entries[8].long_name = G_OPTION_REMAINING;
entries[8].short_name = 0;
entries[8].flags = 0;
entries[8].arg = G_OPTION_ARG_FILENAME_ARRAY;
entries[8].arg_data = &image_names;
entries[8].description = "YOU_HOPEFULLY_DONT_SEE_ME";
entries[8].arg_description = "IMAGE_BASE_NAME [IMAGE_BASE_NAME...]";
entries[9].long_name = NULL;
GOptionGroup *ssv_group
= g_option_group_new ("ssv", "ssv Options",
"Display help for ssv options.", self, NULL);
g_option_group_add_entries (ssv_group, entries);
GOptionContext *option_context = g_option_context_new ("");
g_option_context_set_main_group (option_context, ssv_group);
// Run the parser.
GError *err = NULL;
gboolean parse_results
= g_option_context_parse (option_context, argc, argv, &err);
if ( !parse_results ) {
g_printerr ("%s: option parsing failed: %s\n", g_get_prgname (),
err->message);
exit (EXIT_FAILURE);
}
else {
g_assert (err == NULL);
}
g_option_context_free (option_context);
// Vet and copy the cache directory name (if provided) into a new
// GString instance in self.
if ( cache_dir != NULL ) {
GError *err = NULL;
my_is_writable_directory (cache_dir, &err);
if ( err != NULL ) {
g_printerr ("%s: bad -c or --cache-dir option argument '%s': %s\n",
g_get_prgname (), cache_dir, err->message);
exit (EXIT_FAILURE);
}
g_string_free (self->cache_dir, TRUE);
self->cache_dir = g_string_new (cache_dir);
}
g_free (cache_dir);
// Vet and copy the analysis related arguments into their homes in
// self.
if ( analysis_program != NULL ) {
self->analysis_program = g_string_new (analysis_program);
}
else {
self->analysis_program = NULL;
}
if ( self->analysis_tile_size % 2 != 1 ) {
g_printerr ("%s: bad --analysis_tile_size option argument '%d': not odd\n",
g_get_prgname (), self->analysis_tile_size);
exit (EXIT_FAILURE);
}
// Vet and copy the image name strings into GString instances in the
// array in self.
guint ii;
for ( ii = 0 ; image_names != NULL && image_names[ii] != NULL ; ii++ ) {
GString *cs = g_string_new (image_names[ii]);
GError *err = NULL;
GString *data_name = my_g_string_new_printf ("%s.img", cs->str);
my_is_readable_file (data_name->str, &err);
if ( err != NULL ) {
g_printerr ("%s: file '%s' looks unreadable: %s\n",
g_get_prgname (), data_name->str, err->message);
exit (EXIT_FAILURE);
}
my_g_string_free (data_name);
GString *meta_name = my_g_string_new_printf ("%s.meta", cs->str);
my_is_readable_file (meta_name->str, &err);
if ( err != NULL ) {
g_printerr ("%s: file '%s' looks unreadable: %s\n",
g_get_prgname (), meta_name->str, err->message);
exit (EXIT_FAILURE);
}
my_g_string_free (meta_name);
g_ptr_array_add (self->images, cs);
}
g_strfreev (image_names);
// We require at least one image argument.
if ( self->images->len < 1 ) {
g_printerr ("%s: at least one image base name argument must be "
"provided (try %s --help).\n", g_get_prgname (),
g_get_prgname ());
exit (EXIT_FAILURE);
}
// We require the corrent number of offset arguments.
if ( self->x_offsets->len > 0 ) {
if ( self->x_offsets->len != self->images->len - 1 ) {
g_printerr ("%s: if any offset options are provided, the number "
"provided must be exactly one less than the number of image "
"arguments provided\n", g_get_prgname ());
exit (EXIT_FAILURE);
}
}
// IMPROVEME: Well this restriction has the potential to be very
// annoying: if more than one image is specified to be loaded,
// offset options must be specified for each image beyond the first.
// The sensible thing would be to have default offset of (0, 0) or
// course. But it opend a small can or worms if we want and offset
// for only the third image for example, and I just don't have the
// time to go through and make everything agree.
g_assert (self->x_offsets->len == self->images->len - 1);
g_assert (self->x_offsets->len == self->y_offsets->len);
self->reference_count = 1;
return self;
}
gboolean
mc_args_parse (int *argc, char ***argv, const char *translation_domain, GError ** mcerror)
{
const gchar *_system_codepage;
gboolean ok = TRUE;
mc_return_val_if_error (mcerror, FALSE);
_system_codepage = str_detect_termencoding ();
#ifdef ENABLE_NLS
if (!str_isutf8 (_system_codepage))
bind_textdomain_codeset ("mc", "UTF-8");
#endif
context = g_option_context_new (mc_args_add_usage_info ());
g_option_context_set_ignore_unknown_options (context, FALSE);
mc_args_add_extended_info_to_help ();
main_group = g_option_group_new ("main", _("Main options"), _("Main options"), NULL, NULL);
g_option_group_add_entries (main_group, argument_main_table);
g_option_context_set_main_group (context, main_group);
g_option_group_set_translation_domain (main_group, translation_domain);
terminal_group = g_option_group_new ("terminal", _("Terminal options"),
_("Terminal options"), NULL, NULL);
g_option_group_add_entries (terminal_group, argument_terminal_table);
g_option_context_add_group (context, terminal_group);
g_option_group_set_translation_domain (terminal_group, translation_domain);
color_group = mc_args_new_color_group ();
g_option_group_add_entries (color_group, argument_color_table);
g_option_context_add_group (context, color_group);
g_option_group_set_translation_domain (color_group, translation_domain);
if (!g_option_context_parse (context, argc, argv, mcerror))
{
if (*mcerror == NULL)
mc_propagate_error (mcerror, 0, "%s\n", _("Arguments parse error!"));
else
{
gchar *help_str;
help_str = g_option_context_get_help (context, TRUE, NULL);
if (str_isutf8 (_system_codepage))
mc_replace_error (mcerror, (*mcerror)->code, "%s\n\n%s\n", (*mcerror)->message,
help_str);
else
{
gchar *full_help_str;
full_help_str =
mc_args__convert_help_to_syscharset (_system_codepage, (*mcerror)->message,
help_str);
mc_replace_error (mcerror, (*mcerror)->code, "%s", full_help_str);
g_free (full_help_str);
}
g_free (help_str);
}
ok = FALSE;
}
g_option_context_free (context);
mc_args_clean_temp_help_strings ();
#ifdef ENABLE_NLS
if (!str_isutf8 (_system_codepage))
bind_textdomain_codeset ("mc", _system_codepage);
#endif
return ok;
}
gint
main (gint argc, gchar ** argv)
{
gboolean res = FALSE;
gboolean arg_version = FALSE;
gboolean arg_quiet = FALSE;
gchar *command = NULL, *input_file_name = NULL, *output_file_name = NULL;
gint saved_argc = argc;
BtCmdApplication *app;
GOptionContext *ctx;
GOptionGroup *group;
GError *err = NULL;
#ifdef ENABLE_NLS
setlocale (LC_ALL, "");
bindtextdomain (GETTEXT_PACKAGE, LOCALEDIR);
bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8");
textdomain (GETTEXT_PACKAGE);
#endif /* ENABLE_NLS */
static GOptionEntry options[] = {
{"version", '\0', 0, G_OPTION_ARG_NONE, NULL,
N_("Print application version"), NULL},
{"quiet", 'q', 0, G_OPTION_ARG_NONE, NULL, N_("Be quiet"), NULL},
{"command", 'c', 0, G_OPTION_ARG_STRING, NULL, N_("Command name"),
"{info, play, convert, encode}"},
{"input-file", 'i', 0, G_OPTION_ARG_FILENAME, NULL, N_("Input file name"),
N_("<songfile>")},
{"output-file", 'o', 0, G_OPTION_ARG_FILENAME, NULL, N_("Output file name"),
N_("<songfile>")},
{NULL}
};
// setting this separately gets us from 76 to 10 instructions
options[0].arg_data = &arg_version;
options[1].arg_data = &arg_quiet;
options[2].arg_data = &command;
options[3].arg_data = &input_file_name;
options[4].arg_data = &output_file_name;
// init libraries
ctx = g_option_context_new (NULL);
//g_option_context_add_main_entries(ctx, options, GETTEXT_PACKAGE);
group =
g_option_group_new ("main", _("buzztrax-cmd options"),
_("Show buzztrax-cmd options"), argv[0], NULL);
g_option_group_add_entries (group, options);
g_option_group_set_translation_domain (group, GETTEXT_PACKAGE);
g_option_context_set_main_group (ctx, group);
bt_init_add_option_groups (ctx);
g_option_context_add_group (ctx, btic_init_get_option_group ());
if (!g_option_context_parse (ctx, &argc, &argv, &err)) {
g_print ("Error initializing: %s\n", safe_string (err->message));
g_option_context_free (ctx);
exit (1);
}
if (arg_version) {
g_printf ("%s from " PACKAGE_STRING "\n", argv[0]);
res = TRUE;
goto Done;
}
if (!command) {
if (argc == saved_argc) {
usage (argc, argv, ctx);
}
goto Done;
}
GST_DEBUG_CATEGORY_INIT (GST_CAT_DEFAULT, "bt-cmd", 0,
"music production environment / command ui");
GST_INFO ("starting: command=\"%s\" input=\"%s\" output=\"%s\"", command,
input_file_name, output_file_name);
// give some global context info
g_set_prgname ("buzztrax-cmd");
g_set_application_name ("Buzztrax");
g_setenv ("PULSE_PROP_application.icon_name", "buzztrax", TRUE);
g_setenv ("PULSE_PROP_media.role", "production", TRUE);
app = bt_cmd_application_new (arg_quiet);
// set a default command, if a file is given
if (!command && BT_IS_STRING (input_file_name)) {
command = g_strdup ("p");
}
// depending on the options call the correct method
if (!strcmp (command, "p") || !strcmp (command, "play")) {
if (!BT_IS_STRING (input_file_name))
usage (argc, argv, ctx);
res = bt_cmd_application_play (app, input_file_name);
} else if (!strcmp (command, "i") || !strcmp (command, "info")) {
if (!BT_IS_STRING (input_file_name))
usage (argc, argv, ctx);
res = bt_cmd_application_info (app, input_file_name, output_file_name);
} else if (!strcmp (command, "c") || !strcmp (command, "convert")) {
if (!BT_IS_STRING (input_file_name) || !BT_IS_STRING (output_file_name))
usage (argc, argv, ctx);
res = bt_cmd_application_convert (app, input_file_name, output_file_name);
} else if (!strcmp (command, "e") || !strcmp (command, "encode")) {
if (!BT_IS_STRING (input_file_name) || !BT_IS_STRING (output_file_name))
usage (argc, argv, ctx);
res = bt_cmd_application_encode (app, input_file_name, output_file_name);
} else
usage (argc, argv, ctx);
// free application
g_object_unref (app);
Done:
g_free (command);
g_free (input_file_name);
g_free (output_file_name);
g_option_context_free (ctx);
return !res;
}
Configuration* configuration_new(gint argc, gchar* argv[]) {
/* get memory */
Configuration* c = g_new0(Configuration, 1);
MAGIC_INIT(c);
c->argstr = g_strjoinv(" ", argv);
const gchar* required_parameters = "shadow.config.xml";
gint nRequiredXMLFiles = 1;
c->context = g_option_context_new(required_parameters);
g_option_context_set_summary(c->context, "Shadow - run real applications over simulated networks");
g_option_context_set_description(c->context,
"Shadow is a unique discrete-event network simulator that runs real "
"applications like Tor, and distributed systems of thousands of nodes "
"on a single machine. Shadow combines the accuracy of emulation with the "
"efficiency and control of simulation, achieving the best of both approaches.");
/* set defaults */
c->initialTCPWindow = 10;
c->interfaceBufferSize = 1024000;
c->interfaceBatchTime = 10;
c->randomSeed = 1;
c->cpuThreshold = -1;
c->cpuPrecision = 200;
c->heartbeatInterval = 60;
/* set options to change defaults for the main group */
c->mainOptionGroup = g_option_group_new("main", "Main Options", "Primary simulator options", NULL, NULL);
const GOptionEntry mainEntries[] = {
{ "debug", 'd', 0, G_OPTION_ARG_NONE, &(c->debug), "Pause at startup for debugger attachment", NULL },
{ "heartbeat-frequency", 'h', 0, G_OPTION_ARG_INT, &(c->heartbeatInterval), "Log node statistics every N seconds [60]", "N" },
{ "heartbeat-log-level", 'j', 0, G_OPTION_ARG_STRING, &(c->heartbeatLogLevelInput), "Log LEVEL at which to print node statistics ['message']", "LEVEL" },
{ "heartbeat-log-info", 'i', 0, G_OPTION_ARG_STRING, &(c->heartbeatLogInfo), "Comma separated list of information contained in heartbeat ('node','socket','ram') ['node']", "LIST"},
{ "log-level", 'l', 0, G_OPTION_ARG_STRING, &(c->logLevelInput), "Log LEVEL above which to filter messages ('error' < 'critical' < 'warning' < 'message' < 'info' < 'debug') ['message']", "LEVEL" },
{ "preload", 'p', 0, G_OPTION_ARG_STRING, &(c->preloads), "LD_PRELOAD environment VALUE to use for function interposition (/path/to/lib:...) [None]", "VALUE" },
{ "runahead", 'r', 0, G_OPTION_ARG_INT, &(c->minRunAhead), "If set, overrides the automatically calculated minimum TIME workers may run ahead when sending events between nodes, in milliseconds [0]", "TIME" },
{ "seed", 's', 0, G_OPTION_ARG_INT, &(c->randomSeed), "Initialize randomness for each thread using seed N [1]", "N" },
{ "workers", 'w', 0, G_OPTION_ARG_INT, &(c->nWorkerThreads), "Run concurrently with N worker threads [0]", "N" },
{ "valgrind", 'x', 0, G_OPTION_ARG_NONE, &(c->runValgrind), "Run through valgrind for debugging", NULL },
{ "version", 'v', 0, G_OPTION_ARG_NONE, &(c->printSoftwareVersion), "Print software version and exit", NULL },
{ NULL },
};
g_option_group_add_entries(c->mainOptionGroup, mainEntries);
g_option_context_set_main_group(c->context, c->mainOptionGroup);
/* now fill in the default plug-in examples option group */
c->pluginsOptionGroup = g_option_group_new("sim", "Simulation Examples", "Built-in simulation examples", NULL, NULL);
const GOptionEntry pluginEntries[] =
{
{ "file", 0, 0, G_OPTION_ARG_NONE, &(c->runFileExample), "Run basic HTTP file transfer simulation", NULL },
{ NULL },
};
g_option_group_add_entries(c->pluginsOptionGroup, pluginEntries);
g_option_context_add_group(c->context, c->pluginsOptionGroup);
/* now fill in the network option group */
GString* sockrecv = g_string_new("");
g_string_printf(sockrecv, "Initialize the socket receive buffer to N bytes [%i]", (gint)CONFIG_RECV_BUFFER_SIZE);
GString* socksend = g_string_new("");
g_string_printf(socksend, "Initialize the socket send buffer to N bytes [%i]", (gint)CONFIG_SEND_BUFFER_SIZE);
c->networkOptionGroup = g_option_group_new("sys", "System Options", "Simulated system/network behavior", NULL, NULL);
const GOptionEntry networkEntries[] =
{
{ "cpu-precision", 0, 0, G_OPTION_ARG_INT, &(c->cpuPrecision), "round measured CPU delays to the nearest TIME, in microseconds (negative value to disable fuzzy CPU delays) [200]", "TIME" },
{ "cpu-threshold", 0, 0, G_OPTION_ARG_INT, &(c->cpuThreshold), "TIME delay threshold after which the CPU becomes blocked, in microseconds (negative value to disable CPU delays) (experimental!) [-1]", "TIME" },
{ "interface-batch", 0, 0, G_OPTION_ARG_INT, &(c->interfaceBatchTime), "Batch TIME for network interface sends and receives, in milliseconds [10]", "TIME" },
{ "interface-buffer", 0, 0, G_OPTION_ARG_INT, &(c->interfaceBufferSize), "Size of the network interface receive buffer, in bytes [1024000]", "N" },
{ "interface-qdisc", 0, 0, G_OPTION_ARG_STRING, &(c->interfaceQueuingDiscipline), "The interface queuing discipline QDISC used to select the next sendable socket ('fifo' or 'rr') ['fifo']", "QDISC" },
{ "socket-recv-buffer", 0, 0, G_OPTION_ARG_INT, &(c->initialSocketReceiveBufferSize), sockrecv->str, "N" },
{ "socket-send-buffer", 0, 0, G_OPTION_ARG_INT, &(c->initialSocketSendBufferSize), socksend->str, "N" },
{ "tcp-congestion-control", 0, 0, G_OPTION_ARG_STRING, &(c->tcpCongestionControl), "Congestion control algorithm to use for TCP ('aimd', 'reno', 'cubic') ['cubic']", "TCPCC" },
{ "tcp-ssthresh", 0, 0, G_OPTION_ARG_INT, &(c->tcpSlowStartThreshold), "Set TCP ssthresh value instead of discovering it via packet loss or hystart [0]", "N" },
{ "tcp-windows", 0, 0, G_OPTION_ARG_INT, &(c->initialTCPWindow), "Initialize the TCP send, receive, and congestion windows to N packets [10]", "N" },
{ NULL },
};
g_option_group_add_entries(c->networkOptionGroup, networkEntries);
g_option_context_add_group(c->context, c->networkOptionGroup);
/* parse args */
GError *error = NULL;
if (!g_option_context_parse(c->context, &argc, &argv, &error)) {
g_printerr("** %s **\n", error->message);
gchar* helpString = g_option_context_get_help(c->context, TRUE, NULL);
g_printerr("%s", helpString);
g_free(helpString);
configuration_free(c);
return NULL;
}
/* make sure we have the required arguments. program name is first arg.
* printing the software version requires no other args. running a
* plug-in example also requires no other args. */
if(!(c->printSoftwareVersion) && !(c->runFileExample) && (argc < nRequiredXMLFiles + 1)) {
g_printerr("** Please provide the required parameters **\n");
gchar* helpString = g_option_context_get_help(c->context, TRUE, NULL);
g_printerr("%s", helpString);
g_free(helpString);
configuration_free(c);
return NULL;
}
if(c->nWorkerThreads < 0) {
c->nWorkerThreads = 0;
}
if(c->logLevelInput == NULL) {
c->logLevelInput = g_strdup("message");
}
if(c->heartbeatLogLevelInput == NULL) {
c->heartbeatLogLevelInput = g_strdup("message");
}
if(c->heartbeatLogInfo == NULL) {
c->heartbeatLogInfo = g_strdup("node");
}
if(c->heartbeatInterval < 1) {
c->heartbeatInterval = 1;
}
if(c->initialTCPWindow < 1) {
c->initialTCPWindow = 1;
}
if(c->interfaceBufferSize < CONFIG_MTU) {
c->interfaceBufferSize = CONFIG_MTU;
}
c->interfaceBatchTime *= SIMTIME_ONE_MILLISECOND;
if(c->interfaceBatchTime == 0) {
/* we require at least 1 nanosecond b/c of time granularity */
c->interfaceBatchTime = 1;
}
if(c->interfaceQueuingDiscipline == NULL) {
c->interfaceQueuingDiscipline = g_strdup("fifo");
}
if(!c->initialSocketReceiveBufferSize) {
c->initialSocketReceiveBufferSize = CONFIG_RECV_BUFFER_SIZE;
c->autotuneSocketReceiveBuffer = TRUE;
}
if(!c->initialSocketSendBufferSize) {
c->initialSocketSendBufferSize = CONFIG_SEND_BUFFER_SIZE;
c->autotuneSocketSendBuffer = TRUE;
}
if(c->tcpCongestionControl == NULL) {
c->tcpCongestionControl = g_strdup("cubic");
}
c->inputXMLFilenames = g_queue_new();
for(gint i = 1; i < argc; i++) {
GString* filename = g_string_new(argv[i]);
g_queue_push_tail(c->inputXMLFilenames, filename);
}
if(socksend) {
g_string_free(socksend, TRUE);
}
if(sockrecv) {
g_string_free(sockrecv, TRUE);
}
return c;
}
int
main(int argc, char *argv[])
{
gboolean print_version = FALSE;
gboolean one_shot = FALSE;
gchar *output_plugin = NULL;
gchar **servers_desc = NULL;
gchar **streams_desc = NULL;
gchar **input_plugins = NULL;
gchar **order = NULL;
gchar *config = NULL;
int retval = 0;
GError *error = NULL;
GOptionContext *option_context = NULL;
GOptionGroup *option_group;
#if DEBUG
g_setenv("G_MESSAGES_DEBUG", "all", FALSE);
#endif /* ! DEBUG */
setlocale(LC_ALL, "");
#ifdef ENABLE_NLS
bindtextdomain(GETTEXT_PACKAGE, LOCALEDIR);
bind_textdomain_codeset(GETTEXT_PACKAGE, "UTF-8");
#endif /* ENABLE_NLS */
#if DEBUG
const gchar *debug_log_filename = g_getenv("J4STATUS_DEBUG_LOG_FILENAME");
GDataOutputStream *debug_stream = NULL;
if ( debug_log_filename != NULL )
{
GFile *debug_log;
debug_log = g_file_new_for_path(debug_log_filename);
GError *error = NULL;
GFileOutputStream *debug_log_stream;
debug_log_stream = g_file_append_to(debug_log, G_FILE_CREATE_NONE, NULL, &error);
if ( debug_log_stream == NULL )
{
g_warning("Couldn't open debug log file: %s", error->message);
g_clear_error(&error);
}
else
{
debug_stream = g_data_output_stream_new(G_OUTPUT_STREAM(debug_log_stream));
g_object_unref(debug_log_stream);
g_log_set_default_handler(_j4status_core_debug_log_handler, debug_stream);
}
g_object_unref(debug_log);
}
#endif /* DEBUG */
GOptionEntry entries[] =
{
{ "output", 'o', 0, G_OPTION_ARG_STRING, &output_plugin, "Output plugin to use", "<plugin>" },
{ "listen", 'l', 0, G_OPTION_ARG_STRING_ARRAY, &servers_desc, "Socket to listen on, will create a stream on connection (may be specified several times)", "<listen description>" },
{ "stream", 't', 0, G_OPTION_ARG_STRING_ARRAY, &streams_desc, "Stream to read from/write to (may be specified several times)", "<stream description>" },
{ "input", 'i', 0, G_OPTION_ARG_STRING_ARRAY, &input_plugins, "Input plugins to use (may be specified several times)", "<plugin>" },
{ "order", 'O', 0, G_OPTION_ARG_STRING_ARRAY, &order, "Order of sections, specified once a section (see man)", "<section id>" },
{ "one-shot", '1', 0, G_OPTION_ARG_NONE, &one_shot, "Tells j4status to stop right after starting", NULL },
{ "config", 'c', 0, G_OPTION_ARG_STRING, &config, "Config file to use", "<config>" },
{ "version", 'V', 0, G_OPTION_ARG_NONE, &print_version, "Print version", NULL },
{ NULL }
};
option_context = g_option_context_new("- status line generator");
option_group = g_option_group_new(NULL, NULL, NULL, NULL, NULL);
g_option_group_set_translation_domain(option_group, GETTEXT_PACKAGE);
g_option_group_add_entries(option_group, entries);
g_option_context_set_main_group(option_context, option_group);
if ( ! g_option_context_parse(option_context, &argc, &argv, &error) )
{
g_warning("Option parsing failed: %s\n", error->message);
g_clear_error(&error);
retval = 1;
goto end;
}
g_option_context_free(option_context);
if ( print_version )
{
g_fprintf(stdout, PACKAGE_NAME " " PACKAGE_VERSION "\n");
goto end;
}
if ( config != NULL )
{
g_setenv("J4STATUS_CONFIG_FILE", config, TRUE);
g_free(config);
}
GKeyFile *key_file;
key_file = j4status_config_get_key_file("Plugins");
if ( key_file != NULL )
{
if ( output_plugin == NULL )
output_plugin = g_key_file_get_string(key_file, "Plugins", "Output", NULL);
if ( input_plugins == NULL )
input_plugins = g_key_file_get_string_list(key_file, "Plugins", "Input", NULL, NULL);
if ( order == NULL )
order = g_key_file_get_string_list(key_file, "Plugins", "Order", NULL, NULL);
g_key_file_free(key_file);
}
J4statusCoreContext *context;
context = g_new0(J4statusCoreContext, 1);
J4statusCoreInterface interface = {
.context = context,
.add_section = _j4status_core_add_section,
.remove_section = _j4status_core_remove_section,
.trigger_generate = _j4status_core_trigger_generate,
.trigger_action = _j4status_core_trigger_action,
};
#ifdef G_OS_UNIX
g_unix_signal_add(SIGTERM, _j4status_core_source_quit, context);
g_unix_signal_add(SIGINT, _j4status_core_source_quit, context);
g_unix_signal_add(SIGUSR1, _j4status_core_signal_usr1, context);
g_unix_signal_add(SIGUSR2, _j4status_core_signal_usr2, context);
/* Ignore SIGPIPE as it is useless */
signal(SIGPIPE, SIG_IGN);
#endif /* G_OS_UNIX */
context->output_plugin = j4status_plugins_get_output_plugin(&interface, output_plugin);
if ( context->output_plugin == NULL )
{
g_warning("No usable output plugin, tried '%s'", output_plugin);
retval = 10;
goto end;
}
gchar *header = NULL;
if ( context->output_plugin->interface.generate_header != NULL )
header = context->output_plugin->interface.generate_header(context->output_plugin->context);
/* Creating input/output stream */
context->io = j4status_io_new(context, header, (const gchar * const *) servers_desc, (const gchar * const *) streams_desc);
if ( context->io == NULL )
{
g_warning("Couldn't create input/output streams");
retval = 2;
goto end;
}
if ( order != NULL )
{
context->order_weights = g_hash_table_new_full(g_str_hash, g_str_equal, g_free, NULL);
gchar **id;
for ( id = order ; *id != NULL ; ++id )
g_hash_table_insert(context->order_weights, *id, GINT_TO_POINTER(1 + id - order));
g_free(order);
}
context->sections_hash = g_hash_table_new(g_str_hash, g_str_equal);
context->input_plugins = j4status_plugins_get_input_plugins(&interface, input_plugins);
if ( context->input_plugins == NULL )
{
g_warning("No input plugins, will stop early");
one_shot = TRUE;
retval = 11;
}
context->sections = g_list_reverse(context->sections);
if ( context->order_weights != NULL )
context->sections = g_list_sort(context->sections, _j4status_core_compare_sections);
_j4status_core_start(context);
if ( one_shot )
g_idle_add(_j4status_core_source_quit, context);
context->loop = g_main_loop_new(NULL, FALSE);
g_main_loop_run(context->loop);
g_main_loop_unref(context->loop);
context->loop = NULL;
GList *input_plugin_;
J4statusInputPlugin *input_plugin;
for ( input_plugin_ = context->input_plugins ; input_plugin_ != NULL ; input_plugin_ = g_list_next(input_plugin_) )
{
input_plugin = input_plugin_->data;
input_plugin->interface.uninit(input_plugin->context);
}
if ( context->output_plugin->interface.uninit != NULL )
context->output_plugin->interface.uninit(context->output_plugin->context);
j4status_io_free(context->io);
if ( context->order_weights != NULL )
g_hash_table_unref(context->order_weights);
g_hash_table_unref(context->sections_hash);
end:
#if DEBUG
if ( debug_stream != NULL )
g_object_unref(debug_stream);
#endif /* DEBUG */
return retval;
}
int main(int argc, char *argv[]) {
struct configuration conf= { NULL, NULL, NULL, 0 };
GError *error= NULL;
GOptionContext *context;
g_thread_init(NULL);
init_mutex= g_mutex_new();
context= g_option_context_new("multi-threaded MySQL loader");
GOptionGroup *main_group= g_option_group_new("main", "Main Options", "Main Options", NULL, NULL);
g_option_group_add_entries(main_group, entries);
g_option_group_add_entries(main_group, common_entries);
g_option_context_set_main_group(context, main_group);
if (!g_option_context_parse(context, &argc, &argv, &error)) {
g_print("option parsing failed: %s, try --help\n", error->message);
exit(EXIT_FAILURE);
}
g_option_context_free(context);
if (program_version) {
g_print("myloader %s, built against MySQL %s\n", VERSION, MYSQL_SERVER_VERSION);
exit(EXIT_SUCCESS);
}
set_verbose(verbose);
if (!directory) {
g_critical("a directory needs to be specified, see --help\n");
exit(EXIT_FAILURE);
} else {
char *p= g_strdup_printf("%s/metadata", directory);
if (!g_file_test(p, G_FILE_TEST_EXISTS)) {
g_critical("the specified directory is not a mydumper backup\n");
exit(EXIT_FAILURE);
}
}
MYSQL *conn;
conn= mysql_init(NULL);
mysql_options(conn, MYSQL_READ_DEFAULT_GROUP, "myloader");
if (!mysql_real_connect(conn, hostname, username, password, NULL, port, socket_path, 0)) {
g_critical("Error connection to database: %s", mysql_error(conn));
exit(EXIT_FAILURE);
}
if (!enable_binlog)
mysql_query(conn, "SET SQL_LOG_BIN=0");
mysql_query(conn, "/*!40014 SET FOREIGN_KEY_CHECKS=0*/");
conf.queue= g_async_queue_new();
conf.ready= g_async_queue_new();
guint n;
GThread **threads= g_new(GThread*, num_threads);
struct thread_data *td= g_new(struct thread_data, num_threads);
for (n= 0; n < num_threads; n++) {
td[n].conf= &conf;
td[n].thread_id= n+1;
threads[n]= g_thread_create((GThreadFunc)process_queue, &td[n], TRUE, NULL);
g_async_queue_pop(conf.ready);
}
g_async_queue_unref(conf.ready);
g_message("%d threads created", num_threads);
restore_databases(&conf, conn);
for (n= 0; n < num_threads; n++) {
struct job *j= g_new0(struct job, 1);
j->type = JOB_SHUTDOWN;
g_async_queue_push(conf.queue, j);
}
for (n= 0; n < num_threads; n++) {
g_thread_join(threads[n]);
}
g_async_queue_unref(conf.queue);
mysql_close(conn);
mysql_thread_end();
mysql_library_end();
g_free(directory);
g_free(td);
g_free(threads);
return errors ? EXIT_FAILURE : EXIT_SUCCESS;
}
int
main( int argc, char **argv )
{
GOptionContext *context;
GOptionGroup *main_group;
GError *error = NULL;
int i;
int result;
if( VIPS_INIT( argv[0] ) )
vips_error_exit( "unable to start VIPS" );
textdomain( GETTEXT_PACKAGE );
setlocale( LC_ALL, "" );
context = g_option_context_new( _( "- thumbnail generator" ) );
main_group = g_option_group_new( NULL, NULL, NULL, NULL, NULL );
g_option_group_add_entries( main_group, options );
vips_add_option_entries( main_group );
g_option_group_set_translation_domain( main_group, GETTEXT_PACKAGE );
g_option_context_set_main_group( context, main_group );
if( !g_option_context_parse( context, &argc, &argv, &error ) ) {
if( error ) {
fprintf( stderr, "%s\n", error->message );
g_error_free( error );
}
vips_error_exit( "try \"%s --help\"", g_get_prgname() );
}
g_option_context_free( context );
if( sscanf( thumbnail_size, "%d x %d",
&thumbnail_width, &thumbnail_height ) != 2 ) {
if( sscanf( thumbnail_size, "%d", &thumbnail_width ) != 1 )
vips_error_exit( "unable to parse size \"%s\" -- "
"use eg. 128 or 200x300", thumbnail_size );
thumbnail_height = thumbnail_width;
}
if( rotate_image ) {
#ifndef HAVE_EXIF
vips_warn( "vipsthumbnail", "%s",
_( "auto-rotate disabled: "
"libvips built without exif support" ) );
#endif /*!HAVE_EXIF*/
}
result = 0;
for( i = 1; i < argc; i++ ) {
/* Hang resources for processing this thumbnail off @process.
*/
VipsObject *process = VIPS_OBJECT( vips_image_new() );
if( thumbnail_process( process, argv[i] ) ) {
fprintf( stderr, "%s: unable to thumbnail %s\n",
argv[0], argv[i] );
fprintf( stderr, "%s", vips_error_buffer() );
vips_error_clear();
/* We had a conversion failure: return an error code
* when we finally exit.
*/
result = -1;
}
g_object_unref( process );
}
vips_shutdown();
return( result );
}
