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

TSG-23378 TFE移除平台层的FieldStat2，为适配AArch64做准备

Browse Source
This commit is contained in:
luwenpeng
2024-11-13 14:09:03 +08:00
parent aa98cf915e
commit 3d99178958
18 changed files with 223 additions and 336 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
common/include/tfe_proxy.h
View File

@@ -1,5 +1,5 @@
#pragma once
#include <MESA/field_stat2.h>
#include <fieldstat/fieldstat_easy.h>
#include <event2/event.h>
struct tfe_proxy;
@@ -9,7 +9,7 @@ struct evdns_base* tfe_proxy_get_work_thread_dnsbase(unsigned int thread_id);
struct evhttp_connection* tfe_proxy_get_work_thread_evhttp(unsigned int thread_id);
struct event_base * tfe_proxy_get_gc_evbase(void);
screen_stat_handle_t tfe_proxy_get_fs_handle(void);
struct fieldstat_easy *tfe_proxy_get_fs_handle(void);
void * tfe_proxy_get_error_logger(void);
int tfe_proxy_ssl_add_trust_ca(const char* pem_file);

2
common/include/tfe_utils.h
View File

@@ -46,6 +46,7 @@
extern void * g_default_logger;
extern bool g_print_to_stderr;
extern thread_local unsigned int __currect_thread_id;
#define TFE_LOG_ERROR(handler, fmt, ...) \
do \
@@ -136,6 +137,7 @@ do { if(!(condition)) { TFE_LOG_ERROR(g_default_logger, fmt, ##__VA_ARGS__); abo
#define ATOMIC_ADD(x, y) __atomic_fetch_add(x,y,__ATOMIC_RELAXED)
#define ATOMIC_ZERO(x) __atomic_fetch_and(x,0,__ATOMIC_RELAXED)
#define ATOMIC_SET(x,y) __atomic_store_n(x,y,__ATOMIC_RELAXED)
#define ATOMIC_EXCHANGE(x,y) __atomic_exchange_n(x,y,__ATOMIC_RELAXED)
#ifndef MAX
#define MAX(a, b) (((a) > (b)) ? (a) : (b))
#endif

200
common/src/tfe_future.cpp
View File

@@ -7,9 +7,8 @@
#include <tfe_future.h>
#include <tfe_utils.h>
#include <MESA/MESA_htable.h>
#include <MESA/field_stat2.h>
#include <MESA/MESA_prof_load.h>
#include <fieldstat/fieldstat_easy.h>
static const char* FP_HISTOGRAM_BINS="0.50,0.80,0.9,0.95,0.99";
@@ -17,15 +16,8 @@ struct future_promise_instance
{
int fsid_f_num;
long long f_num;
int no_stats;
int statsd_cycle;
int statsd_format;
MESA_htable_handle name_table;
char statsd_server_ip[256];
int statsd_server_port;
enum field_calc_algo favorite;
char histogram_bins[256];
screen_stat_handle_t fs_handle;
struct fieldstat_easy *fs_handle;
};
struct _future_promise_debug
@@ -57,84 +49,42 @@ struct promise
};
static struct future_promise_instance g_FP_instance;
static int g_is_FP_init=0;
void future_promise_library_init(const char* profile)
void future_promise_library_init(const char *profile)
{
if(g_is_FP_init==1)
if (g_is_FP_init == 1)
{
return;
}
int value=0;
memset(&g_FP_instance,0,sizeof(g_FP_instance));
g_FP_instance.favorite=FS_CALC_CURRENT;
strcpy(g_FP_instance.histogram_bins, FP_HISTOGRAM_BINS);
if(profile!=NULL)
{
MESA_load_profile_int_def(profile, "STAT", "no_stats", &(g_FP_instance.no_stats), 0);
MESA_load_profile_string_def(profile, "STAT", "statsd_server",
g_FP_instance.statsd_server_ip, sizeof(g_FP_instance.statsd_server_ip), "");
MESA_load_profile_int_def(profile, "STAT", "statsd_port", &(g_FP_instance.statsd_server_port), 0);
MESA_load_profile_int_def(profile, "STAT", "statsd_cycle", &(g_FP_instance.statsd_cycle), 2);
// FS_OUTPUT_STATSD=1, FS_OUTPUT_INFLUX_LINE=2
MESA_load_profile_int_def(profile, "STAT", "statsd_format", &(g_FP_instance.statsd_format), 1);
MESA_load_profile_string_def(profile, "STAT", "histogram_bins",
g_FP_instance.histogram_bins, sizeof(g_FP_instance.histogram_bins), FP_HISTOGRAM_BINS);
MESA_load_profile_int_def(profile, "STAT", "print_diff",
&value, 1);
if(value==0)
{
g_FP_instance.favorite=FS_CALC_CURRENT;
}
}
if(g_FP_instance.no_stats)
{
g_is_FP_init=1;
return;
}
memset(&g_FP_instance, 0, sizeof(g_FP_instance));
int output_cycle = 0;
char output_file[TFE_STRING_MAX] = {0};
char histogram_bins[256] = {0};
if (g_FP_instance.statsd_format != 1 && g_FP_instance.statsd_format != 2)
{
g_FP_instance.statsd_format = 1;
}
unsigned int nr_worker_threads = 0;
MESA_load_profile_uint_def(profile, "system", "nr_worker_threads", &nr_worker_threads, 1);
MESA_load_profile_int_def(profile, "STAT", "output_cycle", &output_cycle, 2);
MESA_load_profile_string_def(profile, "STAT", "output_file", output_file, sizeof(output_file), "log/future.fs4");
MESA_load_profile_string_def(profile, "STAT", "histogram_bins", histogram_bins, sizeof(histogram_bins), FP_HISTOGRAM_BINS);
MESA_htable_handle htable = MESA_htable_born();
value=0;
MESA_htable_set_opt(htable, MHO_SCREEN_PRINT_CTRL,&value,sizeof(value));
value=1;
MESA_htable_set_opt(htable, MHO_THREAD_SAFE, &value,sizeof(value));;
value=16;
MESA_htable_set_opt(htable, MHO_MUTEX_NUM, &value,sizeof(value));;
value=1024;
MESA_htable_set_opt(htable, MHO_HASH_SLOT_SIZE, &value,sizeof(value));;
int value = 0;
MESA_htable_set_opt(htable, MHO_SCREEN_PRINT_CTRL, &value, sizeof(value));
value = 1;
MESA_htable_set_opt(htable, MHO_THREAD_SAFE, &value, sizeof(value));
value = 16;
MESA_htable_set_opt(htable, MHO_MUTEX_NUM, &value, sizeof(value));
value = 1024;
MESA_htable_set_opt(htable, MHO_HASH_SLOT_SIZE, &value, sizeof(value));
MESA_htable_mature(htable);
g_FP_instance.name_table=htable;
g_FP_instance.name_table = htable;
screen_stat_handle_t fs=NULL;
const char* stat_path="log/future.fs2";
const char* app_name="FP";
fs=FS_create_handle();
FS_set_para(fs, APP_NAME, app_name, strlen(app_name)+1);
value=1;
FS_set_para(fs, OUTPUT_PROMETHEUS, &value, sizeof(value));
value=0;
FS_set_para(fs, FLUSH_BY_DATE, &value, sizeof(value));
FS_set_para(fs, OUTPUT_DEVICE, stat_path, strlen(stat_path)+1);
value=1;
FS_set_para(fs, PRINT_MODE, &value, sizeof(value));
value=1;
FS_set_para(fs, CREATE_THREAD, &value, sizeof(value));
FS_set_para(fs, STAT_CYCLE, &g_FP_instance.statsd_cycle, sizeof(g_FP_instance.statsd_cycle));
if(strlen(g_FP_instance.statsd_server_ip)>0 && g_FP_instance.statsd_server_port!=0)
{
FS_set_para(fs, STATS_SERVER_IP, g_FP_instance.statsd_server_ip, strlen(g_FP_instance.statsd_server_ip)+1);
FS_set_para(fs, STATS_SERVER_PORT, &(g_FP_instance.statsd_server_port), sizeof(g_FP_instance.statsd_server_port));
FS_set_para(fs, STATS_FORMAT, &(g_FP_instance.statsd_format), sizeof(g_FP_instance.statsd_format));
}
FS_set_para(fs, HISTOGRAM_GLOBAL_BINS, g_FP_instance.histogram_bins, strlen(g_FP_instance.histogram_bins)+1);
g_FP_instance.fsid_f_num=FS_register(fs, FS_STYLE_FIELD, g_FP_instance.favorite, "futures");
FS_start(fs);
g_FP_instance.fs_handle=fs;
g_is_FP_init=1;
g_FP_instance.fs_handle = fieldstat_easy_new(nr_worker_threads, "FP", NULL, 0);
fieldstat_easy_enable_auto_output(g_FP_instance.fs_handle, output_file, output_cycle);
g_FP_instance.fsid_f_num = fieldstat_easy_register_counter(g_FP_instance.fs_handle, "futures");
g_is_FP_init = 1;
return;
}
static struct promise * __future_to_promise(struct future * f)
@@ -147,7 +97,9 @@ static void __promise_destroy(struct promise *p)
{
p->cb_ctx_destroy(p->ctx);
}
if(!g_FP_instance.no_stats) FS_operate(g_FP_instance.fs_handle,g_FP_instance.fsid_f_num, 0, FS_OP_SUB, 1);
fieldstat_easy_counter_incrby(g_FP_instance.fs_handle, __currect_thread_id, g_FP_instance.fsid_f_num, NULL, 0, -1);
memset(p, 0, sizeof(struct promise));
free(p);
return;
@@ -172,58 +124,60 @@ void promise_allow_many_successes(struct promise *p)
struct field_get_set_args
{
MESA_htable_handle htable;
screen_stat_handle_t fs_handle;
struct fieldstat_easy *fs_handle;
int fsid_latency;
int fsid_failed;
};
static long field_get_set_cb(void * data, const uchar * key, uint size, void * user_arg)
static long field_get_set_cb(void *data, const uchar *key, uint size, void *user_arg)
{
struct field_get_set_args* args=(struct field_get_set_args*)user_arg;
int *field_id=NULL, ret=0;
const char* fail_str="_fail";
char buff[size+strlen(fail_str)+1];
if(data==NULL)
struct field_get_set_args *args = (struct field_get_set_args *)user_arg;
int *field_id = NULL, ret = 0;
const char *fail_str = "_fail";
char buff[size + strlen(fail_str) + 1];
if (data == NULL)
{
field_id=(int*)malloc(sizeof(int)*2);
snprintf(buff,sizeof(buff),"%s(ms)",(char*)key);
field_id[0]=FS_register_histogram(args->fs_handle, g_FP_instance.favorite, buff,
1, 30*1000,3);
args->fsid_latency=field_id[0];
snprintf(buff,sizeof(buff),"%s%s",(char*)key,fail_str);
field_id[1]=FS_register(args->fs_handle, FS_STYLE_FIELD, g_FP_instance.favorite, buff);
args->fsid_failed=field_id[1];
ret = MESA_htable_add(args->htable, key, size, (void*)field_id);
assert(ret>=0);
field_id = (int *)malloc(sizeof(int) * 2);
snprintf(buff, sizeof(buff), "%s(ms)", (char *)key);
field_id[0] = fieldstat_easy_register_histogram(args->fs_handle, buff, 1, 500000, 1);
args->fsid_latency = field_id[0];
snprintf(buff, sizeof(buff), "%s%s", (char *)key, fail_str);
field_id[1] = fieldstat_easy_register_counter(args->fs_handle, buff);
args->fsid_failed = field_id[1];
ret = MESA_htable_add(args->htable, key, size, (void *)field_id);
assert(ret >= 0);
}
else
{
field_id=(int*)data;
args->fsid_latency=field_id[0];
args->fsid_failed=field_id[1];
field_id = (int *)data;
args->fsid_latency = field_id[0];
args->fsid_failed = field_id[1];
}
(void)ret;
return 0;
}
struct future * future_create(const char* symbol, future_success_cb * cb_success, future_failed_cb * cb_failed, void * user)
struct future *future_create(const char *symbol, future_success_cb *cb_success, future_failed_cb *cb_failed, void *user)
{
struct promise * p = ALLOC(struct promise, 1);
struct promise *p = ALLOC(struct promise, 1);
p->f.user = user;
p->f.cb_success = cb_success;
p->f.cb_failed = cb_failed;
p->ref_cnt=1;
strncpy(p->f.symbol,symbol,sizeof(p->f.symbol));
if(!g_FP_instance.no_stats)
{
clock_gettime(CLOCK_MONOTONIC,&p->debug.create_time);
long cb_ret=0;
struct field_get_set_args args={.htable = g_FP_instance.name_table, .fs_handle = g_FP_instance.fs_handle};
MESA_htable_search_cb(g_FP_instance.name_table, (const unsigned char*)symbol, strlen(symbol), field_get_set_cb, &args, &cb_ret);
p->debug.fsid_latency=args.fsid_latency;
p->debug.fsid_failed=args.fsid_failed;
FS_operate(g_FP_instance.fs_handle,g_FP_instance.fsid_f_num, 0, FS_OP_ADD, 1);
}
p->ref_cnt = 1;
strncpy(p->f.symbol, symbol, sizeof(p->f.symbol));
clock_gettime(CLOCK_MONOTONIC, &p->debug.create_time);
long cb_ret = 0;
struct field_get_set_args args = {.htable = g_FP_instance.name_table, .fs_handle = g_FP_instance.fs_handle};
MESA_htable_search_cb(g_FP_instance.name_table, (const unsigned char *)symbol, strlen(symbol), field_get_set_cb, &args, &cb_ret);
p->debug.fsid_latency = args.fsid_latency;
p->debug.fsid_failed = args.fsid_failed;
fieldstat_easy_counter_incrby(g_FP_instance.fs_handle, __currect_thread_id, g_FP_instance.fsid_f_num, NULL, 0, 1);
return &p->f;
}
void future_set_timeout(struct future * f, struct timeval timeout)
@@ -255,29 +209,29 @@ void promise_finish(struct promise * p)
__promise_destroy(p);
}
}
static void fp_stat_latency(struct _future_promise_debug* debug, int is_success)
static void fp_stat_latency(struct _future_promise_debug *debug, int is_success)
{
struct timespec end;
long long jiffies_ms=0;
clock_gettime(CLOCK_MONOTONIC,&end);
if(is_success==1)
long long jiffies_ms = 0;
clock_gettime(CLOCK_MONOTONIC, &end);
if (is_success == 1)
{
debug->succ_times++;
}
else
{
FS_operate(g_FP_instance.fs_handle, debug->fsid_failed, 0, FS_OP_ADD, 1);
fieldstat_easy_counter_incrby(g_FP_instance.fs_handle, __currect_thread_id, debug->fsid_failed, NULL, 0, 1);
}
if(debug->succ_times<=1)
if (debug->succ_times <= 1)
{
jiffies_ms=(end.tv_sec-debug->create_time.tv_sec)*1000+(end.tv_nsec-debug->create_time.tv_nsec)/1000000;
FS_operate(g_FP_instance.fs_handle, debug->fsid_latency, 0, FS_OP_SET, jiffies_ms);
jiffies_ms = (end.tv_sec - debug->create_time.tv_sec) * 1000 + (end.tv_nsec - debug->create_time.tv_nsec) / 1000000;
fieldstat_easy_histogram_record(g_FP_instance.fs_handle, __currect_thread_id, debug->fsid_latency, NULL, 0, jiffies_ms);
}
return;
}
void promise_failed(struct promise * p, enum e_future_error error, const char * what)
{
if(!g_FP_instance.no_stats) fp_stat_latency(&p->debug, 0);
fp_stat_latency(&p->debug, 0);
if(!p->f.is_cancelled)
{
p->f.cb_failed(error, what, p->f.user);
@@ -291,7 +245,7 @@ void promise_failed(struct promise * p, enum e_future_error error, const char *
void promise_success(struct promise * p, void * result)
{
if(!g_FP_instance.no_stats) fp_stat_latency(&p->debug, 1);
fp_stat_latency(&p->debug, 1);
if(!p->f.is_cancelled)
{
p->f.cb_success(result, p->f.user);

10
conf/tfe/future.conf
View File

@@ -1,10 +1,4 @@
[STAT]
no_stats=0
statsd_server=127.0.0.1
statsd_port=8100
histogram_bins=0.50,0.80,0.9,0.95
statsd_cycle=5
# FS_OUTPUT_STATSD=1, FS_OUTPUT_INFLUX_LINE=2
statsd_format=2
# printf diff Not available
# print_diff=1
output_file=log/future.json
output_cycle=5

14
conf/tfe/tfe.conf
View File

@@ -147,14 +147,8 @@ tcp_ttl_upstream=75
tcp_ttl_downstream=70
[stat]
statsd_server=127.0.0.1
statsd_port=8100
statsd_cycle=5
# 1:FS_OUTPUT_STATSD; 2:FS_OUTPUT_INFLUX_LINE
statsd_format=2
histogram_bins=0.5,0.8,0.9,0.95
statsd_set_prometheus_port=9001
statsd_set_prometheus_url_path=/tfe_prometheus
output_file=log/tfe.json
output_cycle=5
[traffic_mirror]
enable=1
@@ -163,7 +157,7 @@ device=eth4
type=1
default_vlan_id=2
table_info=resource/pangu/table_info_traffic_mirror.conf
stat_file=log/traffic_mirror.status
stat_file=log/traffic_mirror.json
app_symbol=tfe-mirror
[traffic_steering]
@@ -197,7 +191,7 @@ stat_switch=1
perf_switch=1
table_info=resource/pangu/table_info.conf
accept_path=/opt/tsg/etc/tsg_device_tag.json
stat_file=log/pangu_scan.fs2
stat_file=metrics/pangu_scan.json
effect_interval_s=1
deferred_load_on=0

2
platform/include/internal/proxy.h
View File

@@ -122,7 +122,7 @@ struct tfe_proxy
struct event * gcev;
void * logger;
void * fs_handle;
struct fieldstat_easy *fs_handle;
unsigned int nr_work_threads;
struct tfe_thread_ctx * work_threads[TFE_THREAD_MAX];
int make_work_thread_sleep;

11
platform/include/internal/ssl_sess_cache.h
View File

@@ -4,6 +4,15 @@
#include <openssl/ssl.h>
#include <tfe_stream.h>
struct sess_cache_stat
{
long long size;
long long query_cnt;
long long hit_cnt;
long long miss_cnt;
long long del_err;
};
struct sess_cache;
struct sess_cache * ssl_sess_cache_create(unsigned int slot_size, unsigned int expire_seconds, enum tfe_conn_dir served);
void ssl_sess_cache_destroy(struct sess_cache * cache);
@@ -14,4 +23,4 @@ SSL_SESSION * up_session_get(struct sess_cache * cache, struct sockaddr * addr,
void down_session_set(struct sess_cache * cache, const SSL_SESSION * sess);
void down_session_del(struct sess_cache * cache, const SSL_SESSION * sess);
SSL_SESSION * down_session_get(struct sess_cache * cache, const unsigned char * id, int idlen);
void ssl_sess_cache_stat(struct sess_cache * cache, long long *size, long long* n_query,long long* n_hit);
void ssl_sess_cache_stat(struct sess_cache *cache, struct sess_cache_stat *stat);

17
platform/src/key_keeper.cpp
View File

@@ -419,7 +419,7 @@ static void certstore_rpc_on_succ(void* result, void* user)
TFE_LOG_DEBUG(ctx->ref_keeper->logger, "Key keeper cache add key: %s", ctx->key);
}
}
ctx->ref_keeper->stat.new_issue++;
ATOMIC_INC(&(ctx->ref_keeper->stat.new_issue));
promise_success(p, (void*)kyr);
key_keeper_free_keyring((struct keyring*)kyr);
}
@@ -735,7 +735,7 @@ void key_keeper_async_ask(struct future * f, struct key_keeper * keeper, const c
ctx->key_len = len;
promise_set_ctx(p, (void*)ctx, key_keeper_promise_free_ctx);
long int cb_rtn = 0;
keeper->stat.ask_times++;
ATOMIC_INC(&(keeper->stat.ask_times));
if(!keeper->no_cache)
{
char *tmp = tfe_strdup((const char *)ctx->key);
@@ -821,7 +821,7 @@ void key_keeper_async_ask(struct future * f, struct key_keeper * keeper, const c
}
}
promise_success(p, (void*)kyr);
keeper->stat.new_issue++;
ATOMIC_INC(&(keeper->stat.new_issue));
key_keeper_free_keyring((struct keyring*)kyr);
}
else
@@ -833,14 +833,13 @@ void key_keeper_async_ask(struct future * f, struct key_keeper * keeper, const c
}
return;
}
void key_keeper_statistic(struct key_keeper *keeper, struct key_keeper_stat* result)
void key_keeper_statistic(struct key_keeper *keeper, struct key_keeper_stat *result)
{
if (!keeper->no_cache)
{
// pthread_rwlock_rdlock(&(keeper->rwlock));
keeper->stat.cached_num=MESA_htable_get_elem_num(keeper->cert_cache);
// pthread_rwlock_unlock(&(keeper->rwlock));
result->cached_num = MESA_htable_get_elem_num(keeper->cert_cache);
}
*result = keeper->stat;
return;
result->ask_times = ATOMIC_READ(&(keeper->stat.ask_times));
result->new_issue = ATOMIC_READ(&(keeper->stat.new_issue));
}

78
platform/src/proxy.cpp
View File

@@ -30,7 +30,7 @@
#include <MESA/MESA_handle_logger.h>
#include <MESA/MESA_prof_load.h>
#include <MESA/field_stat2.h>
#include <fieldstat/fieldstat_easy.h>
#include <tfe_utils.h>
#include <tfe_future.h>
@@ -299,17 +299,16 @@ static void __signal_handler_cb(evutil_socket_t fd, short what, void * arg)
static void __gc_handler_cb(evutil_socket_t fd, short what, void * arg)
{
tfe_proxy * ctx = (tfe_proxy *) arg;
int i = 0;
for (i = 0; i < TFE_STAT_MAX; i++)
tfe_proxy *ctx = (tfe_proxy *)arg;
for (int i = 0; i < TFE_STAT_MAX; i++)
{
FS_operate(ctx->fs_handle, ctx->fs_id[i], 0, FS_OP_SET, ATOMIC_READ(&(ctx->stat_val[i])));
long long delta = ATOMIC_EXCHANGE(&(ctx->stat_val[i]), 0);
fieldstat_easy_counter_incrby(ctx->fs_handle, 0, ctx->fs_id[i], NULL, 0, delta);
}
if (ctx->kni_v4_acceptor != NULL)
packet_io_fs_dump(ctx->kni_v4_acceptor->packet_io_fs);
FS_passive_output(ctx->fs_handle);
timestamp_update();
return;
}
@@ -498,54 +497,21 @@ static const char * __str_stat_spec_map[] =
[TFE_STAT_MAX] = NULL
};
int tfe_stat_init(struct tfe_proxy * proxy, const char * profile)
int tfe_stat_init(struct tfe_proxy *proxy, const char *profile)
{
static const char * fieldstat_output = "log/tfe.fs2";
static const char * app_name = "tfe3a";
int output_cycle = 0;
char output_file[TFE_STRING_MAX] = {0};
MESA_load_profile_string_def(profile, "STAT", "output_file", output_file, sizeof(output_file), "log/tfe.fs4");
MESA_load_profile_int_def(profile, "STAT", "output_cycle", &(output_cycle), 5);
int value = 0, i = 0;
screen_stat_handle_t fs_handle = NULL;
char statsd_server_ip[TFE_SYMBOL_MAX]={0};
char histogram_bins[TFE_SYMBOL_MAX]={0};
int statsd_format=0;
int statsd_server_port=0;
MESA_load_profile_string_def(profile, "STAT", "statsd_server", statsd_server_ip,
sizeof(statsd_server_ip), "");
MESA_load_profile_int_def(profile, "STAT", "statsd_port", &(statsd_server_port), 0);
// FS_OUTPUT_STATSD=1, FS_OUTPUT_INFLUX_LINE=2
MESA_load_profile_int_def(profile, "STAT", "statsd_format", &(statsd_format), 1);
MESA_load_profile_string_def(profile, "STAT", "histogram_bins",
histogram_bins, sizeof(histogram_bins), "0.5,0.8,0.9,0.95");
proxy->fs_handle = fieldstat_easy_new(1, "tfe", NULL, 0);
fieldstat_easy_enable_auto_output(proxy->fs_handle, output_file, output_cycle);
if (statsd_format != 1 && statsd_format != 2)
for (int i = 0; i < TFE_STAT_MAX; i++)
{
statsd_format = 1;
proxy->fs_id[i] = fieldstat_easy_register_counter(proxy->fs_handle, __str_stat_spec_map[i]);
}
fs_handle = FS_create_handle();
FS_set_para(fs_handle, OUTPUT_DEVICE, fieldstat_output, (int)strlen(fieldstat_output) + 1);
FS_set_para(fs_handle, APP_NAME, app_name, (int)strlen(app_name) + 1);
value = 1;
FS_set_para(fs_handle, OUTPUT_PROMETHEUS, &value, sizeof(value));
value = 1;
FS_set_para(fs_handle, PRINT_MODE, &value, sizeof(value));
value = 0;
FS_set_para(fs_handle, CREATE_THREAD, &value, sizeof(value));
if(strlen(statsd_server_ip)>0 && statsd_server_port!=0)
{
FS_set_para(fs_handle, STATS_SERVER_IP, statsd_server_ip, strlen(statsd_server_ip)+1);
FS_set_para(fs_handle, STATS_SERVER_PORT, &(statsd_server_port), sizeof(statsd_server_port));
FS_set_para(fs_handle, STATS_FORMAT, &statsd_format, sizeof(statsd_format));
}
FS_set_para(fs_handle, HISTOGRAM_GLOBAL_BINS, histogram_bins, strlen(histogram_bins)+1);
for (i = 0; i < TFE_STAT_MAX; i++)
{
proxy->fs_id[i] = FS_register(fs_handle, FS_STYLE_FIELD, FS_CALC_CURRENT, __str_stat_spec_map[i]);
}
FS_start(fs_handle);
proxy->fs_handle = fs_handle;
return 0;
}
@@ -651,7 +617,7 @@ int main(int argc, char * argv[])
/* PROXY INSTANCE */
g_default_proxy = ALLOC(struct tfe_proxy, 1);
assert(g_default_proxy);
strcpy(g_default_proxy->name, "tfe3a");
strcpy(g_default_proxy->name, "tfe");
g_default_proxy->breakpad = breakpad_init(main_profile, "system", g_default_logger, tfe_version());
CHECK_OR_EXIT(g_default_proxy->breakpad, "Failed at starting breakpad. Exit.");
@@ -661,14 +627,6 @@ int main(int argc, char * argv[])
breakpad_segv_generate();
}
int prometheus_port = 9001;
char prometheus_url_path[1024] = {0};
MESA_load_profile_int_def(main_profile, "STAT", "statsd_set_prometheus_port", &(prometheus_port), 9001);
MESA_load_profile_string_def(main_profile, "STAT", "statsd_set_prometheus_url_path", prometheus_url_path, sizeof(prometheus_url_path), "/tfe_prometheus");
FS_library_set_prometheus_port(prometheus_port);
FS_library_set_prometheus_url_path(prometheus_url_path);
FS_library_init();
future_promise_library_init(future_profile);
/* CONFIG */
ret = tfe_proxy_config(g_default_proxy, main_profile);
@@ -706,9 +664,7 @@ int main(int argc, char * argv[])
CHECK_OR_EXIT(g_default_proxy->sev[i], "Failed at create signal event. Exit.");
evsignal_add(g_default_proxy->sev[i], NULL);
}
int statsd_cycle = 0;
MESA_load_profile_int_def(main_profile, "STAT", "statsd_cycle", &(statsd_cycle), 2);
struct timeval gc_delay = {statsd_cycle, 0};
struct timeval gc_delay = {0, 500 * 1000}; // Microseconds, we set 500 miliseconds here.
evtimer_add(g_default_proxy->gcev, &gc_delay);
timestamp_update();
@@ -809,7 +765,7 @@ struct event_base * tfe_proxy_get_gc_evbase(void)
return g_default_proxy->evbase;
}
screen_stat_handle_t tfe_proxy_get_fs_handle(void)
struct fieldstat_easy *tfe_proxy_get_fs_handle(void)
{
return g_default_proxy->fs_handle;
}

