diff options
Diffstat (limited to 'shaping/test/gtest_shaper_with_swarmkv.cpp')
| -rw-r--r-- | shaping/test/gtest_shaper_with_swarmkv.cpp | 268 |
1 files changed, 267 insertions, 1 deletions
diff --git a/shaping/test/gtest_shaper_with_swarmkv.cpp b/shaping/test/gtest_shaper_with_swarmkv.cpp index e3f2304..ac8a53f 100644 --- a/shaping/test/gtest_shaper_with_swarmkv.cpp +++ b/shaping/test/gtest_shaper_with_swarmkv.cpp @@ -1,11 +1,277 @@ +#include <stdarg.h> +#include <sys/syscall.h> #include <gtest/gtest.h> +#include <MESA/MESA_handle_logger.h> +#include <MESA/swarmkv.h> + +#include "shaper_maat.h" +#include "stub.h" + +struct swarmkv_cli_system +{ + int attached; + char *cluster_name; + char *attach_target_line; +}; + +typedef void proc_result_callback_t(struct cmd_exec_arg* exec_arg, void *uarg); +struct cmd_exec_arg +{ + pthread_cond_t cond; + pthread_mutex_t mutex; + int is_callback_executed; + int success; + int api_invoking_tid; + pthread_t callback_invoking_tid; + int is_sync_callback; + struct swarmkv_reply expected_reply; + proc_result_callback_t *cb; + void *cb_uarg; + int print_reply_on_fail; + int diable_sync_check; +}; + +static struct swarmkv_cli_system g_cli_system; + +int swarmkv_cli_create_cluster(const char *cluster_name, const char *node_string) +{ + char cmd_string[1024]; + snprintf(cmd_string, sizeof(cmd_string), "/opt/MESA/bin/swarmkv-cli --cluster-create %s %s", cluster_name, node_string); + return system(cmd_string); +} + +void swarmkv_cli_set_db(const char *cluster_name) +{ + if(g_cli_system.cluster_name) free(g_cli_system.cluster_name); + asprintf(&(g_cli_system.cluster_name), "%s", cluster_name); +} + +struct cmd_exec_arg* cmd_exec_arg_new(void) +{ + struct cmd_exec_arg* arg=(struct cmd_exec_arg*)calloc(sizeof(struct cmd_exec_arg), 1); + pthread_cond_init(&arg->cond, NULL); + pthread_mutex_init(&arg->mutex, NULL); + arg->callback_invoking_tid=syscall(SYS_gettid); + return arg; +} + +void cmd_exec_arg_expect_OK(struct cmd_exec_arg* arg) +{ + arg->expected_reply.type=SWARMKV_REPLY_STATUS; + if(arg->expected_reply.str) + { + free(arg->expected_reply.str); + arg->expected_reply.str=NULL; + } + arg->expected_reply.str=strdup("OK"); + arg->expected_reply.len=2; +} + +void cmd_exec_arg_expect_cstring(struct cmd_exec_arg* arg, const char* string) +{ + arg->expected_reply.type=SWARMKV_REPLY_STRING; + if(arg->expected_reply.str) + { + free(arg->expected_reply.str); + arg->expected_reply.str=NULL; + } + arg->expected_reply.str=strdup(string); + arg->expected_reply.len=strlen(string); + +} + +void cmd_exec_arg_clear(struct cmd_exec_arg* arg) +{ + arg->success=0; + arg->is_callback_executed=0; + if(!arg->diable_sync_check) + { + arg->api_invoking_tid = syscall(SYS_gettid); + } + arg->callback_invoking_tid=0; + arg->is_sync_callback=0; + return; +} + +typedef void swarmkv_cli_reply_funt_t(struct cmd_exec_arg* reply_arg, const char *); + +int swarmkv_cli_system_cmd(struct cmd_exec_arg* reply_arg, char *result, size_t result_len, swarmkv_cli_reply_funt_t *reply_funt_t, const char *format, ...) +{ + int line_num=0; + char command[1024] = {0}; + char *cmd_str=NULL; + + va_list ap; + va_start(ap,format); + vasprintf(&cmd_str, format, ap); + va_end(ap); + + if(g_cli_system.attached) + { + snprintf(command, sizeof(command), "/opt/MESA/bin/swarmkv-cli -n %s %s --exec %s", g_cli_system.cluster_name, g_cli_system.attach_target_line, cmd_str); + } + else + { + snprintf(command, sizeof(command), "/opt/MESA/bin/swarmkv-cli -n %s --exec %s", g_cli_system.cluster_name, cmd_str); + } + + char *p=result; + char line[1024] = {0}; + FILE *fp = NULL; + + if((fp = popen(command, "r")) == NULL) + { + printf("popen error!\n"); + return 0; + } + memset(result, 0, result_len); + while (fgets(line, sizeof(line), fp)) + { + int len= strlen(line); + line[len-1]='\0'; + if((p - result) < (int)result_len) + { + if(line_num) + { + p += snprintf(p, result_len - (p - result), ","); + } + + p += snprintf(p, result_len - (p - result), "%s", line); + } + line_num++; + } + pclose(fp); + + if(reply_funt_t) + reply_funt_t(reply_arg, result); + free(cmd_str); + return 1; +} + +void swarmkv_expect_reply_string(struct cmd_exec_arg* reply_arg, const char *line) +{ + EXPECT_STREQ(line, reply_arg->expected_reply.str); +} + +static void send_packets(struct shaping_thread_ctx *ctx, struct shaping_flow *sf, int pkt_len, enum shaping_packet_dir dir, int is_tcp_pure_control) +{ + struct stub_packet *packet = (struct stub_packet *)calloc(1, sizeof(struct stub_packet)); + struct metadata meta; + + packet->direction = dir; + packet->length = pkt_len; + + memset(&meta, 0, sizeof(meta)); + + meta.dir = dir; + meta.raw_len = pkt_len; + if (is_tcp_pure_control) { + meta.is_tcp_pure_ctrl = 1; + } + + shaping_packet_process(ctx, packet, &meta, sf); + + polling_entry(ctx->sp, ctx->stat, ctx); + + + return; +} TEST(single_session, generic_profile) -{} +{ + struct stub_pkt_queue *actual_tx_queue; + struct shaping_ctx *ctx = NULL; + struct shaping_flow *sf = NULL; + long long rule_id[] = {0}; + int priority[] = {1}; + int profile_num[] = {1}; + int profile_id[][MAX_REF_PROFILE] = {{0}}; + struct cmd_exec_arg* reply_arg=NULL; + char result[2048]={0}; + + stub_init(); + ctx = shaping_engine_init(); + ASSERT_TRUE(ctx != NULL); + sf = shaping_flow_new(&ctx->thread_ctx[0]); + ASSERT_TRUE(sf != NULL); + + stub_set_matched_shaping_rules(1, rule_id, priority, profile_num, profile_id); + shaper_rules_update(&ctx->thread_ctx[0], sf, rule_id, 1); + + //set swarmkv key + swarmkv_cli_set_db("swarmkv-shaping-nodes"); + reply_arg=cmd_exec_arg_new(); + + cmd_exec_arg_expect_OK(reply_arg); + swarmkv_cli_system_cmd(reply_arg, result, sizeof(result), swarmkv_expect_reply_string, "tcfg tsg-shaping-0-incoming 1000000 1000000"); + swarmkv_cli_system_cmd(reply_arg, result, sizeof(result), swarmkv_expect_reply_string, "tcfg tsg-shaping-0-outgoing 1000000 1000000"); + cmd_exec_arg_clear(reply_arg); + + actual_tx_queue = stub_get_tx_queue(); + + //TODO: compare tx_queue + time_t start_time = time(NULL); + unsigned long long total_bytes = 0; + while (1) { + if (time(NULL) - start_time >= 10) { + break; + } + send_packets(&ctx->thread_ctx[0], sf, 100, SHAPING_DIR_IN, 0); + while(!TAILQ_EMPTY(actual_tx_queue)) + { + struct stub_packet_node *pkt_node = TAILQ_FIRST(actual_tx_queue); + TAILQ_REMOVE(actual_tx_queue, pkt_node, node); + total_bytes += pkt_node->raw_packet->length; + free(pkt_node->raw_packet); + free(pkt_node); + } + } + + EXPECT_EQ(total_bytes * 8, 1000000 * 10); + + + shaping_flow_free(&ctx->thread_ctx[0], sf); + shaper_thread_resource_clear(); + shaping_engine_destroy(ctx); +} int main(int argc, char **argv) { testing::InitGoogleTest(&argc, argv); //testing::GTEST_FLAG(filter) = "single_session.udp_tx_in_order"; + + const char* log_path="./swarmkv-shaping-nodes.log"; + char *err=NULL; + const char *cluster_name="swarmkv-shaping-nodes"; + struct swarmkv *db=NULL; + + swarmkv_cli_create_cluster(cluster_name, "127.0.0.1:5210"); + + if (0 != MESA_handle_runtime_log_creation("./conf/zlog.conf")) + { + fprintf(stderr, "FATAL: unable to create runtime logger\n"); + return -1; + } + + void *log_handle = MESA_create_runtime_log_handle("log/shaping", RLOG_LV_DEBUG); + if (log_handle == NULL) + { + fprintf(stderr, "FATAL: unable to create log handle\n"); + return -1; + } + + struct swarmkv_options* opts=swarmkv_options_new(); + swarmkv_options_set_cluster_port(opts, 5210); + swarmkv_options_set_health_check_port(opts, 6210); + swarmkv_options_set_logger(opts, log_handle); + swarmkv_options_set_caller_thread_number(opts, 1); + db=swarmkv_open(opts, cluster_name, &err); + if(err) + { + printf("swarmkv_open failed: %s.\n", err); + free(err); + } + swarmkv_register_thread(db); + return RUN_ALL_TESTS(); }
\ No newline at end of file |