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

optimize session manager config

Browse Source
This commit is contained in:
luwenpeng
2024-08-30 18:33:41 +08:00
parent d1d5e6e09e
commit 82cb1eaeeb
26 changed files with 632 additions and 1319 deletions
Download Patch File Download Diff File Expand all files Collapse all files

65
infra/session_manager/test/default_config.h Normal file
View File

@@ -0,0 +1,65 @@
#pragma once
#ifdef __cplusplus
extern "C"
{
#endif
#include "session_manager.h"
static struct session_manager_config cfg = {
.tcp_session_max = 256,
.udp_session_max = 256,
.evict_old_on_tcp_table_limit = 1,
.evict_old_on_udp_table_limit = 1,
.expire_period_ms = 0,
.expire_batch_max = 1024,
.tcp_timeout_ms =
{
.init = 1,
.handshake = 2,
.data = 3,
.half_closed = 4,
.time_wait = 5,
.discard_default = 6,
.unverified_rst = 7,
},
.udp_timeout_ms =
{
.data = 8,
.discard_default = 0,
},
.duplicated_packet_bloom_filter =
{
.enable = 1,
.capacity = 1000,
.time_window_ms = 10,
.error_rate = 0.0001,
},
.evicted_session_bloom_filter =
{
.enable = 1,
.capacity = 1000,
.time_window_ms = 10,
.error_rate = 0.0001,
},
.tcp_reassembly =
{
.enable = 1,
.timeout_ms = 1000,
.buffered_segments_max = 16,
},
};
#ifdef __cplusplus
}
#endif

50
infra/session_manager/test/gtest_case_tcp_fast_open.cpp
View File

@@ -4,51 +4,7 @@
#include "packet_private.h"
#include "packet_parser.h"
#include "session_private.h"
#include "session_manager.h"
struct session_manager_config cfg = {
// max session number
.max_tcp_session_num = 256,
.max_udp_session_num = 256,
// session overload
.tcp_overload_evict_old_sess = 1, // 1: evict old session, 0: bypass new session
.udp_overload_evict_old_sess = 1, // 1: evict old session, 0: bypass new session
// tcp timeout
.tcp_init_timeout_ms = 1,
.tcp_handshake_timeout_ms = 2,
.tcp_data_timeout_ms = 3,
.tcp_half_closed_timeout_ms = 4,
.tcp_time_wait_timeout_ms = 5,
.tcp_discard_timeout_ms = 6,
.tcp_unverified_rst_timeout_ms = 7,
// udp timeout
.udp_data_timeout_ms = 8,
.udp_discard_timeout_ms = 0,
// limit
.session_expire_polling_interval_ms = 0,
.session_expire_polling_limit = 1024,
// duplicate packet filter
.duplicated_packet_filter_enable = 1,
.duplicated_packet_filter_capacity = 1000,
.duplicated_packet_filter_timeout_ms = 10,
.duplicated_packet_filter_error_rate = 0.0001,
// evicted session filter
.evicted_session_filter_enable = 1,
.evicted_session_filter_capacity = 1000,
.evicted_session_filter_timeout_ms = 10,
.evicted_session_filter_error_rate = 0.0001,
// TCP Reassembly
.tcp_reassembly_enable = 1,
.tcp_reassembly_max_timeout_ms = 60000,
.tcp_reassembly_max_segments = 16,
};
#include "default_config.h"
static uint64_t session_id_generator(uint64_t now_ms __attribute__((unused)))
{
@@ -406,8 +362,8 @@ TEST(CASE, TCP_FAST_OPEN)
EXPECT_TRUE(stat->tcp_sess_closing == 0);
// expire session
EXPECT_TRUE(session_manager_get_expired_session(mgr, 1 + cfg.tcp_init_timeout_ms) == NULL); // opening -> closing
sess = session_manager_get_expired_session(mgr, 1 + cfg.tcp_init_timeout_ms + cfg.tcp_data_timeout_ms); // closing -> closed
EXPECT_TRUE(session_manager_get_expired_session(mgr, 1 + cfg.tcp_timeout_ms.init) == NULL); // opening -> closing
sess = session_manager_get_expired_session(mgr, 1 + cfg.tcp_timeout_ms.init + cfg.tcp_timeout_ms.data); // closing -> closed
EXPECT_TRUE(sess);
EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED);
EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT);

50
infra/session_manager/test/gtest_filter_tcp_dupkt.cpp
View File