35
platform/src/ssl_service_cache.cpp
View File

@@ -43,16 +43,16 @@ static void ssl_svc_free_client_st(void * data)
struct ssl_service_cache* svc_cache=p->ref_svc_cache;
if(p->is_mutual_auth)
{
svc_cache->stat.mutual_auth_cli_cnt--;
ATOMIC_DEC(&(svc_cache->stat.mutual_auth_cli_cnt));
}
if(p->suspect_pinning_count>=svc_cache->fail_as_cli_pinning_count)
{
svc_cache->stat.pinning_cli_cnt--;
ATOMIC_DEC(&(svc_cache->stat.pinning_cli_cnt));
}
if (p->protocol_error_count >= svc_cache->fail_as_proto_err_count)
{
svc_cache->stat.proto_err_cli_cnt--;
ATOMIC_DEC(&(svc_cache->stat.proto_err_cli_cnt));
}
free(p);
@@ -64,11 +64,11 @@ static void ssl_svc_free_server_st(void * data)
struct ssl_service_cache* svc_cache=p->ref_svc_cache;
if(p->is_ct)
{
svc_cache->stat.ct_srv_cnt--;
ATOMIC_DEC(&(svc_cache->stat.ct_srv_cnt));
}
if(p->is_ev)
{
svc_cache->stat.ev_srv_cnt--;
ATOMIC_DEC(&(svc_cache->stat.ev_srv_cnt));
}
free(p);
return;
@@ -79,7 +79,7 @@ static void ssl_svc_free_app_st(void *data)
struct ssl_service_cache *svc_cache = p->ref_svc_cache;
if (p->down_ssl_success_cnt > svc_cache->succ_as_app_not_pinning_count)
{
svc_cache->stat.app_not_pinning_cnt--;
ATOMIC_DEC(&(svc_cache->stat.app_not_pinning_cnt));
}
free(p);
}
@@ -189,7 +189,7 @@ static long cli_st_write_cb(void * data, const uchar * key, uint size, void * us
}
if(cli_st->suspect_pinning_count==cache->fail_as_cli_pinning_count)
{
cache->stat.pinning_cli_cnt++;
ATOMIC_INC(&(cache->stat.pinning_cli_cnt));
}
}
else if(status->cli_pinning_status==PINNING_ST_PINNING)
@@ -201,12 +201,12 @@ static long cli_st_write_cb(void * data, const uchar * key, uint size, void * us
cli_st->protocol_error_count++;
if(cli_st->protocol_error_count==cache->fail_as_proto_err_count)
{
cache->stat.proto_err_cli_cnt++;
ATOMIC_INC(&(cache->stat.proto_err_cli_cnt));
}
}
if(status->is_mutual_auth==1&&cli_st->is_mutual_auth==0)
{
cache->stat.mutual_auth_cli_cnt++;
ATOMIC_INC(&(cache->stat.mutual_auth_cli_cnt));
cli_st->is_mutual_auth=1;
}
cli_st->last_update_time=now;
@@ -243,7 +243,7 @@ static long srv_st_write_cb(void * data, const uchar * key, uint size, void * us
if(status->is_ev==1&&srv_st->is_ev==0)
{
srv_st->is_ev=1;
cache->stat.ev_srv_cnt++;
ATOMIC_INC(&(cache->stat.ev_srv_cnt));
}
if(status->is_ev!=srv_st->is_ev)
{
@@ -252,7 +252,7 @@ static long srv_st_write_cb(void * data, const uchar * key, uint size, void * us
if(status->is_ct==1&&srv_st->is_ct==0)
{
srv_st->is_ct=1;
cache->stat.ct_srv_cnt++;
ATOMIC_INC(&(cache->stat.ct_srv_cnt));
}
if(status->is_ct!=srv_st->is_ct)
{
@@ -297,7 +297,7 @@ static long app_st_write_cb(void *data, const uchar *key, uint size, void *user_
}
if (app_st->down_ssl_success_cnt > cache->succ_as_app_not_pinning_count)
{
cache->stat.app_not_pinning_cnt++;
ATOMIC_INC(&(cache->stat.app_not_pinning_cnt));
}
return 1;
}
@@ -462,8 +462,13 @@ void ssl_service_cache_destroy(struct ssl_service_cache* cache)
free(cache);
return;
}
void ssl_service_cache_stat(struct ssl_service_cache* svc_cache, struct ssl_service_cache_statistics* result)
void ssl_service_cache_stat(struct ssl_service_cache *svc_cache, struct ssl_service_cache_statistics *result)
{
*result=svc_cache->stat;
return;
result->pinning_cli_cnt = ATOMIC_READ(&(svc_cache->stat.pinning_cli_cnt));
result->mutual_auth_cli_cnt = ATOMIC_READ(&(svc_cache->stat.mutual_auth_cli_cnt));
result->proto_err_cli_cnt = ATOMIC_READ(&(svc_cache->stat.proto_err_cli_cnt));
result->ev_srv_cnt = ATOMIC_READ(&(svc_cache->stat.ev_srv_cnt));
result->ct_srv_cnt = ATOMIC_READ(&(svc_cache->stat.ct_srv_cnt));
result->app_not_pinning_cnt = ATOMIC_READ(&(svc_cache->stat.app_not_pinning_cnt));
result->trusted_cert_cnt = ATOMIC_READ(&(svc_cache->stat.trusted_cert_cnt));
}

26
platform/src/ssl_sess_cache.cpp
View File

@@ -5,7 +5,7 @@
#include <tfe_utils.h>
#include <MESA/MESA_htable.h>
#include <MESA/field_stat2.h>
#include <fieldstat/fieldstat_easy.h>
#define SESS_CACHE_NOT_FOUND -1
#define SESS_CACHE_FOUND 0
@@ -35,7 +35,7 @@ struct sess_cache
{
enum tfe_conn_dir served_for;
MESA_htable_handle hash;
long long hit_cnt, miss_cnt, del_err;
struct sess_cache_stat stat;
};
static void ssl_sess_free_serialized(void * data)
@@ -231,12 +231,12 @@ SSL_SESSION * up_session_get(struct sess_cache * cache, struct sockaddr * addr,
key = NULL;
if (cb_ret == SESS_CACHE_FOUND && args.version>=min_ver && args.version<=max_ver)
{
ATOMIC_INC(&(cache->hit_cnt));
ATOMIC_INC(&(cache->stat.hit_cnt));
return args.sess;
}
else
{
ATOMIC_INC(&(cache->miss_cnt));
ATOMIC_INC(&(cache->stat.miss_cnt));
return NULL;
}
}
@@ -275,12 +275,12 @@ SSL_SESSION * down_session_get(struct sess_cache * cache, const unsigned char *
MESA_htable_search_cb(cache->hash, id, (unsigned int) idlen, sess_cache_get_cb, &result, &cb_ret);
if (cb_ret == SESS_CACHE_FOUND)
{
ATOMIC_INC(&(cache->hit_cnt));
ATOMIC_INC(&(cache->stat.hit_cnt));
return result.sess;
}
else
{
ATOMIC_INC(&(cache->miss_cnt));
ATOMIC_INC(&(cache->stat.miss_cnt));
return NULL;
}
}
@@ -293,7 +293,7 @@ void down_session_del(struct sess_cache * cache, const SSL_SESSION * sess)
int ret = MESA_htable_del(cache->hash, id, len, NULL);
if (ret != MESA_HTABLE_RET_OK)
{
ATOMIC_INC(&(cache->del_err));
ATOMIC_INC(&(cache->stat.del_err));
}
return;
}
@@ -337,11 +337,11 @@ void ssl_sess_cache_destroy(struct sess_cache * cache)
free(cache);
return;
}
void ssl_sess_cache_stat(struct sess_cache * cache, long long *size, long long *n_query, long long* n_hit)
void ssl_sess_cache_stat(struct sess_cache *cache, struct sess_cache_stat *stat)
{
*size=MESA_htable_get_elem_num(cache->hash);
*n_hit=cache->hit_cnt;
*n_query=cache->hit_cnt+cache->miss_cnt;
return;
stat->size = MESA_htable_get_elem_num(cache->hash);
stat->hit_cnt = ATOMIC_READ(&(cache->stat.hit_cnt));
stat->miss_cnt = ATOMIC_READ(&(cache->stat.miss_cnt));
stat->del_err = ATOMIC_READ(&(cache->stat.del_err));
stat->query_cnt = stat->hit_cnt + stat->miss_cnt;
}

