void scaling_t::create_options()
{
sim->add_option(opt_bool("calculate_scale_factors", calculate_scale_factors));
sim->add_option(opt_func("normalize_scale_factors", parse_normalize_scale_factors));
sim->add_option(opt_bool("debug_scale_factors", debug_scale_factors));
sim->add_option(opt_bool("center_scale_delta", center_scale_delta));
sim->add_option(opt_float("scale_delta_multiplier", scale_delta_multiplier)); // multiplies all default scale deltas
sim->add_option(opt_bool("positive_scale_delta", positive_scale_delta));
sim->add_option(opt_bool("scale_lag", scale_lag));
sim->add_option(opt_float("scale_factor_noise", scale_factor_noise));
sim->add_option(opt_float("scale_strength", stats.attribute[ATTR_STRENGTH]));
sim->add_option(opt_float("scale_agility", stats.attribute[ATTR_AGILITY]));
sim->add_option(opt_float("scale_stamina", stats.attribute[ATTR_STAMINA]));
sim->add_option(opt_float("scale_intellect", stats.attribute[ATTR_INTELLECT]));
sim->add_option(opt_float("scale_spirit", stats.attribute[ATTR_SPIRIT]));
sim->add_option(opt_float("scale_spell_power", stats.spell_power));
sim->add_option(opt_float("scale_attack_power", stats.attack_power));
sim->add_option(opt_float("scale_crit_rating", stats.crit_rating));
sim->add_option(opt_float("scale_haste_rating", stats.haste_rating));
sim->add_option(opt_float("scale_mastery_rating", stats.mastery_rating));
sim->add_option(opt_float("scale_multistrike_rating", stats.multistrike_rating));
sim->add_option(opt_float("scale_readiness_rating", stats.readiness_rating));
sim->add_option(opt_float("scale_versatility_rating", stats.versatility_rating));
sim->add_option(opt_float("scale_weapon_dps", stats.weapon_dps));
sim->add_option(opt_float("scale_offhand_weapon_dps", stats.weapon_offhand_dps));
sim->add_option(opt_string("scale_only", scale_only_str));
sim->add_option(opt_string("scale_over", scale_over));
sim->add_option(opt_string("scale_over_player", scale_over_player));
}
void reforge_plot_t::create_options()
{
sim->add_option(opt_int("reforge_plot_iterations", reforge_plot_iterations));
sim->add_option(opt_float("reforge_plot_target_error", reforge_plot_target_error));
sim->add_option(opt_int("reforge_plot_step", reforge_plot_step));
sim->add_option(opt_int("reforge_plot_amount", reforge_plot_amount));
sim->add_option(opt_string("reforge_plot_stat", reforge_plot_stat_str));
sim->add_option(opt_bool("reforge_plot_debug", reforge_plot_debug));
}
void scaling_t::create_options()
{
option_t scaling_options[] =
{
// @option_doc loc=global/scale_factors title="Scale Factors"
opt_bool( "calculate_scale_factors", calculate_scale_factors ),
opt_func( "normalize_scale_factors", parse_normalize_scale_factors ),
opt_bool( "debug_scale_factors", debug_scale_factors ),
opt_bool( "center_scale_delta", center_scale_delta ),
opt_float( "scale_delta_multiplier", scale_delta_multiplier ), // multiplies all default scale deltas
opt_bool( "positive_scale_delta", positive_scale_delta ),
opt_bool( "scale_lag", scale_lag ),
opt_float( "scale_factor_noise", scale_factor_noise ),
opt_float( "scale_strength", stats.attribute[ ATTR_STRENGTH ] ),
opt_float( "scale_agility", stats.attribute[ ATTR_AGILITY ] ),
opt_float( "scale_stamina", stats.attribute[ ATTR_STAMINA ] ),
opt_float( "scale_intellect", stats.attribute[ ATTR_INTELLECT ] ),
opt_float( "scale_spirit", stats.attribute[ ATTR_SPIRIT ] ),
opt_float( "scale_spell_power", stats.spell_power ),
opt_float( "scale_attack_power", stats.attack_power ),
opt_float( "scale_expertise_rating", stats.expertise_rating ),
opt_float( "scale_hit_rating", stats.hit_rating ),
opt_float( "scale_crit_rating", stats.crit_rating ),
opt_float( "scale_haste_rating", stats.haste_rating ),
opt_float( "scale_mastery_rating", stats.mastery_rating ),
opt_float( "scale_dodge_rating", stats.dodge_rating ),
opt_float( "scale_parry_rating", stats.parry_rating ),
opt_float( "scale_weapon_dps", stats.weapon_dps ),
opt_float( "scale_weapon_speed", stats.weapon_speed ),
opt_float( "scale_offhand_weapon_dps", stats.weapon_offhand_dps ),
opt_float( "scale_offhand_weapon_speed", stats.weapon_offhand_speed ),
opt_string( "scale_only", scale_only_str ),
opt_string( "scale_over", scale_over ),
opt_string( "scale_over_player", scale_over_player ),
opt_null()
};
option_t::copy( sim -> options, scaling_options );
}
/**
* Add hidden options for those supplied by the app modes that are not
* the calling app.
*
* For example, add the opts for gtdownload and gtupload if the caller
* was gtserver.
*
* It's possible for the app to be none of gtserver, gtupload or
* gtdownload.
*
* This allows the options to appear in the config file
* without generating an error about them being unknown.
*
* @param app The mode of the app calling this: 'S', 'D', or 'U'
*/
void
gtBaseOpts::add_options_hidden (const char app)
{
boost::program_options::options_description hidden_desc;
if (app != 'D')
{
hidden_desc.add_options ()
(OPT_MAX_CHILDREN, opt_string(), "hidden, ignored")
;
}
if (app != 'S')
{
hidden_desc.add_options ()
(OPT_SERVER, opt_string(), "hidden, ignored")
(OPT_QUEUE, opt_string(), "hidden, ignored")
;
}
add_desc (hidden_desc, NOT_VISIBLE);
}
void plot_t::create_options()
{
option_t plot_options[] =
{
// @option_doc loc=global/scale_factors title="Plots"
opt_int( "dps_plot_iterations", dps_plot_iterations ),
opt_int( "dps_plot_points", dps_plot_points ),
opt_string( "dps_plot_stat", dps_plot_stat_str ),
opt_float( "dps_plot_step", dps_plot_step ),
opt_bool( "dps_plot_debug", dps_plot_debug ),
opt_bool( "dps_plot_positive", dps_plot_positive ),
opt_bool( "dps_plot_negative", dps_plot_negative ),
opt_null()
};
option_t::copy( sim -> options, plot_options );
}
sequence_t::sequence_t( player_t* p, const std::string& sub_action_str ) :
action_t( ACTION_SEQUENCE, "default", p ),
waiting( false ), sequence_wait_on_ready( -1 ),
current_action( -1 ), restarted( false ), last_restart( timespan_t::min() )
{
trigger_gcd = timespan_t::zero();
std::vector<std::string> splits = util::string_split( sub_action_str, ":" );
if ( ! splits.empty() )
{
option_t options[] =
{
opt_string( "name", name_str ),
opt_null()
};
parse_options( options, splits[ 0 ] );
}
// First token is sequence options, so skip
for ( size_t i = 1; i < splits.size(); ++i )
{
std::string::size_type cut_pt = splits[ i ].find( ',' );
std::string action_name( splits[ i ], 0, cut_pt );
std::string action_options;
if ( cut_pt != std::string::npos )
action_options.assign( splits[ i ], cut_pt + 1, std::string::npos );
action_t* a = p -> create_action( action_name, action_options );
if ( ! a )
{
sim -> errorf( "Player %s has unknown sequence action: %s\n", p -> name(), splits[ i ].c_str() );
sim -> cancel();
continue;
}
a -> sequence = true;
sub_actions.push_back( a );
}
sequence_wait_on_ready = wait_on_ready;
wait_on_ready = -1;
}
/** ***************************************************************************
* Process command line arguments and set corresponding globals.
* Shows usage and exits if errors are detected in argument usage.
*
*/
static int process_args(int argc, char * argv[])
{
char * options[COUNT_OPTIONS];
uint64_t user_ram_limit = 0;
#ifdef USE_FIEMAP
using_fiemap = 1;
#endif
int rv = optgen_parse(argc, argv, &operation, options);
if (options[OPT_help]) {
show_help();
return 1;
}
if (rv == OPTGEN_NONE) {
show_banner();
printf("\n");
printf("Run 'dupd help' for a summary of available options.\n");
printf("Run 'dupd usage' for more documentation.\n");
return 1;
}
if (rv != OPTGEN_OK) { // LCOV_EXCL_START
printf("error parsing command line arguments\n");
return 2;
} // LCOV_EXCL_STOP
if (options[OPT_x_small_buffers]) { x_small_buffers = 1; }
if (options[OPT_x_testing]) { only_testing = 1; }
if (options[OPT_quiet]) { log_level = -99; }
log_level = opt_int(options[OPT_verbose_level], log_level);
log_level += opt_count(options[OPT_verbose]);
if (log_level > L_MAX_LOG_LEVEL) { log_level = L_MAX_LOG_LEVEL; }
if (options[OPT_log_only]) { log_only = 1; }
if (start_path_state == START_PATH_NULL) {
start_path[0] = (char *)malloc(DUPD_PATH_MAX);
getcwd(start_path[0], DUPD_PATH_MAX);
start_path_count = 1;
LOG(L_INFO, "Defaulting --path to [%s]\n", start_path[0]);
}
if (options[OPT_file] != NULL) {
file_path = options[OPT_file];
// file path can be relative, normalize in that case
if (file_path[0] != '/') {
file_path = (char *)malloc(DUPD_PATH_MAX);
free_file_path = 1;
getcwd(file_path, DUPD_PATH_MAX);
strcat(file_path, "/");
strcat(file_path, options[OPT_file]);
}
}
db_path = options[OPT_db];
if (db_path == NULL) {
db_path = (char *)malloc(DUPD_PATH_MAX);
free_db_path = 1;
snprintf(db_path, DUPD_PATH_MAX, "%s/.dupd_sqlite", getenv("HOME"));
}
cache_db_path = options[OPT_cache];
if (cache_db_path == NULL) {
cache_db_path = (char *)malloc(DUPD_PATH_MAX);
free_cache_db_path = 1;
snprintf(cache_db_path, DUPD_PATH_MAX, "%s/.dupd_cache", getenv("HOME"));
}
if (options[OPT_link]) { rmsh_link = RMSH_LINK_SOFT; }
if (options[OPT_hardlink]) { rmsh_link = RMSH_LINK_HARD; }
if (options[OPT_hidden]) { scan_hidden = 1; }
if (options[OPT_no_thread_scan]) { threaded_sizetree = 0; }
if (options[OPT_hardlink_is_unique]) { hardlink_is_unique = 1; }
if (options[OPT_one_file_system]) { one_file_system = 1; }
if (options[OPT_x_no_cache]) { use_hash_cache = 0; }
cache_min_size =
(uint64_t)opt_int(options[OPT_x_cache_min_size], cache_min_size);
hash_one_block_size = opt_int(options[OPT_firstblocksize],
hash_one_block_size);
hash_block_size = opt_int(options[OPT_blocksize], hash_block_size);
filecmp_block_size = opt_int(options[OPT_fileblocksize], filecmp_block_size);
hash_one_max_blocks = opt_int(options[OPT_firstblocks], hash_one_max_blocks);
cut_path = options[OPT_cut];
exclude_path = options[OPT_exclude_path];
if (exclude_path != NULL && exclude_path[0] != '/') {
printf("error: --exclude-path must be absolute\n");
return 2;
}
stats_file = options[OPT_stats_file];
minimum_file_size = opt_int(options[OPT_minsize], minimum_file_size);
if (minimum_file_size < 1) { minimum_file_size = 1; }
path_sep_string = (char *)malloc(2);
path_sep_string[0] = (char)path_separator;
path_sep_string[1] = 0;
char * hash_name = opt_string(options[OPT_hash], "xxhash");
if (!strcmp("md5", hash_name)) {
hash_function = HASH_FN_MD5;
} else if (!strcmp("sha1", hash_name)) {
hash_function = HASH_FN_SHA1;
} else if (!strcmp("sha512", hash_name)) {
hash_function = HASH_FN_SHA512;
} else if (!strcmp("xxhash", hash_name)) {
hash_function = HASH_FN_XXHASH;
} else {
printf("error: unknown hash %s\n", hash_name);
return 2;
}
hash_bufsize = hash_get_bufsize(hash_function);
char * report_format_name = opt_string(options[OPT_format], "text");
if (!strcmp("text", report_format_name)) {
report_format = REPORT_FORMAT_TEXT;
} else if (!strcmp("csv", report_format_name)) {
report_format = REPORT_FORMAT_CSV;
} else if (!strcmp("json", report_format_name)) {
report_format = REPORT_FORMAT_JSON;
} else {
printf("error: unknown report format %s\n", report_format_name);
return 2;
}
char * buflimstr = opt_string(options[OPT_buflimit], "0");
if (strcmp("0", buflimstr)) {
int len = strlen(buflimstr);
if (buflimstr[len-1] == 'M') {
user_ram_limit = MB1;
buflimstr[len-1] = 0;
} else if (buflimstr[len-1] == 'G') {
user_ram_limit = GB1;
buflimstr[len-1] = 0;
} else {
user_ram_limit = 1;
}
long c = atol(buflimstr);
user_ram_limit *= c;
if (user_ram_limit < MB8) {
user_ram_limit = MB8;
}
}
if (options[OPT_cmp_two]) {
opt_compare_two = 1;
}
if (hash_one_block_size == 0) {
hash_one_block_size = DEF_HDD_hash_one_block_size;
}
round1_max_bytes = hash_one_block_size * hash_one_max_blocks;
// If user hasn't provided a cache_min_size, do something reasonable
if (cache_min_size == 0) {
if (round1_max_bytes < K512) {
cache_min_size = K512;
} else {
cache_min_size = round1_max_bytes;
}
}
char * sortby = opt_string(options[OPT_sort_by], "def");
if (!strcmp("inode", sortby)) {
sort_bypass = SORT_BY_INODE;
} else if (!strcmp("block", sortby)) {
sort_bypass = SORT_BY_BLOCK;
} else if (!strcmp("none", sortby)) {
sort_bypass = SORT_BY_NONE;
}
if (sort_bypass != 0) {
LOG(L_INFO, "Sort bypass set to %s\n", sortby);
if (hardlink_is_unique) {
printf("Don't do that..\n");
return 2;
}
}
if (sort_bypass != 0 && sort_bypass != SORT_BY_BLOCK) {
using_fiemap = 0;
}
if (options[OPT_x_nofie]) { using_fiemap = 0; }
LOG(L_INFO, "Will be using_fiemap (if available): %d\n", using_fiemap);
uint64_t ram = total_ram();
if (user_ram_limit > 0) {
if (user_ram_limit > ram) {
buffer_limit = 0.9 * ram;
} else {
buffer_limit = user_ram_limit;
}
}
if (buffer_limit == 0) {
buffer_limit = 0.5 * ram;
if (x_small_buffers) {
buffer_limit = MB1;
}
}
int ramm = ram / (1024 * 1024);
int blim = buffer_limit / (1024 * 1024);
LOG(L_INFO, "Reported RAM: %dMB buffer limit: %dMB\n", ramm, blim);
return 0;
}
void
gtBaseOpts::add_options ()
{
m_base_desc.add_options ()
(OPT_BIND_IP ",b", opt_string(), "Bind IP.")
(OPT_CRED_FILE ",c", opt_string(), "Path/file to credentials file.")
(OPT_CFG_DIR_DEPRECATED ",C", opt_string(), "Deprecated use " OPT_RESOURCE_DIR ".")
(OPT_RESOURCE_DIR ",R", opt_string(), "Full path to a directory containing static resource files (dhparam.pem).")
(OPT_ADVERT_IP ",e", opt_string(), "IP Address advertised.")
(OPT_ADVERT_PORT ",f", opt_int(), "TCP Port advertised.")
(OPT_INTERNAL_PORT ",i", opt_string(), "Local IP port to bind on.")
(OPT_LOGGING ",l", opt_string(), "Path/file to log file, follow"
" by the log level.")
(OPT_RATE_LIMIT ",r", opt_float(), "Transfer rate limiter in MB/s.")
(OPT_TIMESTAMP ",t", "Add timestamps to messages"
" logged to the screen.")
(OPT_VERBOSE, opt_int(), "Set on screen verbosity level.")
(OPT_INACTIVE_TIMEOUT ",k", opt_int(), "Timeout transfers after"
" inactivity in minutes.")
(OPT_CURL_NO_VERIFY_SSL, "Do not verify SSL certificates"
" of web services.")
(OPT_PEER_TIMEOUT, opt_int(), "Set libtorrent peer timeout in seconds.")
(OPT_NO_USER_CFG_FILE, "Do not allow users to specify a config file.")
(OPT_ALLOWED_MODES, opt_string(), "Allowed modes in this GeneTorrent"
" installation.")
(OPT_ALLOWED_SERVERS, opt_string(), "Allowed IP address ranges for WSI, tracker,"
" and peer traffic.")
;
if (m_use_path_opt)
{
m_base_desc.add_options ()
(OPT_PATH ",p", opt_string(), "File system path used for"
" uploads and downloads.")
;
}
if (m_use_security_api_opt)
{
m_base_desc.add_options ()
(OPT_SECURITY_API, opt_string(), "SSL Key Signing URL")
;
}
add_desc (m_base_desc);
m_cli_desc.add_options ()
(OPT_CFG_FILE, opt_string(), "Path/file to optional config file.")
(OPT_HELP ",h", "Show help and exit.")
(OPT_VERBOSE_INCR ",v", accumulator<int>(&global_verbosity),
"Increase on screen verbosity level.")
(OPT_VERSION, "Show version and exit.")
;
if (m_use_alt_storage_opts)
{
m_cli_desc.add_options ()
(OPT_NULL_STORAGE, "Enable use of null storage.")
(OPT_ZERO_STORAGE, "Enable use of zero storage.")
;
}
add_desc (m_cli_desc, VISIBLE, CLI_ONLY);
}