@@ -3,53 +3,9 @@
#include "packet_private.h"
#include "packet_parser.h"
#include "session_private.h"
#include "session_manager.h"
#include "default_config.h"
#include "test_packets.h"
struct session_manager_config cfg = {
// max session number
.max_tcp_session_num = 256,
.max_udp_session_num = 256,
// session overload
.tcp_overload_evict_old_sess = 1, // 1: evict old session, 0: bypass new session
.udp_overload_evict_old_sess = 1, // 1: evict old session, 0: bypass new session
// tcp timeout
.tcp_init_timeout_ms = 1,
.tcp_handshake_timeout_ms = 2,
.tcp_data_timeout_ms = 3,
.tcp_half_closed_timeout_ms = 4,
.tcp_time_wait_timeout_ms = 5,
.tcp_discard_timeout_ms = 6,
.tcp_unverified_rst_timeout_ms = 7,
// udp timeout
.udp_data_timeout_ms = 8,
.udp_discard_timeout_ms = 0,
// limit
.session_expire_polling_interval_ms = 0,
.session_expire_polling_limit = 1024,
// duplicate packet filter
.duplicated_packet_filter_enable = 1,
.duplicated_packet_filter_capacity = 1000,
.duplicated_packet_filter_timeout_ms = 10,
.duplicated_packet_filter_error_rate = 0.0001,
// evicted session filter
.evicted_session_filter_enable = 1,
.evicted_session_filter_capacity = 1000,
.evicted_session_filter_timeout_ms = 10,
.evicted_session_filter_error_rate = 0.0001,
// TCP Reassembly
.tcp_reassembly_enable = 1,
.tcp_reassembly_max_timeout_ms = 60000,
.tcp_reassembly_max_segments = 16,
};
static uint64_t session_id_generator(uint64_t now_ms __attribute__((unused)))
{
static uint64_t count = 0;
@@ -292,7 +248,7 @@ TEST(TCP_DUPKT_FILTER_DISABLE, SYN_DUP)
struct session_manager_stat *stat = NULL;
struct session_manager_config _cfg;
memcpy(&_cfg, &cfg, sizeof(struct session_manager_config));
_cfg.duplicated_packet_filter_enable = 0;
_cfg.duplicated_packet_bloom_filter.enable = 0;
mgr = session_manager_new(&_cfg, 1);
EXPECT_TRUE(mgr != NULL);
@@ -343,7 +299,7 @@ TEST(TCP_DUPKT_FILTER_DISABLE, SYNACK_DUP)
struct session_manager_stat *stat = NULL;
struct session_manager_config _cfg;
memcpy(&_cfg, &cfg, sizeof(struct session_manager_config));
_cfg.duplicated_packet_filter_enable = 0;
_cfg.duplicated_packet_bloom_filter.enable = 0;
mgr = session_manager_new(&_cfg, 1);
EXPECT_TRUE(mgr != NULL);

76
infra/session_manager/test/gtest_overload_evict_tcp_sess.cpp
View File

@@ -4,53 +4,9 @@
#include "packet_private.h"
#include "packet_parser.h"
#include "session_private.h"
#include "session_manager.h"
#include "default_config.h"
#include "test_packets.h"
struct session_manager_config cfg = {
// max session number
.max_tcp_session_num = RX_BURST_MAX * 2,
.max_udp_session_num = RX_BURST_MAX * 2,
// session overload
.tcp_overload_evict_old_sess = 1, // 1: evict old session, 0: bypass new session
.udp_overload_evict_old_sess = 1, // 1: evict old session, 0: bypass new session
// tcp timeout
.tcp_init_timeout_ms = 1,
.tcp_handshake_timeout_ms = 2,
.tcp_data_timeout_ms = 3,
.tcp_half_closed_timeout_ms = 4,
.tcp_time_wait_timeout_ms = 5,
.tcp_discard_timeout_ms = 6,
.tcp_unverified_rst_timeout_ms = 7,
// udp timeout
.udp_data_timeout_ms = 8,
.udp_discard_timeout_ms = 0,
// limit
.session_expire_polling_interval_ms = 0,
.session_expire_polling_limit = 1024,
// duplicate packet filter
.duplicated_packet_filter_enable = 1,
.duplicated_packet_filter_capacity = 1000,
.duplicated_packet_filter_timeout_ms = 10,
.duplicated_packet_filter_error_rate = 0.0001,
// evicted session filter
.evicted_session_filter_enable = 1,
.evicted_session_filter_capacity = 1000,
.evicted_session_filter_timeout_ms = 10,
.evicted_session_filter_error_rate = 0.0001,
// TCP Reassembly
.tcp_reassembly_enable = 1,
.tcp_reassembly_max_timeout_ms = 60000,
.tcp_reassembly_max_segments = 16,
};
static uint64_t session_id_generator(uint64_t now_ms __attribute__((unused)))
{
static uint64_t count = 0;
@@ -71,8 +27,12 @@ TEST(TCP_OVERLOAD, EVICT_OLD_SESS)
struct packet pkt;
struct session_manager *mgr = NULL;
struct session_manager_stat *stat = NULL;
struct session_manager_config _cfg;
memcpy(&_cfg, &cfg, sizeof(struct session_manager_config));
_cfg.tcp_session_max = RX_BURST_MAX * 2;
_cfg.udp_session_max = RX_BURST_MAX * 2;
mgr = session_manager_new(&cfg, 1);
mgr = session_manager_new(&_cfg, 1);
EXPECT_TRUE(mgr != NULL);
session_manager_set_session_id_generator(mgr, session_id_generator);
@@ -83,15 +43,15 @@ TEST(TCP_OVERLOAD, EVICT_OLD_SESS)
printf("<= Packet Parse: done\n\n");
// new session
for (uint32_t i = 0; i < cfg.max_tcp_session_num; i++)
for (uint32_t i = 0; i < _cfg.tcp_session_max; i++)
{
packet_set_ip_src_addr(&pkt, i);
EXPECT_TRUE(session_manager_new_session(mgr, &pkt, 1));
}
printf("=> Session Manager: after add %lu new sessions\n", cfg.max_tcp_session_num);
printf("=> Session Manager: after add %lu new sessions\n", _cfg.tcp_session_max);
stat = session_manager_stat(mgr);
EXPECT_TRUE(stat);
EXPECT_TRUE(stat->tcp_sess_used == cfg.max_tcp_session_num);
EXPECT_TRUE(stat->tcp_sess_used == _cfg.tcp_session_max);
EXPECT_TRUE(stat->tcp_sess_opening == RX_BURST_MAX);
EXPECT_TRUE(stat->tcp_sess_active == 0);
EXPECT_TRUE(stat->tcp_sess_closing == 0);
@@ -112,7 +72,9 @@ TEST(TCP_OVERLOAD, EVICT_NEW_SESS)
struct session_manager_stat *stat = NULL;
struct session_manager_config _cfg;
memcpy(&_cfg, &cfg, sizeof(struct session_manager_config));
_cfg.tcp_overload_evict_old_sess = 0;
_cfg.tcp_session_max = RX_BURST_MAX * 2;
_cfg.udp_session_max = RX_BURST_MAX * 2;
_cfg.evict_old_on_tcp_table_limit = 0;
mgr = session_manager_new(&_cfg, 1);
EXPECT_TRUE(mgr != NULL);
@@ -125,16 +87,16 @@ TEST(TCP_OVERLOAD, EVICT_NEW_SESS)
printf("<= Packet Parse: done\n\n");
// new session
for (uint32_t i = 0; i < cfg.max_tcp_session_num; i++)
for (uint32_t i = 0; i < _cfg.tcp_session_max; i++)
{
packet_set_ip_src_addr(&pkt, i);
EXPECT_TRUE(session_manager_new_session(mgr, &pkt, 1));
}
printf("=> Session Manager: after add %lu new sessions\n", cfg.max_tcp_session_num);
printf("=> Session Manager: after add %lu new sessions\n", _cfg.tcp_session_max);
stat = session_manager_stat(mgr);
EXPECT_TRUE(stat);
EXPECT_TRUE(stat->tcp_sess_used == cfg.max_tcp_session_num);
EXPECT_TRUE(stat->tcp_sess_opening == cfg.max_tcp_session_num);
EXPECT_TRUE(stat->tcp_sess_used == _cfg.tcp_session_max);
EXPECT_TRUE(stat->tcp_sess_opening == _cfg.tcp_session_max);
EXPECT_TRUE(stat->tcp_sess_active == 0);
EXPECT_TRUE(stat->tcp_sess_closing == 0);
EXPECT_TRUE(stat->tcp_sess_closed == 0);
@@ -145,15 +107,15 @@ TEST(TCP_OVERLOAD, EVICT_NEW_SESS)
// table full, evict new session
for (uint32_t i = 0; i < RX_BURST_MAX; i++)
{
packet_set_ip_src_addr(&pkt, cfg.max_tcp_session_num + i);
packet_set_ip_src_addr(&pkt, _cfg.tcp_session_max + i);
EXPECT_TRUE(session_manager_lookup_session_by_packet(mgr, &pkt) == NULL);
EXPECT_TRUE(session_manager_new_session(mgr, &pkt, 1) == NULL);
}
printf("=> Session Manager: after evicte new session\n");
stat = session_manager_stat(mgr);
EXPECT_TRUE(stat);
EXPECT_TRUE(stat->tcp_sess_used == cfg.max_tcp_session_num);
EXPECT_TRUE(stat->tcp_sess_opening == cfg.max_tcp_session_num);
EXPECT_TRUE(stat->tcp_sess_used == _cfg.tcp_session_max);
EXPECT_TRUE(stat->tcp_sess_opening == _cfg.tcp_session_max);
EXPECT_TRUE(stat->tcp_sess_active == 0);
EXPECT_TRUE(stat->tcp_sess_closing == 0);
EXPECT_TRUE(stat->tcp_sess_closed == 0);

78
infra/session_manager/test/gtest_overload_evict_udp_sess.cpp
View File

@@ -4,53 +4,9 @@
#include "packet_private.h"
#include "packet_parser.h"
#include "session_private.h"
#include "session_manager.h"
#include "default_config.h"
#include "test_packets.h"
struct session_manager_config cfg = {
// max session number
.max_tcp_session_num = RX_BURST_MAX * 2,
.max_udp_session_num = RX_BURST_MAX * 2,
// session overload
.tcp_overload_evict_old_sess = 1, // 1: evict old session, 0: bypass new session
.udp_overload_evict_old_sess = 1, // 1: evict old session, 0: bypass new session
// tcp timeout
.tcp_init_timeout_ms = 1,
.tcp_handshake_timeout_ms = 2,
.tcp_data_timeout_ms = 3,
.tcp_half_closed_timeout_ms = 4,
.tcp_time_wait_timeout_ms = 5,
.tcp_discard_timeout_ms = 6,
.tcp_unverified_rst_timeout_ms = 7,
// udp timeout
.udp_data_timeout_ms = 8,
.udp_discard_timeout_ms = 0,
// limit
.session_expire_polling_interval_ms = 0,
.session_expire_polling_limit = 1024,
// duplicate packet filter
.duplicated_packet_filter_enable = 1,
.duplicated_packet_filter_capacity = 1000,
.duplicated_packet_filter_timeout_ms = 10,
.duplicated_packet_filter_error_rate = 0.0001,
// evicted session filter
.evicted_session_filter_enable = 1,
.evicted_session_filter_capacity = 1000,
.evicted_session_filter_timeout_ms = 10,
.evicted_session_filter_error_rate = 0.0001,
// TCP Reassembly
.tcp_reassembly_enable = 1,
.tcp_reassembly_max_timeout_ms = 60000,
.tcp_reassembly_max_segments = 16,
};
static uint64_t session_id_generator(uint64_t now_ms __attribute__((unused)))
{
static uint64_t count = 0;
@@ -72,8 +28,12 @@ TEST(UDP_OVERLOAD, EVICT_OLD_SESS)
struct session *sess = NULL;
struct session_manager *mgr = NULL;
struct session_manager_stat *stat = NULL;
struct session_manager_config _cfg;
memcpy(&_cfg, &cfg, sizeof(struct session_manager_config));
_cfg.tcp_session_max = RX_BURST_MAX * 2;
_cfg.udp_session_max = RX_BURST_MAX * 2;
mgr = session_manager_new(&cfg, 1);
mgr = session_manager_new(&_cfg, 1);
EXPECT_TRUE(mgr != NULL);
session_manager_set_session_id_generator(mgr, session_id_generator);
@@ -84,15 +44,15 @@ TEST(UDP_OVERLOAD, EVICT_OLD_SESS)
printf("<= Packet Parse: done\n\n");
// new session
for (uint32_t i = 0; i < cfg.max_udp_session_num; i++)
for (uint32_t i = 0; i < _cfg.udp_session_max; i++)
{
packet_set_ip_src_addr(&pkt, i);
EXPECT_TRUE(session_manager_new_session(mgr, &pkt, 1));
}
printf("=> Session Manager: after add %lu new sessions\n", cfg.max_udp_session_num);
printf("=> Session Manager: after add %lu new sessions\n", _cfg.udp_session_max);
stat = session_manager_stat(mgr);
EXPECT_TRUE(stat);
EXPECT_TRUE(stat->udp_sess_used == cfg.max_udp_session_num);
EXPECT_TRUE(stat->udp_sess_used == _cfg.udp_session_max);
EXPECT_TRUE(stat->udp_sess_opening == RX_BURST_MAX);
EXPECT_TRUE(stat->udp_sess_active == 0);
EXPECT_TRUE(stat->udp_sess_closing == 0);
@@ -136,7 +96,7 @@ TEST(UDP_OVERLOAD, EVICT_OLD_SESS)
// evicted session timeout
packet_set_ip_src_addr(&pkt, 0);
EXPECT_TRUE(session_manager_lookup_session_by_packet(mgr, &pkt) == NULL);
EXPECT_TRUE(session_manager_new_session(mgr, &pkt, 1 + cfg.evicted_session_filter_timeout_ms));
EXPECT_TRUE(session_manager_new_session(mgr, &pkt, 1 + _cfg.evicted_session_bloom_filter.time_window_ms));
printf("=> Session Manager: after evicted session timeout\n");
stat = session_manager_stat(mgr);
EXPECT_TRUE(stat);
@@ -161,7 +121,9 @@ TEST(UDP_OVERLOAD, EVICT_NEW_SESS)
struct session_manager_stat *stat = NULL;
struct session_manager_config _cfg;
memcpy(&_cfg, &cfg, sizeof(struct session_manager_config));
_cfg.udp_overload_evict_old_sess = 0;
_cfg.tcp_session_max = RX_BURST_MAX * 2;
_cfg.udp_session_max = RX_BURST_MAX * 2;
_cfg.evict_old_on_udp_table_limit = 0;
mgr = session_manager_new(&_cfg, 1);
EXPECT_TRUE(mgr != NULL);
@@ -174,16 +136,16 @@ TEST(UDP_OVERLOAD, EVICT_NEW_SESS)
printf("<= Packet Parse: done\n\n");
// new session
for (uint32_t i = 0; i < cfg.max_udp_session_num; i++)
for (uint32_t i = 0; i < _cfg.udp_session_max; i++)
{
packet_set_ip_src_addr(&pkt, i);
EXPECT_TRUE(session_manager_new_session(mgr, &pkt, 1));
}
printf("=> Session Manager: after add %lu new sessions\n", cfg.max_udp_session_num);
printf("=> Session Manager: after add %lu new sessions\n", _cfg.udp_session_max);
stat = session_manager_stat(mgr);
EXPECT_TRUE(stat);
EXPECT_TRUE(stat->udp_sess_used == cfg.max_udp_session_num);
EXPECT_TRUE(stat->udp_sess_opening == cfg.max_udp_session_num);
EXPECT_TRUE(stat->udp_sess_used == _cfg.udp_session_max);
EXPECT_TRUE(stat->udp_sess_opening == _cfg.udp_session_max);
EXPECT_TRUE(stat->udp_sess_active == 0);
EXPECT_TRUE(stat->udp_sess_closing == 0);
EXPECT_TRUE(stat->udp_sess_closed == 0);
@@ -197,15 +159,15 @@ TEST(UDP_OVERLOAD, EVICT_NEW_SESS)
// table full, evict new session
for (uint32_t i = 0; i < RX_BURST_MAX; i++)
{
packet_set_ip_src_addr(&pkt, cfg.max_udp_session_num + i);
packet_set_ip_src_addr(&pkt, _cfg.udp_session_max + i);
EXPECT_TRUE(session_manager_lookup_session_by_packet(mgr, &pkt) == NULL);
EXPECT_TRUE(session_manager_new_session(mgr, &pkt, 1) == NULL);
}
printf("=> Session Manager: after readd %d evicted session\n", RX_BURST_MAX);
stat = session_manager_stat(mgr);
EXPECT_TRUE(stat);
EXPECT_TRUE(stat->udp_sess_used == cfg.max_udp_session_num);
EXPECT_TRUE(stat->udp_sess_opening == cfg.max_udp_session_num);
EXPECT_TRUE(stat->udp_sess_used == _cfg.udp_session_max);
EXPECT_TRUE(stat->udp_sess_opening == _cfg.udp_session_max);
EXPECT_TRUE(stat->udp_sess_active == 0);
EXPECT_TRUE(stat->udp_sess_closing == 0);
EXPECT_TRUE(stat->udp_sess_closed == 0);

46
infra/session_manager/test/gtest_sess_mgr_scan.cpp
View File

@@ -1,55 +1,11 @@
#include <gtest/gtest.h>
#include "session_private.h"
#include "session_manager.h"
#include "packet_private.h"
#include "packet_parser.h"
#include "default_config.h"
#include "test_packets.h"
struct session_manager_config cfg = {
// max session number
.max_tcp_session_num = 256,
.max_udp_session_num = 256,
// session overload
.tcp_overload_evict_old_sess = 1, // 1: evict old session, 0: bypass new session
.udp_overload_evict_old_sess = 1, // 1: evict old session, 0: bypass new session
// tcp timeout
.tcp_init_timeout_ms = 1,
.tcp_handshake_timeout_ms = 2,
.tcp_data_timeout_ms = 3,
.tcp_half_closed_timeout_ms = 4,
.tcp_time_wait_timeout_ms = 5,
.tcp_discard_timeout_ms = 6,
.tcp_unverified_rst_timeout_ms = 7,
// udp timeout
.udp_data_timeout_ms = 8,
.udp_discard_timeout_ms = 0,
// limit
.session_expire_polling_interval_ms = 0,
.session_expire_polling_limit = 1024,
// duplicate packet filter
.duplicated_packet_filter_enable = 1,
.duplicated_packet_filter_capacity = 1000,
.duplicated_packet_filter_timeout_ms = 10,
.duplicated_packet_filter_error_rate = 0.0001,
// evicted session filter
.evicted_session_filter_enable = 1,
.evicted_session_filter_capacity = 1000,
.evicted_session_filter_timeout_ms = 10,
.evicted_session_filter_error_rate = 0.0001,
// TCP Reassembly
.tcp_reassembly_enable = 1,
.tcp_reassembly_max_timeout_ms = 60000,
.tcp_reassembly_max_segments = 16,
};
static uint64_t session_id_generator(uint64_t now_ms __attribute__((unused)))
{
static uint64_t count = 0;

54
infra/session_manager/test/gtest_sess_mgr_tcp_reassembly.cpp
View File

@@ -3,53 +3,9 @@
#include "packet_private.h"
#include "packet_parser.h"
#include "session_private.h"
#include "session_manager.h"
#include "default_config.h"
#include "test_packets.h"
struct session_manager_config cfg = {
// max session number
.max_tcp_session_num = 256,
.max_udp_session_num = 256,
// session overload
.tcp_overload_evict_old_sess = 1, // 1: evict old session, 0: bypass new session
.udp_overload_evict_old_sess = 1, // 1: evict old session, 0: bypass new session
// tcp timeout
.tcp_init_timeout_ms = 1,
.tcp_handshake_timeout_ms = 2,
.tcp_data_timeout_ms = 3,
.tcp_half_closed_timeout_ms = 4,
.tcp_time_wait_timeout_ms = 5,
.tcp_discard_timeout_ms = 6,
.tcp_unverified_rst_timeout_ms = 7,
// udp timeout
.udp_data_timeout_ms = 8,
.udp_discard_timeout_ms = 0,
// limit
.session_expire_polling_interval_ms = 0,
.session_expire_polling_limit = 1024,
// duplicate packet filter
.duplicated_packet_filter_enable = 1,
.duplicated_packet_filter_capacity = 1000,
.duplicated_packet_filter_timeout_ms = 10,
.duplicated_packet_filter_error_rate = 0.0001,
// evicted session filter
.evicted_session_filter_enable = 1,
.evicted_session_filter_capacity = 1000,
.evicted_session_filter_timeout_ms = 10,
.evicted_session_filter_error_rate = 0.0001,
// TCP Reassembly
.tcp_reassembly_enable = 1,
.tcp_reassembly_max_timeout_ms = 60000,
.tcp_reassembly_max_segments = 16,
};
static uint64_t session_id_generator(uint64_t now_ms __attribute__((unused)))
{
static uint64_t count = 0;
@@ -249,8 +205,8 @@ TEST(SESS_MGR_TCP_REASSEMBLY, OUT_OF_ORDER)
session_free_tcp_segment(sess, seg);
// expire session
EXPECT_TRUE(session_manager_get_expired_session(mgr, 7 + cfg.tcp_data_timeout_ms) == NULL); // active -> closing
sess = session_manager_get_expired_session(mgr, 7 + cfg.tcp_data_timeout_ms + cfg.tcp_data_timeout_ms); // closing -> closed
EXPECT_TRUE(session_manager_get_expired_session(mgr, 7 + cfg.tcp_timeout_ms.data) == NULL); // active -> closing
sess = session_manager_get_expired_session(mgr, 7 + cfg.tcp_timeout_ms.data + cfg.tcp_timeout_ms.data); // closing -> closed
EXPECT_TRUE(sess);
EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED);
EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT);
@@ -343,8 +299,8 @@ TEST(SESS_MGR_TCP_REASSEMBLY, SEQ_WRAPAROUND)
session_free_tcp_segment(sess, seg);
// expire session
EXPECT_TRUE(session_manager_get_expired_session(mgr, 4 + cfg.tcp_data_timeout_ms) == NULL); // active -> closing
sess = session_manager_get_expired_session(mgr, 4 + cfg.tcp_data_timeout_ms + cfg.tcp_data_timeout_ms); // closing -> closed
EXPECT_TRUE(session_manager_get_expired_session(mgr, 4 + cfg.tcp_timeout_ms.data) == NULL); // active -> closing
sess = session_manager_get_expired_session(mgr, 4 + cfg.tcp_timeout_ms.data + cfg.tcp_timeout_ms.data); // closing -> closed
EXPECT_TRUE(sess);
EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED);
EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT);

60
infra/session_manager/test/gtest_state_tcp_active_to_closing.cpp
View File

@@ -5,53 +5,9 @@
#include "packet_private.h"
#include "packet_parser.h"
#include "session_private.h"
#include "session_manager.h"
#include "default_config.h"
#include "test_packets.h"
struct session_manager_config cfg = {
// max session number
.max_tcp_session_num = 256,
.max_udp_session_num = 256,
// session overload
.tcp_overload_evict_old_sess = 1, // 1: evict old session, 0: bypass new session
.udp_overload_evict_old_sess = 1, // 1: evict old session, 0: bypass new session
// tcp timeout
.tcp_init_timeout_ms = 1,
.tcp_handshake_timeout_ms = 2,
.tcp_data_timeout_ms = 3,
.tcp_half_closed_timeout_ms = 4,
.tcp_time_wait_timeout_ms = 5,
.tcp_discard_timeout_ms = 6,
.tcp_unverified_rst_timeout_ms = 7,
// udp timeout
.udp_data_timeout_ms = 8,
.udp_discard_timeout_ms = 0,
// limit
.session_expire_polling_interval_ms = 0,
.session_expire_polling_limit = 1024,
// duplicate packet filter
.duplicated_packet_filter_enable = 1,
.duplicated_packet_filter_capacity = 1000,
.duplicated_packet_filter_timeout_ms = 10,
.duplicated_packet_filter_error_rate = 0.0001,
// evicted session filter
.evicted_session_filter_enable = 1,
.evicted_session_filter_capacity = 1000,
.evicted_session_filter_timeout_ms = 10,
.evicted_session_filter_error_rate = 0.0001,
// TCP Reassembly
.tcp_reassembly_enable = 1,
.tcp_reassembly_max_timeout_ms = 60000,
.tcp_reassembly_max_segments = 16,
};
static uint64_t session_id_generator(uint64_t now_ms __attribute__((unused)))
{
static uint64_t count = 0;
@@ -159,7 +115,7 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_FIN_FIN)
EXPECT_TRUE(stat->tcp_sess_closing == 1);
// expire session
sess = session_manager_get_expired_session(mgr, 3 + cfg.tcp_time_wait_timeout_ms);
sess = session_manager_get_expired_session(mgr, 3 + cfg.tcp_timeout_ms.time_wait);
EXPECT_TRUE(sess);
EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED);
EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_CLIENT_FIN);
@@ -245,7 +201,7 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_C2S_RST)
EXPECT_TRUE(stat->tcp_sess_closing == 1);
// expire session
sess = session_manager_get_expired_session(mgr, 3 + cfg.tcp_unverified_rst_timeout_ms);
sess = session_manager_get_expired_session(mgr, 3 + cfg.tcp_timeout_ms.unverified_rst);
EXPECT_TRUE(sess);
EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED);
EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_CLIENT_RST);
@@ -331,7 +287,7 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_S2C_RST)
EXPECT_TRUE(stat->tcp_sess_closing == 1);
// expire session
sess = session_manager_get_expired_session(mgr, 3 + cfg.tcp_unverified_rst_timeout_ms);
sess = session_manager_get_expired_session(mgr, 3 + cfg.tcp_timeout_ms.unverified_rst);
EXPECT_TRUE(sess);
EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED);
EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_SERVER_RST);
@@ -378,8 +334,8 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_DATA_TIMEOUT)
EXPECT_TRUE(stat->tcp_sess_closing == 0);
// expire session
EXPECT_TRUE(session_manager_get_expired_session(mgr, 2 + cfg.tcp_data_timeout_ms) == NULL);
sess = session_manager_get_expired_session(mgr, 2 + cfg.tcp_data_timeout_ms + cfg.tcp_data_timeout_ms);
EXPECT_TRUE(session_manager_get_expired_session(mgr, 2 + cfg.tcp_timeout_ms.data) == NULL);
sess = session_manager_get_expired_session(mgr, 2 + cfg.tcp_timeout_ms.data + cfg.tcp_timeout_ms.data);
EXPECT_TRUE(sess);
EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED);
EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT);
@@ -459,7 +415,7 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_C2S_HALF_CLOSED_TIMEOUT)
EXPECT_TRUE(stat->tcp_sess_closing == 1);
// expire session
sess = session_manager_get_expired_session(mgr, 3 + cfg.tcp_half_closed_timeout_ms);
sess = session_manager_get_expired_session(mgr, 3 + cfg.tcp_timeout_ms.half_closed);
EXPECT_TRUE(sess);
EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED);
EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_CLIENT_FIN);
@@ -539,7 +495,7 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_S2C_HALF_CLOSED_TIMEOUT)
EXPECT_TRUE(stat->tcp_sess_closing == 1);
// expire session
sess = session_manager_get_expired_session(mgr, 3 + cfg.tcp_half_closed_timeout_ms);
sess = session_manager_get_expired_session(mgr, 3 + cfg.tcp_timeout_ms.half_closed);
EXPECT_TRUE(sess);
EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED);
EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_SERVER_FIN);

