diff --git a/userspace/engine/falco_utils.cpp b/userspace/engine/falco_utils.cpp index ac9b6972..01e56ec3 100644 --- a/userspace/engine/falco_utils.cpp +++ b/userspace/engine/falco_utils.cpp @@ -25,15 +25,10 @@ limitations under the License. #include -// these follow the POSIX standard -#define RGX_PROMETHEUS_TIME_DURATION_PATTERN "([0-9]+[a-z]+)" -#define RGX_PROMETHEUS_NUMBER_PATTERN "([0-9]+)" -#define RGX_PROMETHEUS_UNIT_PATTERN "([a-z]+)" +#define RGX_PROMETHEUS_TIME_DURATION "^((?P[0-9]+)y)?((?P[0-9]+)w)?((?P[0-9]+)d)?((?P[0-9]+)h)?((?P[0-9]+)m)?((?P[0-9]+)s)?((?P[0-9]+)ms)?$" -// using pre-compiled regex for better performance -static re2::RE2 s_rgx_prometheus_time_duration(RGX_PROMETHEUS_TIME_DURATION_PATTERN, re2::RE2::POSIX); -static re2::RE2 s_rgx_prometheus_number(RGX_PROMETHEUS_NUMBER_PATTERN, re2::RE2::POSIX); -static re2::RE2 s_rgx_prometheus_unit(RGX_PROMETHEUS_UNIT_PATTERN, re2::RE2::POSIX); +// using pre-compiled regex +static re2::RE2 s_rgx_prometheus_time_duration(RGX_PROMETHEUS_TIME_DURATION); // Prometheus time durations: https://prometheus.io/docs/prometheus/latest/querying/basics/#time-durations #define PROMETHEUS_UNIT_Y "y" ///> assuming a year has always 365d @@ -45,12 +40,13 @@ static re2::RE2 s_rgx_prometheus_unit(RGX_PROMETHEUS_UNIT_PATTERN, re2::RE2::POS #define PROMETHEUS_UNIT_MS "ms" ///> millisecond // standard time unit conversions to milliseconds -#define SECOND_TO_MS 1000 -#define MINUTE_TO_MS SECOND_TO_MS * 60 -#define HOUR_TO_MS MINUTE_TO_MS * 60 -#define DAY_TO_MS HOUR_TO_MS * 24 -#define WEEK_TO_MS DAY_TO_MS * 7 -#define YEAR_TO_MS DAY_TO_MS * 365 +#define ONE_MS_TO_MS 1UL +#define ONE_SECOND_TO_MS 1000UL +#define ONE_MINUTE_TO_MS ONE_SECOND_TO_MS * 60UL +#define ONE_HOUR_TO_MS ONE_MINUTE_TO_MS * 60UL +#define ONE_DAY_TO_MS ONE_HOUR_TO_MS * 24UL +#define ONE_WEEK_TO_MS ONE_DAY_TO_MS * 7UL +#define ONE_YEAR_TO_MS ONE_DAY_TO_MS * 365UL namespace falco { @@ -60,84 +56,74 @@ namespace utils uint64_t parse_prometheus_interval(std::string interval_str) { - uint64_t interval = 0; - /* Sanitize user input, remove possible whitespaces. */ - interval_str.erase(remove_if(interval_str.begin(), interval_str.end(), isspace), interval_str.end()); + uint64_t interval = 0; + /* Sanitize user input, remove possible whitespaces. */ + interval_str.erase(remove_if(interval_str.begin(), interval_str.end(), isspace), interval_str.end()); - if(!interval_str.empty()) + if(!interval_str.empty()) { - /* Option 1: Passing interval directly in ms. Will be deprecated in the future. */ - if(std::all_of(interval_str.begin(), interval_str.end(), ::isdigit)) - { - /* todo: deprecate for Falco 0.36. */ - interval = std::stoull(interval_str, nullptr, 0); - } - /* Option 2: Passing a Prometheus time duration. - * https://prometheus.io/docs/prometheus/latest/querying/basics/#time-durations - */ - else - { - re2::StringPiece input(interval_str); - std::string r; - std::string cur_interval_str; - uint64_t cur_interval; - std::string cur_unit; - bool valid = true; - /* Note that parsing is done at start up only. */ - while(re2::RE2::FindAndConsume(&input, s_rgx_prometheus_time_duration, &r)) - { - RE2::Extract(r, s_rgx_prometheus_number, "\\1", &cur_interval_str); - cur_interval = std::stoull(cur_interval_str, nullptr, 0); - if(cur_interval > 0) - { - RE2::Extract(r, s_rgx_prometheus_unit, "\\1", &cur_unit); - if(cur_unit == PROMETHEUS_UNIT_MS) - { - interval += cur_interval; - } - else if(cur_unit == PROMETHEUS_UNIT_S) - { - interval += cur_interval * SECOND_TO_MS; - } - else if(cur_unit == PROMETHEUS_UNIT_M) - { - interval += cur_interval * MINUTE_TO_MS; - } - else if(cur_unit == PROMETHEUS_UNIT_H) - { - interval += cur_interval * HOUR_TO_MS; - } - else if(cur_unit == PROMETHEUS_UNIT_D) - { - interval += cur_interval * DAY_TO_MS; - } - else if(cur_unit == PROMETHEUS_UNIT_W) - { - interval += cur_interval * WEEK_TO_MS; - } - else if(cur_unit == PROMETHEUS_UNIT_Y) - { - interval += cur_interval * YEAR_TO_MS; - } - else - { - valid = false; - } - } - else - { - valid = false; - } - } - if (!valid) - { - // invalidate if any invalid unit or no corresponding numeric value was found - interval = 0; - } - } - } + /* Option 1: Passing interval directly in ms. Will be deprecated in the future. */ + if(std::all_of(interval_str.begin(), interval_str.end(), ::isdigit)) + { + /* todo: deprecate for Falco 0.36. */ + interval = std::stoull(interval_str, nullptr, 0); + } + /* Option 2: Passing a Prometheus compliant time duration. + * https://prometheus.io/docs/prometheus/latest/querying/basics/#time-durations + */ + else + { + re2::StringPiece input(interval_str); + std::string args[14]; + re2::RE2::Arg arg0(&args[0]); + re2::RE2::Arg arg1(&args[1]); + re2::RE2::Arg arg2(&args[2]); + re2::RE2::Arg arg3(&args[3]); + re2::RE2::Arg arg4(&args[4]); + re2::RE2::Arg arg5(&args[5]); + re2::RE2::Arg arg6(&args[6]); + re2::RE2::Arg arg7(&args[7]); + re2::RE2::Arg arg8(&args[8]); + re2::RE2::Arg arg9(&args[9]); + re2::RE2::Arg arg10(&args[10]); + re2::RE2::Arg arg11(&args[11]); + re2::RE2::Arg arg12(&args[12]); + re2::RE2::Arg arg13(&args[13]); + const re2::RE2::Arg* const matches[14] = {&arg0, &arg1, &arg2, &arg3, &arg4, &arg5, &arg6, &arg7, &arg8, &arg9, &arg10, &arg11, &arg12, &arg13}; - return interval; + const std::map& named_groups = s_rgx_prometheus_time_duration.NamedCapturingGroups(); + int num_groups = s_rgx_prometheus_time_duration.NumberOfCapturingGroups(); + re2::RE2::FullMatchN(input, s_rgx_prometheus_time_duration, matches, num_groups); + + static const char* all_prometheus_units[7] = { + PROMETHEUS_UNIT_Y, PROMETHEUS_UNIT_W, PROMETHEUS_UNIT_D, PROMETHEUS_UNIT_H, + PROMETHEUS_UNIT_M, PROMETHEUS_UNIT_S, PROMETHEUS_UNIT_MS }; + + static const uint64_t all_prometheus_time_conversions[7] = { + ONE_YEAR_TO_MS, ONE_WEEK_TO_MS, ONE_DAY_TO_MS, ONE_HOUR_TO_MS, + ONE_MINUTE_TO_MS, ONE_SECOND_TO_MS, ONE_MS_TO_MS }; + + for(size_t i = 0; i < sizeof(all_prometheus_units) / sizeof(const char*); i++) + { + std::string cur_interval_str; + uint64_t cur_interval = 0; + const auto &group_it = named_groups.find(all_prometheus_units[i]); + if(group_it != named_groups.end()) + { + cur_interval_str = args[group_it->second - 1]; + if(!cur_interval_str.empty()) + { + cur_interval = std::stoull(cur_interval_str, nullptr, 0); + } + if(cur_interval > 0) + { + interval += cur_interval * all_prometheus_time_conversions[i]; + } + } + } + } + } + return interval; } std::string wrap_text(const std::string& in, uint32_t indent, uint32_t line_len)