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 bool 67 server_paused(const char *addr) 68 { 69 struct init_rpc_server *server; 70 71 STAILQ_FOREACH(server, &g_init_rpc_servers, link) { 72 if (strcmp(addr, server->listen_addr) == 0 && !server->active) { 73 return true; 74 } 75 } 76 77 return false; 78 } 79 80 static void 81 initialize_servers(void) 82 { 83 int rc; 84 85 CU_ASSERT(STAILQ_EMPTY(&g_init_rpc_servers)); 86 87 rc = spdk_rpc_initialize(g_test_addr1, NULL); 88 CU_ASSERT(rc == 0); 89 CU_ASSERT(server_exists(g_test_addr1)); 90 CU_ASSERT(server_paused(g_test_addr1) == false); 91 92 rc = spdk_rpc_initialize(g_test_addr2, NULL); 93 CU_ASSERT(rc == 0); 94 CU_ASSERT(server_exists(g_test_addr2)); 95 CU_ASSERT(server_paused(g_test_addr2) == false); 96 } 97 98 static void 99 test_run_multiple_servers_stop_all(void) 100 { 101 initialize_servers(); 102 CU_ASSERT(!STAILQ_EMPTY(&g_init_rpc_servers)); 103 104 spdk_rpc_finish(); 105 CU_ASSERT(STAILQ_EMPTY(&g_init_rpc_servers)); 106 } 107 108 static void 109 test_run_multiple_servers_stop_singles(void) 110 { 111 initialize_servers(); 112 CU_ASSERT(!STAILQ_EMPTY(&g_init_rpc_servers)); 113 114 spdk_rpc_server_finish(g_test_addr1); 115 CU_ASSERT(!server_exists(g_test_addr1)); 116 CU_ASSERT(!STAILQ_EMPTY(&g_init_rpc_servers)); 117 118 spdk_rpc_server_finish(g_test_addr2); 119 CU_ASSERT(!server_exists(g_test_addr2)); 120 CU_ASSERT(STAILQ_EMPTY(&g_init_rpc_servers)); 121 } 122 123 static void 124 test_rpc_set_spdk_log_opts(void) 125 { 126 struct spdk_rpc_opts server1_opts = {}; 127 struct spdk_rpc_opts server2_opts = {}; 128 FILE *test_log_file1 = (void *)0xDEADDEAD; 129 FILE *test_log_file2 = (void *)0xBEEFBEEF; 130 131 reset_global_counters(); 132 133 server1_opts.log_file = test_log_file1; 134 server1_opts.log_level = SPDK_LOG_DEBUG; 135 server1_opts.size = sizeof(server1_opts); 136 server2_opts.log_file = test_log_file2; 137 server2_opts.log_level = SPDK_LOG_ERROR; 138 server2_opts.size = sizeof(server2_opts); 139 140 spdk_rpc_initialize(g_test_addr1, &server1_opts); 141 CU_ASSERT(g_test_log_file == server1_opts.log_file); 142 CU_ASSERT(g_test_log_level == server1_opts.log_level); 143 CU_ASSERT(g_test_log_file_set_count == 1); 144 CU_ASSERT(g_test_log_level_set_count == 1); 145 146 spdk_rpc_initialize(g_test_addr2, &server2_opts); 147 CU_ASSERT(g_test_log_file == server2_opts.log_file); 148 CU_ASSERT(g_test_log_level == server2_opts.log_level); 149 CU_ASSERT(g_test_log_file_set_count == 2); 150 CU_ASSERT(g_test_log_level_set_count == 2); 151 152 spdk_rpc_finish(); 153 } 154 155 static void 156 test_rpc_set_spdk_log_default_opts(void) 157 { 158 FILE *test_log_file_default = NULL; 159 enum spdk_log_level test_log_level_default = SPDK_LOG_DISABLED; 160 161 reset_global_counters(); 162 163 spdk_rpc_initialize(g_test_addr1, NULL); 164 CU_ASSERT(g_test_log_file == test_log_file_default); 165 CU_ASSERT(g_test_log_level == test_log_level_default); 166 CU_ASSERT(g_test_log_file_set_count == 1); 167 CU_ASSERT(g_test_log_level_set_count == 1); 168 169 spdk_rpc_initialize(g_test_addr2, NULL); 170 CU_ASSERT(g_test_log_file == test_log_file_default); 171 CU_ASSERT(g_test_log_level == test_log_level_default); 172 CU_ASSERT(g_test_log_file_set_count == 1); 173 CU_ASSERT(g_test_log_level_set_count == 1); 174 175 spdk_rpc_finish(); 176 } 177 178 static void 179 test_pause_resume_servers(void) 180 { 181 initialize_servers(); 182 183 spdk_rpc_server_pause(g_test_addr1); 184 CU_ASSERT(server_exists(g_test_addr1)); 185 CU_ASSERT(server_paused(g_test_addr1)); 186 187 spdk_rpc_server_pause(g_test_addr2); 188 CU_ASSERT(server_exists(g_test_addr2)); 189 CU_ASSERT(server_paused(g_test_addr2)); 190 191 spdk_rpc_server_resume(g_test_addr2); 192 CU_ASSERT(!server_paused(g_test_addr2)); 193 194 spdk_rpc_server_resume(g_test_addr1); 195 CU_ASSERT(!server_paused(g_test_addr1)); 196 197 spdk_rpc_finish(); 198 } 199 200 static void 201 test_remove_paused_servers(void) 202 { 203 initialize_servers(); 204 205 spdk_rpc_server_pause(g_test_addr1); 206 spdk_rpc_server_pause(g_test_addr2); 207 208 spdk_rpc_server_finish(g_test_addr2); 209 CU_ASSERT(!server_exists(g_test_addr2)); 210 211 CU_ASSERT(server_exists(g_test_addr1)); 212 CU_ASSERT(server_paused(g_test_addr1)); 213 214 spdk_rpc_server_finish(g_test_addr1); 215 } 216 217 int 218 main(int argc, char **argv) 219 { 220 CU_pSuite suite = NULL; 221 unsigned int num_failures; 222 struct spdk_thread *thread; 223 224 CU_initialize_registry(); 225 suite = CU_add_suite("rpc_suite", NULL, NULL); 226 227 spdk_thread_lib_init(NULL, 0); 228 thread = spdk_thread_create(NULL, NULL); 229 spdk_set_thread(thread); 230 231 CU_ADD_TEST(suite, test_run_multiple_servers_stop_all); 232 CU_ADD_TEST(suite, test_run_multiple_servers_stop_singles); 233 CU_ADD_TEST(suite, test_rpc_set_spdk_log_opts); 234 CU_ADD_TEST(suite, test_rpc_set_spdk_log_default_opts); 235 CU_ADD_TEST(suite, test_pause_resume_servers); 236 CU_ADD_TEST(suite, test_remove_paused_servers); 237 238 num_failures = spdk_ut_run_tests(argc, argv, NULL); 239 CU_cleanup_registry(); 240 241 return num_failures; 242 } 243