78
infra/session_manager/test/gtest_state_tcp_init_to_opening.cpp
View File

@@ -5,53 +5,9 @@
#include "packet_private.h"
#include "packet_parser.h"
#include "session_private.h"
#include "session_manager.h"
#include "default_config.h"
#include "test_packets.h"
struct session_manager_config cfg = {
// max session number
.max_tcp_session_num = 256,
.max_udp_session_num = 256,
// session overload
.tcp_overload_evict_old_sess = 1, // 1: evict old session, 0: bypass new session
.udp_overload_evict_old_sess = 1, // 1: evict old session, 0: bypass new session
// tcp timeout
.tcp_init_timeout_ms = 1,
.tcp_handshake_timeout_ms = 2,
.tcp_data_timeout_ms = 3,
.tcp_half_closed_timeout_ms = 4,
.tcp_time_wait_timeout_ms = 5,
.tcp_discard_timeout_ms = 6,
.tcp_unverified_rst_timeout_ms = 7,
// udp timeout
.udp_data_timeout_ms = 8,
.udp_discard_timeout_ms = 0,
// limit
.session_expire_polling_interval_ms = 0,
.session_expire_polling_limit = 1024,
// duplicate packet filter
.duplicated_packet_filter_enable = 1,
.duplicated_packet_filter_capacity = 1000,
.duplicated_packet_filter_timeout_ms = 10,
.duplicated_packet_filter_error_rate = 0.0001,
// evicted session filter
.evicted_session_filter_enable = 1,
.evicted_session_filter_capacity = 1000,
.evicted_session_filter_timeout_ms = 10,
.evicted_session_filter_error_rate = 0.0001,
// TCP Reassembly
.tcp_reassembly_enable = 1,
.tcp_reassembly_max_timeout_ms = 60000,
.tcp_reassembly_max_segments = 16,
};
static uint64_t session_id_generator(uint64_t now_ms __attribute__((unused)))
{
static uint64_t count = 0;
@@ -115,8 +71,8 @@ TEST(TCP_INIT_TO_OPENING, BY_SYN)
EXPECT_TRUE(stat->tcp_sess_closing == 0);
// expire session
EXPECT_TRUE(session_manager_get_expired_session(mgr, 1 + cfg.tcp_init_timeout_ms) == NULL); // opening -> closing
sess = session_manager_get_expired_session(mgr, 1 + cfg.tcp_init_timeout_ms + cfg.tcp_data_timeout_ms); // closing -> closed
EXPECT_TRUE(session_manager_get_expired_session(mgr, 1 + cfg.tcp_timeout_ms.init) == NULL); // opening -> closing
sess = session_manager_get_expired_session(mgr, 1 + cfg.tcp_timeout_ms.init + cfg.tcp_timeout_ms.data); // closing -> closed
EXPECT_TRUE(sess);
EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED);
EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT);
@@ -193,8 +149,8 @@ TEST(TCP_INIT_TO_OPENING, BY_SYNACK)
EXPECT_TRUE(stat->tcp_sess_closing == 0);
// expire session
EXPECT_TRUE(session_manager_get_expired_session(mgr, 1 + cfg.tcp_handshake_timeout_ms) == NULL);
sess = session_manager_get_expired_session(mgr, 1 + cfg.tcp_handshake_timeout_ms + cfg.tcp_data_timeout_ms);
EXPECT_TRUE(session_manager_get_expired_session(mgr, 1 + cfg.tcp_timeout_ms.handshake) == NULL);
sess = session_manager_get_expired_session(mgr, 1 + cfg.tcp_timeout_ms.handshake + cfg.tcp_timeout_ms.data);
EXPECT_TRUE(sess);
EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED);
EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT);
@@ -283,8 +239,8 @@ TEST(TCP_INIT_TO_OPENING, BY_SYN_SYNACK)
EXPECT_TRUE(stat->tcp_sess_closing == 0);
// expire session
EXPECT_TRUE(session_manager_get_expired_session(mgr, 2 + cfg.tcp_handshake_timeout_ms) == NULL);
sess = session_manager_get_expired_session(mgr, 2 + cfg.tcp_handshake_timeout_ms + cfg.tcp_data_timeout_ms);
EXPECT_TRUE(session_manager_get_expired_session(mgr, 2 + cfg.tcp_timeout_ms.handshake) == NULL);
sess = session_manager_get_expired_session(mgr, 2 + cfg.tcp_timeout_ms.handshake + cfg.tcp_timeout_ms.data);
EXPECT_TRUE(sess);
EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED);
EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT);
@@ -385,8 +341,8 @@ TEST(TCP_INIT_TO_OPENING, BY_SYN_SYNACK_ACK)
EXPECT_TRUE(stat->tcp_sess_closing == 0);
// expire session
EXPECT_TRUE(session_manager_get_expired_session(mgr, 3 + cfg.tcp_data_timeout_ms) == NULL);
sess = session_manager_get_expired_session(mgr, 3 + cfg.tcp_data_timeout_ms + cfg.tcp_data_timeout_ms);
EXPECT_TRUE(session_manager_get_expired_session(mgr, 3 + cfg.tcp_timeout_ms.data) == NULL);
sess = session_manager_get_expired_session(mgr, 3 + cfg.tcp_timeout_ms.data + cfg.tcp_timeout_ms.data);
EXPECT_TRUE(sess);
EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED);
EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT);
@@ -482,8 +438,8 @@ TEST(TCP_INIT_TO_OPENING, BY_SYN_RETRANSMISSION)
EXPECT_TRUE(stat->tcp_sess_closing == 0);
// expire session
EXPECT_TRUE(session_manager_get_expired_session(mgr, 2 + cfg.tcp_init_timeout_ms) == NULL);
sess = session_manager_get_expired_session(mgr, 2 + cfg.tcp_init_timeout_ms + cfg.tcp_data_timeout_ms);
EXPECT_TRUE(session_manager_get_expired_session(mgr, 2 + cfg.tcp_timeout_ms.init) == NULL);
sess = session_manager_get_expired_session(mgr, 2 + cfg.tcp_timeout_ms.init + cfg.tcp_timeout_ms.data);
EXPECT_TRUE(sess);
EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED);
EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT);
@@ -580,8 +536,8 @@ TEST(TCP_INIT_TO_OPENING, BY_SYNACK_RETRANSMISSION)
EXPECT_TRUE(stat->tcp_sess_closing == 0);
// expire session
EXPECT_TRUE(session_manager_get_expired_session(mgr, 2 + cfg.tcp_handshake_timeout_ms) == NULL);
sess = session_manager_get_expired_session(mgr, 2 + cfg.tcp_handshake_timeout_ms + cfg.tcp_data_timeout_ms);
EXPECT_TRUE(session_manager_get_expired_session(mgr, 2 + cfg.tcp_timeout_ms.handshake) == NULL);
sess = session_manager_get_expired_session(mgr, 2 + cfg.tcp_timeout_ms.handshake + cfg.tcp_timeout_ms.data);
EXPECT_TRUE(sess);
EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED);
EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT);
@@ -670,8 +626,8 @@ TEST(TCP_INIT_TO_OPENING, BY_C2S_ASMMETRIC)
EXPECT_TRUE(stat->tcp_sess_closing == 0);
// expire session
EXPECT_TRUE(session_manager_get_expired_session(mgr, 2 + cfg.tcp_data_timeout_ms) == NULL);
sess = session_manager_get_expired_session(mgr, 2 + cfg.tcp_data_timeout_ms + cfg.tcp_data_timeout_ms);
EXPECT_TRUE(session_manager_get_expired_session(mgr, 2 + cfg.tcp_timeout_ms.data) == NULL);
sess = session_manager_get_expired_session(mgr, 2 + cfg.tcp_timeout_ms.data + cfg.tcp_timeout_ms.data);
EXPECT_TRUE(sess);
EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED);
EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT);
@@ -760,8 +716,8 @@ TEST(TCP_INIT_TO_OPENING, BY_S2C_ASMMETRIC)
EXPECT_TRUE(stat->tcp_sess_closing == 0);
// expire session
EXPECT_TRUE(session_manager_get_expired_session(mgr, 2 + cfg.tcp_data_timeout_ms) == NULL);
sess = session_manager_get_expired_session(mgr, 2 + cfg.tcp_data_timeout_ms + cfg.tcp_data_timeout_ms);
EXPECT_TRUE(session_manager_get_expired_session(mgr, 2 + cfg.tcp_timeout_ms.data) == NULL);
sess = session_manager_get_expired_session(mgr, 2 + cfg.tcp_timeout_ms.data + cfg.tcp_timeout_ms.data);
EXPECT_TRUE(sess);
EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED);
EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT);

