增加proxy初始化fieldstat，增加sslstream的状态统计输出。

common/include/tfe_utils.h

@@ -73,6 +73,7 @@ do { MESA_handle_runtime_log(handler, RLOG_LV_DEBUG, "tfe", fmt, ##__VA_ARGS__);
 #endif
 
 #define	ATOMIC_INC(x) 	__atomic_fetch_add(x,1,__ATOMIC_RELAXED)
+#define	ATOMIC_DEC(x) 	__atomic_fetch_sub(x,1,__ATOMIC_RELAXED)
 #define	ATOMIC_READ(x)	__atomic_fetch_add(x,0,__ATOMIC_RELAXED)
 
 

common/src/tfe_future.cpp

@@ -68,7 +68,7 @@ void future_promise_library_init(void)
 	g_FP_instance.name_table=htable;
 
 	screen_stat_handle_t fs=NULL;
-	const char* stat_path="./future.status";
+	const char* stat_path="./future.fieldstat";
 	const char* app_name="FP";
 	fs=FS_create_handle();
 	FS_set_para(fs, APP_NAME, app_name, strlen(app_name)+1);

platform/include/internal/proxy.h

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

platform/include/internal/ssl_stream.h

@@ -14,7 +14,7 @@ struct ssl_stream;
 
 struct ssl_mgr;
 struct ssl_mgr * ssl_manager_init(const char * ini_profile, const char * section, struct event_base * ev_base_gc,
-	void * logger, screen_stat_handle_t * fs);
+	void * logger, screen_stat_handle_t fs);
 void ssl_manager_destroy(struct ssl_mgr * mgr);
 
 struct ssl_stream * ssl_upstream_create_result_release_stream(future_result_t * result);

platform/src/proxy.cpp

@@ -137,10 +137,8 @@ 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;
-	(void)fd;
-	(void)what;
-	*/
+	tfe_proxy * ctx = (tfe_proxy *) arg;
+	FS_passive_output(ctx->fs_handle);
 	return;
 }
 
