gfwleak/tango-maat
Archived
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

[FEATURE]support xx_plugin statistics(new API maat_register_thread)

Browse Source
This commit is contained in:
liuwentan
2023-10-13 17:55:51 +08:00
parent 93bfab81e8
commit 48af7e7aac
17 changed files with 800 additions and 259 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
include/maat.h
View File

@@ -160,6 +160,12 @@ int maat_options_set_hit_group_enabled(struct maat_options *opts);
struct maat *maat_new(struct maat_options *opts, const char *table_info_path);
void maat_free(struct maat *instance);
/**
* Each thread can call this function initially, maat will maintain the thread_id internally,
* So it's no need to pass thread_id by maat_scan_xx and xx_plugin_get_ex_data API
*/
void maat_register_thread(struct maat *instance);
/* maat helper API */
int maat_helper_read_column(const char *table_line, int Nth_column,
size_t *column_offset, size_t *column_len);

4
src/inc_internal/maat_bool_plugin.h
View File

@@ -57,6 +57,10 @@ int bool_plugin_runtime_get_ex_data(void *bool_plugin_runtime, unsigned long lon
long long bool_plugin_runtime_update_err_count(void *bool_plugin_runtime);
void bool_plugin_runtime_scan_inc(void *bool_plugin_runtime, int thread_id);
long long bool_plugin_runtime_scan_count(void *bool_plugin_runtime);
#ifdef __cplusplus
}
#endif

4
src/inc_internal/maat_fqdn_plugin.h
View File

@@ -61,6 +61,10 @@ void fqdn_rule_free(struct FQDN_rule *fqdn_rule);
long long fqdn_plugin_runtime_update_err_count(void *fqdn_plugin_runtime);
void fqdn_plugin_runtime_scan_inc(void *fqdn_plugin_runtime, int thread_id);
long long fqdn_plugin_runtime_scan_count(void *fqdn_plugin_runtime);
#ifdef __cplusplus
}
#endif

4
src/inc_internal/maat_ip_plugin.h
View File

@@ -57,6 +57,10 @@ int ip_plugin_runtime_get_ex_data(void *ip_plugin_runtime, const struct ip_addr
long long ip_plugin_runtime_update_err_count(void *ip_plugin_runtime);
void ip_plugin_runtime_scan_inc(void *ip_plugin_rt, int thread_id);
long long ip_plugin_runtime_scan_count(void *ip_plugin_runtime);
#ifdef __cplusplus
}
#endif

4
src/inc_internal/maat_ipport_plugin.h
View File

@@ -59,6 +59,10 @@ int ipport_plugin_runtime_get_ex_data(void *ipport_plugin_runtime, const struct
long long ipport_plugin_runtime_update_err_count(void *ipport_plugin_runtime);
void ipport_plugin_runtime_scan_inc(void *ipport_plugin_rt, int thread_id);
long long ipport_plugin_runtime_scan_count(void *ipport_plugin_runtime);
#ifdef __cplusplus
}
#endif

4
src/inc_internal/maat_plugin.h
View File

@@ -73,6 +73,10 @@ const char *plugin_runtime_cached_row_get(void *plugin_runtime, size_t index);
void *plugin_runtime_get_ex_data(void *plugin_runtime, void *plugin_schema,
const char *key, size_t key_len);
void plugin_runtime_scan_inc(void *plugin_runtime, int thread_id);
long long plugin_runtime_scan_count(void *plugin_runtime);
#ifdef __cplusplus
}
#endif

1
src/inc_internal/maat_rule.h
View File