48
infra/session_manager/test/gtest_state_tcp_init_to_opening_to_active_to_closing_to_closed.cpp
View File

@@ -5,53 +5,9 @@
#include "packet_private.h"
#include "packet_parser.h"
#include "session_private.h"
#include "session_manager.h"
#include "default_config.h"
#include "test_packets.h"
struct session_manager_config cfg = {
// max session number
.max_tcp_session_num = 256,
.max_udp_session_num = 256,
// session overload
.tcp_overload_evict_old_sess = 1, // 1: evict old session, 0: bypass new session
.udp_overload_evict_old_sess = 1, // 1: evict old session, 0: bypass new session
// tcp timeout
.tcp_init_timeout_ms = 1,
.tcp_handshake_timeout_ms = 2,
.tcp_data_timeout_ms = 3,
.tcp_half_closed_timeout_ms = 4,
.tcp_time_wait_timeout_ms = 5,
.tcp_discard_timeout_ms = 6,
.tcp_unverified_rst_timeout_ms = 7,
// udp timeout
.udp_data_timeout_ms = 8,
.udp_discard_timeout_ms = 0,
// limit
.session_expire_polling_interval_ms = 0,
.session_expire_polling_limit = 1024,
// duplicate packet filter
.duplicated_packet_filter_enable = 1,
.duplicated_packet_filter_capacity = 1000,
.duplicated_packet_filter_timeout_ms = 10,
.duplicated_packet_filter_error_rate = 0.0001,
// evicted session filter
.evicted_session_filter_enable = 1,
.evicted_session_filter_capacity = 1000,
.evicted_session_filter_timeout_ms = 10,
.evicted_session_filter_error_rate = 0.0001,
// TCP Reassembly
.tcp_reassembly_enable = 1,
.tcp_reassembly_max_timeout_ms = 60000,
.tcp_reassembly_max_segments = 16,
};
static uint64_t session_id_generator(uint64_t now_ms __attribute__((unused)))
{
static uint64_t count = 0;
@@ -421,7 +377,7 @@ TEST(TCP_INIT_TO_OPENING_TO_ACTIVE_TO_CLOSING_TO_CLOSED, TEST)
EXPECT_TRUE(stat->tcp_sess_closing == 1);
// expire session
sess = session_manager_get_expired_session(mgr, 11 + cfg.tcp_time_wait_timeout_ms);
sess = session_manager_get_expired_session(mgr, 11 + cfg.tcp_timeout_ms.time_wait);
EXPECT_TRUE(sess);
EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED);
EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_CLIENT_FIN);