122
platform/src/ssl_stream.cpp
View File

@@ -173,7 +173,7 @@ struct ssl_mgr
FILE* fp_master_key;
void * logger;
screen_stat_handle_t fs_handle;
struct fieldstat_easy *fs_handle;
long long stat_val[SSL_STAT_MAX];
int fs_id[SSL_STAT_MAX];
};
@@ -350,36 +350,54 @@ const char* ssl_stream_get_error_string(enum ssl_stream_error error)
/*
* Garbage collection handler.
*/
static void
ssl_stream_gc_cb(evutil_socket_t fd, short what, void * arg)
static void ssl_stream_gc_cb(evutil_socket_t fd, short what, void *arg)
{
struct ssl_mgr *mgr=(struct ssl_mgr *)arg;
int i=0;
if(!mgr->no_sesscache)
struct ssl_mgr *mgr = (struct ssl_mgr *)arg;
if (!mgr->no_sesscache)
{
ssl_sess_cache_stat(mgr->up_sess_cache, &(mgr->stat_val[SSL_UP_CACHE_SZ]), &(mgr->stat_val[SSL_UP_CACHE_QUERY]), &(mgr->stat_val[SSL_UP_CACHE_HIT]));
ssl_sess_cache_stat(mgr->down_sess_cache, &(mgr->stat_val[SSL_DOWN_CACHE_SZ]), &(mgr->stat_val[SSL_DOWN_CACHE_QUERY]), &(mgr->stat_val[SSL_DOWN_CACHE_HIT]));
}
struct key_keeper_stat keeper_stat = { 0 };
key_keeper_statistic(mgr->key_keeper, &keeper_stat);
mgr->stat_val[KEY_KEEPER_ASK]=keeper_stat.ask_times;
mgr->stat_val[KEY_KEEPER_ISSUE]=keeper_stat.new_issue;
mgr->stat_val[KEY_KEEPER_CACHE_SIZE]=keeper_stat.cached_num;
struct sess_cache_stat usc_curr_stat = {0};
struct sess_cache_stat dsc_curr_stat = {0};
static struct sess_cache_stat usc_last_stat = {0};
static struct sess_cache_stat dsc_last_stat = {0};
struct ssl_service_cache_statistics svc_stat;
memset(&svc_stat, 0, sizeof(svc_stat));
ssl_service_cache_stat(mgr->svc_cache, &svc_stat);
mgr->stat_val[SSL_SVC_PINNING]=svc_stat.pinning_cli_cnt;
mgr->stat_val[SSL_SVC_MAUTH]=svc_stat.mutual_auth_cli_cnt;
mgr->stat_val[SSL_SVC_CT_CERT]=svc_stat.ct_srv_cnt;
mgr->stat_val[SSL_SVC_EV_CERT]=svc_stat.ev_srv_cnt;
mgr->stat_val[SSL_SVC_APP_NOT_PINNING]=svc_stat.app_not_pinning_cnt;
mgr->stat_val[SSL_SVC_TRUSTED_CERT]=svc_stat.trusted_cert_cnt;
for(i=0;i<SSL_STAT_MAX;i++)
{
FS_operate(mgr->fs_handle, mgr->fs_id[i], 0, FS_OP_SET, ATOMIC_READ(&(mgr->stat_val[i])));
ssl_sess_cache_stat(mgr->up_sess_cache, &usc_curr_stat);
mgr->stat_val[SSL_UP_CACHE_SZ] = usc_curr_stat.size - usc_last_stat.size;
mgr->stat_val[SSL_UP_CACHE_QUERY] = usc_curr_stat.query_cnt - usc_last_stat.query_cnt;
mgr->stat_val[SSL_UP_CACHE_HIT] = usc_curr_stat.hit_cnt- usc_last_stat.hit_cnt;
usc_last_stat = usc_curr_stat;
ssl_sess_cache_stat(mgr->down_sess_cache, &dsc_curr_stat);
mgr->stat_val[SSL_DOWN_CACHE_SZ] = dsc_curr_stat.size - dsc_last_stat.size;
mgr->stat_val[SSL_DOWN_CACHE_QUERY] = dsc_curr_stat.query_cnt - dsc_last_stat.query_cnt;
mgr->stat_val[SSL_DOWN_CACHE_HIT] = dsc_curr_stat.hit_cnt - dsc_last_stat.hit_cnt;
dsc_last_stat = dsc_curr_stat;
}
if(mgr->log_master_key && mgr->fp_master_key)
struct key_keeper_stat keeper_curr_stat = {0};
static struct key_keeper_stat keeper_last_stat = {0};
key_keeper_statistic(mgr->key_keeper, &keeper_curr_stat);
mgr->stat_val[KEY_KEEPER_ASK] = keeper_curr_stat.ask_times - keeper_last_stat.ask_times;
mgr->stat_val[KEY_KEEPER_ISSUE] = keeper_curr_stat.new_issue - keeper_last_stat.new_issue;
mgr->stat_val[KEY_KEEPER_CACHE_SIZE] = keeper_curr_stat.cached_num - keeper_last_stat.cached_num;
keeper_last_stat = keeper_curr_stat;
struct ssl_service_cache_statistics svc_curr_stat = {0};
static struct ssl_service_cache_statistics svc_last_stat = {0};
ssl_service_cache_stat(mgr->svc_cache, &svc_curr_stat);
mgr->stat_val[SSL_SVC_PINNING] = svc_curr_stat.pinning_cli_cnt - svc_last_stat.pinning_cli_cnt;
mgr->stat_val[SSL_SVC_MAUTH] = svc_curr_stat.mutual_auth_cli_cnt - svc_last_stat.mutual_auth_cli_cnt;
mgr->stat_val[SSL_SVC_CT_CERT] = svc_curr_stat.ct_srv_cnt - svc_last_stat.ct_srv_cnt;
mgr->stat_val[SSL_SVC_EV_CERT] = svc_curr_stat.ev_srv_cnt - svc_last_stat.ev_srv_cnt;
mgr->stat_val[SSL_SVC_APP_NOT_PINNING] = svc_curr_stat.app_not_pinning_cnt - svc_last_stat.app_not_pinning_cnt;
mgr->stat_val[SSL_SVC_TRUSTED_CERT] = svc_curr_stat.trusted_cert_cnt - svc_last_stat.trusted_cert_cnt;
svc_last_stat = svc_curr_stat;
for (int i = 0; i < SSL_STAT_MAX; i++)
{
long long delta = ATOMIC_EXCHANGE(&(mgr->stat_val[i]), 0);
fieldstat_easy_counter_incrby(mgr->fs_handle, 0, mgr->fs_id[i], NULL, 0, delta);
}
if (mgr->log_master_key && mgr->fp_master_key)
{
fflush(mgr->fp_master_key);
}
@@ -434,58 +452,14 @@ void ssl_stat_init(struct ssl_mgr * mgr)
spec[SSL_SVC_TRUSTED_CERT]="trusted_cert_nums";
for(i=0;i<SSL_STAT_MAX;i++)
for (i = 0; i < SSL_STAT_MAX; i++)
{
if(spec[i]!=NULL)
if (spec[i] != NULL)
{
mgr->fs_id[i]=FS_register(mgr->fs_handle, FS_STYLE_FIELD, FS_CALC_CURRENT,spec[i]);
mgr->fs_id[i] = fieldstat_easy_register_counter(mgr->fs_handle, spec[i]);
}
}
int value=mgr->fs_id[SSL_UP_CACHE_HIT];
FS_set_para(mgr->fs_handle, ID_INVISBLE, &value, sizeof(value));
value=mgr->fs_id[SSL_UP_CACHE_QUERY];
FS_set_para(mgr->fs_handle, ID_INVISBLE, &value, sizeof(value));
FS_register_ratio(mgr->fs_handle,
mgr->fs_id[SSL_UP_CACHE_HIT],
mgr->fs_id[SSL_UP_CACHE_QUERY],
1,
FS_STYLE_STATUS,
FS_CALC_CURRENT,
"usess_hit");
value=mgr->fs_id[SSL_DOWN_CACHE_HIT];
FS_set_para(mgr->fs_handle, ID_INVISBLE, &value, sizeof(value));
value=mgr->fs_id[SSL_DOWN_CACHE_QUERY];
FS_set_para(mgr->fs_handle, ID_INVISBLE, &value, sizeof(value));
FS_register_ratio(mgr->fs_handle,
mgr->fs_id[SSL_DOWN_CACHE_HIT],
mgr->fs_id[SSL_DOWN_CACHE_QUERY],
1,
FS_STYLE_STATUS,
FS_CALC_CURRENT,
"dsess_hit");
if(!mgr->no_sessticket)
{
value=mgr->fs_id[SSL_DOWN_TIKCET_QUERY];
FS_set_para(mgr->fs_handle, ID_INVISBLE, &value, sizeof(value));
value=mgr->fs_id[SSL_DOWN_TICKET_REUSE];
FS_set_para(mgr->fs_handle, ID_INVISBLE, &value, sizeof(value));
FS_register_ratio(mgr->fs_handle,
mgr->fs_id[SSL_DOWN_TICKET_REUSE],
mgr->fs_id[SSL_DOWN_TIKCET_QUERY],
1,
FS_STYLE_STATUS,
FS_CALC_CURRENT,
"dtkt_hit");
}
struct timeval gc_delay = {0, 500*1000}; //Microseconds, we set 500 miliseconds here.
mgr->gcev = event_new(mgr->ev_base_gc, -1, EV_PERSIST, ssl_stream_gc_cb, mgr);
evtimer_add(mgr->gcev, &gc_delay);

9
plugin/business/doh/src/doh.cpp
View File

@@ -391,11 +391,10 @@ static void doh_maat_scan(const struct tfe_stream *stream, const struct tfe_http
static void doh_gc_cb(evutil_socket_t fd, short what, void *arg)
{
int i = 0;
for (i = 0; i < DOH_STAT_MAX; i++)
for (int i = 0; i < DOH_STAT_MAX; i++)
{
FS_operate(g_doh_conf->fs_handle, g_doh_conf->fs_id[i], 0, FS_OP_SET, ATOMIC_READ(&(g_doh_conf->stat_val[i])));
long long delta = ATOMIC_EXCHANGE(&(g_doh_conf->stat_val[i]), 0);
fieldstat_easy_counter_incrby(g_doh_conf->fs_handle, 0, g_doh_conf->fs_id[i], NULL, 0, delta);
}
}
@@ -413,7 +412,7 @@ static int doh_field_init()
{
if (spec[i] != NULL)
{
g_doh_conf->fs_id[i] = FS_register(g_doh_conf->fs_handle, FS_STYLE_FIELD, FS_CALC_CURRENT, spec[i]);
g_doh_conf->fs_id[i] = fieldstat_easy_register_counter(g_doh_conf->fs_handle, spec[i]);
}
}
g_doh_conf->gcev = event_new(g_doh_conf->gc_evbase, -1, EV_PERSIST, doh_gc_cb, NULL);

2
plugin/business/doh/src/pub.h
View File

@@ -56,7 +56,7 @@ struct doh_conf
long long stat_val[DOH_STAT_MAX];
struct event *gcev;
struct event_base *gc_evbase;
screen_stat_handle_t fs_handle;
struct fieldstat_easy *fs_handle;
struct maat *maat;
};

2
plugin/business/traffic-mirror/include/traffic_mirror.h
View File

@@ -32,7 +32,7 @@ enum
struct traffic_mirror_stat
{
screen_stat_handle_t fs_handle;
struct fieldstat_easy *fs_handle;
uint64_t stat_idx[TRAFFIC_MIRR_STAT_MAX];
uint64_t stat_val[TRAFFIC_MIRR_STAT_MAX];

7
plugin/business/traffic-mirror/src/entry.cpp
View File

@@ -28,7 +28,8 @@ static void stat_output_cb(evutil_socket_t fd, short what, void *arg)
struct traffic_mirror_stat *handle = (struct traffic_mirror_stat *)arg;
for (int i = 0; i < TRAFFIC_MIRR_STAT_MAX; i++)
{
FS_operate(handle->fs_handle, handle->stat_idx[i], 0, FS_OP_SET, ATOMIC_READ(&(handle->stat_val[i])));
long long delta = ATOMIC_EXCHANGE(&(handle->stat_val[i]), 0);
fieldstat_easy_counter_incrby(handle->fs_handle, 0, handle->stat_idx[i], NULL, 0, delta);
}
}
@@ -40,7 +41,6 @@ struct traffic_mirror_stat *traffic_mirror_stat_new()
return NULL;
}
struct timeval gc_delay = {5, 0};
const char *stat_name[TRAFFIC_MIRR_STAT_MAX] = { 0 };
stat_name[TRAFFIC_MIRR_STAT_SUCC_BYTES] = "mirr_succ_B";
stat_name[TRAFFIC_MIRR_STAT_SUCC_PKTS] = "mirr_succ_P";
@@ -50,9 +50,10 @@ struct traffic_mirror_stat *traffic_mirror_stat_new()
handle->evbase = tfe_proxy_get_gc_evbase();
for (int i = 0; i < TRAFFIC_MIRR_STAT_MAX; i++)
{
handle->stat_idx[i] = FS_register(handle->fs_handle, FS_STYLE_FIELD, FS_CALC_CURRENT, stat_name[i]);
handle->stat_idx[i] = fieldstat_easy_register_counter(handle->fs_handle, stat_name[i]);
}
handle->ev = event_new(handle->evbase, -1, EV_PERSIST, stat_output_cb, handle);
struct timeval gc_delay = {0, 500 * 1000}; // Microseconds, we set 500 miliseconds here.
evtimer_add(handle->ev, &gc_delay);
return handle;