@@ -179,6 +179,7 @@ struct maat {
long long new_version;
int is_running;
int thread_counter;
pthread_t cfg_mon_thread;
pthread_mutex_t background_update_mutex;

62
src/maat_api.c
View File

@@ -436,6 +436,25 @@ void maat_free(struct maat *maat_inst)
pthread_join(maat_inst->cfg_mon_thread, &ret);
}
__thread int _thread_local_tid = -1;
void maat_register_thread(struct maat *maat_inst)
{
int thread_id = __sync_fetch_and_add(&maat_inst->thread_counter, 1);
assert(thread_id < maat_inst->opts.nr_worker_thread);
_thread_local_tid = thread_id;
}
static int _get_tid(struct maat *maat_inst)
{
if (_thread_local_tid < 0 ||
_thread_local_tid >= maat_inst->opts.nr_worker_thread) {
return -1;
}
return _thread_local_tid;
}
int maat_helper_read_column(const char *table_line, int Nth_column,
size_t *column_offset, size_t *column_len)
{
@@ -870,6 +889,11 @@ void *maat_plugin_table_get_ex_data(struct maat *maat_inst, int table_id,
return NULL;
}
int thread_id = _get_tid(maat_inst);
if (thread_id >= 0 && thread_id < maat_inst->opts.nr_worker_thread) {
plugin_runtime_scan_inc(runtime, thread_id);
}
void *ret = NULL;
enum table_type table_type = table_manager_get_table_type(maat_inst->tbl_mgr,
table_id);
@@ -901,13 +925,12 @@ int maat_ip_plugin_table_get_ex_data(struct maat *maat_inst, int table_id,
return -1;
}
int n_ex_data = ip_plugin_runtime_get_ex_data(ip_plugin_rt, ip_addr,
ex_data_array, array_size);
if (n_ex_data < 0) {
return -1;
int thread_id = _get_tid(maat_inst);
if (thread_id >= 0 && thread_id < maat_inst->opts.nr_worker_thread) {
ip_plugin_runtime_scan_inc(ip_plugin_rt, thread_id);
}
return n_ex_data;
return ip_plugin_runtime_get_ex_data(ip_plugin_rt, ip_addr, ex_data_array, array_size);
}
int maat_ipport_plugin_table_get_ex_data(struct maat *maat_inst, int table_id,
@@ -929,13 +952,13 @@ int maat_ipport_plugin_table_get_ex_data(struct maat *maat_inst, int table_id,
return -1;
}
int n_ex_data = ipport_plugin_runtime_get_ex_data(ipport_plugin_rt, ip_addr, port,
ex_data_array, array_size);
if (n_ex_data < 0) {
return -1;
int thread_id = _get_tid(maat_inst);
if (thread_id >= 0 && thread_id < maat_inst->opts.nr_worker_thread) {
ipport_plugin_runtime_scan_inc(ipport_plugin_rt, thread_id);
}
return n_ex_data;
return ipport_plugin_runtime_get_ex_data(ipport_plugin_rt, ip_addr, port,
ex_data_array, array_size);
}
int maat_fqdn_plugin_table_get_ex_data(struct maat *maat_inst, int table_id,
@@ -957,13 +980,12 @@ int maat_fqdn_plugin_table_get_ex_data(struct maat *maat_inst, int table_id,
return -1;
}
int n_ex_data = fqdn_plugin_runtime_get_ex_data(fqdn_plugin_rt, fqdn,
ex_data_array, array_size);
if (n_ex_data < 0) {
return -1;
int thread_id = _get_tid(maat_inst);
if (thread_id >= 0 && thread_id < maat_inst->opts.nr_worker_thread) {
fqdn_plugin_runtime_scan_inc(fqdn_plugin_rt, thread_id);
}
return n_ex_data;
return fqdn_plugin_runtime_get_ex_data(fqdn_plugin_rt, fqdn, ex_data_array, array_size);
}
int maat_bool_plugin_table_get_ex_data(struct maat *maat_inst, int table_id,
@@ -985,13 +1007,13 @@ int maat_bool_plugin_table_get_ex_data(struct maat *maat_inst, int table_id,
return -1;
}
int n_ex_data = bool_plugin_runtime_get_ex_data(bool_plugin_rt, item_ids, n_item,
ex_data_array, array_size);
if (n_ex_data < 0) {
return -1;
int thread_id = _get_tid(maat_inst);
if (thread_id >= 0 && thread_id < maat_inst->opts.nr_worker_thread) {
bool_plugin_runtime_scan_inc(bool_plugin_rt, thread_id);
}
return n_ex_data;
return bool_plugin_runtime_get_ex_data(bool_plugin_rt, item_ids, n_item,
ex_data_array, array_size);
}
static inline int scan_status_should_compile_NOT(struct maat_state *state)

31
src/maat_bool_plugin.c
View File

@@ -39,6 +39,7 @@ struct bool_plugin_runtime {
long long rule_num;
long long update_err_cnt;
long long *scan_cnt;
};
/* bool plugin schema API */
@@ -198,6 +199,7 @@ void *bool_plugin_runtime_new(void *bool_plugin_schema, size_t max_thread_num,
bool_plugin_rt->n_worker_thread = max_thread_num;
bool_plugin_rt->ref_garbage_bin = garbage_bin;
bool_plugin_rt->logger = logger;
bool_plugin_rt->scan_cnt = alignment_int64_array_alloc(max_thread_num);
return bool_plugin_rt;
}
@@ -219,6 +221,11 @@ void bool_plugin_runtime_free(void *bool_plugin_runtime)
bool_plugin_rt->ex_data_rt = NULL;
}
if (bool_plugin_rt->scan_cnt != NULL) {
alignment_int64_array_free(bool_plugin_rt->scan_cnt);
bool_plugin_rt->scan_cnt = NULL;
}
FREE(bool_plugin_rt);
}
@@ -569,3 +576,27 @@ long long bool_plugin_runtime_update_err_count(void *bool_plugin_runtime)
struct bool_plugin_runtime *bool_plugin_rt = (struct bool_plugin_runtime *)bool_plugin_runtime;
return bool_plugin_rt->update_err_cnt;
}
void bool_plugin_runtime_scan_inc(void *bool_plugin_runtime, int thread_id)
{
if (NULL == bool_plugin_runtime || thread_id < 0) {
return;
}
struct bool_plugin_runtime *bool_plugin_rt = (struct bool_plugin_runtime *)bool_plugin_runtime;
alignment_int64_array_add(bool_plugin_rt->scan_cnt, thread_id, 1);
}
long long bool_plugin_runtime_scan_count(void *bool_plugin_runtime)
{
if (NULL == bool_plugin_runtime) {
return 0;
}
struct bool_plugin_runtime *bool_plugin_rt = (struct bool_plugin_runtime *)bool_plugin_runtime;
long long sum = alignment_int64_array_sum(bool_plugin_rt->scan_cnt,
bool_plugin_rt->n_worker_thread);
alignment_int64_array_reset(bool_plugin_rt->scan_cnt, bool_plugin_rt->n_worker_thread);
return sum;
}

31
src/maat_fqdn_plugin.c
View File

@@ -40,6 +40,7 @@ struct fqdn_plugin_runtime {
long long rule_num;
long long update_err_cnt;
long long *scan_cnt;
};
void *fqdn_plugin_schema_new(cJSON *json, struct table_manager *tbl_mgr,
@@ -197,6 +198,7 @@ void *fqdn_plugin_runtime_new(void *fqdn_plugin_schema, size_t max_thread_num,
fqdn_plugin_rt->n_worker_thread = max_thread_num;
fqdn_plugin_rt->ref_garbage_bin = garbage_bin;
fqdn_plugin_rt->logger = logger;
fqdn_plugin_rt->scan_cnt = alignment_int64_array_alloc(max_thread_num);
return fqdn_plugin_rt;
}
@@ -218,6 +220,11 @@ void fqdn_plugin_runtime_free(void *fqdn_plugin_runtime)
fqdn_plugin_rt->ex_data_rt = NULL;
}
if (fqdn_plugin_rt->scan_cnt != NULL) {
alignment_int64_array_free(fqdn_plugin_rt->scan_cnt);
fqdn_plugin_rt->scan_cnt = NULL;
}
FREE(fqdn_plugin_rt);
}
@@ -583,3 +590,27 @@ long long fqdn_plugin_runtime_update_err_count(void *fqdn_plugin_runtime)
struct fqdn_plugin_runtime *fqdn_plugin_rt = (struct fqdn_plugin_runtime *)fqdn_plugin_runtime;
return fqdn_plugin_rt->update_err_cnt;
}
void fqdn_plugin_runtime_scan_inc(void *fqdn_plugin_runtime, int thread_id)
{
if (NULL == fqdn_plugin_runtime || thread_id < 0) {
return;
}
struct fqdn_plugin_runtime *fqdn_plugin_rt = (struct fqdn_plugin_runtime *)fqdn_plugin_runtime;
alignment_int64_array_add(fqdn_plugin_rt->scan_cnt, thread_id, 1);
}
long long fqdn_plugin_runtime_scan_count(void *fqdn_plugin_runtime)
{
if (NULL == fqdn_plugin_runtime) {
return 0;
}
struct fqdn_plugin_runtime *fqdn_plugin_rt = (struct fqdn_plugin_runtime *)fqdn_plugin_runtime;
long long sum = alignment_int64_array_sum(fqdn_plugin_rt->scan_cnt,
fqdn_plugin_rt->n_worker_thread);
alignment_int64_array_reset(fqdn_plugin_rt->scan_cnt, fqdn_plugin_rt->n_worker_thread);
return sum;
}

31
src/maat_ip_plugin.c
View File

