hcq/MaxScale
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

MXS-2253 Add MXS_MODULE_PARAM_DURATION

Browse Source 
Added a new module parameter type to be used for parameters
that specify a duration. With the suffixes 'h', 'm', 's' and
'ms' the duration can be specified in hours, minutes, seconds
or milliseconds, respectively.

Irrespective of how the duration is specified, it is always
returned as milliseconds.

For backward compatibility, when a duration value is read it must
be specifed how a value *not* defined using a suffix should be
interpreted; as seconds or milliseconds.

  value = param->get_duration(name, mxs::config::INTERPRET_AS_SECONDS);
This commit is contained in:
Johan Wikman
2019-02-12 11:59:22 +02:00
parent a0d715a39f
commit c116452c25
5 changed files with 203 additions and 9 deletions
Download Patch File Download Diff File Expand all files Collapse all files

123
server/core/config.cc
View File

@ -227,6 +227,8 @@ static pcre2_code* compile_regex_string(const char* regex_string,
bool jit_enabled,
uint32_t options,
uint32_t* output_ovector_size);
static bool duration_is_valid(const char* zValue, mxs::config::DurationUnit* pUnit);
int config_get_ifaddr(unsigned char* output);
static int config_get_release_string(char* release);
@ -1750,6 +1752,17 @@ uint64_t MXS_CONFIG_PARAMETER::get_size(const std::string& key) const
return intval;
}
std::chrono::milliseconds
MXS_CONFIG_PARAMETER::get_duration(const std::string& key,
mxs::config::DurationInterpretation interpretation) const
{
string value = get_string(key);
std::chrono::milliseconds duration { 0 };
MXB_AT_DEBUG(bool rval = ) get_suffixed_duration(value.c_str(), interpretation, &duration);
mxb_assert(rval); // When this function is called, the validity of the value should have been checked.
return duration;
}
int64_t MXS_CONFIG_PARAMETER::get_enum(const std::string& key, const MXS_ENUM_VALUE* enum_mapping) const
{
string param_value = get_string(key);
@ -4322,6 +4335,26 @@ bool config_param_is_valid(const MXS_MODULE_PARAM* params,
}
break;
case MXS_MODULE_PARAM_DURATION:
{
mxs::config::DurationUnit unit;
if (duration_is_valid(value, &unit))
{
valid = true;
if (unit == mxs::config::DURATION_IN_DEFAULT)
{
MXS_WARNING("Specifying durations without a suffix denoting the unit "
"has been deprecated: '%s=%s'. Use the suffixes 'h' (hour), "
"'m' (minute) 's' (second) or 'ms' (milliseconds). "
"For instance, '%s=%ss' or '%s=%sms.",
key, value, key, value, key, value);
}
}
}
break;
case MXS_MODULE_PARAM_BOOL:
if (config_truth_value(value) != -1)
{
@ -4818,6 +4851,96 @@ bool get_suffixed_size(const char* value, uint64_t* dest)
return rval;
}
bool get_suffixed_duration(const char* zValue,
mxs::config::DurationInterpretation interpretation,
std::chrono::milliseconds* pDuration,
mxs::config::DurationUnit* pUnit)
{
if (!isdigit(*zValue))
{
// This will also catch negative values
return false;
}
bool rval = false;
char* zEnd;
uint64_t value = strtoll(zValue, &zEnd, 10);
std::chrono::milliseconds duration;
mxs::config::DurationUnit unit = mxs::config::DURATION_IN_DEFAULT;
switch (*zEnd)
{
case 'H':
case 'h':
unit = mxs::config::DURATION_IN_HOURS;
duration = std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::hours(value));
++zEnd;
break;
case 'M':
case 'm':
if (*(zEnd + 1) == 's' || *(zEnd + 1) == 'S')
{
unit = mxs::config::DURATION_IN_MILLISECONDS;
duration = std::chrono::milliseconds(value);
++zEnd;
}
else
{
unit = mxs::config::DURATION_IN_MINUTES;
duration = std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::minutes(value));
}
++zEnd;
break;
case 'S':
case 's':
unit = mxs::config::DURATION_IN_SECONDS;
duration = std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::seconds(value));
++zEnd;
break;
case 0:
if (interpretation == mxs::config::INTERPRET_AS_SECONDS)
{
duration = std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::seconds(value));
}
else
{
duration = std::chrono::milliseconds(value);
}
break;
default:
break;
};
if (*zEnd == 0)
{
rval = true;
if (pDuration)
{
*pDuration = duration;
}
if (pUnit)
{
*pUnit = unit;
}
}
return rval;
}
static bool duration_is_valid(const char* zValue, mxs::config::DurationUnit* pUnit)
{
// When the validity is checked, it does not matter how the value
// should be interpreted, so any mxs::config::DurationInterpretation is fine.
return get_suffixed_duration(zValue, mxs::config::INTERPRET_AS_SECONDS, nullptr, pUnit);
}
bool config_parse_disk_space_threshold(SERVER::DiskSpaceLimits* pDisk_space_threshold,
const char* zDisk_space_threshold)
{

19
server/core/internal/config.hh
View File

@ -219,6 +219,25 @@ bool is_normal_server_parameter(const char* param);
*/
bool get_suffixed_size(const char* value, uint64_t* dest);
/**
* Converts a string into a duration, intepreting in a case-insensitive manner
* an 'h'-suffix to indicate hours, an 'm'-suffix to indicate minutes, an
* 's'-suffix to indicate seconds and an 'ms'-suffix to indicate milliseconds.
*
* @param zValue A numerical string, possibly suffixed by 'h', 'm',
* 's' or 'ms'.
* @param interpretation How a value lacking a specific suffix should be interpreted.
* @param pDuration Pointer, if non-NULL, where the result is stored.
* @param pUnit Pointer, if non-NULL, where the detected unit is stored.
*
* @return True on success, false on invalid input in which case @c pUnit and
* @c pDuration will not be modified.
*/
bool get_suffixed_duration(const char* zValue,
mxs::config::DurationInterpretation interpretation,
std::chrono::milliseconds* pDuration,
mxs::config::DurationUnit* pUnit = nullptr);
// Dump a parameter list into a file as `key=value` pairs
void dump_param_list(int file,
MXS_CONFIG_PARAMETER* list,

29
server/core/test/test_config.cc
View File

@ -35,14 +35,15 @@ int test_validity()
MXS_MODULE_PARAM params[] =
{
{"p1", MXS_MODULE_PARAM_INT, "-123" },
{"p2", MXS_MODULE_PARAM_COUNT, "123" },
{"p3", MXS_MODULE_PARAM_BOOL, "true" },
{"p4", MXS_MODULE_PARAM_STRING, "default" },
{"p5", MXS_MODULE_PARAM_ENUM, "a", MXS_MODULE_OPT_NONE, enum_values},
{"p6", MXS_MODULE_PARAM_PATH, "/tmp", MXS_MODULE_OPT_PATH_F_OK},
{"p7", MXS_MODULE_PARAM_SERVICE, "my-service" },
{"p8", MXS_MODULE_PARAM_ENUM, "a", MXS_MODULE_OPT_ENUM_UNIQUE, enum_values},
{"p1", MXS_MODULE_PARAM_INT, "-123" },
{"p2", MXS_MODULE_PARAM_COUNT, "123" },
{"p3", MXS_MODULE_PARAM_BOOL, "true" },
{"p4", MXS_MODULE_PARAM_STRING, "default" },
{"p5", MXS_MODULE_PARAM_ENUM, "a", MXS_MODULE_OPT_NONE, enum_values},
{"p6", MXS_MODULE_PARAM_PATH, "/tmp", MXS_MODULE_OPT_PATH_F_OK},
{"p7", MXS_MODULE_PARAM_SERVICE, "my-service" },
{"p8", MXS_MODULE_PARAM_ENUM, "a", MXS_MODULE_OPT_ENUM_UNIQUE, enum_values},
{"p9", MXS_MODULE_PARAM_DURATION, "4711s" },
{MXS_END_MODULE_PARAMS}
};
@ -96,6 +97,18 @@ int test_validity()
TEST(config_param_is_valid(params, "p6", "/tmp", &ctx));
TEST(!config_param_is_valid(params, "p6", "This is not a valid path", &ctx));
/** Duration parameter */
TEST(config_param_is_valid(params, "p9", "4711", &ctx));
TEST(config_param_is_valid(params, "p9", "4711h", &ctx));
TEST(config_param_is_valid(params, "p9", "4711m", &ctx));
TEST(config_param_is_valid(params, "p9", "4711s", &ctx));
TEST(config_param_is_valid(params, "p9", "4711ms", &ctx));
TEST(config_param_is_valid(params, "p9", "4711H", &ctx));
TEST(config_param_is_valid(params, "p9", "4711M", &ctx));
TEST(config_param_is_valid(params, "p9", "4711S", &ctx));
TEST(config_param_is_valid(params, "p9", "4711MS", &ctx));
TEST(!config_param_is_valid(params, "p9", "4711q", &ctx));
/** Service parameter */
CONFIG_CONTEXT svc = {};
svc.object = (char*)"test-service";