@@ -215,6 +213,7 @@ do { if(!(condition)) { TFE_LOG_ERROR(g_default_logger, fmt, ##__VA_ARGS__); exi
 int main(int argc, char *argv[])
 {
 	const char* main_profile="./conf/tfe.conf";
+	const char* fieldstat_output="./tfe.fieldstat";
 
 	g_default_logger = MESA_create_runtime_log_handle("log/tfe.log", RLOG_LV_DEBUG);
 	if (unlikely(g_default_logger == NULL))
@@ -223,15 +222,27 @@ int main(int argc, char *argv[])
 		exit(EXIT_FAILURE);
 	}
 
+
+	
 	future_promise_library_init();
 	/* PROXY INSTANCE */
 	g_default_proxy = ALLOC(struct tfe_proxy, 1);
 	assert(g_default_proxy);
-
+	strcpy(g_default_proxy->name, "tfe3a");
 	/* CONFIG */
 	int ret = tfe_proxy_config(g_default_proxy, main_profile);
 	CHECK_OR_EXIT(ret == 0, "Failed at loading profile %s, Exit.", main_profile);
 
+	/* PERFOMANCE MONITOR */
+	g_default_proxy->fs_handle=FS_create_handle();
+	FS_set_para(g_default_proxy->fs_handle, OUTPUT_DEVICE, fieldstat_output, strlen(fieldstat_output)+1);
+	int value=1;
+	FS_set_para(g_default_proxy->fs_handle, PRINT_MODE, &value, sizeof(value));
+	value=0;
+	FS_set_para(g_default_proxy->fs_handle, CREATE_THREAD, &value, sizeof(value));
+	FS_set_para(g_default_proxy->fs_handle, APP_NAME, g_default_proxy->name, strlen(g_default_proxy->name)+1);
+	FS_start(g_default_proxy->fs_handle);
+
 	/* LOGGER */
 	g_default_proxy->logger = g_default_logger;
 
@@ -245,7 +256,7 @@ int main(int argc, char *argv[])
 
 	/* SSL INIT */
 	g_default_proxy->ssl_mgr_handler = ssl_manager_init(main_profile, "ssl",
-		g_default_proxy->evbase, g_default_logger, NULL);
+		g_default_proxy->evbase, g_default_logger, g_default_proxy->fs_handle);
 	CHECK_OR_EXIT(g_default_proxy->ssl_mgr_handler, "Failed at init SSL manager. Exit.");
 
 	/* PLUGIN INIT */
@@ -265,7 +276,7 @@ int main(int argc, char *argv[])
         evsignal_add(g_default_proxy->sev[i], NULL);
     }
 
-	struct timeval gc_delay = {60, 0};
+	struct timeval gc_delay = {2, 0};
 	evtimer_add(g_default_proxy->gcev , &gc_delay);
 
 	/* WORKER THREAD */

platform/src/ssl_stream.cpp

@@ -51,10 +51,14 @@ enum ssl_stream_stat
 {
 	SSL_UP_NUM,
 	SSL_UP_ERR,
+	SSL_UP_CLOSING,
+	SSL_UP_DIRTY_CLOSED,
 	SSL_UP_CLOSED,
 	SSL_DOWN_NUM,
 	SSL_DOWN_ERR,
+	SSL_DOWN_CLOSING,
 	SSL_DOWN_CLOSED,
+	SSL_DOWN_DIRTY_CLOSED,
 	SSL_NO_CHELLO,
 	SSL_NO_SNI,
 	SSL_FAKE_CRT,
@@ -93,7 +97,7 @@ struct ssl_mgr
     struct event * gcev;
 	
 	void * logger;
-	screen_stat_handle_t* fs_handle;
+	screen_stat_handle_t fs_handle;
 	long long stat_val[SSL_STAT_MAX];
 	int fs_id[SSL_STAT_MAX];
 };
@@ -174,16 +178,21 @@ struct fs_spec
 void ssl_stat_init(struct ssl_mgr * mgr)
 {
 	int i=0;
-	const char* spec[SSL_STAT_MAX]= {
-						[SSL_UP_NUM]="ssl_up",
-						[SSL_UP_ERR]="ssl_up_err",
-						[SSL_UP_CLOSED]="ssl_up_close",
-						[SSL_DOWN_NUM]="ssl_down",
-						[SSL_DOWN_ERR]="ssl_down_err",
-						[SSL_DOWN_CLOSED]="ssl_down_close",
-						[SSL_NO_CHELLO]="ssl_no_chello",
-						[SSL_NO_SNI]="ssl_no_sni",
-						[SSL_FAKE_CRT]="ssl_fake_crt"};
+	const char* spec[SSL_STAT_MAX];
+	spec[SSL_UP_NUM]="ssl_up";
+	spec[SSL_UP_ERR]="sslu_err";						
+	spec[SSL_UP_CLOSING]="sslu_clsing";
+	spec[SSL_UP_CLOSED]="sslu_clsd";
+	spec[SSL_UP_DIRTY_CLOSED]="sslu_dirty_cls";
+	spec[SSL_DOWN_NUM]="ssl_down";
+	spec[SSL_DOWN_ERR]="ssld_err";
+	spec[SSL_DOWN_CLOSING]="ssld_clsing";
+	spec[SSL_DOWN_DIRTY_CLOSED]="ssld_dirty_cls";
+	spec[SSL_DOWN_CLOSED]="ssld_clsd";
+	spec[SSL_NO_CHELLO]="ssl_no_chlo";
+	spec[SSL_NO_SNI]="ssl_no_sni";
+	spec[SSL_FAKE_CRT]="ssl_fk_crt";
+
 	for(i=0;i<SSL_STAT_MAX;i++)
 	{
 		mgr->fs_id[i]=FS_register(mgr->fs_handle, FS_STYLE_STATUS, FS_CALC_CURRENT,spec[i]);
@@ -328,7 +337,6 @@ ssl_stream_gc_cb(evutil_socket_t fd, short what, void * arg)
 {
 	struct ssl_mgr *mgr=(struct ssl_mgr *)arg;
 	int i=0;
-	return;
 	for(i=0;i<SSL_STAT_MAX;i++)
 	{
 		FS_operate(mgr->fs_handle, i, 0, FS_OP_SET, ATOMIC_READ(&(mgr->stat_val[i])));
@@ -337,7 +345,7 @@ ssl_stream_gc_cb(evutil_socket_t fd, short what, void * arg)
 }
 
 struct ssl_mgr * ssl_manager_init(const char * ini_profile, const char * section,
-	struct event_base * ev_base_gc, void * logger, screen_stat_handle_t * fs)
+	struct event_base * ev_base_gc, void * logger, screen_stat_handle_t fs)
 {
     struct timeval gc_delay = {0, 500*1000};	//Microseconds, we set 500 miliseconds here.
 	struct ssl_mgr * mgr = ALLOC(struct ssl_mgr, 1);
@@ -416,8 +424,8 @@ struct ssl_mgr * ssl_manager_init(const char * ini_profile, const char * section
 	}
 
 	memcpy(mgr->ssl_session_context, "mesa-tfe", sizeof(mgr->ssl_session_context));
-	
-	//ssl_stat_init(mgr);
+	mgr->fs_handle=fs;
+	ssl_stat_init(mgr);
 	
 	mgr->gcev = event_new(mgr->ev_base_gc, -1, EV_PERSIST, ssl_stream_gc_cb, mgr);
 	if (!mgr->gcev)
@@ -1243,6 +1251,7 @@ static void pxy_ssl_shutdown_cb(evutil_socket_t fd, short what, void * arg)
 	struct timeval retry_delay = {0, 100};
 
 	void * logger = ctx->s_stream->mgr->logger;
+	struct ssl_mgr* mgr=ctx->s_stream->mgr;
 	short want = 0;
 	int rv = 0, sslerr = 0;
 	char tmp[1024];
@@ -1299,6 +1308,14 @@ retry:
 							  addr_string, fd);
 		tfe_stream_addr_free(addr);
 		free(addr_string);
+		if(ctx->s_stream->dir==CONN_DIR_DOWNSTREAM)
+		{
+			ATOMIC_INC(&(mgr->stat_val[SSL_DOWN_DIRTY_CLOSED]));
+		}
+		else
+		{
+			ATOMIC_INC(&(mgr->stat_val[SSL_UP_DIRTY_CLOSED]));
+		}
 		goto complete;
 	}
 
@@ -1317,12 +1334,15 @@ retry:
 complete:
 	if(ctx->s_stream->dir==CONN_DIR_DOWNSTREAM)
 	{
-		ATOMIC_INC(&(ctx->s_stream->mgr->stat_val[SSL_DOWN_CLOSED]));
+		ATOMIC_INC(&(mgr->stat_val[SSL_DOWN_CLOSED]));
+		ATOMIC_DEC(&(mgr->stat_val[SSL_DOWN_CLOSING]));
 	}
 	else
 	{
-		ATOMIC_INC(&(ctx->s_stream->mgr->stat_val[SSL_UP_CLOSED]));
+		ATOMIC_INC(&(mgr->stat_val[SSL_UP_CLOSED]));
+		ATOMIC_DEC(&(mgr->stat_val[SSL_UP_CLOSING]));
 	}
+	
 	ssl_stream_free(ctx->s_stream);
 	evutil_closesocket(fd);
 	ssl_shutdown_ctx_free(ctx);
@@ -1339,5 +1359,7 @@ void ssl_stream_free_and_close_fd(struct ssl_stream * s_stream, struct event_bas
 	struct ssl_shutdown_ctx * sslshutctx = NULL;
 	assert(fd==s_stream->_do_not_use.fd);
 	sslshutctx = ssl_shutdown_ctx_new(s_stream, evbase);
+	s_stream->dir==CONN_DIR_DOWNSTREAM ? ATOMIC_INC(&(s_stream->mgr->stat_val[SSL_DOWN_CLOSING]))
+										: ATOMIC_INC(&(s_stream->mgr->stat_val[SSL_UP_CLOSING]));
 	pxy_ssl_shutdown_cb(fd, 0, sslshutctx);
 }