54
infra/session_manager/test/gtest_state_tcp_opening_to_active.cpp
View File

@@ -5,53 +5,9 @@
#include "packet_private.h"
#include "packet_parser.h"
#include "session_private.h"
#include "session_manager.h"
#include "default_config.h"
#include "test_packets.h"
struct session_manager_config cfg = {
// max session number
.max_tcp_session_num = 256,
.max_udp_session_num = 256,
// session overload
.tcp_overload_evict_old_sess = 1, // 1: evict old session, 0: bypass new session
.udp_overload_evict_old_sess = 1, // 1: evict old session, 0: bypass new session
// tcp timeout
.tcp_init_timeout_ms = 1,
.tcp_handshake_timeout_ms = 2,
.tcp_data_timeout_ms = 3,
.tcp_half_closed_timeout_ms = 4,
.tcp_time_wait_timeout_ms = 5,
.tcp_discard_timeout_ms = 6,
.tcp_unverified_rst_timeout_ms = 7,
// udp timeout
.udp_data_timeout_ms = 8,
.udp_discard_timeout_ms = 0,
// limit
.session_expire_polling_interval_ms = 0,
.session_expire_polling_limit = 1024,
// duplicate packet filter
.duplicated_packet_filter_enable = 1,
.duplicated_packet_filter_capacity = 1000,
.duplicated_packet_filter_timeout_ms = 10,
.duplicated_packet_filter_error_rate = 0.0001,
// evicted session filter
.evicted_session_filter_enable = 1,
.evicted_session_filter_capacity = 1000,
.evicted_session_filter_timeout_ms = 10,
.evicted_session_filter_error_rate = 0.0001,
// TCP Reassembly
.tcp_reassembly_enable = 1,
.tcp_reassembly_max_timeout_ms = 60000,
.tcp_reassembly_max_segments = 16,
};
static uint64_t session_id_generator(uint64_t now_ms __attribute__((unused)))
{
static uint64_t count = 0;
@@ -127,8 +83,8 @@ TEST(TCP_OPENING_TO_ACTIVE, BY_SYN_C2S_DATA)
EXPECT_TRUE(stat->tcp_sess_closing == 0);
// expire session
EXPECT_TRUE(session_manager_get_expired_session(mgr, 2 + cfg.tcp_data_timeout_ms) == NULL);
sess = session_manager_get_expired_session(mgr, 2 + cfg.tcp_data_timeout_ms + cfg.tcp_data_timeout_ms);
EXPECT_TRUE(session_manager_get_expired_session(mgr, 2 + cfg.tcp_timeout_ms.data) == NULL);
sess = session_manager_get_expired_session(mgr, 2 + cfg.tcp_timeout_ms.data + cfg.tcp_timeout_ms.data);
EXPECT_TRUE(sess);
EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED);
EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT);
@@ -217,8 +173,8 @@ TEST(TCP_OPENING_TO_ACTIVE, BY_SYNACK_S2C_DATA)
EXPECT_TRUE(stat->tcp_sess_closing == 0);
// expire session
EXPECT_TRUE(session_manager_get_expired_session(mgr, 2 + cfg.tcp_data_timeout_ms) == NULL);
sess = session_manager_get_expired_session(mgr, 2 + cfg.tcp_data_timeout_ms + cfg.tcp_data_timeout_ms);
EXPECT_TRUE(session_manager_get_expired_session(mgr, 2 + cfg.tcp_timeout_ms.data) == NULL);
sess = session_manager_get_expired_session(mgr, 2 + cfg.tcp_timeout_ms.data + cfg.tcp_timeout_ms.data);
EXPECT_TRUE(sess);
EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED);
EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT);