@@ -43,6 +43,7 @@ struct ip_plugin_runtime {
long long rule_num;
long long update_err_cnt;
long long *scan_cnt;
};
void *ip_plugin_schema_new(cJSON *json, struct table_manager *tbl_mgr,
@@ -360,6 +361,7 @@ void *ip_plugin_runtime_new(void *ip_plugin_schema, size_t max_thread_num,
ip_plugin_rt->n_worker_thread = max_thread_num;
ip_plugin_rt->ref_garbage_bin = garbage_bin;
ip_plugin_rt->logger = logger;
ip_plugin_rt->scan_cnt = alignment_int64_array_alloc(max_thread_num);
return ip_plugin_rt;
}
@@ -381,6 +383,11 @@ void ip_plugin_runtime_free(void *ip_plugin_runtime)
ip_plugin_rt->ex_data_rt = NULL;
}
if (ip_plugin_rt->scan_cnt != NULL) {
alignment_int64_array_free(ip_plugin_rt->scan_cnt);
ip_plugin_rt->scan_cnt = NULL;
}
FREE(ip_plugin_rt);
}
@@ -583,3 +590,27 @@ long long ip_plugin_runtime_update_err_count(void *ip_plugin_runtime)
struct ip_plugin_runtime *ip_plugin_rt = (struct ip_plugin_runtime *)ip_plugin_runtime;
return ip_plugin_rt->update_err_cnt;
}
void ip_plugin_runtime_scan_inc(void *ip_plugin_runtime, int thread_id)
{
if (NULL == ip_plugin_runtime || thread_id < 0) {
return;
}
struct ip_plugin_runtime *ip_plugin_rt = (struct ip_plugin_runtime *)ip_plugin_runtime;
alignment_int64_array_add(ip_plugin_rt->scan_cnt, thread_id, 1);
}
long long ip_plugin_runtime_scan_count(void *ip_plugin_runtime)
{
if (NULL == ip_plugin_runtime) {
return 0;
}
struct ip_plugin_runtime *ip_plugin_rt = (struct ip_plugin_runtime *)ip_plugin_runtime;
long long sum = alignment_int64_array_sum(ip_plugin_rt->scan_cnt,
ip_plugin_rt->n_worker_thread);
alignment_int64_array_reset(ip_plugin_rt->scan_cnt, ip_plugin_rt->n_worker_thread);
return sum;
}

31
src/maat_ipport_plugin.c
View File

@@ -66,6 +66,7 @@ struct ipport_plugin_runtime {
long long rule_num;
long long update_err_cnt;
long long *scan_cnt;
};
void *ipport_plugin_schema_new(cJSON *json, struct table_manager *tbl_mgr,
@@ -223,6 +224,7 @@ void *ipport_plugin_runtime_new(void *ipport_plugin_schema, size_t max_thread_nu
ipport_plugin_rt->n_worker_thread = max_thread_num;
ipport_plugin_rt->ref_garbage_bin = garbage_bin;
ipport_plugin_rt->logger = logger;
ipport_plugin_rt->scan_cnt = alignment_int64_array_alloc(max_thread_num);
return ipport_plugin_rt;
}
@@ -244,6 +246,11 @@ void ipport_plugin_runtime_free(void *ipport_plugin_runtime)
ipport_plugin_rt->ex_data_rt = NULL;
}
if (ipport_plugin_rt->scan_cnt != NULL) {
alignment_int64_array_free(ipport_plugin_rt->scan_cnt);
ipport_plugin_rt->scan_cnt = NULL;
}
FREE(ipport_plugin_rt);
}
@@ -622,3 +629,27 @@ long long ipport_plugin_runtime_update_err_count(void *ipport_plugin_runtime)
struct ipport_plugin_runtime *ipport_plugin_rt = (struct ipport_plugin_runtime *)ipport_plugin_runtime;
return ipport_plugin_rt->update_err_cnt;
}
void ipport_plugin_runtime_scan_inc(void *ipport_plugin_runtime, int thread_id)
{
if (NULL == ipport_plugin_runtime || thread_id < 0) {
return;
}
struct ipport_plugin_runtime *ipport_plugin_rt = (struct ipport_plugin_runtime *)ipport_plugin_runtime;
alignment_int64_array_add(ipport_plugin_rt->scan_cnt, thread_id, 1);
}
long long ipport_plugin_runtime_scan_count(void *ipport_plugin_runtime)
{
if (NULL == ipport_plugin_runtime) {
return 0;
}
struct ipport_plugin_runtime *ipport_plugin_rt = (struct ipport_plugin_runtime *)ipport_plugin_runtime;
long long sum = alignment_int64_array_sum(ipport_plugin_rt->scan_cnt,
ipport_plugin_rt->n_worker_thread);
alignment_int64_array_reset(ipport_plugin_rt->scan_cnt, ipport_plugin_rt->n_worker_thread);
return sum;
}

34
src/maat_plugin.c
View File

@@ -18,6 +18,7 @@
#include "maat_plugin.h"
#include "maat_limits.h"
#include "maat_table.h"
#include "alignment.h"
#define MODULE_PLUGIN module_name_str("maat.plugin")
@@ -33,12 +34,14 @@ struct plugin_callback_schema {
struct plugin_runtime {
struct ex_data_runtime *ex_data_rt;
size_t n_worker_thread;
struct maat_garbage_bin *ref_garbage_bin;
struct log_handle *logger;
long long rule_num;
long long acc_line_num;
long long update_err_cnt;
long long *scan_cnt;
};
enum plugin_key_type {
@@ -314,8 +317,10 @@ void *plugin_runtime_new(void *plugin_schema, size_t max_thread_num,
&(schema->container_schema));
}
plugin_rt->n_worker_thread = max_thread_num;
plugin_rt->ref_garbage_bin = garbage_bin;
plugin_rt->logger = logger;
plugin_rt->scan_cnt = alignment_int64_array_alloc(max_thread_num);
return plugin_rt;
}
@@ -332,6 +337,11 @@ void plugin_runtime_free(void *plugin_runtime)
plugin_rt->ex_data_rt = NULL;
}
if (plugin_rt->scan_cnt != NULL) {
alignment_int64_array_free(plugin_rt->scan_cnt);
plugin_rt->scan_cnt = NULL;
}
FREE(plugin_rt);
}
@@ -674,3 +684,27 @@ void *plugin_runtime_get_ex_data(void *plugin_runtime, void *plugin_schema,
return ex_data_runtime_get_ex_data_by_key(plugin_rt->ex_data_rt, key, key_len);
}
void plugin_runtime_scan_inc(void *plugin_runtime, int thread_id)
{
if (NULL == plugin_runtime || thread_id < 0) {
return;
}
struct plugin_runtime *plugin_rt = (struct plugin_runtime *)plugin_runtime;
alignment_int64_array_add(plugin_rt->scan_cnt, thread_id, 1);
}
long long plugin_runtime_scan_count(void *plugin_runtime)
{
if (NULL == plugin_runtime) {
return 0;
}
struct plugin_runtime *plugin_rt = (struct plugin_runtime *)plugin_runtime;
long long sum = alignment_int64_array_sum(plugin_rt->scan_cnt,
plugin_rt->n_worker_thread);
alignment_int64_array_reset(plugin_rt->scan_cnt, plugin_rt->n_worker_thread);
return sum;
}

8
src/maat_stat.c
View File

@@ -379,6 +379,10 @@ static void maat_fieldstat_table_row_output(struct maat_stat *stat, int perf_on)
fieldstat_value_set(stat->fs_handle, stat->fs_column_id[i][COLUMN_RULE_NUM], rule_num);
total_rule_num += rule_num;
long long scan_cnt = table_manager_runtime_scan_count(stat->ref_tbl_mgr, i);
fieldstat_value_set(stat->fs_handle, stat->fs_column_id[i][COLUMN_SCAN_CNT], scan_cnt);
total_scan_cnt += scan_cnt;
if (table_type == TABLE_TYPE_PLUGIN || table_type == TABLE_TYPE_IP_PLUGIN ||
table_type == TABLE_TYPE_IPPORT_PLUGIN || table_type == TABLE_TYPE_BOOL_PLUGIN ||
table_type == TABLE_TYPE_FQDN_PLUGIN) {
@@ -406,10 +410,6 @@ static void maat_fieldstat_table_row_output(struct maat_stat *stat, int perf_on)
total_scan_cpu_time += scan_cpu_time;
}
long long scan_cnt = table_manager_runtime_scan_count(stat->ref_tbl_mgr, i);
fieldstat_value_set(stat->fs_handle, stat->fs_column_id[i][COLUMN_SCAN_CNT], scan_cnt);
total_scan_cnt += scan_cnt;
long long hit_cnt = table_manager_runtime_hit_count(stat->ref_tbl_mgr, i);
fieldstat_value_set(stat->fs_handle, stat->fs_column_id[i][COLUMN_HIT_CNT], hit_cnt);
total_hit_cnt += hit_cnt;

5
src/maat_table.c
View File

