diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt index e72dc49..4eeece9 100644 --- a/src/CMakeLists.txt +++ b/src/CMakeLists.txt @@ -2,13 +2,13 @@ cmake_minimum_required(VERSION 2.8) add_definitions(-fPIC) -set(SRC tsg_entry.cpp tsg_rule.cpp tsg_ssl_utils.cpp tsg_send_log.cpp tsg_statistic.cpp tsg_ssh_utils.cpp tsg_gtp_signaling.cpp tsg_action.cpp tsg_leaky_bucket.cpp tsg_dns.cpp tsg_icmp.cpp tsg_tamper.cpp tsg_bridge.cpp tsg_protocol.cpp tsg_sync_state.cpp tsg_variable.cpp tsg_proxy.cpp mpack.c) +set(SRC tsg_entry.cpp tsg_rule.cpp tsg_ssl_utils.cpp tsg_send_log.cpp tsg_statistic.cpp tsg_ssh_utils.cpp tsg_gtp_signaling.cpp tsg_action.cpp tsg_leaky_bucket.cpp tsg_dns.cpp tsg_icmp.cpp tsg_tamper.cpp tsg_bridge.cpp tsg_protocol.cpp tsg_sync_state.cpp tsg_variable.cpp tsg_proxy.cpp mpack.c tsg_stat.cpp) include_directories(${CMAKE_SOURCE_DIR}/inc) include_directories(/opt/MESA/include/MESA/) include_directories(/usr/include/) -set(TSG_MASTER_DEPEND_DYN_LIB MESA_handle_logger MESA_prof_load maat4 pthread MESA_field_stat2 rdkafka cjson MESA_jump_layer fieldstat3) +set(TSG_MASTER_DEPEND_DYN_LIB MESA_handle_logger MESA_prof_load maat4 pthread rdkafka cjson MESA_jump_layer fieldstat3) set(CMAKE_INSTALL_PREFIX /home/mesasoft/sapp_run) diff --git a/src/tsg_action.cpp b/src/tsg_action.cpp index a2d1e0d..55890f1 100644 --- a/src/tsg_action.cpp +++ b/src/tsg_action.cpp @@ -17,6 +17,7 @@ #include #include +#include "tsg_stat.h" #include "tsg_rule.h" #include "app_label.h" #include "tsg_entry.h" @@ -79,11 +80,11 @@ static int set_drop_stream(const struct streaminfo *a_stream, enum TSG_PROTOCOL ret=MESA_set_stream_opt(a_stream, MSO_TIMEOUT, (void *)&g_tsg_para.timeout, sizeof(g_tsg_para.timeout)); if(ret<0) { - FS_operate(g_tsg_para.fs2_handle, g_tsg_para.fs2_field_id[TSG_FS2_SET_TIMOUT_FAILED], 0, FS_OP_ADD, 1); + tsg_stat_flow_update(STAT_STATUS_FAIL, FLOW_STAT_SET_TIMEOUT, 1); } else { - FS_operate(g_tsg_para.fs2_handle, g_tsg_para.fs2_field_id[TSG_FS2_SET_TIMOUT_SUCCESS], 0, FS_OP_ADD, 1); + tsg_stat_flow_update(STAT_STATUS_SUCCESS, FLOW_STAT_SET_TIMEOUT, 1); } break; default: @@ -391,17 +392,18 @@ int tsg_send_inject_packet(const struct streaminfo *a_stream, enum sapp_inject_o int ret=0; if(payload==NULL || payload_len<=0) { + tsg_stat_flow_update(STAT_STATUS_FAIL, FLOW_STAT_INJECT, 1); return -1; } ret=sapp_inject_pkt((struct streaminfo *)a_stream, sio, payload, payload_len, raw_route_dir); if(ret<=0) { - FS_operate(g_tsg_para.fs2_handle, g_tsg_para.fs2_field_id[TSG_FS2_INJECT_PKT_FAILED], 0, FS_OP_ADD, 1); - return -1; + tsg_stat_flow_update(STAT_STATUS_FAIL, FLOW_STAT_INJECT, 1); + return -1; } - FS_operate(g_tsg_para.fs2_handle, g_tsg_para.fs2_field_id[TSG_FS2_INJECT_PKT_SUCCESS], 0, FS_OP_ADD, 1); + tsg_stat_flow_update(STAT_STATUS_SUCCESS, FLOW_STAT_INJECT, 1); return 0; } diff --git a/src/tsg_entry.cpp b/src/tsg_entry.cpp index 24cf918..f25344e 100644 --- a/src/tsg_entry.cpp +++ b/src/tsg_entry.cpp @@ -20,6 +20,7 @@ #include #include +#include "tsg_stat.h" #include "app_label.h" #include "tsg_rule.h" #include "tsg_entry.h" @@ -58,64 +59,6 @@ static __attribute__((__used__)) const char * GIT_VERSION_UNKNOWN = NULL; char TSG_MASTER_VERSION_20200805 = 0; const char *tsg_conffile="tsgconf/main.conf"; -struct id2field g_tsg_fs2_field[TSG_FS2_MAX]={{0, TSG_FS2_TCP_LINKS, "tcp_links"}, - {0, TSG_FS2_UDP_LINKS, "udp_links"}, - {0, TSG_FS2_BYPASS, "bypass"}, - {0, TSG_FS2_HIT_ADDR, "hit_addr"}, - {0, TSG_FS2_HIT_SHARE, "hit_share"}, - {0, TSG_FS2_INTERCEPT, "intercept"}, - {0, TSG_FS2_SHAPING, "shaping"}, - {0, TSG_FS2_S_CHAINING, "s_chaining"}, - {0, TSG_FS2_CTRL_OPENING, "ctrl_open"}, - {0, TSG_FS2_CTRL_CLOSING, "ctrl_close"}, - {0, TSG_FS2_CTRL_ACTIVE, "ctrl_active"}, - {0, TSG_FS2_CTRL_RESETALL, "ctrl_rstall"}, - {0, TSG_FS2_INJECT_CTRL_SUCCESS, "inject_ctrl_succuess"}, - {0, TSG_FS2_INJECT_CTRL_FAILED, "inject_ctrl_failed"}, - {0, TSG_FS2_EXCLUSION, "exclusion"}, - {0, TSG_FS2_APP_DPKT_RESULT, "D_result"}, - {0, TSG_FS2_APP_Q_RESULT, "Q_result"}, - {0, TSG_FS2_APP_USER_RESULT, "U_result"}, - {0, TSG_FS2_APP_BUILT_IN_RESULT, "B_result"}, - {0, TSG_FS2_INJECT_PKT_SUCCESS, "inject_succuess"}, - {0, TSG_FS2_INJECT_PKT_FAILED, "inject_failed"}, - {0, TSG_FS2_MIRRORED_PKT_SUCCESS, "mirror_pkt_suc"}, - {0, TSG_FS2_MIRRORED_BYTE_SUCCESS, "mirror_byte_suc"}, - {0, TSG_FS2_MIRRORED_PKT_FAILED, "mirror_pkt_fai"}, - {0, TSG_FS2_MIRRORED_BYTE_FAILED, "mirror_byte_fai"}, - {0, TSG_FS2_SET_TIMOUT_SUCCESS, "set_timeout_suc"}, - {0, TSG_FS2_SET_TIMOUT_FAILED, "set_timeout_fai"}, - {0, TSG_FS2_SUCESS_TAMPER, "tamper_sucess"}, - {0, TSG_FS2_TAMPER_FAILED_PLOAD_LESS_4, "tamper_nopload"}, - {0, TSG_FS2_TAMPER_FAILED_NOSWAP, "tamper_noswap"}, - {0, TSG_FS2_ASN_ADD, "asn_add"}, - {0, TSG_FS2_ASN_DEL, "asn_del"}, - {0, TSG_FS2_GTPC_ADD, "gtpc_add"}, - {0, TSG_FS2_GTPC_DEL, "gtpc_del"}, - {0, TSG_FS2_LOCATION_ADD, "location_add"}, - {0, TSG_FS2_LOCATION_DEL, "location_del"}, - {0, TSG_FS2_FQDN_ADD, "fqdn_add"}, - {0, TSG_FS2_FQDN_DEL, "fqdn_del"}, - {0, TSG_FS2_SUBSCRIBER_ADD, "subscriber_add"}, - {0, TSG_FS2_SUBSCRIBER_DEL, "subscriber_del"}, - {0, TSG_FS2_SECURIRY_ADD, "security_add"}, - {0, TSG_FS2_SECURIRY_DEL, "security_del"}, - {0, TSG_FS2_MIRRORED_ADD, "mirrored_add"}, - {0, TSG_FS2_MIRRORED_DEL, "mirrored_del"}, - {0, TSG_FS2_HTTP_RES_ADD, "http_res_add"}, - {0, TSG_FS2_HTTP_RES_DEL, "http_res_del"}, - {0, TSG_FS2_DNS_RES_ADD, "dns_profile_add"}, - {0, TSG_FS2_DNS_RES_DEL, "dns_profile_del"}, - {0, TSG_FS2_APP_ID_ADD, "app_id_add"}, - {0, TSG_FS2_APP_ID_DEL, "app_id_del"}, - {0, TSG_FS2_TUNNEL_CATALOG_ADD, "t_catalog_add"}, - {0, TSG_FS2_TUNNEL_CATALOG_DEL, "t_catalog_del"}, - {0, TSG_FS2_TUNNEL_ENDPOINT_ADD, "t_endpoint_add"}, - {0, TSG_FS2_TUNNEL_ENDPOINT_DEL, "t_endpoint_del"}, - {0, TSG_FS2_TUNNEL_LABEL_ADD, "t_label_add"}, - {0, TSG_FS2_TUNNEL_LABEL_DEL, "t_label_del"} - }; - static int init_page_template(const char *conffile) { char page_path[256]; @@ -138,53 +81,6 @@ static int init_page_template(const char *conffile) return 0; } -static int init_fs2_handle(const char *conffile) -{ - int value=0,cycle=0; - int output_prometheus=0; - unsigned short fs_server_port=0; - char app_name[128]={0}; - char fs_server_ip[MAX_IPV4_LEN]={0}; - char fs_output_path[128]={0}; - - MESA_load_profile_int_def(conffile, "FIELD_STAT", "CYCLE", &cycle, 30); - MESA_load_profile_short_nodef(conffile, "FIELD_STAT","TELEGRAF_PORT", (short *)&(fs_server_port)); - MESA_load_profile_string_nodef(conffile,"FIELD_STAT","TELEGRAF_IP",fs_server_ip, sizeof(fs_server_ip)); - MESA_load_profile_string_def(conffile,"FIELD_STAT","OUTPUT_PATH",fs_output_path, sizeof(fs_output_path), "tsg_stat.log"); - MESA_load_profile_string_def(conffile,"FIELD_STAT","APP_NAME", app_name, sizeof(app_name), "tsg_master"); - MESA_load_profile_int_def(conffile, "FIELD_STAT", "PROMETHEUS", &output_prometheus, 1); - - g_tsg_para.fs2_handle=FS_create_handle(); - - value=1;//Rewrite - FS_set_para(g_tsg_para.fs2_handle, PRINT_MODE, &value, sizeof(value)); - value=1;//Do not create stat thread - FS_set_para(g_tsg_para.fs2_handle, CREATE_THREAD, &value, sizeof(value)); - - FS_set_para(g_tsg_para.fs2_handle, STAT_CYCLE, &cycle, sizeof(cycle)); - FS_set_para(g_tsg_para.fs2_handle, APP_NAME, app_name, strlen(app_name)+1); - FS_set_para(g_tsg_para.fs2_handle, OUTPUT_DEVICE, fs_output_path, strlen(fs_output_path)+1); - - value=1; - FS_set_para(g_tsg_para.fs2_handle, OUTPUT_PROMETHEUS, &output_prometheus, sizeof(output_prometheus)); - - if(fs_server_port > 0 && strlen(fs_server_ip) > 0) - { - FS_set_para(g_tsg_para.fs2_handle, STATS_SERVER_IP,fs_server_ip, strlen(fs_server_ip)+1); - FS_set_para(g_tsg_para.fs2_handle, STATS_SERVER_PORT,&(fs_server_port), sizeof(fs_server_port)); - } - - value=FS_OUTPUT_INFLUX_LINE; - FS_set_para(g_tsg_para.fs2_handle, STATS_FORMAT, &value, sizeof(value)); - - for(int i=0; irules+matched_rules->n_rules, inc_rules, n_inc_results*sizeof(struct maat_rule)); matched_rules->n_rules+=n_inc_results; int ret=session_matched_rules_async(a_stream, service, (void *)matched_rules); @@ -1850,7 +1741,6 @@ static unsigned char matched_security_rules_deal(const struct streaminfo *a_stre srt_process_context->is_hitted_allow=1; session_matched_rules_notify(a_stream, TSG_SERVICE_SECURITY, p_rule, 1, a_stream->threadnum); - FS_operate(g_tsg_para.fs2_handle, g_tsg_para.fs2_field_id[TSG_FS2_BYPASS], 0, FS_OP_ADD, 1); srt_action_context_set_rule_method(a_stream, TSG_METHOD_TYPE_ALLOW, a_stream->threadnum); break; default: @@ -1871,8 +1761,6 @@ static unsigned char matched_security_rules_deal(const struct streaminfo *a_stre int matched_shaping_rules_deal(const struct streaminfo *a_stream, struct maat_rule *shaping_rules, size_t n_shaping_rules, int thread_seq) { session_state_sync_in_activing(a_stream, TSG_SERVICE_SHAPING, shaping_rules, n_shaping_rules, thread_seq); - - FS_operate(g_tsg_para.fs2_handle, g_tsg_para.fs2_field_id[TSG_FS2_SHAPING], 0, FS_OP_ADD, 1); srt_action_context_set_rule_method(a_stream, TSG_METHOD_TYPE_UNKNOWN, thread_seq); return 0; @@ -1883,7 +1771,6 @@ int matched_intercept_rules_deal(const struct streaminfo *a_stream, struct maat_ struct maat_rule *p_rule=matched_rules_decision_criteria(intercept_rules, n_intercept_rules); session_state_sync_in_activing(a_stream, TSG_SERVICE_INTERCEPT, p_rule, 1, thread_seq); - FS_operate(g_tsg_para.fs2_handle, g_tsg_para.fs2_field_id[TSG_FS2_INTERCEPT], 0, FS_OP_ADD, 1); srt_action_context_set_rule_method(a_stream, TSG_METHOD_TYPE_UNKNOWN, thread_seq); return 0; @@ -1997,7 +1884,7 @@ int session_app_identify_result_cb(const struct streaminfo *a_stream, int bridge break; case ORIGIN_QM_ENGINE: srt_process_context->is_app_link=FLAG_TRUE; - FS_operate(g_tsg_para.fs2_handle, g_tsg_para.fs2_field_id[TSG_FS2_APP_Q_RESULT], 0, FS_OP_ADD, 1); + tsg_stat_sync_application_update(SYNC_APP_THRID, 1); gather_result->qm_engine_num=session_app_gather_results_update(&(gather_result->qm_engine), gather_result->qm_engine_num, identify_result, get_packet_sequence(a_stream), a_stream->threadnum); scan_app=gather_result->qm_engine; @@ -2005,7 +1892,7 @@ int session_app_identify_result_cb(const struct streaminfo *a_stream, int bridge break; case ORIGIN_USER_DEFINE: srt_process_context->is_app_link=FLAG_TRUE; - FS_operate(g_tsg_para.fs2_handle, g_tsg_para.fs2_field_id[TSG_FS2_APP_USER_RESULT], 0, FS_OP_ADD, 1); + tsg_stat_sync_application_update(SYNC_APP_USER_DEFINE, 1); gather_result->user_define_num=session_app_gather_results_update(&(gather_result->user_define), gather_result->user_define_num, identify_result, get_packet_sequence(a_stream), a_stream->threadnum); scan_app=gather_result->user_define; @@ -2013,7 +1900,7 @@ int session_app_identify_result_cb(const struct streaminfo *a_stream, int bridge break; case ORIGIN_BUILT_IN: srt_process_context->is_app_link=FLAG_TRUE; - FS_operate(g_tsg_para.fs2_handle, g_tsg_para.fs2_field_id[TSG_FS2_APP_BUILT_IN_RESULT], 0, FS_OP_ADD, 1); + tsg_stat_sync_application_update(SYNC_APP_BUILT_IN, 1); gather_result->built_in_num=session_app_gather_results_update(&(gather_result->built_in), gather_result->built_in_num, identify_result, get_packet_sequence(a_stream), a_stream->threadnum); scan_app=gather_result->built_in; @@ -2021,6 +1908,7 @@ int session_app_identify_result_cb(const struct streaminfo *a_stream, int bridge break; case ORIGIN_BASIC_PROTOCOL: srt_process_context->is_app_link=FLAG_TRUE; + tsg_stat_sync_application_update(SYNC_APP_LPI, 1); if(srt_process_context->proto==PROTO_UNKONWN || srt_process_context->proto==PROTO_APP) { srt_process_context_set_l7_protocol(srt_process_context, identify_result->app_id[identify_result->app_id_num-1]); @@ -2134,10 +2022,8 @@ size_t session_pending_state_deal(const struct streaminfo *a_stream, struct sess if(ret>0) { matched_cnt+=ret; - FS_operate(g_tsg_para.fs2_handle, g_tsg_para.fs2_field_id[TSG_FS2_HIT_ADDR], 0, FS_OP_ADD, 1); } - matched_cnt+=session_app_gather_results_scan(a_stream, matched_rules+matched_cnt, n_matched_rules-matched_cnt, srt_process_context, a_stream->threadnum); matched_cnt+=tsg_scan_session_flags(a_stream, g_tsg_maat_feather, srt_process_context->session_flag, (srt_process_context->mid), matched_rules+matched_cnt, n_matched_rules-matched_cnt); @@ -2182,15 +2068,6 @@ static unsigned char tsg_master_data_entry(const struct streaminfo *a_stream, vo if(srt_process_context->first_origin_pkt==0) { srt_process_context->first_origin_pkt=1; - - if(a_stream->type==STREAM_TYPE_TCP) - { - FS_operate(g_tsg_para.fs2_handle, g_tsg_para.fs2_field_id[TSG_FS2_TCP_LINKS], 0, FS_OP_ADD, 1); - } - else - { - FS_operate(g_tsg_para.fs2_handle, g_tsg_para.fs2_field_id[TSG_FS2_UDP_LINKS], 0, FS_OP_ADD, 1); - } matched_cnt+=session_pending_state_deal(a_stream, srt_process_context, matched_rules+matched_cnt, n_matched_rules-matched_cnt, a_packet); if (a_stream->type == STREAM_TYPE_TCP && a_packet != NULL) @@ -2590,7 +2467,8 @@ extern "C" int TSG_MASTER_INIT() } init_page_template(tsg_conffile); - init_fs2_handle(tsg_conffile); + tsg_stat_create(tsg_conffile); + tsg_stat_init(); ret=tsg_maat_rule_init(tsg_conffile); if(ret<0) @@ -2599,16 +2477,17 @@ extern "C" int TSG_MASTER_INIT() return -1; } - g_tsg_log_instance=tsg_sendlog_init(tsg_conffile, g_tsg_para.fs2_handle); + g_tsg_log_instance=tsg_sendlog_init(tsg_conffile); if(g_tsg_log_instance==NULL) { MESA_handle_runtime_log(g_tsg_para.logger, RLOG_LV_FATAL, "INIT_SENDLOG", "tsg_sendlog_init failed ..."); return -1; } - - FS_start(g_tsg_para.fs2_handle); - ret = tsg_metric_init(tsg_conffile, g_tsg_para.logger); + // wait send log topic statistic + tsg_stat_start(); + + ret=tsg_metric_init(tsg_conffile, g_tsg_para.logger); if(ret<0) { MESA_handle_runtime_log(g_tsg_para.logger, RLOG_LV_FATAL, "INIT_STATISTIC", "tsg_metric_init failed ..."); diff --git a/src/tsg_rule.cpp b/src/tsg_rule.cpp index e54e29b..6bc08b7 100644 --- a/src/tsg_rule.cpp +++ b/src/tsg_rule.cpp @@ -5,6 +5,7 @@ #include #include +#include "tsg_stat.h" #include "MESA/http.h" #include "MESA/cJSON.h" #include @@ -442,8 +443,8 @@ void ex_data_gtp_c_new(const char *table_name, int table_id, const char* key, co atomic_inc(&user_info->ref_cnt); *ad=(void *)user_info; - - //FS_operate(g_tsg_para.fs2_handle, g_tsg_para.fs2_field_id[TSG_FS2_GTPC_ADD], 0, FS_OP_ADD, 1); + + tsg_stat_sync_exdata_add_update(SYNC_EXDATA_GTPC, 1); return; } @@ -457,12 +458,12 @@ void ex_data_gtp_c_free(int table_id, void **ad, long argl, void* argp) tsg_free_field(user_info->imsi); tsg_free_field(user_info->msisdn); tsg_free_field(user_info->apn); - tsg_free_field(user_info->imei); + tsg_free_field(user_info->imei); tsg_free_field((char *)(*ad)); *ad=NULL; - //FS_operate(g_tsg_para.fs2_handle, g_tsg_para.fs2_field_id[TSG_FS2_GTPC_DEL], 0, FS_OP_ADD, 1); + tsg_stat_sync_exdata_del_update(SYNC_EXDATA_GTPC, 1); } } @@ -509,7 +510,7 @@ void ex_data_asn_number_new(const char *table_name, int table_id, const char* ke atomic_inc(&asn->ref_cnt); *ad=(void *)asn; - //FS_operate(g_tsg_para.fs2_handle, g_tsg_para.fs2_field_id[TSG_FS2_ASN_ADD], 0, FS_OP_ADD, 1); + tsg_stat_sync_exdata_add_update(SYNC_EXDATA_ASN, 1); return; } @@ -525,7 +526,7 @@ void ex_data_asn_number_free(int table_id, void **ad, long argl, void* argp) tsg_free_field((char *)(*ad)); *ad=NULL; - //FS_operate(g_tsg_para.fs2_handle, g_tsg_para.fs2_field_id[TSG_FS2_ASN_DEL], 0, FS_OP_ADD, 1); + tsg_stat_sync_exdata_del_update(SYNC_EXDATA_ASN, 1); } } @@ -569,7 +570,7 @@ void ex_data_location_new(const char *table_name, int table_id, const char* key, atomic_inc(&location->ref_cnt); *ad=(void *)location; - //FS_operate(g_tsg_para.fs2_handle, g_tsg_para.fs2_field_id[TSG_FS2_LOCATION_ADD], 0, FS_OP_ADD, 1); + tsg_stat_sync_exdata_add_update(SYNC_EXDATA_LOCATION, 1); return; } @@ -588,7 +589,7 @@ void ex_data_location_free(int table_id, void **ad, long argl, void* argp) tsg_free_field((char *)(*ad)); *ad=NULL; - //FS_operate(g_tsg_para.fs2_handle, g_tsg_para.fs2_field_id[TSG_FS2_LOCATION_DEL], 0, FS_OP_ADD, 1); + tsg_stat_sync_exdata_del_update(SYNC_EXDATA_LOCATION, 1); } } @@ -627,7 +628,7 @@ void ex_data_fqdn_category_id_new(const char *table_name, int table_id, const ch atomic_inc(&fqdn_cat->ref_cnt); *ad=(void *)fqdn_cat; - //FS_operate(g_tsg_para.fs2_handle, g_tsg_para.fs2_field_id[TSG_FS2_FQDN_ADD], 0, FS_OP_ADD, 1); + tsg_stat_sync_exdata_add_update(SYNC_EXDATA_FQDN_CATEGORY, 1); return; } @@ -640,7 +641,7 @@ void ex_data_fqdn_category_id_free(int table_id, void **ad, long argl, void* arg { tsg_free_field((char *)(*ad)); *ad=NULL; - //FS_operate(g_tsg_para.fs2_handle, g_tsg_para.fs2_field_id[TSG_FS2_FQDN_DEL], 0, FS_OP_ADD, 1); + tsg_stat_sync_exdata_del_update(SYNC_EXDATA_FQDN_CATEGORY, 1); } } @@ -676,7 +677,7 @@ void ex_data_subscriber_id_new(const char *table_name, int table_id, const char* atomic_inc(&subscriber->ref_cnt); *ad=(void *)subscriber; - //FS_operate(g_tsg_para.fs2_handle, g_tsg_para.fs2_field_id[TSG_FS2_SUBSCRIBER_ADD], 0, FS_OP_ADD, 1); + tsg_stat_sync_exdata_add_update(SYNC_EXDATA_SUBSCRIBER, 1); return; } @@ -684,14 +685,14 @@ void ex_data_subscriber_id_free(int table_id, void **ad, long argl, void* argp) { if((*ad)!=NULL) { - struct subscribe_id_info *subscriber=(struct subscribe_id_info *)(*ad); + struct subscribe_id_info *subscriber=(struct subscribe_id_info *)(*ad); if((__sync_sub_and_fetch(&subscriber->ref_cnt, 1) == 0)) { tsg_free_field(subscriber->subscribe_id); tsg_free_field((char *)(*ad)); *ad=NULL; - //FS_operate(g_tsg_para.fs2_handle, g_tsg_para.fs2_field_id[TSG_FS2_SUBSCRIBER_DEL], 0, FS_OP_ADD, 1); + tsg_stat_sync_exdata_del_update(SYNC_EXDATA_SUBSCRIBER, 1); } } @@ -796,7 +797,7 @@ void ex_data_app_id_dict_new(const char *table_name, int table_id, const char* k atomic_inc(&dict->ref_cnt); *ad=(void *)dict; - //FS_operate(g_tsg_para.fs2_handle, g_tsg_para.fs2_field_id[TSG_FS2_APP_ID_ADD], 0, FS_OP_ADD, 1); + tsg_stat_sync_exdata_add_update(SYNC_EXDATA_APP_ID_DICT, 1); return; } @@ -817,7 +818,7 @@ void ex_data_app_id_dict_free(int table_id, void **ad, long argl, void* argp) tsg_free_field((char *)(*ad)); *ad=NULL; - //FS_operate(g_tsg_para.fs2_handle, g_tsg_para.fs2_field_id[TSG_FS2_APP_ID_DEL], 0, FS_OP_ADD, 1); + tsg_stat_sync_exdata_del_update(SYNC_EXDATA_APP_ID_DICT, 1); } } return; @@ -1254,7 +1255,8 @@ void ex_data_security_compile_new(const char *table_name, int table_id, const ch atomic_inc(&compile->ref_cnt); *ad=(void *)compile; - //FS_operate(g_tsg_para.fs2_handle, g_tsg_para.fs2_field_id[TSG_FS2_SECURIRY_ADD], 0, FS_OP_ADD, 1); + + tsg_stat_sync_exdata_add_update(SYNC_EXDATA_COMPILE, 1); return ; } @@ -1357,9 +1359,8 @@ void ex_data_security_compile_free(int table_id, void **ad, long argl, void *arg tsg_free_field((char *)(*ad)); *ad=NULL; - //FS_operate(g_tsg_para.fs2_handle, g_tsg_para.fs2_field_id[TSG_FS2_SECURIRY_DEL], 0, FS_OP_ADD, 1); + tsg_stat_sync_exdata_del_update(SYNC_EXDATA_COMPILE, 1); } - } static char *get_http_pages_content(const char *filename, int *filelen) @@ -1464,7 +1465,7 @@ void ex_data_http_response_pages_new(const char *table_name, int table_id, const res_pages=NULL; } - //FS_operate(g_tsg_para.fs2_handle, g_tsg_para.fs2_field_id[TSG_FS2_HTTP_RES_ADD], 0, FS_OP_ADD, 1); + tsg_stat_sync_exdata_add_update(SYNC_EXDATA_HTTP_RESPONSE, 1); } void ex_data_http_response_pages_free(int table_id, void **ad, long argl, void* argp) @@ -1478,7 +1479,7 @@ void ex_data_http_response_pages_free(int table_id, void **ad, long argl, void* tsg_free_field((char *)(*ad)); *ad=NULL; - //FS_operate(g_tsg_para.fs2_handle, g_tsg_para.fs2_field_id[TSG_FS2_HTTP_RES_DEL], 0, FS_OP_ADD, 1); + tsg_stat_sync_exdata_del_update(SYNC_EXDATA_HTTP_RESPONSE, 1); } } } @@ -1552,7 +1553,7 @@ void ex_data_dns_profile_records_new(const char *table_name, int table_id, const profile_records=NULL; } - //FS_operate(g_tsg_para.fs2_handle, g_tsg_para.fs2_field_id[TSG_FS2_DNS_RES_ADD], 0, FS_OP_ADD, 1); + tsg_stat_sync_exdata_add_update(SYNC_EXDATA_DNS_RESPONSE, 1); return ; } @@ -1587,7 +1588,7 @@ void ex_data_dns_profile_records_free(int table_id, void **ad, long argl, void * tsg_free_field((char *)(*ad)); *ad=NULL; - //FS_operate(g_tsg_para.fs2_handle, g_tsg_para.fs2_field_id[TSG_FS2_DNS_RES_DEL], 0, FS_OP_ADD, 1); + tsg_stat_sync_exdata_del_update(SYNC_EXDATA_DNS_RESPONSE, 1); } } } @@ -1625,7 +1626,7 @@ void ex_data_mirrored_profile_new(const char *table_name, int table_id, const ch tsg_free_field(vlan_ids_str); vlan_ids_str=NULL; - //FS_operate(g_tsg_para.fs2_handle, g_tsg_para.fs2_field_id[TSG_FS2_MIRRORED_ADD], 0, FS_OP_ADD, 1); + tsg_stat_sync_exdata_add_update(SYNC_EXDATA_MIRRORED, 1); return ; } @@ -1651,7 +1652,7 @@ void ex_data_mirrored_profile_free(int table_id, void **ad, long argl, void *arg { tsg_free_field((char *)(*ad)); *ad=NULL; - //FS_operate(g_tsg_para.fs2_handle, g_tsg_para.fs2_field_id[TSG_FS2_MIRRORED_DEL], 0, FS_OP_ADD, 1); + tsg_stat_sync_exdata_del_update(SYNC_EXDATA_MIRRORED, 1); } } } @@ -1681,7 +1682,7 @@ void ex_data_tunnel_catalog_new(const char *table_name, int table_id, const char atomic_inc(&t_catalog->ref_cnt); *ad=(void *)t_catalog; - //FS_operate(g_tsg_para.fs2_handle, g_tsg_para.fs2_field_id[TSG_FS2_TUNNEL_CATALOG_ADD], 0, FS_OP_ADD, 1); + tsg_stat_sync_exdata_add_update(SYNC_EXDATA_TUNNEL_CATALOG, 1); return; } void ex_data_tunnel_catalog_free(int table_id, void **ad, long argl, void *argp) @@ -1699,7 +1700,7 @@ void ex_data_tunnel_catalog_free(int table_id, void **ad, long argl, void *argp) tsg_free_field(t_catalog->composition); tsg_free_field((char *)(*ad)); *ad=NULL; - //FS_operate(g_tsg_para.fs2_handle, g_tsg_para.fs2_field_id[TSG_FS2_TUNNEL_CATALOG_DEL], 0, FS_OP_ADD, 1); + tsg_stat_sync_exdata_del_update(SYNC_EXDATA_TUNNEL_CATALOG, 1); } } void ex_data_tunnel_catalog_dup(int table_id, void **to, void **from, long argl, void *argp) @@ -1722,7 +1723,7 @@ void ex_data_tunnel_endpoint_new(const char *table_name, int table_id, const cha atomic_inc(&t_endpoint->ref_cnt); *ad=(void *)t_endpoint; - //FS_operate(g_tsg_para.fs2_handle, g_tsg_para.fs2_field_id[TSG_FS2_TUNNEL_ENDPOINT_ADD], 0, FS_OP_ADD, 1); + tsg_stat_sync_exdata_add_update(SYNC_EXDATA_TUNNEL_ENDPOINT, 1); return ; } @@ -1749,7 +1750,7 @@ void ex_data_tunnel_endpoint_free(int table_id, void **ad, long argl, void *argp tsg_free_field(t_endpoint->description); tsg_free_field((char *)(*ad)); *ad=NULL; - //FS_operate(g_tsg_para.fs2_handle, g_tsg_para.fs2_field_id[TSG_FS2_TUNNEL_ENDPOINT_DEL], 0, FS_OP_ADD, 1); + tsg_stat_sync_exdata_del_update(SYNC_EXDATA_TUNNEL_ENDPOINT, 1); } } } @@ -1763,7 +1764,7 @@ void ex_data_tunnel_label_new(const char *table_name, int table_id, const char* { int label_id=column_integer_get_value(table_line, 1); *ad=(void *)(long)label_id; - //FS_operate(g_tsg_para.fs2_handle, g_tsg_para.fs2_field_id[TSG_FS2_TUNNEL_LABEL_ADD], 0, FS_OP_ADD, 1); + tsg_stat_sync_exdata_add_update(SYNC_EXDATA_TUNNEL_LABEL, 1); return ; } @@ -1776,7 +1777,7 @@ void ex_data_tunnel_label_dup(int table_id, void **to, void **from, long argl, v void ex_data_tunnel_label_free(int table_id, void **ad, long argl, void *argp) { - //FS_operate(g_tsg_para.fs2_handle, g_tsg_para.fs2_field_id[TSG_FS2_TUNNEL_LABEL_DEL], 0, FS_OP_ADD, 1); + tsg_stat_sync_exdata_del_update(SYNC_EXDATA_TUNNEL_LABEL, 1); } int init_scan_table(struct maat *feather, const char *conffile) diff --git a/src/tsg_send_log.cpp b/src/tsg_send_log.cpp index 0e37f62..66982a9 100644 --- a/src/tsg_send_log.cpp +++ b/src/tsg_send_log.cpp @@ -17,6 +17,7 @@ #include #include +#include "tsg_stat.h" #include "app_label.h" #include "tsg_entry.h" #include "tsg_bridge.h" @@ -45,21 +46,6 @@ struct TLD_handle_t Document *document; }; -id2field_t g_log_fs2_field[LOG_FS2_TYPE_MAX]={ - {0, LOG_FS2_ABORT_ALLOW, "abort_allow"}, - {0, LOG_FS2_ABORT_DENY, "abort_deny"}, - {0, LOG_FS2_ABORT_MONITOR, "abort_monitor"}, - {0, LOG_FS2_ABORT_INTERCEPT, "abort_intercept"}, - {0, LOG_FS2_ABORT_UNKNOWN, "abort_unknown"}, - {0, LOG_FS2_CREATE_LOG_HANDLE, "create_log_cnt"}, - {0, LOG_FS2_DUP_LOG_HANDLE, "dup_log_cnt"}, - {0, LOG_FS2_APPEND_LOG_HANDLE, "append_log_cnt"}, - {0, LOG_FS2_FREE_LOG_HANDLE, "free_log_cnt"}, - {0, LOG_FS2_FREE_RAPID_SIZE, "free_rapid_size"}, - {0, LOG_FS2_FREE_RAPID_CAPACITY, "free_rapid_capacity"} - }; - - const id2field_t tld_type[TLD_TYPE_MAX]={{TLD_TYPE_UNKNOWN, TLD_TYPE_UNKNOWN, "UNKOWN"}, {TLD_TYPE_LONG, TLD_TYPE_LONG, "LONG"}, {TLD_TYPE_STRING, TLD_TYPE_STRING, "STRING"}, @@ -131,51 +117,53 @@ static int register_topic(struct tsg_log_instance_t *instance, struct topic_stat topic->send_log_percent[i]=100; topic->drop_start[i]=tsg_get_current_time_ms(); } - - topic->fs2_line_id=FS_register(_instance->fs2_handle, FS_STYLE_LINE, FS_CALC_SPEED, topic->name); + + topic->row_idx=tsg_stat_sendlog_row_init((const char *)(topic->name)); return 1; } -static int update_percent(struct tsg_log_instance_t *_instance, int service_id, enum LOG_COLUMN_STATUS column, int thread_id) +static int update_percent(struct tsg_log_instance_t *_instance, int service_id, enum LOG_STATUS column, int thread_id) { long long current_time_ms=tsg_get_current_time_ms(); struct topic_stat *topic=(struct topic_stat *)&(_instance->service2topic[service_id]); switch(column) { - case LOG_COLUMN_STATUS_SUCCESS: - FS_operate(_instance->fs2_handle, topic->fs2_line_id, _instance->fs2_column_id[column], FS_OP_ADD, 1); - FS_operate(_instance->fs2_handle, topic->fs2_line_id, _instance->fs2_column_id[column+1], FS_OP_ADD, 1); + case LOG_STATUS_SUCCESS: + tsg_stat_sendlog_update(topic->row_idx, column, 1); + //tsg_stat_sendlog_update(topic->row_idx, column+1, 1); - FS_operate(_instance->fs2_handle, _instance->sum_line_id, _instance->fs2_column_id[column], FS_OP_ADD, 1); - FS_operate(_instance->fs2_handle, _instance->sum_line_id, _instance->fs2_column_id[column+1], FS_OP_ADD, 1); + tsg_stat_sendlog_update(_instance->sum_stat_row_id, column, 1); + //tsg_stat_sendlog_update(_instance->sum_stat_row_id, column+1, 1); break; - case LOG_COLUMN_STATUS_FAIL: - FS_operate(_instance->fs2_handle, topic->fs2_line_id, _instance->fs2_column_id[column], FS_OP_ADD, 1); - FS_operate(_instance->fs2_handle, topic->fs2_line_id, _instance->fs2_column_id[column+1], FS_OP_ADD, 1); + case LOG_STATUS_FAIL: + tsg_stat_sendlog_update(topic->row_idx, column, 1); + //tsg_stat_sendlog_update(topic->row_idx, column+1, 1); + + tsg_stat_sendlog_update(_instance->sum_stat_row_id, column, 1); + //tsg_stat_sendlog_update(_instance->sum_stat_row_id, column+1, 1); - FS_operate(_instance->fs2_handle, _instance->sum_line_id, _instance->fs2_column_id[column], FS_OP_ADD, 1); - FS_operate(_instance->fs2_handle, _instance->sum_line_id, _instance->fs2_column_id[column+1], FS_OP_ADD, 1); if(current_time_ms - topic->drop_start[thread_id]>=1000) { topic->send_log_percent[thread_id]/=2; topic->drop_start[thread_id]=current_time_ms; } break; - case LOG_COLUMN_STATUS_DROP: + case LOG_STATUS_DROP: if((current_time_ms%100) > topic->send_log_percent[thread_id]) - { - FS_operate(_instance->fs2_handle, topic->fs2_line_id, _instance->fs2_column_id[column], FS_OP_ADD, 1); - FS_operate(_instance->fs2_handle, topic->fs2_line_id, _instance->fs2_column_id[column+1], FS_OP_ADD, 1); + { + tsg_stat_sendlog_update(topic->row_idx, column, 1); + //tsg_stat_sendlog_update(topic->row_idx, column+1, 1); + + tsg_stat_sendlog_update(_instance->sum_stat_row_id, column, 1); + //tsg_stat_sendlog_update(_instance->sum_stat_row_id, column+1, 1); - FS_operate(_instance->fs2_handle, _instance->sum_line_id, _instance->fs2_column_id[column], FS_OP_ADD, 1); - FS_operate(_instance->fs2_handle, _instance->sum_line_id, _instance->fs2_column_id[column+1], FS_OP_ADD, 1); return 1; } break; - case LOG_COLUMN_STATUS_MAX: + case LOG_STATUS_MAX: if(topic->send_log_percent[thread_id]>=100) { break; @@ -184,7 +172,7 @@ static int update_percent(struct tsg_log_instance_t *_instance, int service_id, if((current_time_ms - topic->drop_start[thread_id]) >= _instance->recovery_interval*1000) { topic->send_log_percent[thread_id]++; - topic->drop_start[thread_id]=current_time_ms; + topic->drop_start[thread_id]=current_time_ms; } break; default: @@ -194,16 +182,6 @@ static int update_percent(struct tsg_log_instance_t *_instance, int service_id, return 0; } -static struct tsg_log_instance_t *get_log_instance(void) -{ - if(g_tsg_log_instance!=NULL) - { - return g_tsg_log_instance; - } - - return NULL; -} - static int is_tunnels(const struct streaminfo *a_stream) { const struct streaminfo *ptmp = a_stream; @@ -876,28 +854,49 @@ static int set_link_mac(struct tsg_log_instance_t *_instance, struct TLD_handle_ return 1; } -static int action2fs_id(int action) +enum RULE_STAT { + RULE_STAT_ABORT=0, + RULE_STAT_SEND +}; + +static void fs3_rule_stat_update(enum RULE_STAT stat_type, int action, long long increase) +{ + enum RULE_TYPE rule_type=RULE_TYPE_UNKNOW; + switch(action) { case TSG_ACTION_DENY: - return LOG_FS2_ABORT_DENY; - break; + rule_type=RULE_TYPE_DENY; break; case TSG_ACTION_BYPASS: - return LOG_FS2_ABORT_ALLOW; - break; + rule_type=RULE_TYPE_ALLOW; break; case TSG_ACTION_MONITOR: - return LOG_FS2_ABORT_MONITOR; - break; + rule_type=RULE_TYPE_MONITOR; break; case TSG_ACTION_INTERCEPT: - return LOG_FS2_ABORT_INTERCEPT; - break; + rule_type=RULE_TYPE_INTERCEPT; break; + case TSG_ACTION_NO_INTERCEPT: + rule_type=RULE_TYPE_NO_INTERCEPT; break; + case TSG_ACTION_S_CHAINING: + rule_type=RULE_TYPE_SERVICE_CHAINING; break; + case TSG_ACTION_SHAPING: + rule_type=RULE_TYPE_SHAPING; break; + case TSG_ACTION_SHUNT: + rule_type=RULE_TYPE_SHUNT; break; default: - return LOG_FS2_ABORT_UNKNOWN; - break; + rule_type=RULE_TYPE_UNKNOW; break; } - return LOG_FS2_ABORT_UNKNOWN; + switch(stat_type) + { + case RULE_STAT_ABORT: + tsg_stat_abort_rule_update(rule_type, increase); + break; + case RULE_STAT_SEND: + tsg_stat_send_rule_update(rule_type, increase); + break; + default: + break; + } } int TLD_cancel(struct TLD_handle_t *handle) @@ -907,25 +906,24 @@ int TLD_cancel(struct TLD_handle_t *handle) if (handle->document != NULL) { long long length=0; - struct tsg_log_instance_t *_instance=get_log_instance(); - length=handle->document->GetAllocator().Size(); - FS_operate(_instance->fs2_handle, _instance->fs2_field_id[LOG_FS2_FREE_RAPID_SIZE], 0, FS_OP_ADD, length); + length=handle->document->GetAllocator().Size(); + tsg_stat_log_handle_update(LOG_HANDLE_FREE_SIZE, length); length=handle->document->GetAllocator().Capacity(); - FS_operate(_instance->fs2_handle, _instance->fs2_field_id[LOG_FS2_FREE_RAPID_CAPACITY], 0, FS_OP_ADD, length); + tsg_stat_log_handle_update(LOG_HANDLE_FREE_CAPACITY, length); delete handle->document; handle->document = NULL; delete handle->valueAllocator; handle->valueAllocator=NULL; - - FS_operate(_instance->fs2_handle, _instance->fs2_field_id[LOG_FS2_FREE_LOG_HANDLE], 0, FS_OP_ADD, 1); + + tsg_stat_log_handle_update(LOG_HANDLE_FREE_CNT, 1); } free(handle); - handle = NULL; + handle = NULL; } return 0; @@ -987,11 +985,9 @@ int TLD_append(struct TLD_handle_t *handle, char *key, void *value, TLD_TYPE typ break; } - struct tsg_log_instance_t *_instance=get_log_instance(); + tsg_stat_log_handle_update(LOG_HANDLE_APPEND_CNT, 1); - FS_operate(_instance->fs2_handle, _instance->fs2_field_id[LOG_FS2_APPEND_LOG_HANDLE], 0, FS_OP_ADD, 1); - - return 0; + return 0; } int TLD_array_append(struct TLD_handle_t *handle, char *key, void **array, int array_num, TLD_TYPE type) @@ -1041,16 +1037,14 @@ struct TLD_handle_t *TLD_duplicate(struct TLD_handle_t *handle) _handle->document->CopyFrom(*handle->document, _handle->document->GetAllocator()); - struct tsg_log_instance_t *_instance=get_log_instance(); - FS_operate(_instance->fs2_handle, _instance->fs2_field_id[LOG_FS2_DUP_LOG_HANDLE], 0, FS_OP_ADD, 1); + tsg_stat_log_handle_update(LOG_HANDLE_DUP_CNT, 1); return _handle; } struct TLD_handle_t *TLD_create(int thread_id) { - struct tsg_log_instance_t *_instance=get_log_instance(); - if(_instance->mode==CLOSE) + if(g_tsg_log_instance->mode==CLOSE) { return NULL; } @@ -1058,11 +1052,11 @@ struct TLD_handle_t *TLD_create(int thread_id) struct TLD_handle_t *_handle=(struct TLD_handle_t *)calloc(1, sizeof(struct TLD_handle_t)); _handle->thread_id = thread_id; - _handle->valueAllocator =new MemoryPoolAllocator<>(g_tsg_log_instance->rapidjson_chunk_capacity); + _handle->valueAllocator =new MemoryPoolAllocator<>(g_tsg_log_instance->rapidjson_chunk_capacity); _handle->document = new Document(_handle->valueAllocator); _handle->document->SetObject(); + - FS_operate(_instance->fs2_handle, _instance->fs2_field_id[LOG_FS2_CREATE_LOG_HANDLE], 0, FS_OP_ADD, 1); return _handle; } @@ -1246,6 +1240,8 @@ int set_sce_profile_ids(struct tsg_log_instance_t *_instance, struct TLD_handle_ TLD_append(_handle, _instance->id2field[LOG_COMMON_SCE_PROFILE_IDS].name, (void *) &sce_profile_ids_array, TLD_TYPE_OBJECT); + fs3_rule_stat_update(RULE_STAT_SEND, TSG_ACTION_S_CHAINING, sce->n_profile_ids); + return 0; } @@ -1277,7 +1273,7 @@ int set_shaping_profile_ids(struct tsg_log_instance_t *_instance, struct TLD_han TLD_append(_handle, _instance->id2field[LOG_COMMON_SHAPING_PROFILE_IDS].name, &shaping_array, TLD_TYPE_OBJECT); - //add_object_member(_handle, &shaping_object, _instance->id2field[LOG_COMMON_SHAPING_PROFILE_IDS].name, shaping_array); + fs3_rule_stat_update(RULE_STAT_SEND, TSG_ACTION_SHAPING, shaping->n_shaper_rule); return 0; } @@ -1844,7 +1840,7 @@ int log_common_fields_new(const char *filename, id2field_t *id2field, struct top return 0; } -struct tsg_log_instance_t *tsg_sendlog_init(const char *conffile, screen_stat_handle_t fs2_handle) +struct tsg_log_instance_t *tsg_sendlog_init(const char *conffile) { char override_sled_ip[32]={0}; char kafka_errstr[1024]={0}; @@ -1852,25 +1848,10 @@ struct tsg_log_instance_t *tsg_sendlog_init(const char *conffile, screen_stat_ha rd_kafka_conf_t *rdkafka_conf = NULL; char broker_list[1024]={0}; struct tsg_log_instance_t *_instance=NULL; - char common_field_file[128]={0}; + char common_field_file[128]={0}; char log_path[128]={0}; - _instance=(struct tsg_log_instance_t *)calloc(1, sizeof(struct tsg_log_instance_t)); - _instance->fs2_handle=fs2_handle; - for(int i=0; ifs2_field_id[i]=FS_register(_instance->fs2_handle, FS_STYLE_FIELD, FS_CALC_SPEED, g_log_fs2_field[i].name); - } - - _instance->fs2_column_id[LOG_COLUMN_STATUS_SUCCESS]=FS_register(_instance->fs2_handle, FS_STYLE_COLUMN, FS_CALC_CURRENT, "T_success_log"); - _instance->fs2_column_id[LOG_COLUMN_STATUS_FAIL]=FS_register(_instance->fs2_handle, FS_STYLE_COLUMN, FS_CALC_CURRENT, "T_fail_log"); - _instance->fs2_column_id[LOG_COLUMN_STATUS_DROP]=FS_register(_instance->fs2_handle, FS_STYLE_COLUMN, FS_CALC_CURRENT, "T_drop_log"); - - _instance->fs2_column_id[LOG_COLUMN_STATUS_SUCCESS_S]=FS_register(_instance->fs2_handle, FS_STYLE_COLUMN, FS_CALC_SPEED, "success_log/s"); - _instance->fs2_column_id[LOG_COLUMN_STATUS_FAIL_S]=FS_register(_instance->fs2_handle, FS_STYLE_COLUMN, FS_CALC_SPEED, "fail_log/s"); - _instance->fs2_column_id[LOG_COLUMN_STATUS_DROP_S]=FS_register(_instance->fs2_handle, FS_STYLE_COLUMN, FS_CALC_SPEED, "drop_log/s"); - - _instance->sum_line_id=FS_register(_instance->fs2_handle, FS_STYLE_LINE, FS_CALC_SPEED, "SUM"); + _instance=(struct tsg_log_instance_t *)calloc(1, sizeof(struct tsg_log_instance_t)); MESA_load_profile_int_def(conffile, "TSG_LOG", "LOG_LEVEL",&(_instance->level), 30); MESA_load_profile_string_def(conffile, "TSG_LOG", "LOG_PATH", log_path, sizeof(log_path), "./log/tsglog"); @@ -1890,11 +1871,13 @@ struct tsg_log_instance_t *tsg_sendlog_init(const char *conffile, screen_stat_ha MESA_load_profile_int_def(conffile, "TSG_LOG","TCP_MIN_BYTES", &_instance->tcp_min_log_bytes, 5); MESA_load_profile_int_def(conffile, "TSG_LOG","UDP_MIN_PKTS", &_instance->udp_min_log_pkts, 3); MESA_load_profile_int_def(conffile, "TSG_LOG","UDP_MIN_BYTES", &_instance->udp_min_log_bytes, 5); - + _instance->logger=MESA_create_runtime_log_handle(log_path, _instance->level); if(_instance->logger==NULL) { printf("MESA_create_runtime_log_handle failed ..., path: %s level: %d", log_path, _instance->level); + free(_instance); + _instance=NULL; return NULL; } @@ -1981,6 +1964,7 @@ struct tsg_log_instance_t *tsg_sendlog_init(const char *conffile, screen_stat_ha if(_instance->service2topic!=NULL) { + _instance->sum_stat_row_id=tsg_stat_sendlog_row_init("sum"); for(int i=0; i<_instance->max_service; i++) { if(_instance->service2topic[i].type==TLD_TYPE_MAX && strlen(_instance->service2topic[i].name)>0) @@ -2048,7 +2032,7 @@ void tsg_sendlog_destroy(struct tsg_log_instance_t * instance) int send_log_by_type(struct tsg_log_instance_t *_instance, struct TLD_handle_t *_handle, const struct streaminfo *a_stream, LOG_TYPE log_type, int thread_id) { - int ret=update_percent(_instance, log_type, LOG_COLUMN_STATUS_DROP, thread_id); + int ret=update_percent(_instance, log_type, LOG_STATUS_DROP, thread_id); if(ret==1) { MESA_handle_runtime_log(_instance->logger, RLOG_LV_DEBUG, @@ -2071,7 +2055,7 @@ int send_log_by_type(struct tsg_log_instance_t *_instance, struct TLD_handle_t * int send_event_log(struct tsg_log_instance_t *_instance, struct TLD_handle_t *_handle, const struct streaminfo *a_stream, LOG_TYPE log_type, struct maat_rule *rules, size_t n_rules, int thread_id) { - int fs_id=0,repeat_cnt=0; + int repeat_cnt=0; int policy_id[MAX_RESULT_NUM]={0}; for(size_t i=0;ilevel)) ); - fs_id=action2fs_id((int)rules[i].action); - FS_operate(_instance->fs2_handle, _instance->fs2_field_id[fs_id], 0, FS_OP_ADD, 1); + fs3_rule_stat_update(RULE_STAT_ABORT, (int)rules[i].action, 1); continue; break; case LOG_ALL: @@ -2143,6 +2126,8 @@ int send_event_log(struct tsg_log_instance_t *_instance, struct TLD_handle_t *_h TLD_delete(_handle, _instance->id2field[LOG_COMMON_ACTION].name); TLD_delete(_handle, _instance->id2field[LOG_COMMON_USER_REGION].name); TLD_delete(_handle, _instance->id2field[LOG_COMMON_VSYSTEM_ID].name); + + fs3_rule_stat_update(RULE_STAT_SEND, (int)rules[i].action, 1); } return 0; @@ -2186,7 +2171,8 @@ int tsg_send_log(struct tsg_log_instance_t *instance, struct TLD_handle_t *handl if(_instance->mode==CLOSE) { TLD_cancel(handle); - FS_operate(_instance->fs2_handle, _instance->sum_line_id, _instance->fs2_field_id[LOG_COLUMN_STATUS_DROP], FS_OP_ADD, 1); + tsg_stat_sendlog_update(_instance->sum_stat_row_id, LOG_STATUS_DROP, 1); + tsg_stat_sendlog_update(_instance->sum_stat_row_id, LOG_STATUS_DROP_S, 1); MESA_handle_runtime_log(_instance->logger, RLOG_LV_INFO, "tsg_send_log", "Disable tsg_send_log."); return 0; } @@ -2194,6 +2180,7 @@ int tsg_send_log(struct tsg_log_instance_t *instance, struct TLD_handle_t *handl if(is_hitted_shunt(a_stream)) { TLD_cancel(handle); + fs3_rule_stat_update(RULE_STAT_ABORT, TSG_ACTION_SHUNT, 1); return 0; } @@ -2300,7 +2287,7 @@ int tsg_send_payload(struct tsg_log_instance_t *instance, int topic_id, char *pa status=rd_kafka_produce(_instance->service2topic[topic_id].topic_rkt, RD_KAFKA_PARTITION_UA, RD_KAFKA_MSG_F_COPY, payload, payload_len, NULL, 0, NULL); if(status<0) { - update_percent(_instance, topic_id, LOG_COLUMN_STATUS_FAIL, thread_id); + update_percent(_instance, topic_id, LOG_STATUS_FAIL, thread_id); MESA_handle_runtime_log(_instance->logger, RLOG_LV_INFO, @@ -2317,7 +2304,7 @@ int tsg_send_payload(struct tsg_log_instance_t *instance, int topic_id, char *pa } else { - update_percent(_instance, topic_id, LOG_COLUMN_STATUS_SUCCESS, thread_id); + update_percent(_instance, topic_id, LOG_STATUS_SUCCESS, thread_id); MESA_handle_runtime_log(_instance->logger, RLOG_LV_DEBUG, "tsg_send_log", @@ -2327,7 +2314,7 @@ int tsg_send_payload(struct tsg_log_instance_t *instance, int topic_id, char *pa ); } - update_percent(_instance, topic_id, LOG_COLUMN_STATUS_MAX, thread_id); + update_percent(_instance, topic_id, LOG_STATUS_MAX, thread_id); return 0; } diff --git a/src/tsg_send_log_internal.h b/src/tsg_send_log_internal.h index ff14578..cd0fb6b 100644 --- a/src/tsg_send_log_internal.h +++ b/src/tsg_send_log_internal.h @@ -152,32 +152,6 @@ enum LOG_FIELD_ID LOG_COMMON_MAX }; -enum LOG_COLUMN_STATUS -{ - LOG_COLUMN_STATUS_SUCCESS=0, - LOG_COLUMN_STATUS_SUCCESS_S, - LOG_COLUMN_STATUS_FAIL, - LOG_COLUMN_STATUS_FAIL_S, - LOG_COLUMN_STATUS_DROP, - LOG_COLUMN_STATUS_DROP_S, - LOG_COLUMN_STATUS_MAX -}; - -enum LOG_FS2_TYPE{ - LOG_FS2_ABORT_ALLOW, - LOG_FS2_ABORT_DENY, - LOG_FS2_ABORT_MONITOR, - LOG_FS2_ABORT_INTERCEPT, - LOG_FS2_ABORT_UNKNOWN, - LOG_FS2_CREATE_LOG_HANDLE, - LOG_FS2_DUP_LOG_HANDLE, - LOG_FS2_APPEND_LOG_HANDLE, - LOG_FS2_FREE_LOG_HANDLE, - LOG_FS2_FREE_RAPID_SIZE, - LOG_FS2_FREE_RAPID_CAPACITY, - LOG_FS2_TYPE_MAX -}; - typedef struct _id2field { int type; @@ -189,9 +163,9 @@ struct topic_stat { int status; int type; - int fs2_line_id; + int row_idx; int *send_log_percent; - char name[MAX_STRING_LEN32]; + char name[MAX_STRING_LEN32]; long long *drop_start; rd_kafka_topic_t *topic_rkt; }; @@ -218,9 +192,7 @@ struct tsg_log_instance_t int rapidjson_chunk_capacity; int tcp_flow_project_id; int udp_flow_project_id; - int sum_line_id; - int fs2_column_id[LOG_COLUMN_STATUS_MAX]; - int fs2_field_id[LOG_FS2_TYPE_MAX]; + int sum_stat_row_id; char tcp_label[MAX_STRING_LEN32]; char udp_label[MAX_STRING_LEN32]; char sasl_username[MAX_STRING_LEN32]; @@ -232,12 +204,11 @@ struct tsg_log_instance_t id2field_t id2field[LOG_COMMON_MAX]; rd_kafka_t *kafka_handle; struct topic_stat *service2topic; - screen_stat_handle_t fs2_handle; void *logger; }; int tsg_unknown_app_id_get(struct tsg_log_instance_t *instance); char *log_field_id2name(struct tsg_log_instance_t *instance, enum LOG_FIELD_ID id); -struct tsg_log_instance_t *tsg_sendlog_init(const char *conffile, screen_stat_handle_t fs2_handle); +struct tsg_log_instance_t *tsg_sendlog_init(const char *conffile); void tsg_sendlog_destroy(struct tsg_log_instance_t * instance); diff --git a/src/tsg_stat.cpp b/src/tsg_stat.cpp new file mode 100644 index 0000000..9b15b81 --- /dev/null +++ b/src/tsg_stat.cpp @@ -0,0 +1,294 @@ +#include +#include +#include + +#include "tsg_stat.h" +#include +#include + +struct fs3_rule_stat +{ + int table_id; + int abort_column_id[RULE_TYPE_MAX]; + int send_column_id[RULE_TYPE_MAX]; +}; + +struct fs3_tld_stat +{ + int table_id; + int column_id[LOG_HANDLE_MAX]; +}; + +struct fs3_sendlog_stat +{ + int table_id; + int max_row_idx; + int (*column_id)[LOG_STATUS_MAX]; +}; + +struct fs3_sync_ctrl_stat +{ + int table_id; + int success_column_id[CTRL_SYNC_MAX]; + int fail_column_id[CTRL_SYNC_MAX]; +}; + +struct ctrl_service_status +{ + int activing_column_id[CTRL_SERVICE_MAX]; + int updating_column_id[CTRL_SERVICE_MAX]; +}; + +struct fs3_sync_ctrl_service +{ + int table_id; + struct ctrl_service_status fail; + struct ctrl_service_status success; +}; + +struct fs3_sync_application +{ + int table_id; + int column_id[SYNC_APP_MAX]; +}; + +struct fs3_sync_exdata +{ + int table_id; + int add_column_id[SYNC_EXDATA_MAX]; + int del_column_id[SYNC_EXDATA_MAX]; +}; + +struct fs3_flow +{ + int table_id; + int fail_column_id[FLOW_STAT_MAX]; + int success_column_id[FLOW_STAT_MAX]; +}; + +struct runtime_stat_para +{ + struct fieldstat_tag tags; + struct fs3_flow flow; + struct fs3_tld_stat tld; + struct fs3_rule_stat rule; + struct fs3_sync_exdata exdata; + struct fs3_sendlog_stat sendlog; + struct fs3_sync_application app; + struct fs3_sync_ctrl_stat ctrl_sync; + struct fs3_sync_ctrl_service ctrl_service; + struct fieldstat_instance *fs_instance; +}; + +struct runtime_stat_para g_rt_stat_para={0}; + +static void stat_update(int column_id, long long increase) +{ + fieldstat_value_incrby(g_rt_stat_para.fs_instance, column_id, increase); +} + +void tsg_stat_abort_rule_update(enum RULE_TYPE column_idx, long long increase) +{ + stat_update(g_rt_stat_para.rule.abort_column_id[column_idx], increase); +} + +void tsg_stat_send_rule_update(enum RULE_TYPE column_idx, long long increase) +{ + stat_update(g_rt_stat_para.rule.send_column_id[column_idx], increase); +} + +void tsg_stat_sendlog_update(int row_idx, enum LOG_STATUS column_idx, long long increase) +{ + stat_update(g_rt_stat_para.sendlog.column_id[row_idx][column_idx], increase); +} + +void tsg_stat_log_handle_update(enum LOG_HANDLE column_idx, long long increase) +{ + stat_update(g_rt_stat_para.tld.column_id[column_idx], increase); +} + +void tsg_stat_flow_update(enum STAT_STATUS status, enum FLOW_STAT column_idx, long long increase) +{ + switch(status) + { + case STAT_STATUS_FAIL: + stat_update(g_rt_stat_para.flow.fail_column_id[column_idx], increase); + break; + case STAT_STATUS_SUCCESS: + stat_update(g_rt_stat_para.flow.success_column_id[column_idx], increase); + break; + default: + break; + } +} + +void tsg_stat_sync_ctrl_update(enum STAT_STATUS status, enum CTRL_SYNC column_idx, long long increase) +{ + switch(status) + { + case STAT_STATUS_FAIL: + stat_update(g_rt_stat_para.ctrl_sync.fail_column_id[column_idx], increase); + break; + case STAT_STATUS_SUCCESS: + stat_update(g_rt_stat_para.ctrl_sync.success_column_id[column_idx], increase); + break; + default: + break; + } +} + +void tsg_stat_sync_exdata_add_update(enum SYNC_EXDATA column_idx, long long increase) +{ + stat_update(g_rt_stat_para.exdata.add_column_id[column_idx], increase); +} + +void tsg_stat_sync_exdata_del_update(enum SYNC_EXDATA column_idx, long long increase) +{ + stat_update(g_rt_stat_para.exdata.del_column_id[column_idx], increase); +} + +void tsg_stat_sync_application_update(enum SYNC_APP column_idx, long long increase) +{ + stat_update(g_rt_stat_para.app.column_id[column_idx], increase); +} + +void tsg_stat_ctrl_service_activing_update(enum STAT_STATUS status, enum CTRL_SERVICE column_idx, long long increase) +{ + switch(status) + { + case STAT_STATUS_FAIL: + stat_update(g_rt_stat_para.ctrl_service.fail.activing_column_id[column_idx], increase); + break; + case STAT_STATUS_SUCCESS: + stat_update(g_rt_stat_para.ctrl_service.success.activing_column_id[column_idx], increase); + break; + default: + break; + } +} + +void tsg_stat_ctrl_service_updating_update(enum STAT_STATUS status, enum CTRL_SERVICE column_idx, long long increase) +{ + switch(status) + { + case STAT_STATUS_FAIL: + stat_update(g_rt_stat_para.ctrl_service.fail.updating_column_id[column_idx], increase); + break; + case STAT_STATUS_SUCCESS: + stat_update(g_rt_stat_para.ctrl_service.success.updating_column_id[column_idx], increase); + break; + default: + break; + } +} + +int tsg_stat_create(const char *conffile) +{ + int cycle=0,vsystem_id=0; + unsigned short fs_server_port=0; + char instance_name[128]={0}; + char fs_server_ip[32]={0}; + char fs_output_path[128]={0}; + + MESA_load_profile_int_def(conffile, "FIELD_STAT", "CYCLE", &cycle, 30000); + MESA_load_profile_short_nodef(conffile, "FIELD_STAT","TELEGRAF_PORT", (short *)&(fs_server_port)); + MESA_load_profile_string_nodef(conffile,"FIELD_STAT","TELEGRAF_IP",fs_server_ip, sizeof(fs_server_ip)); + MESA_load_profile_string_def(conffile,"FIELD_STAT","OUTPUT_PATH",fs_output_path, sizeof(fs_output_path), "master.status"); + MESA_load_profile_string_def(conffile,"FIELD_STAT","INSTANCE_NAME", instance_name, sizeof(instance_name), "tsg_master"); + MESA_load_profile_int_def(conffile, "TSG_LOG", "VSYSTEM_ID", &vsystem_id, 1); + + //memset(&(g_rt_stat_para), 0, sizeof(struct runtime_stat_para)); + + g_rt_stat_para.fs_instance=fieldstat_instance_new(instance_name); + fieldstat_set_output_interval(g_rt_stat_para.fs_instance, cycle); + fieldstat_enable_prometheus_output(g_rt_stat_para.fs_instance); + fieldstat_set_local_output(g_rt_stat_para.fs_instance, fs_output_path, "default"); + + if(fs_server_port > 0 && strlen(fs_server_ip) > 0) + { + fieldstat_set_line_protocol_server(g_rt_stat_para.fs_instance, fs_server_ip, fs_server_port); + } + + g_rt_stat_para.tags.key="vsys_id"; + g_rt_stat_para.tags.value_type=0; + g_rt_stat_para.tags.value_int=vsystem_id; + + return 0; +} + +int tsg_stat_init(void) +{ + enum field_type exdata_column_type[SYNC_EXDATA_MAX]={FIELD_TYPE_COUNTER}; + const char *exdata_column_name[SYNC_EXDATA_MAX]={"asn", "gtpc", "location", "fqdn_category", "subscriber", "compile", "mirror", "http_response", "dns_response", "app_id_dict", "tunnel_catalog", "tunnel_endpoint", "tunnel_label"}; + g_rt_stat_para.exdata.table_id=fieldstat_register_table(g_rt_stat_para.fs_instance, "sync_exdata", exdata_column_name, exdata_column_type, SYNC_EXDATA_MAX); + fieldstat_register_table_row(g_rt_stat_para.fs_instance, g_rt_stat_para.exdata.table_id, "add", &(g_rt_stat_para.tags), 1, g_rt_stat_para.exdata.add_column_id); + fieldstat_register_table_row(g_rt_stat_para.fs_instance, g_rt_stat_para.exdata.table_id, "del", &(g_rt_stat_para.tags), 1, g_rt_stat_para.exdata.del_column_id); + + enum field_type flow_column_type[FLOW_STAT_MAX]={FIELD_TYPE_COUNTER}; + const char *flow_column_name[FLOW_STAT_MAX]={"inject", "mirror_pkts", "mirror_bytes", "set_timeout", "tamper"}; + g_rt_stat_para.flow.table_id=fieldstat_register_table(g_rt_stat_para.fs_instance, "flow", flow_column_name, flow_column_type, FLOW_STAT_MAX); + fieldstat_register_table_row(g_rt_stat_para.fs_instance, g_rt_stat_para.flow.table_id, "success", &(g_rt_stat_para.tags), 1, g_rt_stat_para.flow.success_column_id); + fieldstat_register_table_row(g_rt_stat_para.fs_instance, g_rt_stat_para.flow.table_id, "fail", &(g_rt_stat_para.tags), 1, g_rt_stat_para.flow.fail_column_id); + + enum field_type app_sync_column_type[SYNC_APP_MAX]={FIELD_TYPE_COUNTER}; + const char *app_sync_column_name[SYNC_APP_MAX]={"lpi", "dpkt", "thrid", "user_define", "built_in"}; + g_rt_stat_para.app.table_id=fieldstat_register_table(g_rt_stat_para.fs_instance, "sync_application", app_sync_column_name, app_sync_column_type, SYNC_APP_MAX); + fieldstat_register_table_row(g_rt_stat_para.fs_instance, g_rt_stat_para.app.table_id, "sum", &(g_rt_stat_para.tags), 1, g_rt_stat_para.app.column_id); + + enum field_type ctrl_sync_column_type[CTRL_SYNC_MAX]={FIELD_TYPE_COUNTER}; + const char *ctrl_sync_column_name[CTRL_SYNC_MAX]={"unknown", "rstall", "opening", "activing", "updating", "closing"}; + g_rt_stat_para.ctrl_sync.table_id=fieldstat_register_table(g_rt_stat_para.fs_instance, "ctrl_stat", ctrl_sync_column_name, ctrl_sync_column_type, CTRL_SYNC_MAX); + fieldstat_register_table_row(g_rt_stat_para.fs_instance, g_rt_stat_para.ctrl_sync.table_id, "success", &(g_rt_stat_para.tags), 1, g_rt_stat_para.ctrl_sync.success_column_id); + fieldstat_register_table_row(g_rt_stat_para.fs_instance, g_rt_stat_para.ctrl_sync.table_id, "fail", &(g_rt_stat_para.tags), 1, g_rt_stat_para.ctrl_sync.fail_column_id); + + enum field_type ctrl_service_column_type[CTRL_SERVICE_MAX]={FIELD_TYPE_COUNTER}; + const char *ctrl_service_column_name[CTRL_SERVICE_MAX]={"unknown", "sce", "shaping", "intercept"}; + g_rt_stat_para.ctrl_service.table_id=fieldstat_register_table(g_rt_stat_para.fs_instance, "ctrl_service", ctrl_service_column_name, ctrl_service_column_type, CTRL_SERVICE_MAX); + fieldstat_register_table_row(g_rt_stat_para.fs_instance, g_rt_stat_para.ctrl_service.table_id, "activing_success", &(g_rt_stat_para.tags), 1, g_rt_stat_para.ctrl_service.success.activing_column_id); + fieldstat_register_table_row(g_rt_stat_para.fs_instance, g_rt_stat_para.ctrl_service.table_id, "activing_fail", &(g_rt_stat_para.tags), 1, g_rt_stat_para.ctrl_service.fail.activing_column_id); + fieldstat_register_table_row(g_rt_stat_para.fs_instance, g_rt_stat_para.ctrl_service.table_id, "updating_success", &(g_rt_stat_para.tags), 1, g_rt_stat_para.ctrl_service.success.updating_column_id); + fieldstat_register_table_row(g_rt_stat_para.fs_instance, g_rt_stat_para.ctrl_service.table_id, "updating_fail", &(g_rt_stat_para.tags), 1, g_rt_stat_para.ctrl_service.fail.updating_column_id); + + enum field_type rule_column_type[RULE_TYPE_MAX]={FIELD_TYPE_COUNTER}; + const char *rule_column_name[RULE_TYPE_MAX]={"unknown", "shunt", "allow", "deny", "shaping", "intercept", "no_intercept", "service_chaining", "monitor"}; + g_rt_stat_para.rule.table_id=fieldstat_register_table(g_rt_stat_para.fs_instance, "matched_rule", rule_column_name, rule_column_type, RULE_TYPE_MAX); + fieldstat_register_table_row(g_rt_stat_para.fs_instance, g_rt_stat_para.rule.table_id, "abort", &(g_rt_stat_para.tags), 1, g_rt_stat_para.rule.abort_column_id); + fieldstat_register_table_row(g_rt_stat_para.fs_instance, g_rt_stat_para.rule.table_id, "send", &(g_rt_stat_para.tags), 1, g_rt_stat_para.rule.send_column_id); + + enum field_type handle_column_type[LOG_HANDLE_MAX]={FIELD_TYPE_COUNTER}; + const char *handle_column_name[LOG_HANDLE_MAX]={"create", "dup", "append", "free_cnt", "free_size", "free_capacity"}; + g_rt_stat_para.tld.table_id=fieldstat_register_table(g_rt_stat_para.fs_instance, "tld_handle", handle_column_name, handle_column_type, LOG_HANDLE_MAX); + fieldstat_register_table_row(g_rt_stat_para.fs_instance, g_rt_stat_para.tld.table_id, "handle", &(g_rt_stat_para.tags), 1, g_rt_stat_para.tld.column_id); + + enum field_type sendlog_column_type[LOG_STATUS_MAX]={FIELD_TYPE_COUNTER}; + const char *sendlog_column_name[LOG_STATUS_MAX]={"T_success_log", "T_fail_log", "T_drop_log", "success_log/s", "fail_log/s", "drop_log/s"}; + g_rt_stat_para.sendlog.table_id=fieldstat_register_table(g_rt_stat_para.fs_instance, "sendlog", sendlog_column_name, sendlog_column_type, LOG_STATUS_MAX); + + return 0; +} + +int tsg_stat_sendlog_row_init(const char *row_name) +{ + int row_idx=g_rt_stat_para.sendlog.max_row_idx; + if(row_idx==0) + { + g_rt_stat_para.sendlog.column_id=(int (*)[LOG_STATUS_MAX])calloc(row_idx+1, sizeof(int[LOG_STATUS_MAX])); + } + else + { + g_rt_stat_para.sendlog.column_id=(int (*)[LOG_STATUS_MAX])realloc(g_rt_stat_para.sendlog.column_id, (row_idx+1)*sizeof(int[LOG_STATUS_MAX])); + } + + fieldstat_register_table_row(g_rt_stat_para.fs_instance, g_rt_stat_para.sendlog.table_id, row_name, &(g_rt_stat_para.tags), 1, g_rt_stat_para.sendlog.column_id[row_idx]); + + g_rt_stat_para.sendlog.max_row_idx++; + + return row_idx; +} + + +void tsg_stat_start(void) +{ + fieldstat_instance_start(g_rt_stat_para.fs_instance); +} + diff --git a/src/tsg_stat.h b/src/tsg_stat.h new file mode 100644 index 0000000..691b000 --- /dev/null +++ b/src/tsg_stat.h @@ -0,0 +1,130 @@ +#pragma once + +enum STAT_STATUS +{ + STAT_STATUS_SUCCESS=0, + STAT_STATUS_FAIL +}; + +//table: inject, mirror, set_timeout, tamper +enum FLOW_STAT +{ + FLOW_STAT_INJECT=0, + FLOW_STAT_MIRROR_PKT, + FLOW_STAT_MIRROR_BYTE, + FLOW_STAT_SET_TIMEOUT, + FLOW_STAT_TAMPER, + FLOW_STAT_MAX +}; + +//table: LPI, DPKT, THRID, USER_DEFINE, BUILT_IN +enum SYNC_APP +{ + SYNC_APP_LPI=0, + SYNC_APP_DPKT, + SYNC_APP_THRID, + SYNC_APP_USER_DEFINE, + SYNC_APP_BUILT_IN, + SYNC_APP_MAX +}; + +//table: asn, gtpc, location, fqdn_category, subscriber, compile, mirror, http_response, dns_response, app_id_dict, tunnel_catalog, tunnel_endpoint, tunnel_label +enum SYNC_EXDATA +{ + SYNC_EXDATA_ASN=0, + SYNC_EXDATA_GTPC, + SYNC_EXDATA_LOCATION, + SYNC_EXDATA_FQDN_CATEGORY, + SYNC_EXDATA_SUBSCRIBER, + SYNC_EXDATA_COMPILE, + SYNC_EXDATA_MIRRORED, + SYNC_EXDATA_HTTP_RESPONSE, + SYNC_EXDATA_DNS_RESPONSE, + SYNC_EXDATA_APP_ID_DICT, + SYNC_EXDATA_TUNNEL_CATALOG, + SYNC_EXDATA_TUNNEL_ENDPOINT, + SYNC_EXDATA_TUNNEL_LABEL, + SYNC_EXDATA_MAX +}; + +//table: success, success/s, fail, fail/s, drop, drop/s +enum LOG_STATUS +{ + LOG_STATUS_SUCCESS=0, + LOG_STATUS_SUCCESS_S, + LOG_STATUS_FAIL, + LOG_STATUS_FAIL_S, + LOG_STATUS_DROP, + LOG_STATUS_DROP_S, + LOG_STATUS_MAX +}; + +//table: create, duplication, append, free_count, free_size, free_capacity + +enum LOG_HANDLE +{ + LOG_HANDLE_CREATE_CNT, + LOG_HANDLE_DUP_CNT, + LOG_HANDLE_APPEND_CNT, + LOG_HANDLE_FREE_CNT, + LOG_HANDLE_FREE_SIZE, + LOG_HANDLE_FREE_CAPACITY, + LOG_HANDLE_MAX +}; + +//table: unknown, shunt, allow, deny, shaping, intercept, no_intercept, service_chaining, monitor + +enum RULE_TYPE +{ + RULE_TYPE_UNKNOW=0, + RULE_TYPE_SHUNT, + RULE_TYPE_ALLOW, + RULE_TYPE_DENY, + RULE_TYPE_SHAPING, + RULE_TYPE_INTERCEPT, + RULE_TYPE_NO_INTERCEPT, + RULE_TYPE_SERVICE_CHAINING, + RULE_TYPE_MONITOR, + RULE_TYPE_MAX +}; + +//table: unknown, rstall, opening, activing, log_update, closing +enum CTRL_SYNC +{ + CTRL_SYNC_UNKNOWN=0, + CTRL_SYNC_RSTALL, + CTRL_SYNC_OPENING, + CTRL_SYNC_ACTIVING, + CTRL_SYNC_LOG_UPDATE, + CTRL_SYNC_CLOSING, + CTRL_SYNC_MAX +}; + +//table: activing, updating +enum CTRL_SERVICE +{ + CTRL_SERVICE_UNKNOWN=0, + CTRL_SERVICE_CHAINING, + CTRL_SERVICE_SHAPING, + CTRL_SERVICE_INTERCEPT, + CTRL_SERVICE_MAX +}; + +int tsg_stat_create(const char *conffile); +int tsg_stat_init(void); +int tsg_stat_sendlog_row_init(const char *row_name); +void tsg_stat_start(void); +// return row index + +void tsg_stat_abort_rule_update(enum RULE_TYPE column_idx, long long increase); +void tsg_stat_send_rule_update(enum RULE_TYPE column_idx, long long increase); +void tsg_stat_log_handle_update(enum LOG_HANDLE column_idx, long long increase); +void tsg_stat_sync_exdata_add_update(enum SYNC_EXDATA column_idx, long long increase); +void tsg_stat_sync_exdata_del_update(enum SYNC_EXDATA column_idx, long long increase); +void tsg_stat_sync_application_update(enum SYNC_APP column_idx, long long increase); +void tsg_stat_sendlog_update(int row_idx, enum LOG_STATUS column_idx, long long increase); +void tsg_stat_flow_update(enum STAT_STATUS status, enum FLOW_STAT column_idx, long long increase); +void tsg_stat_sync_ctrl_update(enum STAT_STATUS status, enum CTRL_SYNC column_idx, long long increase); +void tsg_stat_ctrl_service_activing_update(enum STAT_STATUS status, enum CTRL_SERVICE column_idx, long long increase); +void tsg_stat_ctrl_service_updating_update(enum STAT_STATUS status, enum CTRL_SERVICE column_idx, long long increase); + diff --git a/src/tsg_sync_state.cpp b/src/tsg_sync_state.cpp index e9cecc5..e4be062 100644 --- a/src/tsg_sync_state.cpp +++ b/src/tsg_sync_state.cpp @@ -4,6 +4,7 @@ #include #include +#include "tsg_stat.h" #include "tsg_variable.h" #include "tsg_sync_state.h" #include "tsg_send_log.h" @@ -43,13 +44,8 @@ static int mpack_send_pkt(const struct streaminfo *a_stream, mpack_writer_t *wri ret = sapp_inject_ctrl_pkt((struct streaminfo *)a_stream, SIO_DEFAULT, *mpack_data, *mpack_size, a_stream->routedir); if (ret == -1) { - FS_operate(g_tsg_para.fs2_handle, g_tsg_para.fs2_field_id[TSG_FS2_INJECT_CTRL_FAILED], 0, FS_OP_ADD, 1); MESA_handle_runtime_log(g_tsg_para.logger, RLOG_LV_DEBUG, "MSGPACK_BUFF_SEND", "An error occurred injecting the data! addr: %s", PRINTADDR(a_stream, g_tsg_para.level)); } - else - { - FS_operate(g_tsg_para.fs2_handle, g_tsg_para.fs2_field_id[TSG_FS2_INJECT_CTRL_SUCCESS], 0, FS_OP_ADD, 1); - } free(*mpack_data); *mpack_data = NULL; @@ -85,17 +81,28 @@ int tsg_send_session_state(const struct streaminfo *a_stream, unsigned char stat int tsg_sync_resetall_state(const struct streaminfo *a_stream) { - if (a_stream == NULL) + if(a_stream==NULL) { + tsg_stat_sync_ctrl_update(STAT_STATUS_FAIL, CTRL_SYNC_RSTALL, 1); return -1; } - + char *mpack_data = NULL; size_t mpack_size = 0; mpack_writer_t writer; mpack_init_map(a_stream, &writer, "resetall", &mpack_data, &mpack_size); - return mpack_send_pkt(a_stream, &writer, &mpack_data, &mpack_size); + int ret=mpack_send_pkt(a_stream, &writer, &mpack_data, &mpack_size); + if(ret==-1) + { + tsg_stat_sync_ctrl_update(STAT_STATUS_FAIL, CTRL_SYNC_RSTALL, 1); + } + else + { + tsg_stat_sync_ctrl_update(STAT_STATUS_SUCCESS, CTRL_SYNC_RSTALL, 1); + } + + return 0; } static void mpack_append_string(mpack_writer_t *writer, char *str) @@ -282,6 +289,7 @@ int tsg_sync_policy_update(const struct streaminfo *a_stream, struct update_poli { if (a_stream == NULL || policy_update == NULL || policy_update->type >= POLICY_UPDATE_MAX || n_policy_update == 0) { + tsg_stat_sync_ctrl_update(STAT_STATUS_FAIL, CTRL_SYNC_UNKNOWN, 1); return -1; } @@ -301,21 +309,70 @@ int tsg_sync_policy_update(const struct streaminfo *a_stream, struct update_poli { mpack_append_update_policy(&writer, &policy_update[i], policy_update[i].type); } + mpack_complete_map(&writer); // params - return mpack_send_pkt(a_stream, &writer, &mpack_data, &mpack_size); + enum STAT_STATUS status; + int ret=mpack_send_pkt(a_stream, &writer, &mpack_data, &mpack_size); + if(ret==-1) + { + status=STAT_STATUS_FAIL; + } + else + { + status=STAT_STATUS_SUCCESS; + + } + + tsg_stat_sync_ctrl_update(status, CTRL_SYNC_ACTIVING, 1); + + switch(policy_update[0].type) + { + case POLICY_UPDATE_SHAPING: + tsg_stat_ctrl_service_activing_update(status, CTRL_SERVICE_SHAPING, 1); + break; + case POLICY_UPDATE_INTERCEPT: + tsg_stat_ctrl_service_activing_update(status, CTRL_SERVICE_INTERCEPT, 1); + break; + case POLICY_UPDATE_SERVICE_CHAINING: + tsg_stat_ctrl_service_activing_update(status, CTRL_SERVICE_CHAINING, 1); + break; + default: + tsg_stat_ctrl_service_activing_update(status, CTRL_SERVICE_UNKNOWN, 1); + break; + } + + return ret; } int tsg_sync_closing_state(const struct streaminfo *a_stream, unsigned char state) { - return tsg_send_session_state(a_stream, state); + int ret=tsg_send_session_state(a_stream, state); + if(ret==-1) + { + tsg_stat_sync_ctrl_update(STAT_STATUS_FAIL, CTRL_SYNC_CLOSING, 1); + } + else + { + tsg_stat_sync_ctrl_update(STAT_STATUS_SUCCESS, CTRL_SYNC_CLOSING, 1); + } + + return ret; } int tsg_sync_opening_state(const struct streaminfo *a_stream, unsigned char state) { - tsg_send_session_state(a_stream, state); - - return 0; + int ret=tsg_send_session_state(a_stream, state); + if(ret==-1) + { + tsg_stat_sync_ctrl_update(STAT_STATUS_FAIL, CTRL_SYNC_OPENING, 1); + } + else + { + tsg_stat_sync_ctrl_update(STAT_STATUS_SUCCESS, CTRL_SYNC_OPENING, 1); + } + + return ret; } static char *mpack_parse_get_string(mpack_node_t node, char *p_str, int thread_seq) @@ -466,8 +523,9 @@ int mpack_parse_proxy_intercept_info(const struct streaminfo *a_stream, mpack_tr int tsg_parse_log_update_payload(const struct streaminfo *a_stream, const void *payload, unsigned int payload_len) { - if (a_stream == NULL || payload == NULL || payload_len == 0) + if(a_stream==NULL || payload==NULL || payload_len==0) { + tsg_stat_ctrl_service_updating_update(STAT_STATUS_FAIL, CTRL_SERVICE_UNKNOWN, 1); return -1; } @@ -480,6 +538,7 @@ int tsg_parse_log_update_payload(const struct streaminfo *a_stream, const void * { MESA_handle_runtime_log(g_tsg_para.logger, RLOG_LV_INFO, "PARSE_LOG_UPDATE", "mpack_tree_parse error! payload_len = %u", payload_len); mpack_tree_destroy(&tree); + tsg_stat_ctrl_service_updating_update(STAT_STATUS_FAIL, CTRL_SERVICE_UNKNOWN, 1); return -1; } @@ -488,6 +547,7 @@ int tsg_parse_log_update_payload(const struct streaminfo *a_stream, const void * { MESA_handle_runtime_log(g_tsg_para.logger, RLOG_LV_INFO, "PARSE_LOG_UPDATE", "method error! mpack_node_type(method) = %d", (int)mpack_node_type(method)); mpack_tree_destroy(&tree); + tsg_stat_ctrl_service_updating_update(STAT_STATUS_FAIL, CTRL_SERVICE_UNKNOWN, 1); return -1; } @@ -496,6 +556,7 @@ int tsg_parse_log_update_payload(const struct streaminfo *a_stream, const void * // mpack_node_str(method) is contiguous memory MESA_handle_runtime_log(g_tsg_para.logger, RLOG_LV_INFO, "PARSE_LOG_UPDATE", "method error! mpack_node_strlen(method) = %lu", mpack_node_strlen(method)); mpack_tree_destroy(&tree); + tsg_stat_ctrl_service_updating_update(STAT_STATUS_FAIL, CTRL_SERVICE_UNKNOWN, 1); return -1; } @@ -505,6 +566,7 @@ int tsg_parse_log_update_payload(const struct streaminfo *a_stream, const void * // if session_id = 0, it's could be mpack_node_type(root) = nil MESA_handle_runtime_log(g_tsg_para.logger, RLOG_LV_INFO, "PARSE_LOG_UPDATE", "session_id error! session_id: %llu, real session_id: %llu", session_id, tsg_get_stream_trace_id(a_stream)); mpack_tree_destroy(&tree); + tsg_stat_ctrl_service_updating_update(STAT_STATUS_FAIL, CTRL_SERVICE_UNKNOWN, 1); return -1; } @@ -513,27 +575,60 @@ int tsg_parse_log_update_payload(const struct streaminfo *a_stream, const void * { MESA_handle_runtime_log(g_tsg_para.logger, RLOG_LV_INFO, "PARSE_LOG_UPDATE", "params_node error!"); mpack_tree_destroy(&tree); + tsg_stat_ctrl_service_updating_update(STAT_STATUS_FAIL, CTRL_SERVICE_UNKNOWN, 1); return -1; } mpack_node_t temp_node = mpack_node_map_str_optional(params_node, "sce", 3); if (mpack_node_type(temp_node) != mpack_type_nil && mpack_node_type(temp_node) != mpack_type_missing) { - return mpack_parse_sce_profile_ids(a_stream, tree, temp_node); + int ret=mpack_parse_sce_profile_ids(a_stream, tree, temp_node); + if(ret==-1) + { + tsg_stat_ctrl_service_updating_update(STAT_STATUS_FAIL, CTRL_SERVICE_CHAINING, 1); + } + else + { + tsg_stat_ctrl_service_updating_update(STAT_STATUS_SUCCESS, CTRL_SERVICE_CHAINING, 1); + } + + return ret; } temp_node = mpack_node_map_str_optional(params_node, "shaper", 6); if (mpack_node_type(temp_node) != mpack_type_nil && mpack_node_type(temp_node) != mpack_type_missing) { - return mpack_parse_shaper_profile_ids(a_stream, tree, temp_node); + int ret=mpack_parse_shaper_profile_ids(a_stream, tree, temp_node); + if(ret==-1) + { + tsg_stat_ctrl_service_updating_update(STAT_STATUS_FAIL, CTRL_SERVICE_SHAPING, 1); + } + else + { + tsg_stat_ctrl_service_updating_update(STAT_STATUS_SUCCESS, CTRL_SERVICE_SHAPING, 1); + } + + return ret; } temp_node = mpack_node_map_str_optional(params_node, "proxy", 5); if (mpack_node_type(temp_node) != mpack_type_nil && mpack_node_type(temp_node) != mpack_type_missing) { - return mpack_parse_proxy_intercept_info(a_stream, tree, temp_node); + int ret=mpack_parse_proxy_intercept_info(a_stream, tree, temp_node); + if(ret==-1) + { + tsg_stat_ctrl_service_updating_update(STAT_STATUS_FAIL, CTRL_SERVICE_INTERCEPT, 1); + } + else + { + tsg_stat_ctrl_service_updating_update(STAT_STATUS_SUCCESS, CTRL_SERVICE_INTERCEPT, 1); + } + + return ret; } + tsg_stat_ctrl_service_updating_update(STAT_STATUS_FAIL, CTRL_SERVICE_UNKNOWN, 1); + MESA_handle_runtime_log(g_tsg_para.logger, RLOG_LV_DEBUG, "PDARSE_LOG_UPDATE", "pkt error! there is no log!"); mpack_tree_destroy(&tree); return -1; diff --git a/src/tsg_sync_state.h b/src/tsg_sync_state.h index a585de1..3eb4a1a 100644 --- a/src/tsg_sync_state.h +++ b/src/tsg_sync_state.h @@ -141,6 +141,8 @@ struct sce_log_update uint32_t profile_ids[SCE_PROFILE_IDS]; }; +int tsg_init_sync_status(struct fieldstat_instance *fs3_instance); + int tsg_sync_resetall_state(const struct streaminfo *a_stream); int tsg_send_session_state(const struct streaminfo *a_stream, unsigned char state); int tsg_sync_opening_state(const struct streaminfo *a_stream, unsigned char state); diff --git a/src/tsg_tamper.cpp b/src/tsg_tamper.cpp index 1958a26..3a283f4 100644 --- a/src/tsg_tamper.cpp +++ b/src/tsg_tamper.cpp @@ -4,6 +4,7 @@ #include #include +#include "tsg_stat.h" #include "tsg_entry.h" #include #include "tsg_protocol_common.h" @@ -32,90 +33,73 @@ #define IPV6_UDP_PALYLOAD_START_INDEX 48 //ipv6_len(40) + udp_len(8) #define IPV6_IP_PAYLOAD_INDEX 4 //ipv6_payload_index(4) -int swap_payload2byte(char *str, int endlen) +int swap_payload2byte(char *str, int endlen) { - char temp; + char temp; - if(endlen<4){ //最少满??6bit的长度，即最?字节? - return 0; - } + if(endlen<4) + { + return 0; + } - //这样交换是别面校验和不对的问? - for(int i=1; iptcpdetail->pdata; - trans_layload_len = a_stream->ptcpdetail->datalen; + if(a_stream==NULL || raw_pkt==NULL) + { + tsg_stat_flow_update(STAT_STATUS_FAIL, FLOW_STAT_TAMPER, 1); + return -1; + } + + *tamper_count = *tamper_count + 1; + p_trans_payload = (char *)a_stream->ptcpdetail->pdata; + trans_layload_len = a_stream->ptcpdetail->datalen; - if((p_trans_payload==NULL)||(trans_layload_len<=4)){ - FS_operate(g_tsg_para.fs2_handle, g_tsg_para.fs2_field_id[TSG_FS2_TAMPER_FAILED_PLOAD_LESS_4], 0, FS_OP_ADD, 1); - MESA_handle_runtime_log(g_tsg_para.logger, - RLOG_LV_DEBUG, - __FUNCTION__, - "Addr: %s, try send num %ld ptcpdetail->pdata %p, ptcpdetail->datalen %d rawpkt %p , but packet is not tamper because the payload is too short or there is no payload", - PRINTADDR(a_stream, g_tsg_para.level), - *tamper_count, - p_trans_payload, - trans_layload_len, - raw_pkt); + if((p_trans_payload==NULL)||(trans_layload_len<=4)) + { + tsg_stat_flow_update(STAT_STATUS_FAIL, FLOW_STAT_TAMPER, 1); + return -1; + } - return -1; - } + memcpy(tamper_buf, p_trans_payload, trans_layload_len); + tamper_index=swap_payload2byte(tamper_buf, trans_layload_len); + if(tamper_index<=0) + { + tsg_stat_flow_update(STAT_STATUS_FAIL, FLOW_STAT_TAMPER, 1); + return -1; + } - memcpy(tamper_buf, p_trans_payload, trans_layload_len); - tamper_index = swap_payload2byte(tamper_buf, trans_layload_len); - if(tamper_index > 0 ){ - if(0 == tsg_send_inject_packet(a_stream, SIO_DEFAULT, tamper_buf, trans_layload_len, a_stream->routedir)){ - FS_operate(g_tsg_para.fs2_handle, g_tsg_para.fs2_field_id[TSG_FS2_SUCESS_TAMPER], 0, FS_OP_ADD, 1); - MESA_handle_runtime_log(g_tsg_para.logger, - RLOG_LV_DEBUG, - __FUNCTION__, - "Addr: %s, try send num %ld ptcpdetail->pdata %p, ptcpdetail->datalen %d rawpkt %p, modify the index(%d) position of the payload:(old: %02x %02x %02x %02x, new: %02x %02x %02x %02x)", - PRINTADDR(a_stream, g_tsg_para.level), - *tamper_count, - p_trans_payload, - trans_layload_len, - raw_pkt, - tamper_index, - (uint8_t)p_trans_payload[tamper_index-1], (uint8_t)p_trans_payload[tamper_index], (uint8_t)p_trans_payload[tamper_index+1], (uint8_t)p_trans_payload[tamper_index+2], - (uint8_t)tamper_buf[tamper_index-1], (uint8_t)tamper_buf[tamper_index], (uint8_t)tamper_buf[tamper_index+1], (uint8_t)tamper_buf[tamper_index+2]); - return 0; - } - } - - FS_operate(g_tsg_para.fs2_handle, g_tsg_para.fs2_field_id[TSG_FS2_TAMPER_FAILED_NOSWAP], 0, FS_OP_ADD, 1); - MESA_handle_runtime_log(g_tsg_para.logger, - RLOG_LV_DEBUG, - __FUNCTION__, - "Addr: %s, try send num %ld ptcpdetail->pdata %p, ptcpdetail->datalen %d rawpkt %p, payload tamper failed because payload data same", - PRINTADDR(a_stream, g_tsg_para.level), - *tamper_count, - p_trans_payload, - trans_layload_len, - raw_pkt); - - return -1; + int ret=tsg_send_inject_packet(a_stream, SIO_DEFAULT, tamper_buf, trans_layload_len, a_stream->routedir); + if(ret==-1) + { + tsg_stat_flow_update(STAT_STATUS_FAIL, FLOW_STAT_TAMPER, 1); + } + else + { + tsg_stat_flow_update(STAT_STATUS_SUCCESS, FLOW_STAT_TAMPER, 1); + } + + return ret; } diff --git a/src/tsg_variable.h b/src/tsg_variable.h index 6cf5413..0ec6348 100644 --- a/src/tsg_variable.h +++ b/src/tsg_variable.h @@ -4,71 +4,8 @@ #include "tsg_bridge.h" #include -#include #include -enum TSG_FS2_TYPE -{ - TSG_FS2_TCP_LINKS=0, - TSG_FS2_UDP_LINKS, - TSG_FS2_BYPASS, - TSG_FS2_HIT_ADDR, - TSG_FS2_HIT_SHARE, - TSG_FS2_INTERCEPT, - TSG_FS2_SHAPING, - TSG_FS2_S_CHAINING, - TSG_FS2_CTRL_OPENING, - TSG_FS2_CTRL_CLOSING, - TSG_FS2_CTRL_ACTIVE, - TSG_FS2_CTRL_RESETALL, - TSG_FS2_INJECT_CTRL_SUCCESS, - TSG_FS2_INJECT_CTRL_FAILED, - TSG_FS2_EXCLUSION, - TSG_FS2_APP_DPKT_RESULT, - TSG_FS2_APP_Q_RESULT, - TSG_FS2_APP_USER_RESULT, - TSG_FS2_APP_BUILT_IN_RESULT, - TSG_FS2_INJECT_PKT_SUCCESS, - TSG_FS2_INJECT_PKT_FAILED, - TSG_FS2_MIRRORED_PKT_SUCCESS, - TSG_FS2_MIRRORED_BYTE_SUCCESS, - TSG_FS2_MIRRORED_PKT_FAILED, - TSG_FS2_MIRRORED_BYTE_FAILED, - TSG_FS2_SET_TIMOUT_SUCCESS, - TSG_FS2_SET_TIMOUT_FAILED, - TSG_FS2_SUCESS_TAMPER, - TSG_FS2_TAMPER_FAILED_PLOAD_LESS_4, - TSG_FS2_TAMPER_FAILED_NOSWAP, - TSG_FS2_ASN_ADD, - TSG_FS2_ASN_DEL, - TSG_FS2_GTPC_ADD, - TSG_FS2_GTPC_DEL, - TSG_FS2_LOCATION_ADD, - TSG_FS2_LOCATION_DEL, - TSG_FS2_FQDN_ADD, - TSG_FS2_FQDN_DEL, - TSG_FS2_SUBSCRIBER_ADD, - TSG_FS2_SUBSCRIBER_DEL, - TSG_FS2_SECURIRY_ADD, - TSG_FS2_SECURIRY_DEL, - TSG_FS2_MIRRORED_ADD, - TSG_FS2_MIRRORED_DEL, - TSG_FS2_HTTP_RES_ADD, - TSG_FS2_HTTP_RES_DEL, - TSG_FS2_DNS_RES_ADD, - TSG_FS2_DNS_RES_DEL, - TSG_FS2_APP_ID_ADD, - TSG_FS2_APP_ID_DEL, - TSG_FS2_TUNNEL_CATALOG_ADD, - TSG_FS2_TUNNEL_CATALOG_DEL, - TSG_FS2_TUNNEL_ENDPOINT_ADD, - TSG_FS2_TUNNEL_ENDPOINT_DEL, - TSG_FS2_TUNNEL_LABEL_ADD, - TSG_FS2_TUNNEL_LABEL_DEL, - TSG_FS2_MAX -}; - - enum DEPLOY_MODE { DEPLOY_MODE_MIRROR, @@ -137,13 +74,11 @@ struct tsg_rt_para int identify_app_max_pkt_num; int unknown_app_id; int proto_flag; //enum TSG_PROTOCOL - int fs2_field_id[TSG_FS2_MAX]; char device_sn[MAX_STRING_LEN128]; char log_path[MAX_STRING_LEN128]; char device_id_command[MAX_STRING_LEN128]; void *logger; struct reset_argv reset; - screen_stat_handle_t fs2_handle; struct l7_protocol *name_by_id; struct l7_protocol *id_by_name; struct traffic_mirror *mirror_handle; diff --git a/test/src/CMakeLists.txt b/test/src/CMakeLists.txt index 664a1ef..fa6cb21 100644 --- a/test/src/CMakeLists.txt +++ b/test/src/CMakeLists.txt @@ -9,21 +9,21 @@ include_directories(${PROJECT_SOURCE_DIR}/src/) add_definitions(-std=c++11) LINK_DIRECTORIES(/opt/MESA/lib) -add_executable(gtest_rule ${PROJECT_SOURCE_DIR}/src/tsg_rule.cpp ${PROJECT_SOURCE_DIR}/src/tsg_variable.cpp gtest_common.cpp gtest_rule.cpp) -target_link_libraries(gtest_rule gtest-static ctemplate-static cjson MESA_prof_load MESA_handle_logger maat4) +add_executable(gtest_rule ${PROJECT_SOURCE_DIR}/src/tsg_rule.cpp ${PROJECT_SOURCE_DIR}/src/tsg_variable.cpp ${PROJECT_SOURCE_DIR}/src/tsg_stat.cpp gtest_common.cpp gtest_rule.cpp) +target_link_libraries(gtest_rule gtest-static ctemplate-static cjson MESA_prof_load MESA_handle_logger maat4 fieldstat3) -add_executable(gtest_tableinfo ${PROJECT_SOURCE_DIR}/src/tsg_rule.cpp ${PROJECT_SOURCE_DIR}/src/tsg_variable.cpp gtest_common.cpp gtest_tableinfo.cpp) -target_link_libraries(gtest_tableinfo gtest-static ctemplate-static cjson MESA_prof_load MESA_handle_logger maat4) +add_executable(gtest_tableinfo ${PROJECT_SOURCE_DIR}/src/tsg_rule.cpp ${PROJECT_SOURCE_DIR}/src/tsg_variable.cpp ${PROJECT_SOURCE_DIR}/src/tsg_stat.cpp gtest_common.cpp gtest_tableinfo.cpp) +target_link_libraries(gtest_tableinfo gtest-static ctemplate-static cjson MESA_prof_load MESA_handle_logger maat4 fieldstat3) -add_executable(gtest_bridge ${PROJECT_SOURCE_DIR}/src/tsg_bridge.cpp ${PROJECT_SOURCE_DIR}/src/tsg_protocol.cpp ${PROJECT_SOURCE_DIR}/src/tsg_variable.cpp gtest_common.cpp gtest_bridge.cpp) -target_link_libraries(gtest_bridge gtest-static ctemplate-static cjson MESA_prof_load MESA_handle_logger maat4) +add_executable(gtest_bridge ${PROJECT_SOURCE_DIR}/src/tsg_bridge.cpp ${PROJECT_SOURCE_DIR}/src/tsg_protocol.cpp ${PROJECT_SOURCE_DIR}/src/tsg_variable.cpp ${PROJECT_SOURCE_DIR}/src/tsg_stat.cpp gtest_common.cpp gtest_bridge.cpp) +target_link_libraries(gtest_bridge gtest-static ctemplate-static cjson MESA_prof_load MESA_handle_logger maat4 fieldstat3) -add_executable(gtest_action ${PROJECT_SOURCE_DIR}/src/tsg_action.cpp ${PROJECT_SOURCE_DIR}/src/tsg_leaky_bucket.cpp ${PROJECT_SOURCE_DIR}/src/tsg_dns.cpp ${PROJECT_SOURCE_DIR}/src/tsg_icmp.cpp ${PROJECT_SOURCE_DIR}/src/tsg_tamper.cpp ${PROJECT_SOURCE_DIR}/src/tsg_variable.cpp gtest_common.cpp gtest_action.cpp) -target_link_libraries(gtest_action gtest-static ctemplate-static cjson MESA_prof_load MESA_handle_logger maat4 MESA_field_stat2) +add_executable(gtest_action ${PROJECT_SOURCE_DIR}/src/tsg_action.cpp ${PROJECT_SOURCE_DIR}/src/tsg_leaky_bucket.cpp ${PROJECT_SOURCE_DIR}/src/tsg_dns.cpp ${PROJECT_SOURCE_DIR}/src/tsg_icmp.cpp ${PROJECT_SOURCE_DIR}/src/tsg_tamper.cpp ${PROJECT_SOURCE_DIR}/src/tsg_variable.cpp ${PROJECT_SOURCE_DIR}/src/tsg_stat.cpp gtest_common.cpp gtest_action.cpp) +target_link_libraries(gtest_action gtest-static ctemplate-static cjson MESA_prof_load MESA_handle_logger maat4 fieldstat3) -add_executable(gtest_sendlog ${PROJECT_SOURCE_DIR}/src/tsg_send_log.cpp ${PROJECT_SOURCE_DIR}/src/tsg_variable.cpp gtest_common.cpp gtest_kafka.cpp gtest_sendlog.cpp) -target_link_libraries(gtest_sendlog gtest-static ctemplate-static cjson MESA_prof_load MESA_handle_logger maat4 rdkafka MESA_field_stat2) +add_executable(gtest_sendlog ${PROJECT_SOURCE_DIR}/src/tsg_send_log.cpp ${PROJECT_SOURCE_DIR}/src/tsg_variable.cpp ${PROJECT_SOURCE_DIR}/src/tsg_stat.cpp gtest_common.cpp gtest_kafka.cpp gtest_sendlog.cpp) +target_link_libraries(gtest_sendlog gtest-static ctemplate-static cjson MESA_prof_load MESA_handle_logger maat4 rdkafka fieldstat3) set(TSG_MASTER_SRC ${PROJECT_SOURCE_DIR}/src/tsg_entry.cpp ${PROJECT_SOURCE_DIR}/src/tsg_rule.cpp @@ -43,13 +43,14 @@ set(TSG_MASTER_SRC ${PROJECT_SOURCE_DIR}/src/tsg_entry.cpp ${PROJECT_SOURCE_DIR}/src/tsg_protocol.cpp ${PROJECT_SOURCE_DIR}/src/tsg_proxy.cpp ${PROJECT_SOURCE_DIR}/src/mpack.c + ${PROJECT_SOURCE_DIR}/src/tsg_stat.cpp ) add_executable(gtest_master ${TSG_MASTER_SRC} gtest_kafka.cpp gtest_common.cpp gtest_master.cpp) target_link_libraries(gtest_master gtest-static ctemplate-static cjson MESA_prof_load MESA_handle_logger MESA_jump_layer MESA_field_stat2 maat4 MESA_htable fieldstat3) -add_executable(gtest_sync_state ${PROJECT_SOURCE_DIR}/src/tsg_sync_state.cpp ${PROJECT_SOURCE_DIR}/src/mpack.c gtest_common.cpp gtest_sync_state.cpp) -target_link_libraries(gtest_sync_state gtest-static cjson ctemplate-static MESA_handle_logger) +add_executable(gtest_sync_state ${PROJECT_SOURCE_DIR}/src/tsg_sync_state.cpp ${PROJECT_SOURCE_DIR}/src/mpack.c ${PROJECT_SOURCE_DIR}/src/tsg_stat.cpp gtest_common.cpp gtest_sync_state.cpp) +target_link_libraries(gtest_sync_state gtest-static cjson ctemplate-static MESA_prof_load MESA_handle_logger fieldstat3) add_executable(gtest_fieldstat3 ${TSG_MASTER_SRC} gtest_common.cpp gtest_kafka.cpp gtest_fieldstat3.cpp) target_link_libraries(gtest_fieldstat3 gtest-static ctemplate-static cjson MESA_prof_load MESA_handle_logger MESA_jump_layer MESA_field_stat2 maat4 MESA_htable fieldstat3) diff --git a/test/src/gtest_rule.cpp b/test/src/gtest_rule.cpp index 7d7fd51..a3082af 100644 --- a/test/src/gtest_rule.cpp +++ b/test/src/gtest_rule.cpp @@ -1,8 +1,9 @@ #include #include #include - #include + +#include "tsg_stat.h" #include "tsg_rule.h" #include "tsg_label.h" #include "tsg_entry.h" @@ -1091,7 +1092,11 @@ TEST(TMAPI, ScanAppPropertiesPolicy) int main(int argc, char *argv[]) { + tsg_stat_create("./tsgconf/main.conf"); + tsg_stat_init(); tsg_maat_rule_init("tsgconf/main.conf"); + tsg_stat_start(); + testing::InitGoogleTest(&argc, argv); return RUN_ALL_TESTS(); } diff --git a/test/src/gtest_sendlog.cpp b/test/src/gtest_sendlog.cpp index 8a5d7d9..3d6cde2 100644 --- a/test/src/gtest_sendlog.cpp +++ b/test/src/gtest_sendlog.cpp @@ -5,6 +5,7 @@ #include #include +#include "tsg_stat.h" #include "tsg_rule.h" #include "tsg_bridge.h" #include "tsg_send_log.h" @@ -17,7 +18,7 @@ struct maat *g_tsg_maat_feather; -extern struct tsg_log_instance_t *tsg_sendlog_init(const char * conffile, screen_stat_handle_t fs2_handle); +extern struct tsg_log_instance_t *tsg_sendlog_init(const char * conffile, screen_stat_handle_t fs3_instance); char *tsg_device_tag_get(void) { @@ -365,21 +366,11 @@ TEST(Master, SendBgpRecord) int main(int argc, char *argv[]) { - screen_stat_handle_t fs2_handle=FS_create_handle(); + tsg_stat_create("./tsgconf/main.conf"); + tsg_stat_init(); - int value=0,cycle=30; - value=1;//Rewrite - FS_set_para(fs2_handle, PRINT_MODE, &value, sizeof(value)); - value=1;//Do not create stat thread - FS_set_para(fs2_handle, CREATE_THREAD, &value, sizeof(value)); - FS_set_para(fs2_handle, STAT_CYCLE, &cycle, sizeof(cycle)); - FS_set_para(fs2_handle, APP_NAME, (char *)"test", strlen((char *)"test")+1); - - value=FS_OUTPUT_INFLUX_LINE; - FS_set_para(fs2_handle, STATS_FORMAT, &value, sizeof(value)); - - g_tsg_log_instance=tsg_sendlog_init("./tsgconf/main.conf", fs2_handle); - FS_start(fs2_handle); + g_tsg_log_instance=tsg_sendlog_init("./tsgconf/main.conf"); + tsg_stat_start(); testing::InitGoogleTest(&argc, argv); return RUN_ALL_TESTS(); diff --git a/test/src/gtest_sync_state.cpp b/test/src/gtest_sync_state.cpp index b28bef9..17c50cf 100644 --- a/test/src/gtest_sync_state.cpp +++ b/test/src/gtest_sync_state.cpp @@ -6,6 +6,7 @@ #include #include +#include "tsg_stat.h" #include "tsg_sync_state.h" #include "tsg_variable.h" #include "mpack.h" @@ -1464,10 +1465,13 @@ TEST(LOG_UPDATE, ProxyTwice) int main(int argc, char *argv[]) { - g_tsg_para.logger = MESA_create_runtime_log_handle("log/tsg_sync_state", 10); - // tsg_bridge_init("tsgconf/main.conf"); - testing::InitGoogleTest(&argc, argv); - int ret = RUN_ALL_TESTS(); - MESA_destroy_runtime_log_handle(g_tsg_para.logger); - return ret; + g_tsg_para.logger = MESA_create_runtime_log_handle("log/tsg_sync_state", 10); + tsg_stat_create("./tsgconf/main.conf"); + tsg_stat_init(); + tsg_stat_start(); + + testing::InitGoogleTest(&argc, argv); + int ret = RUN_ALL_TESTS(); + MESA_destroy_runtime_log_handle(g_tsg_para.logger); + return ret; } diff --git a/test/src/gtest_tableinfo.cpp b/test/src/gtest_tableinfo.cpp index 263a9f3..28ea6c8 100644 --- a/test/src/gtest_tableinfo.cpp +++ b/test/src/gtest_tableinfo.cpp @@ -1,8 +1,9 @@ #include #include #include - #include + +#include "tsg_stat.h" #include "tsg_rule.h" #include "tsg_label.h" #include "tsg_entry.h" @@ -1379,9 +1380,14 @@ TEST(TSG_Table, APP_SIG_SESSION_ATTRIBUTE_INTEGER) maat_state_free(mid); mid = NULL; } + int main(int argc, char *argv[]) { - tsg_maat_rule_init("tsgconf/main.conf"); - testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); + tsg_stat_create("./tsgconf/main.conf"); + tsg_stat_init(); + + tsg_maat_rule_init("tsgconf/main.conf"); + tsg_stat_start(); + testing::InitGoogleTest(&argc, argv); + return RUN_ALL_TESTS(); } \ No newline at end of file