68
infra/session_manager/test/gtest_state_tcp_opening_to_closing.cpp
View File

@@ -5,53 +5,9 @@
#include "packet_private.h"
#include "packet_parser.h"
#include "session_private.h"
#include "session_manager.h"
#include "default_config.h"
#include "test_packets.h"
struct session_manager_config cfg = {
// max session number
.max_tcp_session_num = 256,
.max_udp_session_num = 256,
// session overload
.tcp_overload_evict_old_sess = 1, // 1: evict old session, 0: bypass new session
.udp_overload_evict_old_sess = 1, // 1: evict old session, 0: bypass new session
// tcp timeout
.tcp_init_timeout_ms = 1,
.tcp_handshake_timeout_ms = 2,
.tcp_data_timeout_ms = 3,
.tcp_half_closed_timeout_ms = 4,
.tcp_time_wait_timeout_ms = 5,
.tcp_discard_timeout_ms = 6,
.tcp_unverified_rst_timeout_ms = 7,
// udp timeout
.udp_data_timeout_ms = 8,
.udp_discard_timeout_ms = 0,
// limit
.session_expire_polling_interval_ms = 0,
.session_expire_polling_limit = 1024,
// duplicate packet filter
.duplicated_packet_filter_enable = 1,
.duplicated_packet_filter_capacity = 1000,
.duplicated_packet_filter_timeout_ms = 10,
.duplicated_packet_filter_error_rate = 0.0001,
// evicted session filter
.evicted_session_filter_enable = 1,
.evicted_session_filter_capacity = 1000,
.evicted_session_filter_timeout_ms = 10,
.evicted_session_filter_error_rate = 0.0001,
// TCP Reassembly
.tcp_reassembly_enable = 1,
.tcp_reassembly_max_timeout_ms = 60000,
.tcp_reassembly_max_segments = 16,
};
static uint64_t session_id_generator(uint64_t now_ms __attribute__((unused)))
{
static uint64_t count = 0;
@@ -139,7 +95,7 @@ TEST(TCP_OPENING_TO_CLOSING, BY_FIN_FIN)
EXPECT_TRUE(stat->tcp_sess_closing == 1);
// expire session
sess = session_manager_get_expired_session(mgr, 3 + cfg.tcp_time_wait_timeout_ms);
sess = session_manager_get_expired_session(mgr, 3 + cfg.tcp_timeout_ms.time_wait);
EXPECT_TRUE(sess);
EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED);
EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_CLIENT_FIN);
@@ -234,7 +190,7 @@ TEST(TCP_OPENING_TO_CLOSING, BY_C2S_RST)
EXPECT_TRUE(stat->tcp_sess_closing == 1);
// expire session
sess = session_manager_get_expired_session(mgr, 2 + cfg.tcp_unverified_rst_timeout_ms);
sess = session_manager_get_expired_session(mgr, 2 + cfg.tcp_timeout_ms.unverified_rst);
EXPECT_TRUE(sess);
EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED);
EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_CLIENT_RST);
@@ -329,7 +285,7 @@ TEST(TCP_OPENING_TO_CLOSING, BY_S2C_RST)
EXPECT_TRUE(stat->tcp_sess_closing == 1);
// expire session
sess = session_manager_get_expired_session(mgr, 2 + cfg.tcp_unverified_rst_timeout_ms);
sess = session_manager_get_expired_session(mgr, 2 + cfg.tcp_timeout_ms.unverified_rst);
EXPECT_TRUE(sess);
EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED);
EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_SERVER_RST);
@@ -386,8 +342,8 @@ TEST(TCP_OPENING_TO_CLOSING, BY_INIT_TIMEOUT)
EXPECT_TRUE(stat->tcp_sess_closing == 0);
// expire session
EXPECT_TRUE(session_manager_get_expired_session(mgr, 1 + cfg.tcp_init_timeout_ms) == NULL);
sess = session_manager_get_expired_session(mgr, 1 + cfg.tcp_init_timeout_ms + cfg.tcp_data_timeout_ms);
EXPECT_TRUE(session_manager_get_expired_session(mgr, 1 + cfg.tcp_timeout_ms.init) == NULL);
sess = session_manager_get_expired_session(mgr, 1 + cfg.tcp_timeout_ms.init + cfg.tcp_timeout_ms.data);
EXPECT_TRUE(sess);
EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED);
EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT);
@@ -476,8 +432,8 @@ TEST(TCP_OPENING_TO_CLOSING, BY_HANDSHAKE_TIMEOUT)
EXPECT_TRUE(stat->tcp_sess_closing == 0);
// expire session
EXPECT_TRUE(session_manager_get_expired_session(mgr, 2 + cfg.tcp_handshake_timeout_ms) == NULL);
sess = session_manager_get_expired_session(mgr, 2 + cfg.tcp_handshake_timeout_ms + cfg.tcp_data_timeout_ms);
EXPECT_TRUE(session_manager_get_expired_session(mgr, 2 + cfg.tcp_timeout_ms.handshake) == NULL);
sess = session_manager_get_expired_session(mgr, 2 + cfg.tcp_timeout_ms.handshake + cfg.tcp_timeout_ms.data);
EXPECT_TRUE(sess);
EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED);
EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT);
@@ -578,8 +534,8 @@ TEST(TCP_OPENING_TO_CLOSING, BY_DATA_TIMEOUT)
EXPECT_TRUE(stat->tcp_sess_closing == 0);
// expire session
EXPECT_TRUE(session_manager_get_expired_session(mgr, 3 + cfg.tcp_data_timeout_ms) == NULL);
sess = session_manager_get_expired_session(mgr, 3 + cfg.tcp_data_timeout_ms + cfg.tcp_data_timeout_ms);
EXPECT_TRUE(session_manager_get_expired_session(mgr, 3 + cfg.tcp_timeout_ms.data) == NULL);
sess = session_manager_get_expired_session(mgr, 3 + cfg.tcp_timeout_ms.data + cfg.tcp_timeout_ms.data);
EXPECT_TRUE(sess);
EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED);
EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT);
@@ -668,7 +624,7 @@ TEST(TCP_OPENING_TO_CLOSING, BY_C2S_HALF_FIN)
EXPECT_TRUE(stat->tcp_sess_closing == 1);
// expire session
sess = session_manager_get_expired_session(mgr, 2 + cfg.tcp_half_closed_timeout_ms);
sess = session_manager_get_expired_session(mgr, 2 + cfg.tcp_timeout_ms.half_closed);
EXPECT_TRUE(sess);
EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED);
EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_CLIENT_FIN);
@@ -757,7 +713,7 @@ TEST(TCP_OPENING_TO_CLOSING, BY_S2C_HALF_FIN)
EXPECT_TRUE(stat->tcp_sess_closing == 1);
// expire session
sess = session_manager_get_expired_session(mgr, 2 + cfg.tcp_half_closed_timeout_ms);
sess = session_manager_get_expired_session(mgr, 2 + cfg.tcp_timeout_ms.half_closed);
EXPECT_TRUE(sess);
EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED);
EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_SERVER_FIN);

50
infra/session_manager/test/gtest_state_udp_init_to_opening_to_active_to_closing.cpp
View File

