1 /* SPDX-License-Identifier: BSD-3-Clause 2 * Copyright (C) 2024 Intel Corporation. 3 * All rights reserved. 4 */ 5 6 #include "spdk/stdinc.h" 7 8 #include "spdk_internal/cunit.h" 9 10 #include "init/rpc.c" 11 #include "common/lib/test_env.c" 12 13 DEFINE_STUB(spdk_rpc_listen, int, (const char *listen_addr), 0); 14 DEFINE_STUB(spdk_rpc_server_listen, struct spdk_rpc_server *, (const char *listen_addr), 15 (struct spdk_rpc_server *)0xdeadbeef); 16 DEFINE_STUB(spdk_rpc_verify_methods, bool, (void), true); 17 DEFINE_STUB_V(spdk_rpc_accept, (void)); 18 DEFINE_STUB_V(spdk_rpc_close, (void)); 19 DEFINE_STUB_V(spdk_rpc_server_accept, (struct spdk_rpc_server *server)); 20 DEFINE_STUB_V(spdk_rpc_server_close, (struct spdk_rpc_server *server)); 21 DEFINE_STUB_V(spdk_rpc_set_state, (uint32_t state)); 22 23 enum spdk_log_level g_test_log_level = SPDK_LOG_DISABLED; 24 FILE *g_test_log_file = NULL; 25 uint8_t g_test_log_level_set_count = 0; 26 uint8_t g_test_log_file_set_count = 0; 27 28 const char *g_test_addr1 = "/var/tmp/test_addr1.sock"; 29 const char *g_test_addr2 = "/var/tmp/test_addr2.sock"; 30 31 void 32 spdk_jsonrpc_set_log_level(enum spdk_log_level level) 33 { 34 g_test_log_level = level; 35 g_test_log_level_set_count++; 36 } 37 38 void 39 spdk_jsonrpc_set_log_file(FILE *file) 40 { 41 g_test_log_file = file; 42 g_test_log_file_set_count++; 43 } 44 45 static void 46 reset_global_counters(void) 47 { 48 g_test_log_level_set_count = 0; 49 g_test_log_file_set_count = 0; 50 } 51 52 static bool 53 server_exists(const char *addr) 54 { 55 struct init_rpc_server *server; 56 57 STAILQ_FOREACH(server, &g_init_rpc_servers, link) { 58 if (strcmp(addr, server->listen_addr) == 0) { 59 return true; 60 } 61 } 62 63 return false; 64 } 65 66 static void 67 initialize_servers(void) 68 { 69 int rc; 70 71 CU_ASSERT(STAILQ_EMPTY(&g_init_rpc_servers)); 72 73 rc = spdk_rpc_initialize(g_test_addr1, NULL); 74 CU_ASSERT(rc == 0); 75 CU_ASSERT(server_exists(g_test_addr1)); 76 77 rc = spdk_rpc_initialize(g_test_addr2, NULL); 78 CU_ASSERT(rc == 0); 79 CU_ASSERT(server_exists(g_test_addr2)); 80 } 81 82 static void 83 test_run_multiple_servers_stop_all(void) 84 { 85 initialize_servers(); 86 CU_ASSERT(!STAILQ_EMPTY(&g_init_rpc_servers)); 87 88 spdk_rpc_finish(); 89 CU_ASSERT(STAILQ_EMPTY(&g_init_rpc_servers)); 90 } 91 92 static void 93 test_run_multiple_servers_stop_singles(void) 94 { 95 initialize_servers(); 96 CU_ASSERT(!STAILQ_EMPTY(&g_init_rpc_servers)); 97 98 spdk_rpc_server_finish(g_test_addr1); 99 CU_ASSERT(!server_exists(g_test_addr1)); 100 CU_ASSERT(!STAILQ_EMPTY(&g_init_rpc_servers)); 101 102 spdk_rpc_server_finish(g_test_addr2); 103 CU_ASSERT(!server_exists(g_test_addr2)); 104 CU_ASSERT(STAILQ_EMPTY(&g_init_rpc_servers)); 105 } 106 107 static void 108 test_rpc_set_spdk_log_opts(void) 109 { 110 struct spdk_rpc_opts server1_opts = {}; 111 struct spdk_rpc_opts server2_opts = {}; 112 FILE *test_log_file1 = (void *)0xDEADDEAD; 113 FILE *test_log_file2 = (void *)0xBEEFBEEF; 114 115 reset_global_counters(); 116 117 server1_opts.log_file = test_log_file1; 118 server1_opts.log_level = SPDK_LOG_DEBUG; 119 server1_opts.size = sizeof(server1_opts); 120 server2_opts.log_file = test_log_file2; 121 server2_opts.log_level = SPDK_LOG_ERROR; 122 server2_opts.size = sizeof(server2_opts); 123 124 spdk_rpc_initialize(g_test_addr1, &server1_opts); 125 CU_ASSERT(g_test_log_file == server1_opts.log_file); 126 CU_ASSERT(g_test_log_level == server1_opts.log_level); 127 CU_ASSERT(g_test_log_file_set_count == 1); 128 CU_ASSERT(g_test_log_level_set_count == 1); 129 130 spdk_rpc_initialize(g_test_addr2, &server2_opts); 131 CU_ASSERT(g_test_log_file == server2_opts.log_file); 132 CU_ASSERT(g_test_log_level == server2_opts.log_level); 133 CU_ASSERT(g_test_log_file_set_count == 2); 134 CU_ASSERT(g_test_log_level_set_count == 2); 135 136 spdk_rpc_finish(); 137 } 138 139 static void 140 test_rpc_set_spdk_log_default_opts(void) 141 { 142 FILE *test_log_file_default = NULL; 143 enum spdk_log_level test_log_level_default = SPDK_LOG_DISABLED; 144 145 reset_global_counters(); 146 147 spdk_rpc_initialize(g_test_addr1, NULL); 148 CU_ASSERT(g_test_log_file == test_log_file_default); 149 CU_ASSERT(g_test_log_level == test_log_level_default); 150 CU_ASSERT(g_test_log_file_set_count == 1); 151 CU_ASSERT(g_test_log_level_set_count == 1); 152 153 spdk_rpc_initialize(g_test_addr2, NULL); 154 CU_ASSERT(g_test_log_file == test_log_file_default); 155 CU_ASSERT(g_test_log_level == test_log_level_default); 156 CU_ASSERT(g_test_log_file_set_count == 1); 157 CU_ASSERT(g_test_log_level_set_count == 1); 158 159 spdk_rpc_finish(); 160 } 161 162 int 163 main(int argc, char **argv) 164 { 165 CU_pSuite suite = NULL; 166 unsigned int num_failures; 167 struct spdk_thread *thread; 168 169 CU_initialize_registry(); 170 suite = CU_add_suite("rpc_suite", NULL, NULL); 171 172 spdk_thread_lib_init(NULL, 0); 173 thread = spdk_thread_create(NULL, NULL); 174 spdk_set_thread(thread); 175 176 CU_ADD_TEST(suite, test_run_multiple_servers_stop_all); 177 CU_ADD_TEST(suite, test_run_multiple_servers_stop_singles); 178 CU_ADD_TEST(suite, test_rpc_set_spdk_log_opts); 179 CU_ADD_TEST(suite, test_rpc_set_spdk_log_default_opts); 180 181 num_failures = spdk_ut_run_tests(argc, argv, NULL); 182 CU_cleanup_registry(); 183 184 return num_failures; 185 } 186