2
plugin/business/traffic-mirror/src/rebuild.cpp
View File

@@ -6,6 +6,8 @@
#include <marsio.h>
#include <netinet/ip.h>
#include <netinet/ip6.h>
#define __FAVOR_BSD 1
#include <netinet/tcp.h>
struct traffic_mirror_rebuild
{

16
plugin/business/tsg-http/src/tsg_http.cpp
View File

@@ -152,7 +152,7 @@ struct tsg_proxy_rt
int plolicy_table_id[POLICY_PROFILE_TABLE_MAX];
ctemplate::Template * tpl_403, * tpl_404, * tpl_451;
screen_stat_handle_t fs_handle;
struct fieldstat_easy *fs_handle;
long long stat_val[__PX_STAT_MAX];
int fs_id[__PX_STAT_MAX];
struct event_base* gc_evbase;
@@ -167,15 +167,13 @@ struct tsg_proxy_rt
};
struct tsg_proxy_rt * g_proxy_rt;
static void proxy_http_gc_cb(evutil_socket_t fd, short what, void * arg)
static void proxy_http_gc_cb(evutil_socket_t fd, short what, void *arg)
{
int i=0;
for(i=0;i<__PX_STAT_MAX;i++)
for (int i = 0; i < __PX_STAT_MAX; i++)
{
FS_operate(g_proxy_rt->fs_handle, g_proxy_rt->fs_id[i], 0, FS_OP_SET, ATOMIC_READ(&(g_proxy_rt->stat_val[i])));
long long delta = ATOMIC_EXCHANGE(&(g_proxy_rt->stat_val[i]), 0);
fieldstat_easy_counter_incrby(g_proxy_rt->fs_handle, 0, g_proxy_rt->fs_id[i], NULL, 0, delta);
}
return;
}
static void proxy_http_stat_init(struct tsg_proxy_rt * pangu_runtime)
@@ -200,9 +198,9 @@ static void proxy_http_stat_init(struct tsg_proxy_rt * pangu_runtime)
for(i=0;i<__PX_STAT_MAX;i++)
{
if(spec[i]!=NULL)
if (spec[i] != NULL)
{
pangu_runtime->fs_id[i]=FS_register(pangu_runtime->fs_handle, FS_STYLE_FIELD, FS_CALC_CURRENT, spec[i]);
pangu_runtime->fs_id[i] = fieldstat_easy_register_counter(pangu_runtime->fs_handle, spec[i]);
}
}
g_proxy_rt->gcev = event_new(pangu_runtime->gc_evbase, -1, EV_PERSIST, proxy_http_gc_cb, NULL);