@@ -5,53 +5,9 @@
#include "packet_private.h"
#include "packet_parser.h"
#include "session_private.h"
#include "session_manager.h"
#include "default_config.h"
#include "test_packets.h"
struct session_manager_config cfg = {
// max session number
.max_tcp_session_num = 256,
.max_udp_session_num = 256,
// session overload
.tcp_overload_evict_old_sess = 1, // 1: evict old session, 0: bypass new session
.udp_overload_evict_old_sess = 1, // 1: evict old session, 0: bypass new session
// tcp timeout
.tcp_init_timeout_ms = 1,
.tcp_handshake_timeout_ms = 2,
.tcp_data_timeout_ms = 3,
.tcp_half_closed_timeout_ms = 4,
.tcp_time_wait_timeout_ms = 5,
.tcp_discard_timeout_ms = 6,
.tcp_unverified_rst_timeout_ms = 7,
// udp timeout
.udp_data_timeout_ms = 8,
.udp_discard_timeout_ms = 0,
// limit
.session_expire_polling_interval_ms = 0,
.session_expire_polling_limit = 1024,
// duplicate packet filter
.duplicated_packet_filter_enable = 1,
.duplicated_packet_filter_capacity = 1000,
.duplicated_packet_filter_timeout_ms = 10,
.duplicated_packet_filter_error_rate = 0.0001,
// evicted session filter
.evicted_session_filter_enable = 1,
.evicted_session_filter_capacity = 1000,
.evicted_session_filter_timeout_ms = 10,
.evicted_session_filter_error_rate = 0.0001,
// TCP Reassembly
.tcp_reassembly_enable = 1,
.tcp_reassembly_max_timeout_ms = 60000,
.tcp_reassembly_max_segments = 16,
};
static uint64_t session_id_generator(uint64_t now_ms __attribute__((unused)))
{
static uint64_t count = 0;
@@ -141,8 +97,8 @@ TEST(UDP_INIT_TO_OPENING_TO_ACTIVE_TO_CLOSING, TEST)
EXPECT_TRUE(stat->udp_sess_closing == 0);
// expire session
EXPECT_TRUE(session_manager_get_expired_session(mgr, 2 + cfg.udp_data_timeout_ms) == NULL); // active -> closing
sess = session_manager_get_expired_session(mgr, 2 + cfg.udp_data_timeout_ms + cfg.udp_data_timeout_ms); // closing -> closed
EXPECT_TRUE(session_manager_get_expired_session(mgr, 2 + cfg.udp_timeout_ms.data) == NULL); // active -> closing
sess = session_manager_get_expired_session(mgr, 2 + cfg.udp_timeout_ms.data + cfg.udp_timeout_ms.data); // closing -> closed
EXPECT_TRUE(sess);
EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED);
EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT);

54
infra/session_manager/test/gtest_state_udp_init_to_opening_to_closing.cpp
View File

@@ -5,53 +5,9 @@
#include "packet_private.h"
#include "packet_parser.h"
#include "session_private.h"
#include "session_manager.h"
#include "default_config.h"
#include "test_packets.h"
struct session_manager_config cfg = {
// max session number
.max_tcp_session_num = 256,
.max_udp_session_num = 256,
// session overload
.tcp_overload_evict_old_sess = 1, // 1: evict old session, 0: bypass new session
.udp_overload_evict_old_sess = 1, // 1: evict old session, 0: bypass new session
// tcp timeout
.tcp_init_timeout_ms = 1,
.tcp_handshake_timeout_ms = 2,
.tcp_data_timeout_ms = 3,
.tcp_half_closed_timeout_ms = 4,
.tcp_time_wait_timeout_ms = 5,
.tcp_discard_timeout_ms = 6,
.tcp_unverified_rst_timeout_ms = 7,
// udp timeout
.udp_data_timeout_ms = 8,
.udp_discard_timeout_ms = 0,
// limit
.session_expire_polling_interval_ms = 0,
.session_expire_polling_limit = 1024,
// duplicate packet filter
.duplicated_packet_filter_enable = 1,
.duplicated_packet_filter_capacity = 1000,
.duplicated_packet_filter_timeout_ms = 10,
.duplicated_packet_filter_error_rate = 0.0001,
// evicted session filter
.evicted_session_filter_enable = 1,
.evicted_session_filter_capacity = 1000,
.evicted_session_filter_timeout_ms = 10,
.evicted_session_filter_error_rate = 0.0001,
// TCP Reassembly
.tcp_reassembly_enable = 1,
.tcp_reassembly_max_timeout_ms = 60000,
.tcp_reassembly_max_segments = 16,
};
static uint64_t session_id_generator(uint64_t now_ms __attribute__((unused)))
{
static uint64_t count = 0;
@@ -116,8 +72,8 @@ TEST(UDP_INIT_TO_OPENING_TO_CLOSING, BY_C2S)
EXPECT_TRUE(stat->udp_sess_closing == 0);
// expire session
EXPECT_TRUE(session_manager_get_expired_session(mgr, 1 + cfg.udp_data_timeout_ms) == NULL); // opening -> closing
sess = session_manager_get_expired_session(mgr, 1 + cfg.udp_data_timeout_ms + cfg.udp_data_timeout_ms); // closing -> closed
EXPECT_TRUE(session_manager_get_expired_session(mgr, 1 + cfg.udp_timeout_ms.data) == NULL); // opening -> closing
sess = session_manager_get_expired_session(mgr, 1 + cfg.udp_timeout_ms.data + cfg.udp_timeout_ms.data); // closing -> closed
EXPECT_TRUE(sess);
EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED);
EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT);
@@ -195,8 +151,8 @@ TEST(UDP_INIT_TO_OPENING_TO_CLOSING, BY_S2C)
EXPECT_TRUE(stat->udp_sess_closing == 0);
// expire session
EXPECT_TRUE(session_manager_get_expired_session(mgr, 1 + cfg.udp_data_timeout_ms) == NULL); // opening -> closing
sess = session_manager_get_expired_session(mgr, 1 + cfg.udp_data_timeout_ms + cfg.udp_data_timeout_ms); // closing -> closed
EXPECT_TRUE(session_manager_get_expired_session(mgr, 1 + cfg.udp_timeout_ms.data) == NULL); // opening -> closing
sess = session_manager_get_expired_session(mgr, 1 + cfg.udp_timeout_ms.data + cfg.udp_timeout_ms.data); // closing -> closed
EXPECT_TRUE(sess);
EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED);

50
infra/session_manager/test/gtest_timeout_tcp_data.cpp
View File

@@ -4,53 +4,9 @@
#include "packet_private.h"
#include "packet_parser.h"
#include "session_private.h"
#include "session_manager.h"
#include "default_config.h"
#include "test_packets.h"
struct session_manager_config cfg = {
// max session number
.max_tcp_session_num = 256,
.max_udp_session_num = 256,
// session overload
.tcp_overload_evict_old_sess = 1, // 1: evict old session, 0: bypass new session
.udp_overload_evict_old_sess = 1, // 1: evict old session, 0: bypass new session
// tcp timeout
.tcp_init_timeout_ms = 1,
.tcp_handshake_timeout_ms = 2,
.tcp_data_timeout_ms = 3,
.tcp_half_closed_timeout_ms = 4,
.tcp_time_wait_timeout_ms = 5,
.tcp_discard_timeout_ms = 6,
.tcp_unverified_rst_timeout_ms = 7,
// udp timeout
.udp_data_timeout_ms = 8,
.udp_discard_timeout_ms = 0,
// limit
.session_expire_polling_interval_ms = 0,
.session_expire_polling_limit = 1024,
// duplicate packet filter
.duplicated_packet_filter_enable = 1,
.duplicated_packet_filter_capacity = 1000,
.duplicated_packet_filter_timeout_ms = 10,
.duplicated_packet_filter_error_rate = 0.0001,
// evicted session filter
.evicted_session_filter_enable = 1,
.evicted_session_filter_capacity = 1000,
.evicted_session_filter_timeout_ms = 10,
.evicted_session_filter_error_rate = 0.0001,
// TCP Reassembly
.tcp_reassembly_enable = 1,
.tcp_reassembly_max_timeout_ms = 60000,
.tcp_reassembly_max_segments = 16,
};
static uint64_t session_id_generator(uint64_t now_ms __attribute__((unused)))
{
static uint64_t count = 0;
@@ -93,8 +49,8 @@ TEST(TIMEOUT, TCP_TIMEOUT_DATA)
EXPECT_TRUE(session_manager_update_session(mgr, sess, &pkt, 2) == 0);
// expire session
EXPECT_TRUE(session_manager_get_expired_session(mgr, 2 + cfg.tcp_data_timeout_ms) == NULL);
sess = session_manager_get_expired_session(mgr, 2 + cfg.tcp_data_timeout_ms + cfg.tcp_data_timeout_ms);
EXPECT_TRUE(session_manager_get_expired_session(mgr, 2 + cfg.tcp_timeout_ms.data) == NULL);
sess = session_manager_get_expired_session(mgr, 2 + cfg.tcp_timeout_ms.data + cfg.tcp_timeout_ms.data);
EXPECT_TRUE(sess);
EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED);
EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT);