@@ -194,6 +194,7 @@ struct table_operations table_ops[TABLE_TYPE_MAX] = {
.free_runtime = plugin_runtime_free,
.update_runtime = plugin_runtime_update,
.commit_runtime = plugin_runtime_commit,
.scan_count = plugin_runtime_scan_count,
.rule_count = plugin_runtime_rule_count,
.update_err_count = plugin_runtime_update_err_count
},
@@ -205,6 +206,7 @@ struct table_operations table_ops[TABLE_TYPE_MAX] = {
.free_runtime = ip_plugin_runtime_free,
.update_runtime = ip_plugin_runtime_update,
.commit_runtime = ip_plugin_runtime_commit,
.scan_count = ip_plugin_runtime_scan_count,
.rule_count = ip_plugin_runtime_rule_count,
.update_err_count = ip_plugin_runtime_update_err_count
},
@@ -217,6 +219,7 @@ struct table_operations table_ops[TABLE_TYPE_MAX] = {
.update_runtime = ipport_plugin_runtime_update,
.commit_runtime = ipport_plugin_runtime_commit,
.rule_count = ipport_plugin_runtime_rule_count,
.scan_count = ipport_plugin_runtime_scan_count,
.update_err_count = ipport_plugin_runtime_update_err_count
},
{
@@ -227,6 +230,7 @@ struct table_operations table_ops[TABLE_TYPE_MAX] = {
.free_runtime = fqdn_plugin_runtime_free,
.update_runtime = fqdn_plugin_runtime_update,
.commit_runtime = fqdn_plugin_runtime_commit,
.scan_count = fqdn_plugin_runtime_scan_count,
.rule_count = fqdn_plugin_runtime_rule_count,
.update_err_count = fqdn_plugin_runtime_update_err_count
},
@@ -238,6 +242,7 @@ struct table_operations table_ops[TABLE_TYPE_MAX] = {
.free_runtime = bool_plugin_runtime_free,
.update_runtime = bool_plugin_runtime_update,
.commit_runtime = bool_plugin_runtime_commit,
.scan_count = bool_plugin_runtime_scan_count,
.rule_count = bool_plugin_runtime_rule_count,
.update_err_count = bool_plugin_runtime_update_err_count
},

663
test/maat_framework_perf_gtest.cpp
View File

@@ -433,6 +433,7 @@ void *perf_string_scan_thread(void *arg)
struct maat_state *state = maat_state_new(maat_inst, param->thread_id);
int table_id = maat_get_table_id(maat_inst, table_name);
maat_register_thread(maat_inst);
clock_gettime(CLOCK_MONOTONIC, &start);
for (int i = 0; i < param->test_count; i++) {
@@ -474,234 +475,6 @@ void *perf_string_update_thread(void *arg)
return is_all_hit;
}
void *perf_regex_scan_thread(void *arg)
{
struct thread_param *param = (struct thread_param *)arg;
struct maat *maat_inst = param->maat_inst;
const char *table_name = param->table_name;
struct timespec start, end;
const char *scan_data = "http://www.cyberessays.com/search_results.php?action=search&query=username,abckkk,1234567";
long long results[ARRAY_SIZE] = {0};
int hit_times = 0;
size_t n_hit_result = 0;
struct maat_state *state = maat_state_new(maat_inst, param->thread_id);
int table_id = maat_get_table_id(maat_inst, table_name);
clock_gettime(CLOCK_MONOTONIC, &start);
for (int i = 0; i < param->test_count; i++) {
int ret = maat_scan_string(maat_inst, table_id, scan_data, strlen(scan_data),
results, ARRAY_SIZE, &n_hit_result, state);
if (ret == MAAT_SCAN_HIT) {
hit_times++;
}
maat_state_reset(state);
}
clock_gettime(CLOCK_MONOTONIC, &end);
param->time_elapse_ms = (end.tv_sec - start.tv_sec) * 1000 + (end.tv_nsec - start.tv_nsec) / 1000000;
int *is_all_hit = ALLOC(int, 1);
*is_all_hit = (hit_times == param->test_count ? 1 : 0);
log_info(param->logger, MODULE_FRAMEWORK_PERF_GTEST,
"thread_id:%d regex_scan time_elapse:%lldms hit_times:%d",
param->thread_id, param->time_elapse_ms, hit_times);
return is_all_hit;
}
void *perf_regex_update_thread(void *arg)
{
struct thread_param *param = (struct thread_param *)arg;
struct maat *maat_inst = param->maat_inst;
const char *table_name = param->table_name;
const int CMD_EXPR_NUM = 10;
char keyword_buf[128];
for (int i = 0; i < CMD_EXPR_NUM; i++) {
random_keyword_generate(keyword_buf, sizeof(keyword_buf));
test_add_expr_command(maat_inst, table_name, keyword_buf);
sleep(1);
}
int *is_all_hit = ALLOC(int, 1);
*is_all_hit = 1;
return is_all_hit;
}
void *perf_ip_scan_thread(void *arg)
{
struct thread_param *param = (struct thread_param *)arg;
struct maat *maat_inst = param->maat_inst;
const char *table_name = param->table_name;
struct timespec start, end;
char ip_str[32] = "10.0.0.1";
uint32_t ip_addr;
uint16_t port = htons(65530);
int ret = inet_pton(AF_INET, ip_str, &ip_addr);
EXPECT_EQ(ret, 1);
int hit_times = 0;
long long results[ARRAY_SIZE] = {0};
size_t n_hit_result = 0;
struct maat_state *state = maat_state_new(maat_inst, param->thread_id);
int table_id = maat_get_table_id(maat_inst, table_name);
clock_gettime(CLOCK_MONOTONIC, &start);
for (int i = 0; i < param->test_count; i++) {
int ret = maat_scan_ipv4(maat_inst, table_id, ip_addr, port, 6,
results, ARRAY_SIZE, &n_hit_result, state);
if (ret == MAAT_SCAN_HIT) {
hit_times++;
}
maat_state_reset(state);
}
clock_gettime(CLOCK_MONOTONIC, &end);
param->time_elapse_ms = (end.tv_sec - start.tv_sec) * 1000 + (end.tv_nsec - start.tv_nsec) / 1000000;
int *is_all_hit = ALLOC(int, 1);
*is_all_hit = (hit_times == param->test_count ? 1 : 0);
log_info(param->logger, MODULE_FRAMEWORK_PERF_GTEST,
"thread_id:%d ip_scan time_elapse:%lldms hit_times:%d",
param->thread_id, param->time_elapse_ms, hit_times);
return is_all_hit;
}
void *perf_ip_update_thread(void *arg)
{
struct thread_param *param = (struct thread_param *)arg;
struct maat *maat_inst = param->maat_inst;
const char *table_name = param->table_name;
const int CMD_EXPR_NUM = 10;
char ip_str[10][32] = {
"10.0.7.101",
"10.0.7.102",
"10.0.7.103",
"10.0.7.104",
"10.0.7.105",
"10.0.7.106",
"10.0.7.107",
"10.0.7.108",
"10.0.7.109",
"10.0.7.110"};
uint16_t port = 65530;
for (int i = 0; i < CMD_EXPR_NUM; i++) {
test_add_ip_command(maat_inst, table_name, ip_str[i], port);
sleep(1);
}
int *is_all_hit = ALLOC(int, 1);
*is_all_hit = 1;
return is_all_hit;
}
void *perf_integer_scan_thread(void *arg)
{
struct thread_param *param = (struct thread_param *)arg;
struct maat *maat_inst = param->maat_inst;
const char *table_name = param->table_name;
struct timespec start, end;
int hit_times = 0;
long long results[ARRAY_SIZE] = {0};
size_t n_hit_result = 0;
struct maat_state *state = maat_state_new(maat_inst, param->thread_id);
int table_id = maat_get_table_id(maat_inst, table_name);
clock_gettime(CLOCK_MONOTONIC, &start);
for (int i = 0; i < param->test_count; i++) {
int ret = maat_scan_integer(maat_inst, table_id, 3000, results,
ARRAY_SIZE, &n_hit_result, state);
if (ret == MAAT_SCAN_HIT) {
hit_times++;
}
maat_state_reset(state);
}
clock_gettime(CLOCK_MONOTONIC, &end);
param->time_elapse_ms = (end.tv_sec - start.tv_sec) * 1000 +
(end.tv_nsec - start.tv_nsec) / 1000000;
int *is_all_hit = ALLOC(int, 1);
*is_all_hit = (hit_times == param->test_count ? 1 : 0);
log_info(param->logger, MODULE_FRAMEWORK_PERF_GTEST,
"thread_id:%d integer_scan time_elapse:%lldms hit_times:%d",
param->thread_id, param->time_elapse_ms, hit_times);
return is_all_hit;
}
void *perf_integer_update_thread(void *arg)
{
struct thread_param *param = (struct thread_param *)arg;
struct maat *maat_inst = param->maat_inst;
const char *table_name = param->table_name;
const int CMD_EXPR_NUM = 10;
for (int i = 0; i < CMD_EXPR_NUM; i++) {
test_add_integer_command(maat_inst, table_name, 3001+i, 3001+i);
sleep(1);
}
int *is_all_hit = ALLOC(int, 1);
*is_all_hit = 1;
return is_all_hit;
}
void *perf_flag_scan_thread(void *arg)
{
struct thread_param *param = (struct thread_param *)arg;
struct maat *maat_inst = param->maat_inst;
const char *table_name = param->table_name;
struct timespec start, end;
int hit_times = 0;
long long results[ARRAY_SIZE] = {0};
size_t n_hit_result = 0;
long long scan_data = 15;
struct maat_state *state = maat_state_new(maat_inst, param->thread_id);
int table_id = maat_get_table_id(maat_inst, table_name);
clock_gettime(CLOCK_MONOTONIC, &start);
for (int i = 0; i < param->test_count; i++) {
int ret = maat_scan_flag(maat_inst, table_id, scan_data, results,
ARRAY_SIZE, &n_hit_result, state);
if (ret == MAAT_SCAN_HIT) {
hit_times++;
}
maat_state_reset(state);
}
clock_gettime(CLOCK_MONOTONIC, &end);
param->time_elapse_ms = (end.tv_sec - start.tv_sec) * 1000 +
(end.tv_nsec - start.tv_nsec) / 1000000;
int *is_all_hit = ALLOC(int, 1);
*is_all_hit = (hit_times == param->test_count ? 1 : 0);
log_info(param->logger, MODULE_FRAMEWORK_PERF_GTEST,
"thread_id:%d flag_scan time_elapse:%lldms hit_times:%d",
param->thread_id, param->time_elapse_ms, hit_times);
return is_all_hit;
}
void *perf_flag_update_thread(void *arg)
{
struct thread_param *param = (struct thread_param *)arg;
struct maat *maat_inst = param->maat_inst;
const char *table_name = param->table_name;
const int CMD_EXPR_NUM = 10;
for (int i = 0; i < CMD_EXPR_NUM; i++) {
test_add_flag_command(maat_inst, table_name, i, 15);
sleep(1);
}
int *is_all_hit = ALLOC(int, 1);
*is_all_hit = 1;
return is_all_hit;
}
TEST_F(MaatPerfStringScan, LiteralMultiThread) {
const char *table_name = "EXPR_LITERAL_PERF_CONFIG";
struct maat *maat_inst = MaatPerfStringScan::_shared_maat_inst;
@@ -748,9 +521,110 @@ TEST_F(MaatPerfStringScan, LiteralMultiThread) {
PERF_THREAD_NUM, scan_per_second);
}
TEST_F(MaatPerfStringScan, RegexMultiThread) {
class MaatPerfRegexScan : public testing::Test
{
protected:
static void SetUpTestCase() {
const char *accept_tags = "{\"tags\":[{\"tag\":\"location\",\"value\":\"北京/朝阳/华严北里/甲22号\"},"
"{\"tag\":\"isp\",\"value\":\"移动\"},{\"tag\":\"location\",\"value\":\"Astana\"}]}";
char redis_ip[64] = "127.0.0.1";
int redis_port = 6379;
int redis_db = 0;
logger = log_handle_create("./maat_framework_perf_gtest.log", 0);
int ret = write_config_to_redis(redis_ip, redis_port, redis_db, logger);
if (ret < 0) {
log_error(logger, MODULE_FRAMEWORK_PERF_GTEST,
"[%s:%d] write config to redis failed.", __FUNCTION__, __LINE__);
}
struct maat_options *opts = maat_options_new();
maat_options_set_stat_file(opts, "./stat.log");
maat_options_set_perf_on(opts);
maat_options_set_redis(opts, redis_ip, redis_port, redis_db);
maat_options_set_logger(opts, "./maat_framework_perf_gtest.log", LOG_LEVEL_INFO);
maat_options_set_accept_tags(opts, accept_tags);
maat_options_set_caller_thread_number(opts, 5);
_shared_maat_inst = maat_new(opts, table_info_path);
maat_options_free(opts);
if (NULL == _shared_maat_inst) {
log_error(logger, MODULE_FRAMEWORK_PERF_GTEST,
"[%s:%d] create maat instance in MaatRegexScan failed.",
__FUNCTION__, __LINE__);
}
}
static void TearDownTestCase() {
maat_free(_shared_maat_inst);
log_handle_destroy(logger);
}
static struct log_handle *logger;
static struct maat *_shared_maat_inst;
};
struct maat *MaatPerfRegexScan::_shared_maat_inst;
struct log_handle *MaatPerfRegexScan::logger;
void *perf_regex_scan_thread(void *arg)
{
struct thread_param *param = (struct thread_param *)arg;
struct maat *maat_inst = param->maat_inst;
const char *table_name = param->table_name;
struct timespec start, end;
const char *scan_data = "http://www.cyberessays.com/search_results.php?action=search&query=username,abckkk,1234567";
long long results[ARRAY_SIZE] = {0};
int hit_times = 0;
size_t n_hit_result = 0;
struct maat_state *state = maat_state_new(maat_inst, param->thread_id);
int table_id = maat_get_table_id(maat_inst, table_name);
maat_register_thread(maat_inst);
clock_gettime(CLOCK_MONOTONIC, &start);
for (int i = 0; i < param->test_count; i++) {
int ret = maat_scan_string(maat_inst, table_id, scan_data, strlen(scan_data),
results, ARRAY_SIZE, &n_hit_result, state);
if (ret == MAAT_SCAN_HIT) {
hit_times++;
}
maat_state_reset(state);
}
clock_gettime(CLOCK_MONOTONIC, &end);
param->time_elapse_ms = (end.tv_sec - start.tv_sec) * 1000 + (end.tv_nsec - start.tv_nsec) / 1000000;
int *is_all_hit = ALLOC(int, 1);
*is_all_hit = (hit_times == param->test_count ? 1 : 0);
log_info(param->logger, MODULE_FRAMEWORK_PERF_GTEST,
"thread_id:%d regex_scan time_elapse:%lldms hit_times:%d",
param->thread_id, param->time_elapse_ms, hit_times);
return is_all_hit;
}
void *perf_regex_update_thread(void *arg)
{
struct thread_param *param = (struct thread_param *)arg;
struct maat *maat_inst = param->maat_inst;
const char *table_name = param->table_name;
const int CMD_EXPR_NUM = 10;
char keyword_buf[128];
for (int i = 0; i < CMD_EXPR_NUM; i++) {
random_keyword_generate(keyword_buf, sizeof(keyword_buf));
test_add_expr_command(maat_inst, table_name, keyword_buf);
sleep(1);
}
int *is_all_hit = ALLOC(int, 1);
*is_all_hit = 1;
return is_all_hit;
}
TEST_F(MaatPerfRegexScan, RegexMultiThread) {
const char *table_name = "EXPR_REGEX_PERF_CONFIG";
struct maat *maat_inst = MaatPerfStringScan::_shared_maat_inst;
struct maat *maat_inst = MaatPerfRegexScan::_shared_maat_inst;
int table_id = maat_get_table_id(maat_inst, table_name);
ASSERT_GT(table_id, 0);
@@ -795,6 +669,60 @@ TEST_F(MaatPerfStringScan, RegexMultiThread) {
PERF_THREAD_NUM, scan_per_second);
}
void *perf_integer_scan_thread(void *arg)
{
struct thread_param *param = (struct thread_param *)arg;
struct maat *maat_inst = param->maat_inst;
const char *table_name = param->table_name;
struct timespec start, end;
int hit_times = 0;
long long results[ARRAY_SIZE] = {0};
size_t n_hit_result = 0;
struct maat_state *state = maat_state_new(maat_inst, param->thread_id);
int table_id = maat_get_table_id(maat_inst, table_name);
maat_register_thread(maat_inst);
clock_gettime(CLOCK_MONOTONIC, &start);
for (int i = 0; i < param->test_count; i++) {
int ret = maat_scan_integer(maat_inst, table_id, 3000, results,
ARRAY_SIZE, &n_hit_result, state);
if (ret == MAAT_SCAN_HIT) {
hit_times++;
}
maat_state_reset(state);
}
clock_gettime(CLOCK_MONOTONIC, &end);
param->time_elapse_ms = (end.tv_sec - start.tv_sec) * 1000 +
(end.tv_nsec - start.tv_nsec) / 1000000;
int *is_all_hit = ALLOC(int, 1);
*is_all_hit = (hit_times == param->test_count ? 1 : 0);
log_info(param->logger, MODULE_FRAMEWORK_PERF_GTEST,
"thread_id:%d integer_scan time_elapse:%lldms hit_times:%d",
param->thread_id, param->time_elapse_ms, hit_times);
return is_all_hit;
}
void *perf_integer_update_thread(void *arg)
{
struct thread_param *param = (struct thread_param *)arg;
struct maat *maat_inst = param->maat_inst;
const char *table_name = param->table_name;
const int CMD_EXPR_NUM = 10;
for (int i = 0; i < CMD_EXPR_NUM; i++) {
test_add_integer_command(maat_inst, table_name, 3001+i, 3001+i);
sleep(1);
}
int *is_all_hit = ALLOC(int, 1);
*is_all_hit = 1;
return is_all_hit;
}
class MaatPerfStreamScan : public testing::Test
{
protected:
@@ -855,6 +783,7 @@ void *perf_stream_scan_thread(void *arg)
int table_id = maat_get_table_id(maat_inst, table_name);
struct maat_state *state = maat_state_new(maat_inst, param->thread_id);
struct maat_stream *sp = maat_stream_new(maat_inst, table_id, state);
maat_register_thread(maat_inst);
clock_gettime(CLOCK_MONOTONIC, &start);
for (int i = 0; i < param->test_count; i++) {
@@ -968,6 +897,76 @@ protected:
struct maat *MaatPerfIPScan::_shared_maat_inst;
struct log_handle *MaatPerfIPScan::logger;
void *perf_ip_scan_thread(void *arg)
{
struct thread_param *param = (struct thread_param *)arg;
struct maat *maat_inst = param->maat_inst;
const char *table_name = param->table_name;
struct timespec start, end;
char ip_str[32] = "10.0.0.1";
uint32_t ip_addr;
uint16_t port = htons(65530);
int ret = inet_pton(AF_INET, ip_str, &ip_addr);
EXPECT_EQ(ret, 1);
int hit_times = 0;
long long results[ARRAY_SIZE] = {0};
size_t n_hit_result = 0;
struct maat_state *state = maat_state_new(maat_inst, param->thread_id);
int table_id = maat_get_table_id(maat_inst, table_name);
maat_register_thread(maat_inst);
clock_gettime(CLOCK_MONOTONIC, &start);
for (int i = 0; i < param->test_count; i++) {
int ret = maat_scan_ipv4(maat_inst, table_id, ip_addr, port, 6,
results, ARRAY_SIZE, &n_hit_result, state);
if (ret == MAAT_SCAN_HIT) {
hit_times++;
}
maat_state_reset(state);
}
clock_gettime(CLOCK_MONOTONIC, &end);
param->time_elapse_ms = (end.tv_sec - start.tv_sec) * 1000 + (end.tv_nsec - start.tv_nsec) / 1000000;
int *is_all_hit = ALLOC(int, 1);
*is_all_hit = (hit_times == param->test_count ? 1 : 0);
log_info(param->logger, MODULE_FRAMEWORK_PERF_GTEST,
"thread_id:%d ip_scan time_elapse:%lldms hit_times:%d",
param->thread_id, param->time_elapse_ms, hit_times);
return is_all_hit;
}
void *perf_ip_update_thread(void *arg)
{
struct thread_param *param = (struct thread_param *)arg;
struct maat *maat_inst = param->maat_inst;
const char *table_name = param->table_name;
const int CMD_EXPR_NUM = 10;
char ip_str[10][32] = {
"10.0.7.101",
"10.0.7.102",
"10.0.7.103",
"10.0.7.104",
"10.0.7.105",
"10.0.7.106",
"10.0.7.107",
"10.0.7.108",
"10.0.7.109",
"10.0.7.110"};
uint16_t port = 65530;
for (int i = 0; i < CMD_EXPR_NUM; i++) {
test_add_ip_command(maat_inst, table_name, ip_str[i], port);
sleep(1);
}
int *is_all_hit = ALLOC(int, 1);
*is_all_hit = 1;
return is_all_hit;
}
TEST_F(MaatPerfIPScan, MultiThread)
{
const char *table_name = "IP_PERF_CONFIG";
@@ -1155,6 +1154,59 @@ protected:
struct maat *MaatPerfFlagScan::_shared_maat_inst;
struct log_handle *MaatPerfFlagScan::logger;
void *perf_flag_scan_thread(void *arg)
{
struct thread_param *param = (struct thread_param *)arg;
struct maat *maat_inst = param->maat_inst;
const char *table_name = param->table_name;
struct timespec start, end;
int hit_times = 0;
long long results[ARRAY_SIZE] = {0};
size_t n_hit_result = 0;
long long scan_data = 15;
struct maat_state *state = maat_state_new(maat_inst, param->thread_id);
int table_id = maat_get_table_id(maat_inst, table_name);
clock_gettime(CLOCK_MONOTONIC, &start);
for (int i = 0; i < param->test_count; i++) {
int ret = maat_scan_flag(maat_inst, table_id, scan_data, results,
ARRAY_SIZE, &n_hit_result, state);
if (ret == MAAT_SCAN_HIT) {
hit_times++;
}
maat_state_reset(state);
}
clock_gettime(CLOCK_MONOTONIC, &end);
param->time_elapse_ms = (end.tv_sec - start.tv_sec) * 1000 +
(end.tv_nsec - start.tv_nsec) / 1000000;
int *is_all_hit = ALLOC(int, 1);
*is_all_hit = (hit_times == param->test_count ? 1 : 0);
log_info(param->logger, MODULE_FRAMEWORK_PERF_GTEST,
"thread_id:%d flag_scan time_elapse:%lldms hit_times:%d",
param->thread_id, param->time_elapse_ms, hit_times);
return is_all_hit;
}
void *perf_flag_update_thread(void *arg)
{
struct thread_param *param = (struct thread_param *)arg;
struct maat *maat_inst = param->maat_inst;
const char *table_name = param->table_name;
const int CMD_EXPR_NUM = 10;
for (int i = 0; i < CMD_EXPR_NUM; i++) {
test_add_flag_command(maat_inst, table_name, i, 15);
sleep(1);
}
int *is_all_hit = ALLOC(int, 1);
*is_all_hit = 1;
return is_all_hit;
}
TEST_F(MaatPerfFlagScan, MultiThread) {
const char *table_name = "FLAG_PERF_CONFIG";
struct maat *maat_inst = MaatPerfFlagScan::_shared_maat_inst;
@@ -1296,6 +1348,7 @@ void* perf_fqdn_plugin_scan_thread(void *arg)
int i=0, ret=0, hit_times=0;
int table_id = maat_get_table_id(maat_inst, param->table_name);
maat_register_thread(maat_inst);
memset(&result, 0, sizeof(result));
struct timespec start, end;
@@ -1522,6 +1575,7 @@ void* perf_bool_plugin_scan_thread(void *arg)
int i=0, ret=0, hit_times=0;
int table_id = maat_get_table_id(maat_inst, param->table_name);
maat_register_thread(maat_inst);
memset(&result, 0, sizeof(result));
struct timespec start, end;
@@ -1711,11 +1765,11 @@ static void *ip_plugin_get_thread(void *arg)
struct maat *maat_inst = (struct maat *)arg;
int table_id = maat_get_table_id(maat_inst, table_name);
maat_register_thread(maat_inst);
struct timespec start, end;
struct ip_addr ipv4;
ipv4.ip_type = IPv4;
inet_pton(AF_INET, "191.70.72.1", &ipv4.ipv4);
clock_gettime(CLOCK_MONOTONIC, &start);
@@ -1769,6 +1823,153 @@ TEST_F(MaatPerfFileScan, IPPlugin) {
}
}
class MaatPerfIPPortPluginScan : public testing::Test
{
protected:
static void SetUpTestCase() {
const char *accept_tags = "{\"tags\":[{\"tag\":\"location\",\"value\":\"北京/朝阳/华严北里/甲22号\"},"
"{\"tag\":\"isp\",\"value\":\"移动\"},{\"tag\":\"location\",\"value\":\"Astana\"}]}";
char redis_ip[64] = "127.0.0.1";
int redis_port = 6379;
int redis_db = 0;
logger = log_handle_create("./maat_framework_perf_gtest.log", 0);
int ret = write_config_to_redis(redis_ip, redis_port, redis_db, logger);
if (ret < 0) {
log_error(logger, MODULE_FRAMEWORK_PERF_GTEST,
"[%s:%d] write config to redis failed.", __FUNCTION__, __LINE__);
}
struct maat_options *opts = maat_options_new();
maat_options_set_stat_file(opts, "./stat.log");
maat_options_set_perf_on(opts);
maat_options_set_redis(opts, redis_ip, redis_port, redis_db);
maat_options_set_logger(opts, "./maat_framework_perf_gtest.log", LOG_LEVEL_INFO);
maat_options_set_accept_tags(opts, accept_tags);
maat_options_set_caller_thread_number(opts, 5);
_shared_maat_inst = maat_new(opts, table_info_path);
maat_options_free(opts);
if (NULL == _shared_maat_inst) {
log_error(logger, MODULE_FRAMEWORK_PERF_GTEST,
"[%s:%d] create maat instance in MaatFlagScan failed.",
__FUNCTION__, __LINE__);
}
}
static void TearDownTestCase() {
maat_free(_shared_maat_inst);
log_handle_destroy(logger);
}
static struct log_handle *logger;
static struct maat *_shared_maat_inst;
};
struct maat *MaatPerfIPPortPluginScan::_shared_maat_inst;
struct log_handle *MaatPerfIPPortPluginScan::logger;
static void *perf_ipport_plugin_scan_thread(void *arg)
{
struct thread_param *param = (struct thread_param *)arg;
struct maat *maat_inst = param->maat_inst;
struct perf_ip_plugin_ud *results[ARRAY_SIZE];
int i = 0, ret = 0, hit_times = 0;
int table_id = maat_get_table_id(maat_inst, param->table_name);
maat_register_thread(maat_inst);
struct ip_addr ipv4;
ipv4.ip_type = IPv4;
inet_pton(AF_INET, "192.168.100.1", &ipv4.ipv4);
uint16_t port = htons(215);
for (i = 0; i < param->test_count; i++) {
ret = maat_ipport_plugin_table_get_ex_data(maat_inst, table_id, &ipv4,
port, (void**)results, 4);
if (ret > 0) {
hit_times++;
}
}
int *is_all_hit = (int *)malloc(sizeof(int));
*is_all_hit = (hit_times == param->test_count) ? 1 : 0;
log_info(maat_inst->logger, MODULE_FRAMEWORK_PERF_GTEST,
"ipport_plugin_get_ex_data hit_times:%d", hit_times);
return is_all_hit;
}
void *perf_ipport_plugin_update_thread(void *arg)
{
struct thread_param *param = (struct thread_param *)arg;
struct maat *maat_inst = param->maat_inst;
const int CMD_EXPR_NUM = 20;
int i = 0;
struct maat_cmd_line line_rule;
char line_buff[1024];
for (i = 0; i < CMD_EXPR_NUM; i++) {
line_rule.rule_id = (int)maat_cmd_incrby(maat_inst, "TEST_PLUG_SEQ", 1);
line_rule.table_name = param->table_name;
snprintf(line_buff, 1024, "%lld\t4\t192.168.100.1\t%d\t%d\t1",
line_rule.rule_id, 200+i, 300+i);
line_rule.table_line = line_buff;
line_rule.expire_after = 0;
maat_cmd_set_line(maat_inst, &line_rule);
sleep(WAIT_FOR_EFFECTIVE_S);
}
int *is_all_hit = (int *)malloc(sizeof(int));
*is_all_hit = 1;
return is_all_hit;
}
TEST_F(MaatPerfIPPortPluginScan, MultiThread) {
struct maat *maat_inst = MaatPerfIPPortPluginScan::_shared_maat_inst;
const char* table_name = "TEST_IPPORT_PLUGIN_WITH_EXDATA";
int ip_plugin_ex_data_counter = 0;
int table_id = maat_get_table_id(maat_inst, table_name);
ASSERT_GT(table_id, 0);
int ret = maat_plugin_table_ex_schema_register(maat_inst, table_name,
perf_ip_plugin_EX_new_cb,
perf_ip_plugin_EX_free_cb,
perf_ip_plugin_EX_dup_cb,
0, &ip_plugin_ex_data_counter);
ASSERT_TRUE(ret>=0);
pthread_t threads[PERF_THREAD_NUM + 1];
struct thread_param thread_params[PERF_THREAD_NUM + 1];
int i = 0;
int *is_all_hit = NULL;
for (i = 0; i < PERF_THREAD_NUM + 1; i++) {
thread_params[i].maat_inst = maat_inst;
thread_params[i].thread_id = i;
thread_params[i].table_name = table_name;
thread_params[i].test_count = PERF_SCAN_COUNT;
thread_params[i].time_elapse_ms = 0;
thread_params[i].logger = logger;
if (i < PERF_THREAD_NUM) {
pthread_create(&threads[i], NULL, perf_ipport_plugin_scan_thread, thread_params+i);
} else {
thread_params[i].test_count = 0;
pthread_create(&threads[i], NULL, perf_ipport_plugin_update_thread, thread_params+i);
}
}
for (i = 0; i < PERF_THREAD_NUM + 1; i++) {
pthread_join(threads[i], (void **)&is_all_hit);
EXPECT_EQ(*is_all_hit, 1);
*is_all_hit = 0;
free(is_all_hit);
}
}
int main(int argc, char ** argv)
{
int ret=0;

128
test/maat_json.json
View File

@@ -2973,6 +2973,134 @@
"not_flag": 0
}
]
},
{
"compile_id": 211,
"service": 0,
"action": 0,
"do_blacklist": 0,
"do_log": 0,
"effective_rage": 0,
"user_region": "ip_perf_test",
"is_valid": "yes",
"groups": [
{
"regions": [
{
"table_type": "ip_plus",
"table_name": "IP_PERF_CONFIG",
"table_content": {
"addr_type": "ipv4",
"addr_format": "range",
"ip1": "10.0.0.1",
"ip2": "10.0.0.6",
"port_format": "range",
"port1": "65530",
"port2": "65535",
"protocol": 6
}
}
],
"not_flag": 0
}
]
},
{
"compile_id": 212,
"service": 1,
"action": 1,
"do_blacklist": 1,
"do_log": 1,
"user_region": "integer_perf_test",
"is_valid": "yes",
"groups": [
{
"group_name": "Untitled",
"regions": [
{
"table_name": "INTEGER_PERF_CONFIG",
"table_type": "interval",
"table_content": {
"low_boundary": 3000,
"up_boundary": 3000
}
}
]
}
]
},
{
"compile_id": 213,
"service": 1,
"action": 1,
"do_blacklist": 1,
"do_log": 1,
"user_region": "expr_perf_test",
"is_valid": "yes",
"groups": [
{
"regions": [
{
"table_name": "EXPR_LITERAL_PERF_CONFIG",
"table_type": "expr",
"table_content": {
"keywords": "today&yesterday",
"expr_type": "and",
"match_method": "sub",
"format": "uncase plain"
}
}
]
}
]
},
{
"compile_id": 214,
"service": 0,
"action": 0,
"do_blacklist": 0,
"do_log": 0,
"user_region": "flag_perf_test",
"is_valid": "yes",
"groups": [
{
"regions": [
{
"table_type": "flag",
"table_name": "FLAG_PERF_CONFIG",
"table_content": {
"flag": 15,
"flag_mask": 15
}
}
]
}
]
},
{
"compile_id": 215,
"service": 1,
"action": 1,
"do_blacklist": 1,
"do_log": 1,
"user_region": "expr_perf_test",
"is_valid": "yes",
"groups": [
{
"regions": [
{
"table_name": "EXPR_REGEX_PERF_CONFIG",
"table_type": "expr",
"table_content": {
"keywords": "action=search\\&query=(.*)",
"expr_type": "regex",
"match_method": "sub",
"format": "uncase plain"
}
}
]
}
]
}
],
"plugin_table": [