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
spdk_jsonrpc_set_log_level(enum spdk_log_level level)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
spdk_jsonrpc_set_log_file(FILE * file)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
reset_global_counters(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
server_exists(const char * addr)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
server_paused(const char * addr)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
initialize_servers(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
test_run_multiple_servers_stop_all(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
test_run_multiple_servers_stop_singles(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
test_rpc_set_spdk_log_opts(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
test_rpc_set_spdk_log_default_opts(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
test_pause_resume_servers(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
test_remove_paused_servers(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
main(int argc,char ** argv)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