50
infra/session_manager/test/gtest_timeout_tcp_handshake.cpp
View File

@@ -4,53 +4,9 @@
#include "packet_private.h"
#include "packet_parser.h"
#include "session_private.h"
#include "session_manager.h"
#include "default_config.h"
#include "test_packets.h"
struct session_manager_config cfg = {
// max session number
.max_tcp_session_num = 256,
.max_udp_session_num = 256,
// session overload
.tcp_overload_evict_old_sess = 1, // 1: evict old session, 0: bypass new session
.udp_overload_evict_old_sess = 1, // 1: evict old session, 0: bypass new session
// tcp timeout
.tcp_init_timeout_ms = 1,
.tcp_handshake_timeout_ms = 2,
.tcp_data_timeout_ms = 3,
.tcp_half_closed_timeout_ms = 4,
.tcp_time_wait_timeout_ms = 5,
.tcp_discard_timeout_ms = 6,
.tcp_unverified_rst_timeout_ms = 7,
// udp timeout
.udp_data_timeout_ms = 8,
.udp_discard_timeout_ms = 0,
// limit
.session_expire_polling_interval_ms = 0,
.session_expire_polling_limit = 1024,
// duplicate packet filter
.duplicated_packet_filter_enable = 1,
.duplicated_packet_filter_capacity = 1000,
.duplicated_packet_filter_timeout_ms = 10,
.duplicated_packet_filter_error_rate = 0.0001,
// evicted session filter
.evicted_session_filter_enable = 1,
.evicted_session_filter_capacity = 1000,
.evicted_session_filter_timeout_ms = 10,
.evicted_session_filter_error_rate = 0.0001,
// TCP Reassembly
.tcp_reassembly_enable = 1,
.tcp_reassembly_max_timeout_ms = 60000,
.tcp_reassembly_max_segments = 16,
};
static uint64_t session_id_generator(uint64_t now_ms __attribute__((unused)))
{
static uint64_t count = 0;
@@ -81,8 +37,8 @@ TEST(TIMEOUT, TCP_TIMEOUT_HANDSHAKE)
EXPECT_TRUE(sess);
// expire session
EXPECT_TRUE(session_manager_get_expired_session(mgr, 1 + cfg.tcp_handshake_timeout_ms) == NULL);
sess = session_manager_get_expired_session(mgr, 1 + cfg.tcp_handshake_timeout_ms + cfg.tcp_data_timeout_ms);
EXPECT_TRUE(session_manager_get_expired_session(mgr, 1 + cfg.tcp_timeout_ms.handshake) == NULL);
sess = session_manager_get_expired_session(mgr, 1 + cfg.tcp_timeout_ms.handshake + cfg.tcp_timeout_ms.data);
EXPECT_TRUE(sess);
EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED);
EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT);

50
infra/session_manager/test/gtest_timeout_tcp_init.cpp
View File

@@ -4,53 +4,9 @@
#include "packet_private.h"
#include "packet_parser.h"
#include "session_private.h"
#include "session_manager.h"
#include "default_config.h"
#include "test_packets.h"
struct session_manager_config cfg = {
// max session number
.max_tcp_session_num = 256,
.max_udp_session_num = 256,
// session overload
.tcp_overload_evict_old_sess = 1, // 1: evict old session, 0: bypass new session
.udp_overload_evict_old_sess = 1, // 1: evict old session, 0: bypass new session
// tcp timeout
.tcp_init_timeout_ms = 1,
.tcp_handshake_timeout_ms = 2,
.tcp_data_timeout_ms = 3,
.tcp_half_closed_timeout_ms = 4,
.tcp_time_wait_timeout_ms = 5,
.tcp_discard_timeout_ms = 6,
.tcp_unverified_rst_timeout_ms = 7,
// udp timeout
.udp_data_timeout_ms = 8,
.udp_discard_timeout_ms = 0,
// limit
.session_expire_polling_interval_ms = 0,
.session_expire_polling_limit = 1024,
// duplicate packet filter
.duplicated_packet_filter_enable = 1,
.duplicated_packet_filter_capacity = 1000,
.duplicated_packet_filter_timeout_ms = 10,
.duplicated_packet_filter_error_rate = 0.0001,
// evicted session filter
.evicted_session_filter_enable = 1,
.evicted_session_filter_capacity = 1000,
.evicted_session_filter_timeout_ms = 10,
.evicted_session_filter_error_rate = 0.0001,
// TCP Reassembly
.tcp_reassembly_enable = 1,
.tcp_reassembly_max_timeout_ms = 60000,
.tcp_reassembly_max_segments = 16,
};
static uint64_t session_id_generator(uint64_t now_ms __attribute__((unused)))
{
static uint64_t count = 0;
@@ -81,8 +37,8 @@ TEST(TIMEOUT, TCP_TIMEOUT_INIT)
EXPECT_TRUE(sess);
// expire session
EXPECT_TRUE(session_manager_get_expired_session(mgr, 1 + cfg.tcp_init_timeout_ms) == NULL); // opening -> closing
sess = session_manager_get_expired_session(mgr, 1 + cfg.tcp_init_timeout_ms + cfg.tcp_data_timeout_ms); // closing -> closed
EXPECT_TRUE(session_manager_get_expired_session(mgr, 1 + cfg.tcp_timeout_ms.init) == NULL); // opening -> closing
sess = session_manager_get_expired_session(mgr, 1 + cfg.tcp_timeout_ms.init + cfg.tcp_timeout_ms.data); // closing -> closed
EXPECT_TRUE(sess);
EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED);
EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT);

54
infra/session_manager/test/gtest_timeout_udp_data.cpp
View File

@@ -4,53 +4,9 @@
#include "packet_private.h"
#include "packet_parser.h"
#include "session_private.h"
#include "session_manager.h"
#include "default_config.h"
#include "test_packets.h"
struct session_manager_config cfg = {
// max session number
.max_tcp_session_num = 256,
.max_udp_session_num = 256,
// session overload
.tcp_overload_evict_old_sess = 1, // 1: evict old session, 0: bypass new session
.udp_overload_evict_old_sess = 1, // 1: evict old session, 0: bypass new session
// tcp timeout
.tcp_init_timeout_ms = 1,
.tcp_handshake_timeout_ms = 2,
.tcp_data_timeout_ms = 3,
.tcp_half_closed_timeout_ms = 4,
.tcp_time_wait_timeout_ms = 5,
.tcp_discard_timeout_ms = 6,
.tcp_unverified_rst_timeout_ms = 7,
// udp timeout
.udp_data_timeout_ms = 8,
.udp_discard_timeout_ms = 0,
// limit
.session_expire_polling_interval_ms = 0,
.session_expire_polling_limit = 1024,
// duplicate packet filter
.duplicated_packet_filter_enable = 1,
.duplicated_packet_filter_capacity = 1000,
.duplicated_packet_filter_timeout_ms = 10,
.duplicated_packet_filter_error_rate = 0.0001,
// evicted session filter
.evicted_session_filter_enable = 1,
.evicted_session_filter_capacity = 1000,
.evicted_session_filter_timeout_ms = 10,
.evicted_session_filter_error_rate = 0.0001,
// TCP Reassembly
.tcp_reassembly_enable = 1,
.tcp_reassembly_max_timeout_ms = 60000,
.tcp_reassembly_max_segments = 16,
};
static uint64_t session_id_generator(uint64_t now_ms __attribute__((unused)))
{
static uint64_t count = 0;
@@ -81,8 +37,8 @@ TEST(TIMEOUT, UDP_TIMEOUT_DATA1)
EXPECT_TRUE(sess);
// expire session
EXPECT_TRUE(session_manager_get_expired_session(mgr, 1 + cfg.udp_data_timeout_ms) == NULL); // opening -> closing
sess = session_manager_get_expired_session(mgr, 1 + cfg.udp_data_timeout_ms + cfg.udp_data_timeout_ms); // closing -> closed
EXPECT_TRUE(session_manager_get_expired_session(mgr, 1 + cfg.udp_timeout_ms.data) == NULL); // opening -> closing
sess = session_manager_get_expired_session(mgr, 1 + cfg.udp_timeout_ms.data + cfg.udp_timeout_ms.data); // closing -> closed
EXPECT_TRUE(sess);
EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED);
EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT);
@@ -130,8 +86,8 @@ TEST(TIMEOUT, UDP_TIMEOUT_DATA2)
EXPECT_TRUE(session_manager_update_session(mgr, sess, &pkt, 2) == 0);
// expire session
EXPECT_TRUE(session_manager_get_expired_session(mgr, 2 + cfg.udp_data_timeout_ms) == NULL); // active -> closing
sess = session_manager_get_expired_session(mgr, 2 + cfg.udp_data_timeout_ms + cfg.udp_data_timeout_ms); // closing -> closed
EXPECT_TRUE(session_manager_get_expired_session(mgr, 2 + cfg.udp_timeout_ms.data) == NULL); // active -> closing
sess = session_manager_get_expired_session(mgr, 2 + cfg.udp_timeout_ms.data + cfg.udp_timeout_ms.data); // closing -> closed
EXPECT_TRUE(sess);
EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED);
EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT);