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

使用有向图（Directed Acyclic Graph）描述分组间的引用关系，引入igraph库。

Browse Source
This commit is contained in:
zhengchao
2019-05-03 20:26:37 +08:00
parent 0cdf2224b6
commit 29c4d7ebf3
7 changed files with 233 additions and 161 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
src/CMakeLists.txt
View File

@@ -20,6 +20,7 @@ set_target_properties(maat_frame_static PROPERTIES CLEAN_DIRECT_OUTPUT 1)
target_include_directories(maat_frame_static PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/inc_internal/) target_include_directories(maat_frame_static PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/inc_internal/)
#target_include_directories(maat_frame_static PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/inc_internal/hiredis) #target_include_directories(maat_frame_static PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/inc_internal/hiredis)
target_link_libraries(maat_frame_static hiredis-vip-static) target_link_libraries(maat_frame_static hiredis-vip-static)
target_link_libraries(maat_frame_static igraph-static)
# Shared Library Output # Shared Library Output
add_library(maat_frame_shared SHARED ${MAAT_SRC}) add_library(maat_frame_shared SHARED ${MAAT_SRC})
@@ -32,6 +33,7 @@ set_target_properties(maat_frame_shared PROPERTIES LINK_FLAGS "-Wl,--version-scr
target_include_directories(maat_frame_shared PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/inc_internal/) target_include_directories(maat_frame_shared PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/inc_internal/)
target_include_directories(maat_frame_shared PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/inc_internal/hiredis) target_include_directories(maat_frame_shared PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/inc_internal/hiredis)
target_link_libraries(maat_frame_shared hiredis-vip-static ${MAAT_DEPEND_DYN_LIB}) target_link_libraries(maat_frame_shared hiredis-vip-static ${MAAT_DEPEND_DYN_LIB})
target_link_libraries(maat_frame_shared igraph-static ${MAAT_DEPEND_DYN_LIB})
install(FILES ${PROJECT_SOURCE_DIR}/inc/Maat_rule.h DESTINATION include/MESA/) install(FILES ${PROJECT_SOURCE_DIR}/inc/Maat_rule.h DESTINATION include/MESA/)
install(FILES ${PROJECT_SOURCE_DIR}/inc/Maat_command.h DESTINATION include/MESA/) install(FILES ${PROJECT_SOURCE_DIR}/inc/Maat_command.h DESTINATION include/MESA/)

40
src/entry/Maat_api.cpp
View File

@@ -135,9 +135,9 @@ size_t pickup_hit_region_from_compile(struct bool_expr *compile_hit,
} }
return k; return k;
} }
void fill_maat_rule(struct Maat_rule_t *rule, const struct _head_Maat_rule_t* rule_head, const char* srv_def, int srv_def_len) void fill_maat_rule(struct Maat_rule_t *rule, const struct _head_Maat_rule* rule_head, const char* srv_def, int srv_def_len)
{ {
memcpy(rule, rule_head, sizeof(struct _head_Maat_rule_t)); memcpy(rule, rule_head, sizeof(struct _head_Maat_rule));
memcpy(rule->service_defined, srv_def, MIN(srv_def_len,MAX_SERVICE_DEFINE_LEN)); memcpy(rule->service_defined, srv_def, MIN(srv_def_len,MAX_SERVICE_DEFINE_LEN));
return; return;
} }
@@ -158,21 +158,21 @@ int region_compile(_Maat_feather_t*feather,struct _INNER_scan_status_t *_mid,int
int shortcut_avilable_cnt=0; int shortcut_avilable_cnt=0;
unsigned char has_not_flag=0; unsigned char has_not_flag=0;
struct bool_matcher* bm=feather->scanner->bool_matcher_expr_compiler; struct bool_matcher* bm=feather->scanner->bool_matcher_expr_compiler;
struct Maat_group_inner_t* group_rule=NULL; struct Maat_group_inner* group_rule=NULL;
struct Maat_compile_inner_t* array_mi_rule[MAX_SCANNER_HIT_NUM]; struct Maat_compile_inner* array_mi_rule[MAX_SCANNER_HIT_NUM];
struct Maat_compile_inner_t* _mi_rule=NULL; struct Maat_compile_inner* _mi_rule=NULL;
int region_pos[MAX_SCANNER_HIT_NUM]; int region_pos[MAX_SCANNER_HIT_NUM];
_mid->cur_hit_cnt=0; _mid->cur_hit_cnt=0;
for(i=0;i<region_hit_num;i++) for(i=0;i<region_hit_num;i++)
{ {
group_rule=*(struct Maat_group_inner_t**)((char*)region_hit+region_type_size*i+group_offset); group_rule=*(struct Maat_group_inner**)((char*)region_hit+region_type_size*i+group_offset);
if(group_rule->group_id<0) if(group_rule->group_id<0)
{ {
continue; continue;
} }
if(group_rule->compile_shortcut!=NULL&&group_rule->ref_cnt==1&&shortcut_avilable_cnt<MAX_SCANNER_HIT_NUM) if(group_rule->compile_shortcut!=NULL&&group_rule->ref_cnt==1&&shortcut_avilable_cnt<MAX_SCANNER_HIT_NUM)
{ {
array_mi_rule[shortcut_avilable_cnt]=(struct Maat_compile_inner_t*)(group_rule->compile_shortcut); array_mi_rule[shortcut_avilable_cnt]=(struct Maat_compile_inner*)(group_rule->compile_shortcut);
shortcut_avilable_cnt++; shortcut_avilable_cnt++;
} }
_mid->cur_hit_id[_mid->cur_hit_cnt]=group_rule->group_id; _mid->cur_hit_id[_mid->cur_hit_cnt]=group_rule->group_id;
@@ -252,15 +252,15 @@ int region_compile(_Maat_feather_t*feather,struct _INNER_scan_status_t *_mid,int
return result_cnt; return result_cnt;
} }
int exprid2region_id(struct Maat_group_inner_t* group_rule,int expr_id,int* district_id) int exprid2region_id(struct Maat_group_inner* group_rule,int expr_id,int* district_id)
{ {
int i=0,region_id=-1; int i=0,region_id=-1;
struct _Maat_region_inner_t* region_rule=NULL; struct Maat_region_inner* region_rule=NULL;
assert(group_rule->group_id>=0); assert(group_rule->group_id>=0);
pthread_mutex_lock(&(group_rule->mutex)); pthread_mutex_lock(&(group_rule->mutex));
for(i=0;i<group_rule->region_boundary;i++) for(i=0;i<group_rule->region_boundary;i++)
{ {
region_rule=(struct _Maat_region_inner_t*)dynamic_array_read(group_rule->regions, i); region_rule=(struct Maat_region_inner*)dynamic_array_read(group_rule->regions, i);
if(region_rule==NULL) if(region_rule==NULL)
{ {
continue; continue;
@@ -277,13 +277,13 @@ int exprid2region_id(struct Maat_group_inner_t* group_rule,int expr_id,int* dist
} }
int match_district(struct _OUTER_scan_status_t *_mid,scan_result_t *region_hit,int region_hit_num) int match_district(struct _OUTER_scan_status_t *_mid,scan_result_t *region_hit,int region_hit_num)
{ {
struct Maat_group_inner_t* group_rule=NULL; struct Maat_group_inner* group_rule=NULL;
int i=0; int i=0;
int district_id=-1,region_id=-1; int district_id=-1,region_id=-1;
int ret_region_num=region_hit_num; int ret_region_num=region_hit_num;
while(i<ret_region_num) while(i<ret_region_num)
{ {
group_rule=(struct Maat_group_inner_t*)(region_hit[i].tag); group_rule=(struct Maat_group_inner*)(region_hit[i].tag);
region_id=exprid2region_id(group_rule, region_hit[i].expr_id,&district_id); region_id=exprid2region_id(group_rule, region_hit[i].expr_id,&district_id);
if(region_id>0&&district_id!=_mid->district_id) if(region_id>0&&district_id!=_mid->district_id)
{ {
@@ -379,7 +379,7 @@ int fill_region_hit_detail(const char* scan_buff,const _INNER_scan_status_t* _mi
memset(r_in_c_flag,0,sizeof(r_in_c_flag)); memset(r_in_c_flag,0,sizeof(r_in_c_flag));
memset(region_pos,0,sizeof(region_pos)); memset(region_pos,0,sizeof(region_pos));
struct Maat_group_inner_t* group_rule=NULL; struct Maat_group_inner* group_rule=NULL;
//for each hitted compile cfg,find its region_ids //for each hitted compile cfg,find its region_ids
for(i=0;i<compile_cnt&&i<detail_num;i++) for(i=0;i<compile_cnt&&i<detail_num;i++)
{ {
@@ -391,7 +391,7 @@ int fill_region_hit_detail(const char* scan_buff,const _INNER_scan_status_t* _mi
{ {
pos=region_pos[j]; pos=region_pos[j];
r_in_c_flag[pos]=1; r_in_c_flag[pos]=1;
group_rule=(struct Maat_group_inner_t*)(region_hit[pos].tag); group_rule=(struct Maat_group_inner*)(region_hit[pos].tag);
region_id=exprid2region_id(group_rule,region_hit[pos].expr_id,&district_id); region_id=exprid2region_id(group_rule,region_hit[pos].expr_id,&district_id);
if(region_id<0) if(region_id<0)
{ {
@@ -411,7 +411,7 @@ int fill_region_hit_detail(const char* scan_buff,const _INNER_scan_status_t* _mi
{ {
if(r_in_c_flag[k]==0) if(r_in_c_flag[k]==0)
{ {
group_rule=(struct Maat_group_inner_t*)(region_hit[k].tag); group_rule=(struct Maat_group_inner*)(region_hit[k].tag);
hit_detail[j].config_id=-2; hit_detail[j].config_id=-2;
hit_detail[j].hit_region_cnt=1; hit_detail[j].hit_region_cnt=1;
hit_detail[j].region_pos[0].region_id=exprid2region_id(group_rule,region_hit[k].expr_id,&district_id); hit_detail[j].region_pos[0].region_id=exprid2region_id(group_rule,region_hit[k].expr_id,&district_id);
@@ -1042,7 +1042,7 @@ int Maat_table_callback_register(Maat_feather_t feather,short table_id,
void rule_ex_data_new_cb(const uchar * key, uint size, void * data, void * user) void rule_ex_data_new_cb(const uchar * key, uint size, void * data, void * user)
{ {
struct compile_ex_data_idx *ex_desc=(struct compile_ex_data_idx*)user; struct compile_ex_data_idx *ex_desc=(struct compile_ex_data_idx*)user;
struct Maat_compile_inner_t *compile_inner=(struct Maat_compile_inner_t *)data; struct Maat_compile_inner *compile_inner=(struct Maat_compile_inner *)data;
MAAT_RULE_EX_DATA ad=NULL; MAAT_RULE_EX_DATA ad=NULL;
if(compile_inner->ref_table==NULL || compile_inner->ref_table->table_id!=ex_desc->table_id || compile_inner->db_c_rule==NULL) if(compile_inner->ref_table==NULL || compile_inner->ref_table->table_id!=ex_desc->table_id || compile_inner->db_c_rule==NULL)
@@ -1104,12 +1104,12 @@ failed:
MAAT_RULE_EX_DATA Maat_rule_get_ex_data(Maat_feather_t feather, const struct Maat_rule_t* rule, int idx) MAAT_RULE_EX_DATA Maat_rule_get_ex_data(Maat_feather_t feather, const struct Maat_rule_t* rule, int idx)
{ {
struct _Maat_feather_t *_feather=(struct _Maat_feather_t *)feather; struct _Maat_feather_t *_feather=(struct _Maat_feather_t *)feather;
struct Maat_compile_inner_t *compile_inner=NULL; struct Maat_compile_inner *compile_inner=NULL;
const struct compile_table_desc* compile_desc=NULL; const struct compile_table_desc* compile_desc=NULL;
const struct compile_ex_data_idx* ex_desc=NULL; const struct compile_ex_data_idx* ex_desc=NULL;
MAAT_RULE_EX_DATA ad=NULL; MAAT_RULE_EX_DATA ad=NULL;
compile_inner=(struct Maat_compile_inner_t *)HASH_fetch_by_id(_feather->scanner->compile_hash, rule->config_id); compile_inner=(struct Maat_compile_inner *)HASH_fetch_by_id(_feather->scanner->compile_hash, rule->config_id);
if(compile_inner==NULL) if(compile_inner==NULL)
{ {
return NULL; return NULL;
@@ -2153,11 +2153,11 @@ int Maat_read_rule(Maat_feather_t feather, const struct Maat_rule_t* rule, enum
{ {
int ret=0; int ret=0;
struct _Maat_feather_t *_feather=(struct _Maat_feather_t *)feather; struct _Maat_feather_t *_feather=(struct _Maat_feather_t *)feather;
struct Maat_compile_inner_t *compile_inner=NULL; struct Maat_compile_inner *compile_inner=NULL;
switch(type) switch(type)
{ {
case MAAT_RULE_SERV_DEFINE: case MAAT_RULE_SERV_DEFINE:
compile_inner=(struct Maat_compile_inner_t *)HASH_fetch_by_id(_feather->scanner->compile_hash, rule->config_id); compile_inner=(struct Maat_compile_inner *)HASH_fetch_by_id(_feather->scanner->compile_hash, rule->config_id);
if(compile_inner==NULL) if(compile_inner==NULL)
{ {
ret=0; ret=0;

20
src/entry/Maat_command.cpp
View File

@@ -836,9 +836,9 @@ int reconstruct_cmd(struct _Maat_feather_t *feather, struct _Maat_cmd_inner_t* _
struct Maat_group_t* group_cmd=NULL; struct Maat_group_t* group_cmd=NULL;
struct Maat_region_t* region_cmd=NULL; struct Maat_region_t* region_cmd=NULL;
struct Maat_compile_inner_t *compile_inner=NULL; struct Maat_compile_inner *compile_inner=NULL;
struct Maat_group_inner_t* group_inner=NULL; struct Maat_group_inner* group_inner=NULL;
struct _Maat_region_inner_t* region_inner=NULL; struct Maat_region_inner* region_inner=NULL;
void* logger=feather->logger; void* logger=feather->logger;
int config_id=cmd->compile.config_id; int config_id=cmd->compile.config_id;
@@ -848,7 +848,7 @@ int reconstruct_cmd(struct _Maat_feather_t *feather, struct _Maat_cmd_inner_t* _
,"MAAT not ready."); ,"MAAT not ready.");
return -1; return -1;
} }
compile_inner=(struct Maat_compile_inner_t *)HASH_fetch_by_id(feather->scanner->compile_hash, config_id); compile_inner=(struct Maat_compile_inner *)HASH_fetch_by_id(feather->scanner->compile_hash, config_id);
//Operation on compile_inner is thread safe, no immediate memory free when delete a compile rule or a scanner. //Operation on compile_inner is thread safe, no immediate memory free when delete a compile rule or a scanner.
//In another words, if the compile_inner is accessable from compile means, its was valid in at least 10 seconds (garbage bury). //In another words, if the compile_inner is accessable from compile means, its was valid in at least 10 seconds (garbage bury).
if(compile_inner==NULL) if(compile_inner==NULL)
@@ -864,7 +864,7 @@ int reconstruct_cmd(struct _Maat_feather_t *feather, struct _Maat_cmd_inner_t* _
cmd->groups=(struct Maat_group_t*)calloc(sizeof(struct Maat_group_t),cmd->group_num); cmd->groups=(struct Maat_group_t*)calloc(sizeof(struct Maat_group_t),cmd->group_num);
for(i=0;i<compile_inner->group_boundary;i++) for(i=0;i<compile_inner->group_boundary;i++)
{ {
group_inner=(struct Maat_group_inner_t*)dynamic_array_read(compile_inner->groups,i); group_inner=(struct Maat_group_inner*)dynamic_array_read(compile_inner->groups,i);
if(group_inner==NULL) if(group_inner==NULL)
{ {
continue; continue;
@@ -880,7 +880,7 @@ int reconstruct_cmd(struct _Maat_feather_t *feather, struct _Maat_cmd_inner_t* _
group_cmd->regions=(struct Maat_region_t*)calloc(sizeof(struct Maat_region_t),group_cmd->region_num); group_cmd->regions=(struct Maat_region_t*)calloc(sizeof(struct Maat_region_t),group_cmd->region_num);
for(j=0;j<group_inner->region_boundary;j++) for(j=0;j<group_inner->region_boundary;j++)
{ {
region_inner=(struct _Maat_region_inner_t*)dynamic_array_read(group_inner->regions,j); region_inner=(struct Maat_region_inner*)dynamic_array_read(group_inner->regions,j);
if(region_inner==NULL) if(region_inner==NULL)
{ {
continue; continue;
@@ -1358,10 +1358,10 @@ int fix_table_name(_Maat_feather_t* feather,struct Maat_cmd_t* cmd)
struct Maat_region_t* p_region=NULL; struct Maat_region_t* p_region=NULL;
enum MAAT_TABLE_TYPE table_type; enum MAAT_TABLE_TYPE table_type;
struct Maat_compile_inner_t *compile_rule=NULL; struct Maat_compile_inner *compile_rule=NULL;
if(feather->scanner!=NULL) if(feather->scanner!=NULL)
{ {
compile_rule=(struct Maat_compile_inner_t*)HASH_fetch_by_id(feather->scanner->compile_hash, cmd->compile.config_id); compile_rule=(struct Maat_compile_inner*)HASH_fetch_by_id(feather->scanner->compile_hash, cmd->compile.config_id);
if(compile_rule!=NULL) if(compile_rule!=NULL)
{ {
MESA_handle_runtime_log(feather->logger,RLOG_LV_FATAL,maat_module MESA_handle_runtime_log(feather->logger,RLOG_LV_FATAL,maat_module
@@ -2056,8 +2056,8 @@ int Maat_cmd_set_group(Maat_feather_t feather,int group_id, const struct Maat_re
if(_feather->AUTO_NUMBERING_ON==1) if(_feather->AUTO_NUMBERING_ON==1)
{ {
return -1; return -1;
} }
//struct Maat_group_inner_t* group_inner=NULL; //struct Maat_group_inner* group_inner=NULL;
//group_inner=(struct Maat_group_inner*)HASH_fetch_by_id(_feather->scanner->group_hash, group_id); //group_inner=(struct Maat_group_inner*)HASH_fetch_by_id(_feather->scanner->group_hash, group_id);
//NOT implemented yet. //NOT implemented yet.
assert(0); assert(0);

274
src/entry/Maat_rule.cpp
View File

@@ -506,7 +506,7 @@ int HASH_delete_by_id(MESA_htable_handle hash,int id)
ret=MESA_htable_del(hash,(unsigned char*)&id, sizeof(id), NULL); ret=MESA_htable_del(hash,(unsigned char*)&id, sizeof(id), NULL);
return ret; return ret;
} }
MAAT_RULE_EX_DATA rule_ex_data_new(const struct _head_Maat_rule_t * rule_head, const char* srv_def, const struct compile_ex_data_idx* ex_desc) MAAT_RULE_EX_DATA rule_ex_data_new(const struct _head_Maat_rule * rule_head, const char* srv_def, const struct compile_ex_data_idx* ex_desc)
{ {
MAAT_RULE_EX_DATA ad=NULL; MAAT_RULE_EX_DATA ad=NULL;
struct Maat_rule_t rule; struct Maat_rule_t rule;
@@ -514,7 +514,7 @@ MAAT_RULE_EX_DATA rule_ex_data_new(const struct _head_Maat_rule_t * rule_head, c
ex_desc->new_func(ex_desc->idx, &rule, srv_def, &ad, ex_desc->argl,ex_desc->argp); ex_desc->new_func(ex_desc->idx, &rule, srv_def, &ad, ex_desc->argl,ex_desc->argp);
return ad; return ad;
} }
void rule_ex_data_free(const struct _head_Maat_rule_t * rule_head, const char* srv_def, MAAT_RULE_EX_DATA *ad, const struct compile_ex_data_idx* ex_desc) void rule_ex_data_free(const struct _head_Maat_rule * rule_head, const char* srv_def, MAAT_RULE_EX_DATA *ad, const struct compile_ex_data_idx* ex_desc)
{ {
struct Maat_rule_t rule; struct Maat_rule_t rule;
fill_maat_rule(&rule, rule_head, srv_def, strlen(srv_def)+1); fill_maat_rule(&rule, rule_head, srv_def, strlen(srv_def)+1);
@@ -836,9 +836,9 @@ error_jump:
map_destroy(string2int_map); map_destroy(string2int_map);
return table_cnt; return table_cnt;
} }
struct Maat_group_inner_t* create_group_rule(int group_id) struct Maat_group_inner* create_group_rule(int group_id)
{ {
struct Maat_group_inner_t* group=(struct Maat_group_inner_t*)malloc(sizeof(struct Maat_group_inner_t)); struct Maat_group_inner* group=(struct Maat_group_inner*)malloc(sizeof(struct Maat_group_inner));
group->group_id=group_id; group->group_id=group_id;
group->region_cnt=0; group->region_cnt=0;
group->region_boundary=0; group->region_boundary=0;
@@ -850,7 +850,7 @@ struct Maat_group_inner_t* create_group_rule(int group_id)
pthread_mutex_init(&(group->mutex), NULL); pthread_mutex_init(&(group->mutex), NULL);
return group; return group;
} }
void _destroy_group_rule(struct Maat_group_inner_t* group) void _destroy_group_rule(struct Maat_group_inner* group)
{ {
dynamic_array_destroy(group->regions,free); dynamic_array_destroy(group->regions,free);
group->region_cnt=0; group->region_cnt=0;
@@ -865,7 +865,7 @@ void _destroy_group_rule(struct Maat_group_inner_t* group)
free(group); free(group);
} }
void destroy_group_rule(struct Maat_group_inner_t* group) void destroy_group_rule(struct Maat_group_inner* group)
{ {
if(group->ref_cnt>0||group->region_cnt>0) if(group->ref_cnt>0||group->region_cnt>0)
@@ -874,15 +874,15 @@ void destroy_group_rule(struct Maat_group_inner_t* group)
} }
_destroy_group_rule(group); _destroy_group_rule(group);
} }
void make_group_set(struct Maat_compile_inner_t* compile_rule, struct bool_expr* a_set, unsigned char *has_not) void make_group_set(struct Maat_compile_inner* compile_rule, struct bool_expr* a_set, unsigned char *has_not)
{ {
int i=0,j=0; int i=0,j=0;
a_set->user_tag=compile_rule; a_set->user_tag=compile_rule;
struct Maat_group_inner_t*group=NULL; struct Maat_group_inner*group=NULL;
assert(compile_rule->group_cnt<=MAX_ITEMS_PER_BOOL_EXPR); assert(compile_rule->group_cnt<=MAX_ITEMS_PER_BOOL_EXPR);
for(i=0,j=0;i<compile_rule->group_boundary&&j<MAX_ITEMS_PER_BOOL_EXPR;i++) for(i=0,j=0;i<compile_rule->group_boundary&&j<MAX_ITEMS_PER_BOOL_EXPR;i++)
{ {
group=(struct Maat_group_inner_t*)dynamic_array_read(compile_rule->groups, i); group=(struct Maat_group_inner*)dynamic_array_read(compile_rule->groups, i);
if(group==NULL) if(group==NULL)
{ {
continue; continue;
@@ -906,7 +906,7 @@ struct compile_walker
void walk_compile_hash(const uchar * key, uint size, void * data, void * user) void walk_compile_hash(const uchar * key, uint size, void * data, void * user)
{ {
struct bool_expr* one_set=NULL; struct bool_expr* one_set=NULL;
struct Maat_compile_inner_t* compile_rule=(struct Maat_compile_inner_t*)data; struct Maat_compile_inner* compile_rule=(struct Maat_compile_inner*)data;
struct compile_walker* walker=(struct compile_walker*)user; struct compile_walker* walker=(struct compile_walker*)user;
unsigned char has_not_flag=0; unsigned char has_not_flag=0;
MESA_lqueue_head update_q=walker->update_q; MESA_lqueue_head update_q=walker->update_q;
@@ -994,9 +994,9 @@ void EMPTY_FREE(void*p)
{ {
return; return;
} }
struct Maat_compile_inner_t * create_compile_rule(int compile_id) struct Maat_compile_inner * create_compile_rule(int compile_id)
{ {
struct Maat_compile_inner_t* p=ALLOC(struct Maat_compile_inner_t,1); struct Maat_compile_inner* p=ALLOC(struct Maat_compile_inner,1);
p->compile_id=compile_id; p->compile_id=compile_id;
p->group_cnt=0; p->group_cnt=0;
p->group_boundary=1; p->group_boundary=1;
@@ -1005,11 +1005,11 @@ struct Maat_compile_inner_t * create_compile_rule(int compile_id)
pthread_rwlock_init(&(p->rwlock), NULL); pthread_rwlock_init(&(p->rwlock), NULL);
return p; return p;
} }
void _destroy_compile_rule(struct Maat_compile_inner_t * compile_rule) void _destroy_compile_rule(struct Maat_compile_inner * compile_rule)
{ {
const struct Maat_table_desc* table=compile_rule->ref_table; const struct Maat_table_desc* table=compile_rule->ref_table;
const struct compile_table_desc* compile_desc=&(table->compile); const struct compile_table_desc* compile_desc=&(table->compile);
struct db_compile_rule_t* db_compile_rule=compile_rule->db_c_rule; struct db_compile_rule* db_compile_rule=compile_rule->db_c_rule;
int i=0; int i=0;
compile_rule->compile_id=-1; compile_rule->compile_id=-1;
dynamic_array_destroy(compile_rule->groups,NULL); dynamic_array_destroy(compile_rule->groups,NULL);
@@ -1035,14 +1035,14 @@ void _destroy_compile_rule(struct Maat_compile_inner_t * compile_rule)
pthread_rwlock_destroy(&(compile_rule->rwlock)); pthread_rwlock_destroy(&(compile_rule->rwlock));
free(compile_rule); free(compile_rule);
} }
void destroy_compile_rule(struct Maat_compile_inner_t * p) void destroy_compile_rule(struct Maat_compile_inner * p)
{ {
int i=0; int i=0;
UNUSED struct Maat_compile_inner_t* p_group=NULL; UNUSED struct Maat_compile_inner* p_group=NULL;
assert(p->group_cnt==0); assert(p->group_cnt==0);
for(i=0;i<p->group_boundary;i++) for(i=0;i<p->group_boundary;i++)
{ {
p_group=(struct Maat_compile_inner_t*)dynamic_array_read(p->groups,i); p_group=(struct Maat_compile_inner*)dynamic_array_read(p->groups,i);
assert(p_group==NULL); assert(p_group==NULL);
} }
_destroy_compile_rule(p); _destroy_compile_rule(p);
@@ -1107,7 +1107,7 @@ void destroy_rs_ip_rule(scan_rule_t* p)
{ {
free(p); free(p);
} }
scan_rule_t* create_rs_intval_rule(unsigned int sub_type,struct db_intval_rule_t *intval_rule) scan_rule_t* create_rs_intval_rule(unsigned int sub_type,struct db_intval_rule *intval_rule)
{ {
scan_rule_t *p_rule=(scan_rule_t*)calloc(sizeof(scan_rule_t),1); scan_rule_t *p_rule=(scan_rule_t*)calloc(sizeof(scan_rule_t),1);
p_rule->rule_type=RULETYPE_INT; p_rule->rule_type=RULETYPE_INT;
@@ -1173,7 +1173,7 @@ void op_expr_add_rule(struct op_expr_t* op_expr,scan_rule_t* p_rule)
return; return;
} }
GIE_digest_t* create_digest_rule(unsigned int id, enum GIE_operation op,const char* digest, GIE_digest_t* create_digest_rule(unsigned int id, enum GIE_operation op,const char* digest,
short cfds_lvl,struct Maat_group_inner_t* tag) short cfds_lvl,struct Maat_group_inner* tag)
{ {
GIE_digest_t* rule=(GIE_digest_t*)calloc(sizeof(GIE_digest_t),1); GIE_digest_t* rule=(GIE_digest_t*)calloc(sizeof(GIE_digest_t),1);
int digest_len=0; int digest_len=0;
@@ -1328,6 +1328,9 @@ struct Maat_scanner_t* create_maat_scanner(unsigned int version,_Maat_feather_t
scanner->region_hash=MESA_htable_create(&hargs, sizeof(hargs)); scanner->region_hash=MESA_htable_create(&hargs, sizeof(hargs));
MESA_htable_print_crtl(scanner->region_hash,0); MESA_htable_print_crtl(scanner->region_hash,0);
ret=igraph_empty(&scanner->group_graph, 0, IGRAPH_DIRECTED);
assert(ret==IGRAPH_SUCCESS);
scanner->district_map=map_create(); scanner->district_map=map_create();
scanner->version=version; scanner->version=version;
@@ -1413,6 +1416,7 @@ void destroy_maat_scanner(struct Maat_scanner_t*scanner)
{ {
table_runtime_free(scanner->table_rt[i]); table_runtime_free(scanner->table_rt[i]);
} }
igraph_destroy(&scanner->group_graph);
free(scanner); free(scanner);
return; return;
} }
@@ -1648,13 +1652,13 @@ void digest_batch_update(GIE_handle_t* handle,MESA_lqueue_head update_q,void*log
update_array=NULL; update_array=NULL;
return; return;
} }
struct Maat_group_inner_t* add_region_to_group(struct Maat_group_inner_t* group,int table_id,int region_id,int district_id,int expr_id,enum MAAT_TABLE_TYPE region_type) struct Maat_group_inner* add_region_to_group(struct Maat_group_inner* group,int table_id,int region_id,int district_id,int expr_id,enum MAAT_TABLE_TYPE region_type)
{ {
int i=0; int i=0;
struct _Maat_region_inner_t* region_rule=NULL; struct Maat_region_inner* region_rule=NULL;
for(i=0;i<group->region_boundary;i++) for(i=0;i<group->region_boundary;i++)
{ {
region_rule=(struct _Maat_region_inner_t*)dynamic_array_read(group->regions, i); region_rule=(struct Maat_region_inner*)dynamic_array_read(group->regions, i);
if(region_rule==NULL) if(region_rule==NULL)
{ {
continue; continue;
@@ -1666,7 +1670,7 @@ struct Maat_group_inner_t* add_region_to_group(struct Maat_group_inner_t* group,
} }
if(i==group->region_boundary)//new region if(i==group->region_boundary)//new region
{ {
region_rule=(struct _Maat_region_inner_t*)malloc(sizeof(struct _Maat_region_inner_t)); region_rule=(struct Maat_region_inner*)malloc(sizeof(struct Maat_region_inner));
region_rule->region_id=region_id; region_rule->region_id=region_id;
region_rule->expr_id_cnt=1; region_rule->expr_id_cnt=1;
region_rule->expr_id_ub=region_rule->expr_id_lb=expr_id; region_rule->expr_id_ub=region_rule->expr_id_lb=expr_id;
@@ -1687,11 +1691,11 @@ struct Maat_group_inner_t* add_region_to_group(struct Maat_group_inner_t* group,
} }
return group; return group;
} }
void cancel_last_region_from_group(struct Maat_group_inner_t* group,int region_id,int expr_id) void cancel_last_region_from_group(struct Maat_group_inner* group,int region_id,int expr_id)
{ {
struct _Maat_region_inner_t* region_rule=NULL; struct Maat_region_inner* region_rule=NULL;
pthread_mutex_lock(&(group->mutex)); pthread_mutex_lock(&(group->mutex));
region_rule=(struct _Maat_region_inner_t*)dynamic_array_read(group->regions,group->region_boundary-1); region_rule=(struct Maat_region_inner*)dynamic_array_read(group->regions,group->region_boundary-1);
assert(region_rule->expr_id_ub==expr_id&&region_rule->region_id==region_id); assert(region_rule->expr_id_ub==expr_id&&region_rule->region_id==region_id);
if(region_rule->expr_id_cnt==1) if(region_rule->expr_id_cnt==1)
{ {
@@ -1708,14 +1712,14 @@ void cancel_last_region_from_group(struct Maat_group_inner_t* group,int region_i
pthread_mutex_unlock(&(group->mutex)); pthread_mutex_unlock(&(group->mutex));
return; return;
} }
unsigned int del_region_from_group(struct Maat_group_inner_t* group,int region_id,unsigned int *output_expr_id,int output_size) unsigned int del_region_from_group(struct Maat_group_inner* group,int region_id,unsigned int *output_expr_id,int output_size)
{ {
int i=0,j=0; int i=0,j=0;
struct _Maat_region_inner_t* region_rule=NULL; struct Maat_region_inner* region_rule=NULL;
pthread_mutex_lock(&(group->mutex)); pthread_mutex_lock(&(group->mutex));
for(i=0;i<group->region_boundary;i++) for(i=0;i<group->region_boundary;i++)
{ {
region_rule=(struct _Maat_region_inner_t*)dynamic_array_read(group->regions, i); region_rule=(struct Maat_region_inner*)dynamic_array_read(group->regions, i);
if(region_rule==NULL) if(region_rule==NULL)
{ {
continue; continue;
@@ -1740,11 +1744,11 @@ unsigned int del_region_from_group(struct Maat_group_inner_t* group,int region_i
return j; return j;
} }
int add_group_to_compile(struct Maat_compile_inner_t*a_compile_rule,struct Maat_group_inner_t* a_rule_group, int not_flag) int add_group_to_compile(struct Maat_compile_inner*a_compile_rule,struct Maat_group_inner* a_rule_group, int not_flag)
{ {
int i=0,ret=-1; int i=0,ret=-1;
int write_pos=-1; int write_pos=-1;
struct Maat_group_inner_t* p=NULL; struct Maat_group_inner* p=NULL;
pthread_rwlock_wrlock(&(a_compile_rule->rwlock)); pthread_rwlock_wrlock(&(a_compile_rule->rwlock));
if(a_compile_rule->db_c_rule!=NULL if(a_compile_rule->db_c_rule!=NULL
&&a_compile_rule->group_cnt>=a_compile_rule->db_c_rule->declare_grp_num &&a_compile_rule->group_cnt>=a_compile_rule->db_c_rule->declare_grp_num
@@ -1756,7 +1760,7 @@ int add_group_to_compile(struct Maat_compile_inner_t*a_compile_rule,struct Maat_
for(i=0;i<a_compile_rule->group_boundary;i++) for(i=0;i<a_compile_rule->group_boundary;i++)
{ {
p=(struct Maat_group_inner_t*)dynamic_array_read(a_compile_rule->groups,i); p=(struct Maat_group_inner*)dynamic_array_read(a_compile_rule->groups,i);
if(p==NULL) if(p==NULL)
{ {
write_pos=i; write_pos=i;
@@ -1807,7 +1811,7 @@ int add_group_to_compile(struct Maat_compile_inner_t*a_compile_rule,struct Maat_
{ {
for(i=0;i<a_compile_rule->group_boundary;i++) for(i=0;i<a_compile_rule->group_boundary;i++)
{ {
p=(struct Maat_group_inner_t*)dynamic_array_read(a_compile_rule->groups,i); p=(struct Maat_group_inner*)dynamic_array_read(a_compile_rule->groups,i);
if(p!=NULL) if(p!=NULL)
{ {
p->compile_shortcut=NULL; p->compile_shortcut=NULL;
@@ -1820,14 +1824,14 @@ error_out:
return ret; return ret;
} }
struct Maat_group_inner_t* del_group_from_compile(struct Maat_compile_inner_t*a_compile_rule,int group_id) struct Maat_group_inner* del_group_from_compile(struct Maat_compile_inner*a_compile_rule,int group_id)
{ {
int i=0; int i=0;
struct Maat_group_inner_t* group_rule=NULL; struct Maat_group_inner* group_rule=NULL;
pthread_rwlock_wrlock(&(a_compile_rule->rwlock)); pthread_rwlock_wrlock(&(a_compile_rule->rwlock));
for(i=0;i<MAAT_MAX_EXPR_ITEM_NUM;i++) for(i=0;i<MAAT_MAX_EXPR_ITEM_NUM;i++)
{ {
group_rule=(struct Maat_group_inner_t*)dynamic_array_read(a_compile_rule->groups,i); group_rule=(struct Maat_group_inner*)dynamic_array_read(a_compile_rule->groups,i);
if(group_rule==NULL) if(group_rule==NULL)
{ {
continue; continue;
@@ -1905,7 +1909,7 @@ int add_expr_rule(struct Maat_table_desc* table,struct db_str_rule_t* db_rule,st
int expr_id=0,district_id=-1; int expr_id=0,district_id=-1;
struct expr_table_desc* expr_desc=&(table->expr); struct expr_table_desc* expr_desc=&(table->expr);
scan_rule_t*p_rule=NULL; scan_rule_t*p_rule=NULL;
struct Maat_group_inner_t* group_rule=NULL; struct Maat_group_inner* group_rule=NULL;
enum MAAT_CHARSET dst_charset=CHARSET_NONE; enum MAAT_CHARSET dst_charset=CHARSET_NONE;
char *sub_key_array[MAAT_MAX_EXPR_ITEM_NUM]; char *sub_key_array[MAAT_MAX_EXPR_ITEM_NUM];
int key_left_offset[MAAT_MAX_EXPR_ITEM_NUM]={-1},key_right_offset[MAAT_MAX_EXPR_ITEM_NUM]={-1}; int key_left_offset[MAAT_MAX_EXPR_ITEM_NUM]={-1},key_right_offset[MAAT_MAX_EXPR_ITEM_NUM]={-1};
@@ -1916,7 +1920,7 @@ int add_expr_rule(struct Maat_table_desc* table,struct db_str_rule_t* db_rule,st
} }
int sub_expr_cnt=0; int sub_expr_cnt=0;
struct op_expr_t *op_expr=NULL; struct op_expr_t *op_expr=NULL;
struct Maat_group_inner_t* u_para=NULL; struct Maat_group_inner* u_para=NULL;
if(table->table_type==TABLE_TYPE_EXPR_PLUS) if(table->table_type==TABLE_TYPE_EXPR_PLUS)
{ {
@@ -1924,7 +1928,7 @@ int add_expr_rule(struct Maat_table_desc* table,struct db_str_rule_t* db_rule,st
str_unescape(db_rule->district); str_unescape(db_rule->district);
district_id=get_district_id(scanner, db_rule->district); district_id=get_district_id(scanner, db_rule->district);
} }
group_rule=(struct Maat_group_inner_t*)HASH_fetch_by_id(scanner->group_hash, db_rule->group_id); group_rule=(struct Maat_group_inner*)HASH_fetch_by_id(scanner->group_hash, db_rule->group_id);
if(group_rule==NULL) if(group_rule==NULL)
{ {
group_rule=create_group_rule(db_rule->group_id); group_rule=create_group_rule(db_rule->group_id);
@@ -2163,13 +2167,13 @@ int add_expr_rule(struct Maat_table_desc* table,struct db_str_rule_t* db_rule,st
} }
int add_ip_rule(struct Maat_table_desc* table,struct db_ip_rule_t* db_ip_rule,struct Maat_scanner_t *scanner,void* logger) int add_ip_rule(struct Maat_table_desc* table,struct db_ip_rule_t* db_ip_rule,struct Maat_scanner_t *scanner,void* logger)
{ {
struct Maat_group_inner_t* group_rule=NULL; struct Maat_group_inner* group_rule=NULL;
scan_rule_t* p_rule=NULL; scan_rule_t* p_rule=NULL;
struct op_expr_t* op_expr=NULL; struct op_expr_t* op_expr=NULL;
struct Maat_group_inner_t* u_para=NULL; struct Maat_group_inner* u_para=NULL;
int expr_id=0,district_id=-1; int expr_id=0,district_id=-1;
group_rule=(struct Maat_group_inner_t*)HASH_fetch_by_id(scanner->group_hash, db_ip_rule->group_id); group_rule=(struct Maat_group_inner*)HASH_fetch_by_id(scanner->group_hash, db_ip_rule->group_id);
if(group_rule==NULL) if(group_rule==NULL)
{ {
group_rule=create_group_rule(db_ip_rule->group_id); group_rule=create_group_rule(db_ip_rule->group_id);
@@ -2193,15 +2197,15 @@ int add_ip_rule(struct Maat_table_desc* table,struct db_ip_rule_t* db_ip_rule,st
MESA_lqueue_join_tail(scanner->region_update_q, &op_expr, sizeof(void*)); MESA_lqueue_join_tail(scanner->region_update_q, &op_expr, sizeof(void*));
return 0; return 0;
} }
int add_intval_rule(struct Maat_table_desc* table,struct db_intval_rule_t* intval_rule,struct Maat_scanner_t *scanner,void* logger) int add_intval_rule(struct Maat_table_desc* table,struct db_intval_rule* intval_rule,struct Maat_scanner_t *scanner,void* logger)
{ {
struct Maat_group_inner_t* group_rule=NULL; struct Maat_group_inner* group_rule=NULL;
scan_rule_t* p_rule=NULL; scan_rule_t* p_rule=NULL;
struct op_expr_t* op_expr=NULL; struct op_expr_t* op_expr=NULL;
struct Maat_group_inner_t* u_para=NULL; struct Maat_group_inner* u_para=NULL;
int expr_id=0,district_id=-1; int expr_id=0,district_id=-1;
group_rule=(struct Maat_group_inner_t*)HASH_fetch_by_id(scanner->group_hash, intval_rule->group_id); group_rule=(struct Maat_group_inner*)HASH_fetch_by_id(scanner->group_hash, intval_rule->group_id);
if(group_rule==NULL) if(group_rule==NULL)
{ {
group_rule=create_group_rule(intval_rule->group_id); group_rule=create_group_rule(intval_rule->group_id);
@@ -2224,15 +2228,15 @@ int add_intval_rule(struct Maat_table_desc* table,struct db_intval_rule_t* intva
MESA_lqueue_join_tail(scanner->region_update_q, &op_expr, sizeof(void*)); MESA_lqueue_join_tail(scanner->region_update_q, &op_expr, sizeof(void*));
return 0; return 0;
} }
int add_digest_rule(struct Maat_table_desc* table,struct db_digest_rule_t* db_digest_rule,struct Maat_scanner_t *scanner,void* logger) int add_digest_rule(struct Maat_table_desc* table,struct db_digest_rule* db_digest_rule,struct Maat_scanner_t *scanner,void* logger)
{ {
struct Maat_group_inner_t* group_rule=NULL; struct Maat_group_inner* group_rule=NULL;
GIE_digest_t* digest_rule=NULL; GIE_digest_t* digest_rule=NULL;
struct Maat_group_inner_t* u_para=NULL; struct Maat_group_inner* u_para=NULL;
struct Maat_table_runtime * table_rt=scanner->table_rt[table->table_id]; struct Maat_table_runtime * table_rt=scanner->table_rt[table->table_id];
int expr_id=0,district_id=-1; int expr_id=0,district_id=-1;
group_rule=(struct Maat_group_inner_t*)HASH_fetch_by_id(scanner->group_hash, db_digest_rule->group_id); group_rule=(struct Maat_group_inner*)HASH_fetch_by_id(scanner->group_hash, db_digest_rule->group_id);
if(group_rule==NULL) if(group_rule==NULL)
{ {
group_rule=create_group_rule(db_digest_rule->group_id); group_rule=create_group_rule(db_digest_rule->group_id);
@@ -2261,10 +2265,10 @@ int del_region_rule(struct Maat_table_desc* table,int region_id,int group_id,int
int i=0; int i=0;
unsigned int expr_id[MAAT_MAX_EXPR_ITEM_NUM*MAX_CHARSET_NUM]={0}; unsigned int expr_id[MAAT_MAX_EXPR_ITEM_NUM*MAX_CHARSET_NUM]={0};
int expr_num=0; int expr_num=0;
struct Maat_group_inner_t* group_rule=NULL; struct Maat_group_inner* group_rule=NULL;
struct op_expr_t* op_expr=NULL; struct op_expr_t* op_expr=NULL;
GIE_digest_t* digest_rule=NULL; GIE_digest_t* digest_rule=NULL;
group_rule=(struct Maat_group_inner_t*)HASH_fetch_by_id(maat_scanner->group_hash, group_id); group_rule=(struct Maat_group_inner*)HASH_fetch_by_id(maat_scanner->group_hash, group_id);
if(group_rule==NULL) if(group_rule==NULL)
{ {
MESA_handle_runtime_log(logger,RLOG_LV_FATAL,maat_module , MESA_handle_runtime_log(logger,RLOG_LV_FATAL,maat_module ,
@@ -2320,82 +2324,117 @@ int del_region_rule(struct Maat_table_desc* table,int region_id,int group_id,int
} }
return 0; return 0;
} }
int add_group_rule(struct Maat_table_desc* table,struct db_group_rule_t* db_group_rule,struct Maat_scanner_t *scanner,void* logger) int add_group_rule(struct Maat_table_desc* table, struct db_group_rule_t* db_group_rule, struct Maat_scanner_t *scanner, void* logger)
{ {
struct Maat_group_inner_t* group_rule=NULL; struct Maat_group_inner* group_rule=NULL, *parent_group=NULL;
struct Maat_compile_inner_t*compile_rule=NULL; struct Maat_compile_inner*compile_rule=NULL;
int ret=0; int ret=0;
group_rule=(struct Maat_group_inner_t*)HASH_fetch_by_id(scanner->group_hash, db_group_rule->group_id); group_rule=(struct Maat_group_inner*)HASH_fetch_by_id(scanner->group_hash, db_group_rule->group_id);
if(group_rule==NULL) if(group_rule==NULL)
{ {
group_rule=create_group_rule(db_group_rule->group_id); group_rule=create_group_rule(db_group_rule->group_id);
group_rule->table_id=table->table_id; group_rule->table_id=table->table_id;
ret=HASH_add_by_id(scanner->group_hash, group_rule->group_id, group_rule);
ret=HASH_add_by_id(scanner->group_hash, db_group_rule->group_id, group_rule);
assert(ret>=0); assert(ret>=0);
} }
compile_rule=(struct Maat_compile_inner_t*)HASH_fetch_by_id(scanner->compile_hash, db_group_rule->compile_id); if(db_group_rule->parent_type==PARENT_TYPE_GROUP)
if(compile_rule==NULL)
{ {
compile_rule=create_compile_rule(db_group_rule->compile_id); parent_group=(struct Maat_group_inner*)HASH_fetch_by_id(scanner->group_hash, db_group_rule->parent_id);
ret=HASH_add_by_id(scanner->compile_hash, db_group_rule->compile_id, compile_rule); if(parent_group==NULL)
assert(ret>=0); {
parent_group=create_group_rule(db_group_rule->parent_id);
parent_group->table_id=table->table_id;
ret=HASH_add_by_id(scanner->group_hash, parent_group->group_id, parent_group);
assert(ret>=0);
}
group_rule->ref_cnt++;
igraph_add_edge(&(scanner->group_graph), db_group_rule->group_id, db_group_rule->parent_id);
} }
ret=add_group_to_compile(compile_rule, group_rule, db_group_rule->not_flag); else
if(ret<0)
{ {
MESA_handle_runtime_log(logger,RLOG_LV_FATAL,maat_module, group_rule->has_compile_neighbors=1;
"update error,add group: %s %d to compile rule %d error, compile rule is full or duplicate group." compile_rule=(struct Maat_compile_inner*)HASH_fetch_by_id(scanner->compile_hash, db_group_rule->parent_id);
,table->table_name[table->updating_name] if(compile_rule==NULL)
,db_group_rule->group_id {
,db_group_rule->compile_id); compile_rule=create_compile_rule(db_group_rule->parent_id);
return -1; ret=HASH_add_by_id(scanner->compile_hash, db_group_rule->parent_id, compile_rule);
assert(ret>=0);
}
ret=add_group_to_compile(compile_rule, group_rule, db_group_rule->not_flag);
if(ret<0)
{
MESA_handle_runtime_log(logger, RLOG_LV_FATAL, maat_module,
"update error,add group: %s %d to compile rule %d error, compile rule is full or duplicate group."
,table->table_name[table->updating_name]
,db_group_rule->group_id
,db_group_rule->parent_id);
return -1;
}
} }
return 0; return 0;
} }
void del_group_rule(struct Maat_table_desc* table,struct db_group_rule_t* db_group_rule,struct Maat_scanner_t *scanner,void* logger) void del_group_rule(struct Maat_table_desc* table, struct db_group_rule_t* db_group_rule, struct Maat_scanner_t *scanner, void* logger)
{ {
struct Maat_compile_inner_t*compile_rule=NULL; struct Maat_compile_inner*compile_rule=NULL;
struct Maat_group_inner_t* group_rule=NULL; struct Maat_group_inner* group_rule=NULL;
compile_rule=(struct Maat_compile_inner_t*)HASH_fetch_by_id(scanner->compile_hash, db_group_rule->compile_id); igraph_es_t es;
if(compile_rule==NULL) int ret=0;
if(db_group_rule->parent_type==PARENT_TYPE_GROUP)
{ {
MESA_handle_runtime_log(logger,RLOG_LV_FATAL,maat_module , group_rule->ref_cnt--;
"update error,delete %s group rule error : compile id %d does not exisit." igraph_es_pairs_small(&es, IGRAPH_DIRECTED, db_group_rule->group_id, db_group_rule->parent_id);
,table->table_name[table->updating_name] ret=igraph_delete_edges(&scanner->group_graph, es);
,db_group_rule->compile_id); if(ret!=IGRAPH_SUCCESS)
return; {
MESA_handle_runtime_log(logger, RLOG_LV_FATAL, maat_module ,
"update error, delete %s group %d from parent group %d error, not such relation before.",
table->table_name[table->updating_name],
db_group_rule->group_id,
db_group_rule->parent_id);
}
igraph_es_destroy(&es);
} }
group_rule=del_group_from_compile(compile_rule, db_group_rule->group_id); else
if(group_rule==NULL)
{ {
MESA_handle_runtime_log(logger,RLOG_LV_FATAL,maat_module , compile_rule=(struct Maat_compile_inner*)HASH_fetch_by_id(scanner->compile_hash, db_group_rule->parent_id);
"update error,delete %s group rule error : group id %d not in compile id %d." if(compile_rule==NULL)
,table->table_name[table->updating_name] {
,db_group_rule->group_id MESA_handle_runtime_log(logger, RLOG_LV_FATAL, maat_module,
,db_group_rule->compile_id); "update error, delete %s group %d error : compile id %d does not exisit.",
return; table->table_name[table->updating_name],
db_group_rule->group_id,
db_group_rule->parent_id);
return;
}
group_rule=del_group_from_compile(compile_rule, db_group_rule->group_id);
if(group_rule==NULL)
{
MESA_handle_runtime_log(logger, RLOG_LV_FATAL, maat_module,
"update error, delete %s group rule error : group id %d not in compile id %d."
,table->table_name[table->updating_name]
,db_group_rule->group_id
,db_group_rule->parent_id);
return;
}
if(compile_rule->group_cnt==0&&compile_rule->is_valid==0)
{
HASH_delete_by_id(scanner->compile_hash, db_group_rule->parent_id);
garbage_bagging(GARBAGE_COMPILE_RULE, compile_rule, scanner->tomb_ref);
}
} }
if(compile_rule->group_cnt==0&&compile_rule->is_valid==0)
{
HASH_delete_by_id(scanner->compile_hash, db_group_rule->compile_id);
garbage_bagging(GARBAGE_COMPILE_RULE, compile_rule, scanner->tomb_ref);
}
//Directly delete group id will not destroyp group_rule,it 'll be destroyed when delete this group's last region.
if(group_rule->ref_cnt==0&&group_rule->region_cnt==0) if(group_rule->ref_cnt==0&&group_rule->region_cnt==0)
{ {
//Directly delete table %s group id %d, do this when delete its last region. garbage_bagging(GARBAGE_GROUP_RULE, group_rule, scanner->tomb_ref);
} }
return; return;
} }
int add_compile_rule(struct Maat_table_desc* table,struct db_compile_rule_t* db_compile_rule,struct Maat_scanner_t *scanner,void* logger) int add_compile_rule(struct Maat_table_desc* table,struct db_compile_rule* db_compile_rule,struct Maat_scanner_t *scanner,void* logger)
{ {
struct Maat_compile_inner_t *compile_rule=NULL; struct Maat_compile_inner *compile_rule=NULL;
struct _head_Maat_rule_t *p_maat_rule_head=&(db_compile_rule->m_rule_head); struct _head_Maat_rule *p_maat_rule_head=&(db_compile_rule->m_rule_head);
int i=0; int i=0;
compile_rule=(struct Maat_compile_inner_t*)HASH_fetch_by_id(scanner->compile_hash, p_maat_rule_head->config_id); compile_rule=(struct Maat_compile_inner*)HASH_fetch_by_id(scanner->compile_hash, p_maat_rule_head->config_id);
if(compile_rule==NULL) if(compile_rule==NULL)
{ {
compile_rule=create_compile_rule(p_maat_rule_head->config_id); compile_rule=create_compile_rule(p_maat_rule_head->config_id);
@@ -2422,10 +2461,10 @@ int add_compile_rule(struct Maat_table_desc* table,struct db_compile_rule_t* db_
return 0; return 0;
} }
int del_compile_rule(struct Maat_table_desc* table,struct db_compile_rule_t* db_compile_rule,struct Maat_scanner_t *scanner,void* logger) int del_compile_rule(struct Maat_table_desc* table,struct db_compile_rule* db_compile_rule,struct Maat_scanner_t *scanner,void* logger)
{ {
struct Maat_compile_inner_t *compile_rule=NULL; struct Maat_compile_inner *compile_rule=NULL;
compile_rule=(struct Maat_compile_inner_t*)HASH_fetch_by_id(scanner->compile_hash, db_compile_rule->m_rule_head.config_id); compile_rule=(struct Maat_compile_inner*)HASH_fetch_by_id(scanner->compile_hash, db_compile_rule->m_rule_head.config_id);
if(compile_rule==NULL) if(compile_rule==NULL)
{ {
MESA_handle_runtime_log(logger,RLOG_LV_FATAL,maat_module , MESA_handle_runtime_log(logger,RLOG_LV_FATAL,maat_module ,
@@ -2451,11 +2490,12 @@ void update_group_rule(struct Maat_table_desc* table,const char* table_line,stru
struct Maat_table_runtime* table_rt=scanner->table_rt[table->table_id]; struct Maat_table_runtime* table_rt=scanner->table_rt[table->table_id];
int ret=0; int ret=0;
memset(&db_group_rule, 0, sizeof(db_group_rule)); memset(&db_group_rule, 0, sizeof(db_group_rule));
ret=sscanf(table_line,"%d\t%d\t%d\t%d", &(db_group_rule.group_id), ret=sscanf(table_line,"%d\t%d\t%d\t%d\t%d", &(db_group_rule.group_id),
&(db_group_rule.compile_id), &(db_group_rule.parent_id),
&(db_group_rule.is_valid), &(db_group_rule.is_valid),
&(db_group_rule.not_flag)); &(db_group_rule.not_flag),
if(ret!=3&&ret!=4) &(db_group_rule.parent_type));
if(ret!=3&&ret!=4&&ret!=5)
{ {
MESA_handle_runtime_log(logger,RLOG_LV_INFO,maat_module , MESA_handle_runtime_log(logger,RLOG_LV_INFO,maat_module ,
"update error,invalid format of group table %s:%s", "update error,invalid format of group table %s:%s",
@@ -2467,6 +2507,14 @@ void update_group_rule(struct Maat_table_desc* table,const char* table_line,stru
{ {
db_group_rule.not_flag=0; db_group_rule.not_flag=0;
} }
if(!db_group_rule.parent_type==PARENT_TYPE_GROUP && db_group_rule.not_flag)
{
MESA_handle_runtime_log(logger,RLOG_LV_INFO,maat_module ,
"update error, invalid format of group table %s:%s not operation is forbidden for non-compile parent.",
table->table_name[table->updating_name], table_line);
table->udpate_err_cnt++;
return;
}
if(db_group_rule.is_valid==FALSE) if(db_group_rule.is_valid==FALSE)
{ {
del_group_rule(table, &db_group_rule, scanner, logger); del_group_rule(table, &db_group_rule, scanner, logger);
@@ -2488,7 +2536,7 @@ void update_group_rule(struct Maat_table_desc* table,const char* table_line,stru
MESA_handle_runtime_log(logger,RLOG_LV_INFO,maat_module , MESA_handle_runtime_log(logger,RLOG_LV_INFO,maat_module ,
"duplicate config of group table %s group_id %d compile_id %d.", table->table_name[0], "duplicate config of group table %s group_id %d compile_id %d.", table->table_name[0],
db_group_rule.group_id, db_group_rule.group_id,
db_group_rule.compile_id); db_group_rule.parent_id);
} }
else else
@@ -2822,7 +2870,7 @@ error_out:
void update_intval_rule(struct Maat_table_desc* table,const char* table_line,struct Maat_scanner_t *scanner,void* logger,int group_mode_on) void update_intval_rule(struct Maat_table_desc* table,const char* table_line,struct Maat_scanner_t *scanner,void* logger,int group_mode_on)
{ {
struct db_intval_rule_t* intval_rule=ALLOC(struct db_intval_rule_t, 1); struct db_intval_rule* intval_rule=ALLOC(struct db_intval_rule, 1);
struct Maat_table_runtime* table_rt=scanner->table_rt[table->table_id]; struct Maat_table_runtime* table_rt=scanner->table_rt[table->table_id];
int ret=0; int ret=0;
ret=sscanf(table_line,"%d\t%d\t%u\t%u\t%d",&(intval_rule->region_id) ret=sscanf(table_line,"%d\t%d\t%u\t%u\t%d",&(intval_rule->region_id)
@@ -2900,8 +2948,8 @@ void update_compile_rule(struct Maat_table_desc* table,const char* table_line,st
struct compile_table_desc* compile_desc=&(table->compile); struct compile_table_desc* compile_desc=&(table->compile);
struct Maat_table_runtime* table_rt=scanner->table_rt[table->table_id]; struct Maat_table_runtime* table_rt=scanner->table_rt[table->table_id];
struct db_compile_rule_t *p_compile=ALLOC(struct db_compile_rule_t, 1); struct db_compile_rule *p_compile=ALLOC(struct db_compile_rule, 1);
struct _head_Maat_rule_t* p_m_rule=&(p_compile->m_rule_head); struct _head_Maat_rule* p_m_rule=&(p_compile->m_rule_head);
char user_region[MAX_TABLE_LINE_SIZE]={0}; char user_region[MAX_TABLE_LINE_SIZE]={0};
char tag_str[MAX_TABLE_LINE_SIZE]={0}; char tag_str[MAX_TABLE_LINE_SIZE]={0};
int ret=0; int ret=0;
@@ -2984,7 +3032,7 @@ no_save:
void update_digest_rule(struct Maat_table_desc* table,const char* table_line,struct Maat_scanner_t *scanner,void* logger,int group_mode_on) void update_digest_rule(struct Maat_table_desc* table,const char* table_line,struct Maat_scanner_t *scanner,void* logger,int group_mode_on)
{ {
struct Maat_table_runtime* table_rt=scanner->table_rt[table->table_id]; struct Maat_table_runtime* table_rt=scanner->table_rt[table->table_id];
struct db_digest_rule_t* digest_rule=ALLOC(struct db_digest_rule_t, 1); struct db_digest_rule* digest_rule=ALLOC(struct db_digest_rule, 1);
int ret=0; int ret=0;
char digest_buff[MAX_TABLE_LINE_SIZE]={'\0'}; char digest_buff[MAX_TABLE_LINE_SIZE]={'\0'};
if(table->table_type==TABLE_TYPE_DIGEST) if(table->table_type==TABLE_TYPE_DIGEST)

42
src/inc_internal/Maat_rule_internal.h
View File

@@ -12,7 +12,7 @@
#include "dynamic_array.h" #include "dynamic_array.h"
#include "bool_matcher.h" #include "bool_matcher.h"
#include "hiredis.h" #include "hiredis.h"
#include "igraph/igraph.h"
#include "stream_fuzzy_hash.h" #include "stream_fuzzy_hash.h"
#include "gram_index_engine.h" #include "gram_index_engine.h"
#include "alignment_int64.h" #include "alignment_int64.h"
@@ -69,14 +69,14 @@ struct db_ip_rule_t
}; };
int is_valid; int is_valid;
}; };
struct db_intval_rule_t struct db_intval_rule
{ {
int region_id; int region_id;
int group_id; int group_id;
interval_rule_t intval; interval_rule_t intval;
int is_valid; int is_valid;
}; };
struct db_digest_rule_t struct db_digest_rule
{ {
int region_id; int region_id;
int group_id; int group_id;
@@ -85,7 +85,7 @@ struct db_digest_rule_t
short confidence_degree; short confidence_degree;
int is_valid; int is_valid;
}; };
struct _head_Maat_rule_t struct _head_Maat_rule
{ {
int config_id; int config_id;
int service_id; int service_id;
@@ -95,20 +95,23 @@ struct _head_Maat_rule_t
char resevered; char resevered;
int serv_def_len; int serv_def_len;
}; };
struct db_compile_rule_t struct db_compile_rule
{ {
struct _head_Maat_rule_t m_rule_head;// fix len of Maat_rule_t struct _head_Maat_rule m_rule_head;// fix len of Maat_rule_t
char* service_defined; char* service_defined;
long long effective_range; long long effective_range;
int is_valid; int is_valid;
int declare_grp_num; int declare_grp_num;
}; };
#define PARENT_TYPE_COMPILE 0
#define PARENT_TYPE_GROUP 1
struct db_group_rule_t struct db_group_rule_t
{ {
int group_id; int group_id;
int compile_id; int parent_id;
int is_valid; int is_valid;
int not_flag; int not_flag;
int parent_type; //PARENT_TYPE_**, 0:compile, 1: group.
}; };
struct op_expr_t struct op_expr_t
{ {
@@ -120,7 +123,7 @@ struct op_expr_t
int rule_type; int rule_type;
}; };
struct _Maat_region_inner_t struct Maat_region_inner
{ {
int region_id; int region_id;
int district_id; int district_id;
@@ -130,7 +133,7 @@ struct _Maat_region_inner_t
int expr_id_ub; int expr_id_ub;
enum MAAT_TABLE_TYPE table_type; enum MAAT_TABLE_TYPE table_type;
}; };
struct Maat_group_inner_t struct Maat_group_inner
{ {
int group_id; int group_id;
int table_id; int table_id;
@@ -138,14 +141,15 @@ struct Maat_group_inner_t
int region_cnt; int region_cnt;
int ref_cnt; int ref_cnt;
char* group_name; char* group_name;
int has_compile_neighbors;
dynamic_array_t *regions; dynamic_array_t *regions;
void* compile_shortcut; void* compile_shortcut;
pthread_mutex_t mutex; pthread_mutex_t mutex;
}; };
struct Maat_compile_inner_t struct Maat_compile_inner
{ {
struct db_compile_rule_t *db_c_rule; struct db_compile_rule *db_c_rule;
dynamic_array_t *groups; //element is struct Maat_group_inner_t* dynamic_array_t *groups; //element is struct Maat_group_inner*
char not_flag[MAX_ITEMS_PER_BOOL_EXPR]; char not_flag[MAX_ITEMS_PER_BOOL_EXPR];
char is_valid; char is_valid;
int compile_id;//equal to db_c_rule->m_rule.config_id int compile_id;//equal to db_c_rule->m_rule.config_id
@@ -281,6 +285,8 @@ struct Maat_scanner_t
MESA_htable_handle compile_hash; MESA_htable_handle compile_hash;
MESA_htable_handle district_map; MESA_htable_handle district_map;
MESA_htable_handle tmp_district_map; MESA_htable_handle tmp_district_map;
igraph_t group_graph;
unsigned int district_num; unsigned int district_num;
unsigned int cfg_num; unsigned int cfg_num;
unsigned int exprid_generator; unsigned int exprid_generator;
@@ -412,8 +418,8 @@ struct _maat_garbage_t
union union
{ {
struct Maat_scanner_t* scanner; struct Maat_scanner_t* scanner;
struct Maat_group_inner_t* group_rule; struct Maat_group_inner* group_rule;
struct Maat_compile_inner_t* compile_rule; struct Maat_compile_inner* compile_rule;
struct bool_matcher* bool_matcher; struct bool_matcher* bool_matcher;
void * raw; void * raw;
MESA_htable_handle str2int_map; MESA_htable_handle str2int_map;
@@ -443,7 +449,7 @@ int parse_accept_tag(const char* value, struct rule_tag** result, void* logger);
void garbage_bagging(enum maat_garbage_type type,void *p,MESA_lqueue_head garbage_q); void garbage_bagging(enum maat_garbage_type type,void *p,MESA_lqueue_head garbage_q);
void garbage_bagging_with_timeout(enum maat_garbage_type type,void *p, int timeout, MESA_lqueue_head garbage_q); void garbage_bagging_with_timeout(enum maat_garbage_type type,void *p, int timeout, MESA_lqueue_head garbage_q);
void garbage_bury(MESA_lqueue_head garbage_q,void *logger); void garbage_bury(MESA_lqueue_head garbage_q,void *logger);
void make_group_set(struct Maat_compile_inner_t* compile_rule, struct bool_expr* a_set, unsigned char *has_not); void make_group_set(struct Maat_compile_inner* compile_rule, struct bool_expr* a_set, unsigned char *has_not);
int read_table_description(struct Maat_table_desc** p_table_info,int num,const char* table_info_path,int max_thread_num,void* logger); int read_table_description(struct Maat_table_desc** p_table_info,int num,const char* table_info_path,int max_thread_num,void* logger);
void maat_start_cb(long long new_version,int update_type,void*u_para); void maat_start_cb(long long new_version,int update_type,void*u_para);
int maat_update_cb(const char* table_name,const char* line,void *u_para); int maat_update_cb(const char* table_name,const char* line,void *u_para);
@@ -466,9 +472,9 @@ int get_foreign_keys_by_prefix(redisContext *ctx, struct serial_rule_t* rule_lis
void get_foreign_conts(redisContext *ctx, struct serial_rule_t* rule_list, int rule_num, int print_fn, void *logger); void get_foreign_conts(redisContext *ctx, struct serial_rule_t* rule_list, int rule_num, int print_fn, void *logger);
void rewrite_table_line_with_foreign(struct serial_rule_t*p); void rewrite_table_line_with_foreign(struct serial_rule_t*p);
void fill_maat_rule(struct Maat_rule_t *rule, const struct _head_Maat_rule_t* rule_head, const char* srv_def, int srv_def_len); void fill_maat_rule(struct Maat_rule_t *rule, const struct _head_Maat_rule* rule_head, const char* srv_def, int srv_def_len);
MAAT_RULE_EX_DATA rule_ex_data_new(const struct _head_Maat_rule_t * rule_head, const char* srv_def, const struct compile_ex_data_idx* ex_desc); MAAT_RULE_EX_DATA rule_ex_data_new(const struct _head_Maat_rule * rule_head, const char* srv_def, const struct compile_ex_data_idx* ex_desc);
void rule_ex_data_free(const struct _head_Maat_rule_t * rule_head, const char* srv_def, MAAT_RULE_EX_DATA *ad, const struct compile_ex_data_idx* ex_desc); void rule_ex_data_free(const struct _head_Maat_rule * rule_head, const char* srv_def, MAAT_RULE_EX_DATA *ad, const struct compile_ex_data_idx* ex_desc);
MESA_htable_handle wrap_plugin_EX_hash_new(long long estimate_size, Maat_plugin_EX_key2index_func_t * key2index); MESA_htable_handle wrap_plugin_EX_hash_new(long long estimate_size, Maat_plugin_EX_key2index_func_t * key2index);
int plugin_EX_data_new(const struct Maat_table_desc* plugin_table, const char* line, MESA_htable_handle key2ex_hash, void *logger); int plugin_EX_data_new(const struct Maat_table_desc* plugin_table, const char* line, MESA_htable_handle key2ex_hash, void *logger);
int plugin_EX_data_free(const struct Maat_table_desc* plugin_table, const char* line, MESA_htable_handle key2ex_hash, void *logger); int plugin_EX_data_free(const struct Maat_table_desc* plugin_table, const char* line, MESA_htable_handle key2ex_hash, void *logger);

16
vendor/CMakeLists.txt vendored
View File

@@ -30,3 +30,19 @@ file(MAKE_DIRECTORY ${HIREDIS_INCLUDE_DIRECTORIES})
add_library(hiredis-vip-static STATIC IMPORTED GLOBAL) add_library(hiredis-vip-static STATIC IMPORTED GLOBAL)
set_property(TARGET hiredis-vip-static PROPERTY IMPORTED_LOCATION ${SOURCE_DIR}/libhiredis_vip.a) set_property(TARGET hiredis-vip-static PROPERTY IMPORTED_LOCATION ${SOURCE_DIR}/libhiredis_vip.a)
set_property(TARGET hiredis-vip-static PROPERTY INTERFACE_INCLUDE_DIRECTORIES ${SOURCE_DIR}) set_property(TARGET hiredis-vip-static PROPERTY INTERFACE_INCLUDE_DIRECTORIES ${SOURCE_DIR})
ExternalProject_Add(igraph PREFIX igraph
URL ${CMAKE_CURRENT_SOURCE_DIR}/igraph-0.7.1.tar.gz
URL_MD5 4f6e7c16b45fce8ed423516a9786e4e8
CONFIGURE_COMMAND ./configure --prefix=<INSTALL_DIR> --disable-shared --with-pic
BUILD_COMMAND make
INSTALL_COMMAND make install
BUILD_IN_SOURCE 1)
ExternalProject_Get_Property(igraph INSTALL_DIR)
file(MAKE_DIRECTORY ${INSTALL_DIR}/include)
add_library(igraph-static STATIC IMPORTED GLOBAL)
add_dependencies(igraph-static igraph)
set_property(TARGET igraph-static PROPERTY IMPORTED_LOCATION ${INSTALL_DIR}/lib/libigraph.a)
set_property(TARGET igraph-static PROPERTY INTERFACE_INCLUDE_DIRECTORIES ${INSTALL_DIR}/include)

BIN
vendor/igraph-0.7.1.tar.gz vendored Normal file
View File

Binary file not shown.