The FreeRADIUS server $Id: 15bac2a4c627c01d1aa2047687b3418955ac7f00 $
Loading...
Searching...
No Matches
trunk_tests.c
Go to the documentation of this file.
1#include <freeradius-devel/util/acutest.h>
2#include <freeradius-devel/util/acutest_helpers.h>
3#include <freeradius-devel/util/syserror.h>
4#include <sys/socket.h>
5
6#define TRUNK_TESTS 1
7#include "trunk.c"
8
9//#include <gperftools/profiler.h>
10typedef struct {
11 trunk_request_t *treq; //!< Trunk request.
12 bool cancelled; //!< Seen by the cancelled callback.
13 bool completed; //!< Seen by the complete callback.
14 bool failed; //!< Seen by the failed callback.
15 bool freed; //!< Seen by the free callback.
16 bool signal_partial; //!< Muxer should signal that this request is partially written.
17 bool signal_cancel_partial; //!< Muxer should signal that this request is partially cancelled.
18 int priority; //!< Priority of request
19} test_proto_request_t;
20
21typedef struct {
22 uint64_t cancelled; //!< Count of tests in this run that were cancelled.
23 uint64_t completed; //!< Count of tests in this run that completed.
24 uint64_t failed; //!< Count of tests in this run that failed.
25 uint64_t freed; //!< Count of tests in this run that were freed.
26} test_proto_stats_t;
27
28#define DEBUG_LVL_SET if (acutest_verbose_level_ >= 3) fr_debug_lvl = L_DBG_LVL_4 + 1
29
30static void test_mux(UNUSED fr_event_list_t *el, trunk_connection_t *tconn, connection_t *conn, UNUSED void *uctx)
31{
32 trunk_request_t *treq;
33 size_t count = 0;
34 int fd = *(talloc_get_type_abort(conn->h, int));
35 ssize_t slen;
36
37 while (trunk_connection_pop_request(&treq, tconn) == 0) {
38 test_proto_request_t *preq = treq->pub.preq;
39 count++;
40
41 /*
42 * Simulate a partial write
43 */
44 if (preq && preq->signal_partial) {
45 trunk_request_signal_partial(treq);
46 preq->signal_partial = false;
47 break;
48 }
49
50 if (acutest_verbose_level_ >= 3) printf("%s - Wrote %p\n", __FUNCTION__, preq);
51
52 slen = write(fd, &preq, sizeof(preq));
53 if (slen < 0) return;
54 if (slen == 0) return;
55 if (slen < (ssize_t)sizeof(preq)) abort();
56
57 trunk_request_signal_sent(treq);
58 }
59 TEST_CHECK(count > 0);
60}
61
62static void test_cancel_mux(UNUSED fr_event_list_t *el, trunk_connection_t *tconn, connection_t *conn, UNUSED void *uctx)
63{
64 trunk_request_t *treq;
65 size_t count = 0;
66 int fd = *(talloc_get_type_abort(conn->h, int));
67 ssize_t slen;
68
69 /*
70 * For cancellation we just do
71 */
72 while ((trunk_connection_pop_cancellation(&treq, tconn) == 0)) {
73 test_proto_request_t *preq = treq->pub.preq;
74 count++;
75
76 /*
77 * Simulate a partial cancel write
78 */
79 if (preq && preq->signal_cancel_partial) {
80 trunk_request_signal_cancel_partial(treq);
81 preq->signal_cancel_partial = false;
82 break;
83 }
84
85 if (acutest_verbose_level_ >= 3) printf("%s - Wrote %p\n", __FUNCTION__, preq);
86 slen = write(fd, &preq, sizeof(preq));
87 if (slen < 0) {
88 fr_perror("%s - %s", __FUNCTION__, fr_syserror(errno));
89 return;
90 }
91 if (slen == 0) return;
92 if (slen < (ssize_t)sizeof(preq)) abort();
93
94 trunk_request_signal_cancel_sent(treq);
95 }
96 TEST_CHECK(count > 0);
97}
98
99static void test_demux(UNUSED fr_event_list_t *el, UNUSED trunk_connection_t *tconn, connection_t *conn, UNUSED void *uctx)
100{
101 int fd = *(talloc_get_type_abort(conn->h, int));
102 test_proto_request_t *preq;
103 ssize_t slen;
104
105 for (;;) {
106 slen = read(fd, &preq, sizeof(preq));
107 if (slen <= 0) break;
108
109 if (acutest_verbose_level_ >= 3) printf("%s - Read %p (%zu)\n", __FUNCTION__, preq, (size_t)slen);
110
111 /*
112 * Coverity considers data read from a file to be tainted,
113 * and considers its use to be a defect--but almost all the
114 * rest of the loop validates the pointer to the extent
115 * possible--all of the pointer should be read, its talloc
116 * "dynamic type" had better be right, and it should either
117 * be freed or have a statethe demuxer can handle or ignore.
118 * This isn't like a range check on a numeric value;
119 * Coverity doesn't recognize it as validation.
120 */
121 TEST_CHECK(slen == sizeof(preq));
122 talloc_get_type_abort(preq, test_proto_request_t);
123
124 if (preq->freed) continue;
125
126 /*
127 * Demuxer can handle both normal requests and cancelled ones
128 */
129 switch (preq->treq->pub.state) {
130 case TRUNK_REQUEST_STATE_CANCEL:
131 break; /* Hack - just ignore it */
132
133 case TRUNK_REQUEST_STATE_CANCEL_SENT:
134 /* coverity[tainted_data] */
135 trunk_request_signal_cancel_complete(preq->treq);
136 break;
137
138 case TRUNK_REQUEST_STATE_SENT:
139 /* coverity[tainted_data] */
140 trunk_request_signal_complete(preq->treq);
141 break;
142
143 default:
144 fr_assert(0);
145 break;
146 }
147 }
148}
149
150static void _conn_io_error(UNUSED fr_event_list_t *el, UNUSED int fd, UNUSED int flags,
151 UNUSED int fd_errno, void *uctx)
152{
153
154 trunk_connection_t *tconn = talloc_get_type_abort(uctx, trunk_connection_t);
155
156 trunk_connection_signal_reconnect(tconn, CONNECTION_FAILED);
157}
158
159static void _conn_io_read(UNUSED fr_event_list_t *el, UNUSED int fd, UNUSED int flags, void *uctx)
160{
161 trunk_connection_t *tconn = talloc_get_type_abort(uctx, trunk_connection_t);
162 trunk_connection_signal_readable(tconn);
163}
164
165static void _conn_io_write(UNUSED fr_event_list_t *el, UNUSED int fd, UNUSED int flags, void *uctx)
166{
167 trunk_connection_t *tconn = talloc_get_type_abort(uctx, trunk_connection_t);
168 trunk_connection_signal_writable(tconn);
169}
170
171static void _conn_notify(trunk_connection_t *tconn, connection_t *conn,
172 fr_event_list_t *el,
173 trunk_connection_event_t notify_on, UNUSED void *uctx)
174{
175 int fd = *(talloc_get_type_abort(conn->h, int));
176
177 switch (notify_on) {
178 case TRUNK_CONN_EVENT_NONE:
179 fr_event_fd_delete(el, fd, FR_EVENT_FILTER_IO);
180 break;
181
182 case TRUNK_CONN_EVENT_READ:
183 TEST_CHECK(fr_event_fd_insert(conn, NULL, el, fd, _conn_io_read, NULL, _conn_io_error, tconn) == 0);
184 break;
185
186 case TRUNK_CONN_EVENT_WRITE:
187 TEST_CHECK(fr_event_fd_insert(conn, NULL, el, fd, NULL, _conn_io_write, _conn_io_error, tconn) == 0);
188 break;
189
190 case TRUNK_CONN_EVENT_BOTH:
191 TEST_CHECK(fr_event_fd_insert(conn, NULL, el, fd, _conn_io_read, _conn_io_write, _conn_io_error, tconn) == 0);
192 break;
193
194 default:
195 fr_assert(0);
196 }
197}
198
199static void test_request_cancel(UNUSED connection_t *conn, void *preq,
200 UNUSED trunk_cancel_reason_t reason, void *uctx)
201{
202 test_proto_stats_t *stats = uctx;
203 test_proto_request_t *our_preq;
204
205 if (!preq) return;
206
207 our_preq = talloc_get_type_abort(preq, test_proto_request_t);
208 our_preq->cancelled = true;
209 if (stats) stats->cancelled++;
210}
211
212static void test_request_complete(UNUSED request_t *request, void *preq, UNUSED void *rctx, void *uctx)
213{
214 test_proto_stats_t *stats = uctx;
215 test_proto_request_t *our_preq;
216
217 if (!preq) return;
218
219 our_preq = talloc_get_type_abort(preq, test_proto_request_t);
220 our_preq->completed = true;
221 if (stats) stats->completed++;
222}
223
224static void test_request_fail(UNUSED request_t *request, void *preq, UNUSED void *rctx, UNUSED trunk_request_state_t state, void *uctx)
225{
226 test_proto_stats_t *stats = uctx;
227 test_proto_request_t *our_preq;
228
229 if (!preq) return;
230
231 our_preq = talloc_get_type_abort(preq, test_proto_request_t);
232 our_preq->failed = true;
233 if (stats) stats->failed++;
234}
235
236static void test_request_free(UNUSED request_t *request, void *preq, void *uctx)
237{
238 test_proto_stats_t *stats = uctx;
239 test_proto_request_t *our_preq;
240
241 if (!preq) return;
242
243 our_preq = talloc_get_type_abort(preq, test_proto_request_t);
244 our_preq->freed = true;
245 if (stats) stats->freed++;
246}
247
248/** Whenever the second socket in a socket pair is readable, read all pending data, and write it back
249 *
250 */
251static void _conn_io_loopback(UNUSED fr_event_list_t *el, int fd, UNUSED int flags, void *uctx)
252{
253 int *our_h = talloc_get_type_abort(uctx, int);
254 static uint8_t buff[1024];
255 static size_t to_write;
256 ssize_t slen;
257
258 fr_assert(fd == our_h[1]);
259
260 while (true) {
261 slen = read(fd, buff, sizeof(buff));
262 if (slen <= 0) return;
263
264 to_write = (size_t)slen;
265
266 if (acutest_verbose_level_ >= 3) printf("%s - Read %zu bytes of data\n", __FUNCTION__, slen);
267 slen = write(our_h[1], buff, (size_t)to_write);
268 if (slen < 0) return;
269
270 if (slen < (ssize_t)to_write) {
271 to_write -= slen;
272 if (acutest_verbose_level_ >= 3) {
273 printf("%s - Partial write %zu bytes left\n", __FUNCTION__, to_write);
274 }
275 return;
276 } else {
277 if (acutest_verbose_level_ >= 3) printf("%s - Wrote %zu bytes of data\n", __FUNCTION__, slen);
278 }
279 }
280}
281
282static void _conn_close(UNUSED fr_event_list_t *el, void *h, UNUSED void *uctx)
283{
284 int *our_h = talloc_get_type_abort(h, int);
285
286 talloc_free_children(our_h); /* Clear the IO handlers */
287
288 close(our_h[0]);
289 close(our_h[1]);
290
291 talloc_free(our_h);
292}
293
294/** Insert I/O handlers that loop any data back round
295 *
296 */
297static connection_state_t _conn_open(fr_event_list_t *el, void *h, UNUSED void *uctx)
298{
299 int *our_h = talloc_get_type_abort(h, int);
300
301 /*
302 * This always needs to be inserted
303 */
304 TEST_CHECK(fr_event_fd_insert(our_h, NULL, el, our_h[1], _conn_io_loopback, NULL, NULL, our_h) == 0);
305
306 return CONNECTION_STATE_CONNECTED;
307}
308
309/** Allocate a basic socket pair
310 *
311 */
312CC_NO_UBSAN(function) /* UBSAN: false positive - public vs private connection_t trips --fsanitize=function*/
313static connection_state_t _conn_init(void **h_out, connection_t *conn, UNUSED void *uctx)
314{
315 int *h;
316
317 h = talloc_array(conn, int, 2);
318 socketpair(AF_UNIX, SOCK_STREAM, 0, h);
319
320 fr_nonblock(h[0]);
321 fr_nonblock(h[1]);
322 connection_signal_on_fd(conn, h[0]);
323 *h_out = h;
324
325 return CONNECTION_STATE_CONNECTING;
326}
327
328static connection_t *test_setup_socket_pair_connection_alloc(trunk_connection_t *tconn,
329 fr_event_list_t *el,
330 connection_conf_t const *conn_conf,
331 char const *log_prefix, UNUSED void *uctx)
332{
333 connection_conf_t cstat;
334
335 if (!conn_conf) {
336 memset(&cstat, 0, sizeof(cstat));
337 conn_conf = &cstat;
338 }
339 return connection_alloc(tconn, el,
340 &(connection_funcs_t){
341 .init = _conn_init,
342 .open = _conn_open,
343 .close = _conn_close
344 },
345 conn_conf,
346 log_prefix, tconn);
347}
348
349static int8_t test_preq_cmp(void const *a, void const *b)
350{
351 test_proto_request_t const *preq_a = a;
352 test_proto_request_t const *preq_b = b;
353 return CMP(preq_a->priority, preq_b->priority);
354}
355
356static trunk_t *test_setup_trunk(TALLOC_CTX *ctx, fr_event_list_t *el, trunk_conf_t *conf, bool with_cancel_mux, void *uctx)
357{
358 trunk_io_funcs_t io_funcs = {
359 .connection_alloc = test_setup_socket_pair_connection_alloc,
360 .connection_notify = _conn_notify,
361 .request_prioritise = test_preq_cmp,
362 .request_mux = test_mux,
363 .request_demux = test_demux,
364 .request_cancel = test_request_cancel,
365 .request_complete = test_request_complete,
366 .request_fail = test_request_fail,
367 .request_free = test_request_free
368 };
369
370 /*
371 * Function list is copied, so this is OK.
372 */
373 if (with_cancel_mux) io_funcs.request_cancel_mux = test_cancel_mux;
374
375 return trunk_alloc(ctx, el, &io_funcs, conf, "test_socket_pair", uctx, false);
376}
377
378static void test_socket_pair_alloc_then_free(void)
379{
380 TALLOC_CTX *ctx = talloc_init_const("test");
381 trunk_t *trunk;
382 fr_event_list_t *el;
383 int events;
384
385 trunk_conf_t conf = {
386 .start = 2,
387 .min = 2
388 };
389 trunk_io_funcs_t io_funcs = {
390 .connection_alloc = test_setup_socket_pair_connection_alloc,
391 .request_prioritise = fr_pointer_cmp,
392 };
393
394 DEBUG_LVL_SET;
395
396 el = fr_event_list_alloc(ctx, NULL, NULL);
397
398 fr_timer_list_set_time_func(el->tl, test_time);
399
400 trunk = trunk_alloc(ctx, el, &io_funcs, &conf, "test_socket_pair", NULL, false);
401 TEST_CHECK(trunk != NULL);
402 if (!trunk) return;
403
404 TEST_CHECK(trunk_connection_count_by_state(trunk, TRUNK_CONN_CONNECTING) == 2);
405 events = fr_event_corral(el, test_time_base, true);
406 TEST_CHECK(events == 2); /* Two I/O write events, no timers */
407 fr_event_service(el);
408 TEST_CHECK(trunk_connection_count_by_state(trunk, TRUNK_CONN_ACTIVE) == 2);
409
410 events = fr_event_corral(el, test_time_base, false);
411 TEST_CHECK(events == 0); /* I/O events should have been cleared */
412
413 talloc_free(trunk);
414 talloc_free(ctx);
415}
416
417static void test_socket_pair_alloc_then_reconnect_then_free(void)
418{
419 TALLOC_CTX *ctx = talloc_init_const("test");
420 trunk_t *trunk;
421 fr_event_list_t *el;
422 int events;
423 trunk_conf_t conf = {
424 .start = 2,
425 .min = 2,
426 .conn_conf = &(connection_conf_t){
427 .reconnection_delay = fr_time_delta_from_nsec(NSEC / 2)
428 }
429 };
430 trunk_io_funcs_t io_funcs = {
431 .connection_alloc = test_setup_socket_pair_connection_alloc,
432 .request_prioritise = fr_pointer_cmp,
433 };
434 DEBUG_LVL_SET;
435
436 el = fr_event_list_alloc(ctx, NULL, NULL);
437
438 if (!el) return;
439
440 fr_timer_list_set_time_func(el->tl, test_time);
441
442 trunk = trunk_alloc(ctx, el, &io_funcs, &conf, "test_socket_pair", NULL, false);
443 TEST_CHECK(trunk != NULL);
444 if (!trunk) return;
445
446 events = fr_event_corral(el, test_time_base, true);
447 TEST_CHECK(events == 2); /* Two I/O write events, no timers */
448 TEST_CHECK(trunk_connection_count_by_state(trunk, TRUNK_CONN_CONNECTING) == 2);
449 fr_event_service(el);
450 TEST_CHECK(trunk_connection_count_by_state(trunk, TRUNK_CONN_ACTIVE) == 2);
451
452 events = fr_event_corral(el, test_time_base, false);
453 TEST_CHECK(events == 0); /* I/O events should have been cleared */
454 TEST_MSG("Got %u events", events);
455
456 trunk_reconnect(trunk, TRUNK_CONN_ACTIVE, CONNECTION_FAILED);
457
458 test_time_base = fr_time_add_time_delta(test_time_base, fr_time_delta_from_sec(2));
459 events = fr_event_corral(el, test_time_base, true);
460 TEST_CHECK(events == 1); /* Two timer events but event loops only adds one to the total*/
461 TEST_MSG("Got %u events", events);
462 fr_event_service(el);
463
464 TEST_CHECK(trunk_connection_count_by_state(trunk, TRUNK_CONN_CONNECTING) == 2);
465
466 events = fr_event_corral(el, test_time_base, true);
467 TEST_CHECK(events == 2); /* Two I/O write events, no timers */
468 fr_event_service(el);
469
470 TEST_CHECK(trunk_connection_count_by_state(trunk, TRUNK_CONN_ACTIVE) == 2);
471 events = fr_event_corral(el, test_time_base, false);
472 TEST_CHECK(events == 0); /* I/O events should have been cleared */
473
474 talloc_free(trunk);
475 talloc_free(ctx);
476}
477
478CC_NO_UBSAN(function) /* UBSAN: false positive - public vs private connection_t trips --fsanitize=function*/
479static connection_state_t _conn_init_no_signal(void **h_out, connection_t *conn, UNUSED void *uctx)
480{
481 int *h;
482
483 h = talloc_array(conn, int, 2);
484 socketpair(AF_UNIX, SOCK_STREAM, 0, h);
485 *h_out = h;
486
487 return CONNECTION_STATE_CONNECTING;
488}
489
490static connection_t *test_setup_socket_pair_1s_timeout_connection_alloc(trunk_connection_t *tconn,
491 fr_event_list_t *el,
492 UNUSED connection_conf_t const *conf,
493 char const *log_prefix, void *uctx)
494{
495 return connection_alloc(tconn, el,
496 &(connection_funcs_t){
497 .init = _conn_init_no_signal,
498 .open = _conn_open,
499 .close = _conn_close
500 },
501 &(connection_conf_t){
502 .connection_timeout = fr_time_delta_from_sec(1),
503 .reconnection_delay = fr_time_delta_from_sec(1)
504 },
505 log_prefix, uctx);
506}
507
508static void test_socket_pair_alloc_then_connect_timeout(void)
509{
510 TALLOC_CTX *ctx = talloc_init_const("test");
511 trunk_t *trunk;
512 fr_event_list_t *el;
513 int events;
514 trunk_connection_t *tconn;
515 trunk_conf_t conf = {
516 .start = 1,
517 .min = 1
518 };
519 trunk_io_funcs_t io_funcs = {
520 .connection_alloc = test_setup_socket_pair_1s_timeout_connection_alloc,
521 .request_prioritise = fr_pointer_cmp,
522 };
523
524 DEBUG_LVL_SET;
525
526 el = fr_event_list_alloc(ctx, NULL, NULL);
527
528 fr_timer_list_set_time_func(el->tl, test_time);
529
530
531 trunk = trunk_alloc(ctx, el, &io_funcs, &conf, "test_socket_pair", NULL, false);
532 TEST_CHECK(trunk != NULL);
533 if (!trunk) return;
534
535 /*
536 * Trigger connection timeout
537 */
538 test_time_base = fr_time_add_time_delta(test_time_base, fr_time_delta_from_nsec(NSEC * 1.5));
539 TEST_CHECK(fr_event_list_num_timers(el) == 1); /* One timer event for the connection timeout */
540 events = fr_event_corral(el, test_time_base, true);
541 TEST_CHECK(events == 1); /* We didn't install the I/O events */
542
543 tconn = fr_dlist_head(&trunk->connecting);
544 TEST_CHECK(tconn != NULL);
545 if (tconn == NULL) return;
546
547 TEST_CHECK(connection_get_num_timed_out(tconn->pub.conn) == 0);
548 TEST_CHECK(connection_get_num_reconnected(tconn->pub.conn) == 0);
549
550 /*
551 * Timeout should now fire
552 */
553 fr_event_service(el);
554
555 /*
556 * Connection delay not implemented for timed out connections
557 */
558 TEST_CHECK(connection_get_num_timed_out(tconn->pub.conn) == 1);
559 TEST_CHECK(connection_get_num_reconnected(tconn->pub.conn) == 1);
560
561 events = fr_event_corral(el, test_time_base, false);
562 TEST_CHECK(events == 0); /* I/O events should have been cleared */
563
564 talloc_free(trunk);
565 talloc_free(ctx);
566}
567
568static connection_t *test_setup_socket_pair_1s_reconnection_delay_alloc(trunk_connection_t *tconn,
569 fr_event_list_t *el,
570 UNUSED connection_conf_t const *conn_conf,
571 char const *log_prefix, void *uctx)
572{
573 return connection_alloc(tconn, el,
574 &(connection_funcs_t){
575 .init = _conn_init,
576 .open = _conn_open,
577 .close = _conn_close
578 },
579 &(connection_conf_t){
580 .connection_timeout = fr_time_delta_from_sec(1),
581 .reconnection_delay = fr_time_delta_from_sec(1)
582 },
583 log_prefix, uctx);
584}
585
586static void test_socket_pair_alloc_then_reconnect_check_delay(void)
587{
588 TALLOC_CTX *ctx = talloc_init_const("test");
589 trunk_t *trunk;
590 fr_event_list_t *el;
591 int events;
592 trunk_connection_t *tconn;
593 trunk_conf_t conf = {
594 .start = 1,
595 .min = 1,
596 .conn_conf = &(connection_conf_t){
597 .reconnection_delay = fr_time_delta_from_sec(1),
598 .connection_timeout = fr_time_delta_from_sec(1)
599 }
600 };
601 trunk_io_funcs_t io_funcs = {
602 .connection_alloc = test_setup_socket_pair_1s_reconnection_delay_alloc,
603 .request_prioritise = fr_pointer_cmp,
604 };
605
606 DEBUG_LVL_SET;
607
608 el = fr_event_list_alloc(ctx, NULL, NULL);
609 fr_timer_list_set_time_func(el->tl, test_time);
610
611 trunk = trunk_alloc(ctx, el, &io_funcs, &conf, "test_socket_pair", NULL, false);
612 TEST_CHECK(trunk != NULL);
613 if (!trunk) return;
614
615 /*
616 * Trigger connection timeout
617 */
618 test_time_base = fr_time_add_time_delta(test_time_base, fr_time_delta_from_nsec(NSEC * 1.5));
619 TEST_CHECK(fr_event_list_num_timers(el) == 1); /* One timer event for the connection timeout */
620 events = fr_event_corral(el, test_time_base, true);
621 TEST_CHECK(events == 2); /* We didn't install the I/O events */
622 fr_event_service(el);
623
624 tconn = fr_minmax_heap_min_peek(trunk->active);
625 TEST_CHECK(tconn != NULL);
626 if (tconn == NULL) return;
627
628 TEST_CHECK(connection_get_num_timed_out(tconn->pub.conn) == 0);
629 TEST_CHECK(connection_get_num_reconnected(tconn->pub.conn) == 0);
630
631 /*
632 * Trigger reconnection
633 */
634 connection_signal_reconnect(tconn->pub.conn, CONNECTION_FAILED);
635 test_time_base = fr_time_add_time_delta(test_time_base, fr_time_delta_from_nsec(NSEC * 0.5));
636
637 events = fr_event_corral(el, test_time_base, false);
638 TEST_CHECK(events == 0); /* Reconnect delay not ready to fire yet, no I/O handlers installed */
639 TEST_CHECK(fr_event_list_num_timers(el) == 1); /* One timer event for reconnect delay */
640
641 test_time_base = fr_time_add_time_delta(test_time_base, fr_time_delta_from_sec(1));
642 events = fr_event_corral(el, test_time_base, false);
643 TEST_CHECK(events == 1); /* Reconnect delay should now be ready to fire */
644
645 fr_event_service(el); /* Services the timer, which then triggers init */
646
647 TEST_CHECK(connection_get_num_timed_out(tconn->pub.conn) == 0);
648 TEST_CHECK(connection_get_num_reconnected(tconn->pub.conn) == 1);
649
650 events = fr_event_corral(el, test_time_base, true);
651 TEST_CHECK(events == 1); /* Should have a pending I/O event and a timer */
652
653 talloc_free(trunk);
654 talloc_free(ctx);
655}
656
657/*
658 * Test basic enqueue and dequeue
659 */
660static void test_enqueue_basic(void)
661{
662 TALLOC_CTX *ctx = talloc_init_const("test");
663 trunk_t *trunk;
664 fr_event_list_t *el;
665 trunk_conf_t conf = {
666 .start = 1,
667 .min = 1,
668 .manage_interval = fr_time_delta_from_nsec(NSEC * 0.5)
669 };
670 test_proto_request_t *preq;
671 trunk_request_t *treq = NULL;
672 trunk_enqueue_t rcode;
673
674 DEBUG_LVL_SET;
675
676 el = fr_event_list_alloc(ctx, NULL, NULL);
677 fr_timer_list_set_time_func(el->tl, test_time);
678
679 trunk = test_setup_trunk(ctx, el, &conf, true, NULL);
680
681 /*
682 * Our preq is a pointer to the trunk
683 * request so we don't have to manage
684 * a tree of requests and responses.
685 */
686 preq = talloc_zero(NULL, test_proto_request_t);
687
688 /*
689 * The trunk is active, but there's no
690 * connections.
691 *
692 * We're under the current request limit
693 * so the request should enter the
694 * backlog.
695 */
696 rcode = trunk_request_enqueue(&treq, trunk, NULL, preq, NULL);
697 preq->treq = treq;
698 TEST_CHECK(rcode == TRUNK_ENQUEUE_IN_BACKLOG);
699
700 TEST_CHECK(trunk_request_count_by_state(trunk, TRUNK_CONN_ALL, TRUNK_REQUEST_STATE_BACKLOG) == 1);
701
702 /*
703 * Allow the connection to establish
704 */
705 fr_event_corral(el, test_time_base, false);
706 fr_event_service(el);
707
708 TEST_CHECK(trunk_request_count_by_state(trunk, TRUNK_CONN_ALL, TRUNK_REQUEST_STATE_BACKLOG) == 0);
709 TEST_CHECK(trunk_request_count_by_state(trunk, TRUNK_CONN_ALL, TRUNK_REQUEST_STATE_PENDING) == 1);
710
711 /*
712 * Should now be active and have a write event
713 * inserted into the event loop.
714 */
715 TEST_CHECK(trunk_connection_count_by_state(trunk, TRUNK_CONN_ACTIVE) == 1);
716
717 /*
718 * Trunk should be signalled the connection is
719 * writable.
720 *
721 * We should then:
722 * - Pop a request from the pending queue.
723 * - Write the request to the socket pair
724 */
725 fr_event_corral(el, test_time_base, false);
726 fr_event_service(el);
727
728 TEST_CHECK(trunk_request_count_by_state(trunk, TRUNK_CONN_ALL, TRUNK_REQUEST_STATE_SENT) == 1);
729
730 /*
731 * Gives the loopback function a chance
732 * to read the data, and write it back.
733 */
734 fr_event_corral(el, test_time_base, false);
735 fr_event_service(el);
736
737 /*
738 * Trunk should be signalled the connection is
739 * readable.
740 *
741 * We should then:
742 * - Read the (looped back) response.
743 * - Signal the trunk that the connection is readable.
744 */
745 fr_event_corral(el, test_time_base, false);
746 fr_event_service(el);
747
748 TEST_CHECK(preq->completed == true);
749 TEST_CHECK(preq->failed == false);
750 TEST_CHECK(preq->cancelled == false);
751 TEST_CHECK(preq->freed == true);
752 talloc_free(preq);
753
754 talloc_free(trunk);
755 talloc_free(ctx);
756}
757
758/*
759 * Test request cancellations when the connection is in various states
760 */
761static void test_enqueue_cancellation_points(void)
762{
763 TALLOC_CTX *ctx = talloc_init_const("test");
764 trunk_t *trunk;
765 fr_event_list_t *el;
766 trunk_conf_t conf = {
767 .start = 1,
768 .min = 1,
769 .manage_interval = fr_time_delta_from_nsec(NSEC * 0.5)
770 };
771 test_proto_request_t *preq;
772 trunk_request_t *treq = NULL;
773
774 DEBUG_LVL_SET;
775
776 el = fr_event_list_alloc(ctx, NULL, NULL);
777 fr_timer_list_set_time_func(el->tl, test_time);
778
779 trunk = test_setup_trunk(ctx, el, &conf, false, NULL);
780 preq = talloc_zero(NULL, test_proto_request_t);
781 trunk_request_enqueue(&treq, trunk, NULL, preq, NULL);
782
783 TEST_CASE("cancellation via trunk free - TRUNK_REQUEST_STATE_BACKLOG");
784 talloc_free(trunk);
785 TEST_CHECK(preq->completed == false);
786 TEST_CHECK(preq->failed == true);
787 TEST_CHECK(preq->cancelled == false);
788 TEST_CHECK(preq->freed == true);
789 talloc_free(preq);
790
791 TEST_CASE("cancellation via signal - TRUNK_REQUEST_STATE_BACKLOG");
792 trunk = test_setup_trunk(ctx, el, &conf, false, NULL);
793 preq = talloc_zero(NULL, test_proto_request_t);
794 treq = NULL;
795 trunk_request_enqueue(&treq, trunk, NULL, preq, NULL);
796 preq->treq = treq;
797 trunk_request_signal_cancel(treq);
798 TEST_CHECK(trunk_request_count_by_state(trunk, TRUNK_CONN_ALL, TRUNK_REQUEST_STATE_ALL) == 0);
799
800 TEST_CHECK(preq->completed == false);
801 TEST_CHECK(preq->failed == false); /* Request/rctx not guaranteed after signal, so can't call fail */
802 TEST_CHECK(preq->cancelled == false);
803 TEST_CHECK(preq->freed == true);
804 talloc_free(preq);
805 talloc_free(trunk);
806
807 TEST_CASE("cancellation via trunk free - TRUNK_REQUEST_STATE_PARTIAL");
808 trunk = test_setup_trunk(ctx, el, &conf, false, NULL);
809 preq = talloc_zero(NULL, test_proto_request_t);
810 preq->signal_partial = true;
811 treq = NULL;
812 trunk_request_enqueue(&treq, trunk, NULL, preq, NULL);
813 preq->treq = treq;
814
815 fr_event_corral(el, test_time_base, false); /* Connect the connection */
816 fr_event_service(el);
817
818 fr_event_corral(el, test_time_base, false); /* Send the request */
819 fr_event_service(el);
820
821 TEST_CHECK(trunk_request_count_by_state(trunk, TRUNK_CONN_ALL, TRUNK_REQUEST_STATE_PARTIAL));
822
823 talloc_free(trunk);
824
825 TEST_CHECK(preq->completed == false);
826 TEST_CHECK(preq->failed == true);
827 TEST_CHECK(preq->cancelled == true);
828 TEST_CHECK(preq->freed == true);
829 talloc_free(preq);
830
831 TEST_CASE("cancellation via signal - TRUNK_REQUEST_STATE_PARTIAL");
832 trunk = test_setup_trunk(ctx, el, &conf, false, NULL);
833 preq = talloc_zero(NULL, test_proto_request_t);
834 preq->signal_partial = true;
835 treq = NULL;
836 trunk_request_enqueue(&treq, trunk, NULL, preq, NULL);
837 preq->treq = treq;
838
839 fr_event_corral(el, test_time_base, false); /* Connect the connection */
840 fr_event_service(el);
841
842 fr_event_corral(el, test_time_base, false); /* Send the request */
843 fr_event_service(el);
844
845 TEST_CHECK(trunk_request_count_by_state(trunk, TRUNK_CONN_ALL, TRUNK_REQUEST_STATE_PARTIAL) == 1);
846 trunk_request_signal_cancel(treq);
847 TEST_CHECK(trunk_request_count_by_state(trunk, TRUNK_CONN_ALL, TRUNK_REQUEST_STATE_ALL) == 0);
848
849 TEST_CHECK(preq->completed == false);
850 TEST_CHECK(preq->failed == false); /* Request/rctx not guaranteed after signal, so can't call fail */
851 TEST_CHECK(preq->cancelled == true);
852 TEST_CHECK(preq->freed == true);
853 talloc_free(preq);
854 talloc_free(trunk);
855
856 TEST_CASE("cancellation via trunk free - TRUNK_REQUEST_STATE_SENT");
857 trunk = test_setup_trunk(ctx, el, &conf, false, NULL);
858 preq = talloc_zero(NULL, test_proto_request_t);
859 treq = NULL;
860 trunk_request_enqueue(&treq, trunk, NULL, preq, NULL);
861 preq->treq = treq;
862
863 fr_event_corral(el, test_time_base, false); /* Connect the connection */
864 fr_event_service(el);
865
866 fr_event_corral(el, test_time_base, false); /* Send the request */
867 fr_event_service(el);
868
869 TEST_CHECK(trunk_request_count_by_state(trunk, TRUNK_CONN_ALL, TRUNK_REQUEST_STATE_SENT) == 1);
870 talloc_free(trunk);
871
872 TEST_CHECK(preq->completed == false);
873 TEST_CHECK(preq->failed == true);
874 TEST_CHECK(preq->cancelled == true);
875 TEST_CHECK(preq->freed == true);
876 talloc_free(preq);
877
878 TEST_CASE("cancellation via signal - TRUNK_REQUEST_STATE_SENT");
879 trunk = test_setup_trunk(ctx, el, &conf, false, NULL);
880 preq = talloc_zero(NULL, test_proto_request_t);
881 treq = NULL;
882 trunk_request_enqueue(&treq, trunk, NULL, preq, NULL);
883 preq->treq = treq;
884
885 fr_event_corral(el, test_time_base, false); /* Connect the connection */
886 fr_event_service(el);
887
888 fr_event_corral(el, test_time_base, false); /* Send the request */
889 fr_event_service(el);
890
891 TEST_CHECK(trunk_request_count_by_state(trunk, TRUNK_CONN_ALL, TRUNK_REQUEST_STATE_SENT) == 1);
892 trunk_request_signal_cancel(treq);
893 TEST_CHECK(trunk_request_count_by_state(trunk, TRUNK_CONN_ALL, TRUNK_REQUEST_STATE_ALL) == 0);
894
895 TEST_CHECK(preq->completed == false);
896 TEST_CHECK(preq->failed == false); /* Request/rctx not guaranteed after signal, so can't call fail */
897 TEST_CHECK(preq->cancelled == true);
898 TEST_CHECK(preq->freed == true);
899 talloc_free(preq);
900 talloc_free(trunk);
901
902 TEST_CASE("cancellation via trunk free - TRUNK_REQUEST_STATE_CANCEL_PARTIAL");
903 trunk = test_setup_trunk(ctx, el, &conf, true, NULL);
904 preq = talloc_zero(NULL, test_proto_request_t);
905 preq->signal_cancel_partial = true;
906 treq = NULL;
907 trunk_request_enqueue(&treq, trunk, NULL, preq, NULL);
908 preq->treq = treq;
909
910 fr_event_corral(el, test_time_base, false); /* Connect the connection */
911 fr_event_service(el);
912
913 fr_event_corral(el, test_time_base, false); /* Send the request */
914 fr_event_service(el);
915
916 TEST_CHECK(trunk_request_count_by_state(trunk, TRUNK_CONN_ALL, TRUNK_REQUEST_STATE_SENT) == 1);
917 trunk_request_signal_cancel(treq);
918 TEST_CHECK(trunk_request_count_by_state(trunk, TRUNK_CONN_ALL, TRUNK_REQUEST_STATE_CANCEL) == 1);
919
920 fr_event_corral(el, test_time_base, false); /* Send the cancellation request */
921 fr_event_service(el);
922
923 TEST_CHECK(trunk_request_count_by_state(trunk, TRUNK_CONN_ALL, TRUNK_REQUEST_STATE_CANCEL_PARTIAL) == 1);
924
925 talloc_free(trunk);
926
927 TEST_CHECK(preq->completed == false);
928 TEST_CHECK(preq->failed == false);
929 TEST_CHECK(preq->cancelled == true);
930 TEST_CHECK(preq->freed == true);
931 talloc_free(preq);
932
933 TEST_CASE("cancellation via trunk free - TRUNK_REQUEST_STATE_CANCEL_SENT");
934 trunk = test_setup_trunk(ctx, el, &conf, true, NULL);
935 preq = talloc_zero(NULL, test_proto_request_t);
936 treq = NULL;
937 trunk_request_enqueue(&treq, trunk, NULL, preq, NULL);
938 preq->treq = treq;
939
940 fr_event_corral(el, test_time_base, false); /* Connect the connection */
941 fr_event_service(el);
942
943 fr_event_corral(el, test_time_base, false); /* Send the request */
944 fr_event_service(el);
945
946 TEST_CHECK(trunk_request_count_by_state(trunk, TRUNK_CONN_ALL, TRUNK_REQUEST_STATE_SENT) == 1);
947 trunk_request_signal_cancel(treq);
948 TEST_CHECK(trunk_request_count_by_state(trunk, TRUNK_CONN_ALL, TRUNK_REQUEST_STATE_CANCEL) == 1);
949
950 fr_event_corral(el, test_time_base, false); /* Send the cancellation request */
951 fr_event_service(el);
952
953 TEST_CHECK(trunk_request_count_by_state(trunk, TRUNK_CONN_ALL, TRUNK_REQUEST_STATE_CANCEL_SENT) == 1);
954
955 talloc_free(trunk);
956
957 TEST_CHECK(preq->completed == false);
958 TEST_CHECK(preq->failed == false);
959 TEST_CHECK(preq->cancelled == true);
960 TEST_CHECK(preq->freed == true);
961 talloc_free(preq);
962
963 TEST_CASE("trunk free after TRUNK_REQUEST_STATE_CANCEL_COMPLETE");
964 trunk = test_setup_trunk(ctx, el, &conf, true, NULL);
965 preq = talloc_zero(NULL, test_proto_request_t);
966 treq = NULL;
967 trunk_request_enqueue(&treq, trunk, NULL, preq, NULL);
968 preq->treq = treq;
969
970 fr_event_corral(el, test_time_base, false); /* Connect the connection */
971 fr_event_service(el);
972
973 fr_event_corral(el, test_time_base, false); /* Send the request */
974 fr_event_service(el);
975
976 TEST_CHECK(trunk_request_count_by_state(trunk, TRUNK_CONN_ALL, TRUNK_REQUEST_STATE_SENT) == 1);
977 trunk_request_signal_cancel(treq);
978 TEST_CHECK(trunk_request_count_by_state(trunk, TRUNK_CONN_ALL, TRUNK_REQUEST_STATE_CANCEL) == 1);
979
980 fr_event_corral(el, test_time_base, false); /* Send the cancellation request */
981 fr_event_service(el);
982
983 TEST_CHECK(trunk_request_count_by_state(trunk, TRUNK_CONN_ALL, TRUNK_REQUEST_STATE_CANCEL_SENT) == 1);
984
985 fr_event_corral(el, test_time_base, false); /* Loop the cancel request back round */
986 fr_event_service(el);
987
988 fr_event_corral(el, test_time_base, false); /* Read the cancel ACK (such that it is) */
989 fr_event_service(el);
990
991 TEST_CHECK(trunk_request_count_by_state(trunk, TRUNK_CONN_ALL, TRUNK_REQUEST_STATE_ALL) == 0);
992
993 talloc_free(trunk);
994
995 TEST_CHECK(preq->completed == false);
996 TEST_CHECK(preq->failed == false);
997 TEST_CHECK(preq->cancelled == true);
998 TEST_CHECK(preq->freed == true);
999 talloc_free(preq);
1000
1001
1002 talloc_free(ctx);
1003}
1004
1005/*
1006 * Test PARTIAL -> SENT and CANCEL-PARTIAL -> CANCEL-SENT
1007 */
1008static void test_partial_to_complete_states(void)
1009{
1010 TALLOC_CTX *ctx = talloc_init_const("test");
1011 trunk_t *trunk;
1012 fr_event_list_t *el;
1013 trunk_conf_t conf = {
1014 .start = 1,
1015 .min = 1,
1016 .manage_interval = fr_time_delta_from_nsec(NSEC * 0.5)
1017 };
1018 test_proto_request_t *preq;
1019 trunk_request_t *treq = NULL;
1020
1021 DEBUG_LVL_SET;
1022
1023 el = fr_event_list_alloc(ctx, NULL, NULL);
1024 fr_timer_list_set_time_func(el->tl, test_time);
1025
1026 trunk = test_setup_trunk(ctx, el, &conf, true, NULL);
1027 preq = talloc_zero(NULL, test_proto_request_t);
1028 preq->signal_partial = true;
1029 preq->signal_cancel_partial = true;
1030
1031 TEST_CASE("TRUNK_REQUEST_STATE_PARTIAL -> TRUNK_REQUEST_STATE_SENT");
1032
1033 trunk_request_enqueue(&treq, trunk, NULL, preq, NULL);
1034 preq->treq = treq;
1035
1036 fr_event_corral(el, test_time_base, false); /* Connect the connection */
1037 fr_event_service(el);
1038
1039 fr_event_corral(el, test_time_base, false); /* Send the request */
1040 fr_event_service(el);
1041
1042 TEST_CHECK(trunk_request_count_by_state(trunk, TRUNK_CONN_ALL, TRUNK_REQUEST_STATE_PARTIAL) == 1);
1043
1044 fr_event_corral(el, test_time_base, false); /* Complete the partial request */
1045 fr_event_service(el);
1046
1047 TEST_CHECK(trunk_request_count_by_state(trunk, TRUNK_CONN_ALL, TRUNK_REQUEST_STATE_SENT) == 1);
1048
1049 trunk_request_signal_cancel(treq);
1050 TEST_CHECK(trunk_request_count_by_state(trunk, TRUNK_CONN_ALL, TRUNK_REQUEST_STATE_CANCEL) == 1);
1051
1052 TEST_CASE("TRUNK_REQUEST_STATE_CANCEL_PARTIAL -> TRUNK_REQUEST_STATE_CANCEL_SENT");
1053
1054 fr_event_corral(el, test_time_base, false); /* Send partial cancel request */
1055 fr_event_service(el);
1056
1057 TEST_CHECK(trunk_request_count_by_state(trunk, TRUNK_CONN_ALL, TRUNK_REQUEST_STATE_CANCEL_PARTIAL) == 1);
1058
1059 fr_event_corral(el, test_time_base, false); /* Complete the partial cancellation */
1060 fr_event_service(el);
1061
1062 TEST_CHECK(trunk_request_count_by_state(trunk, TRUNK_CONN_ALL, TRUNK_REQUEST_STATE_CANCEL_SENT) == 1);
1063
1064 fr_event_corral(el, test_time_base, false); /* Loop the cancellation request back */
1065 fr_event_service(el);
1066
1067 TEST_CHECK(trunk_request_count_by_state(trunk, TRUNK_CONN_ALL, TRUNK_REQUEST_STATE_ALL) == 0);
1068
1069 talloc_free(trunk);
1070
1071 TEST_CHECK(preq->completed == false);
1072 TEST_CHECK(preq->failed == false);
1073 TEST_CHECK(preq->cancelled == true);
1074 TEST_CHECK(preq->freed == true);
1075 talloc_free(preq);
1076
1077 talloc_free(ctx);
1078}
1079
1080/*
1081 * Test calling reconnect with requests in each different state
1082 */
1083static void test_requeue_on_reconnect(void)
1084{
1085 TALLOC_CTX *ctx = talloc_init_const("test");
1086 trunk_t *trunk;
1087 fr_event_list_t *el;
1088 trunk_conf_t conf = {
1089 .start = 2,
1090 .min = 2,
1091 .manage_interval = fr_time_delta_from_nsec(NSEC * 0.5),
1092 .conn_conf = &(connection_conf_t){
1093 .reconnection_delay = fr_time_delta_from_nsec(NSEC / 10)
1094 },
1095 .backlog_on_failed_conn = true
1096 };
1097 test_proto_request_t *preq;
1098 trunk_request_t *treq = NULL;
1099 trunk_connection_t *tconn;
1100
1101 DEBUG_LVL_SET;
1102 fr_talloc_fault_setup();
1103
1104 el = fr_event_list_alloc(ctx, NULL, NULL);
1105 fr_timer_list_set_time_func(el->tl, test_time);
1106
1107 trunk = test_setup_trunk(ctx, el, &conf, true, NULL);
1108 preq = talloc_zero(ctx, test_proto_request_t);
1109 preq->signal_partial = true;
1110 preq->signal_cancel_partial = true;
1111
1112 fr_event_corral(el, test_time_base, false); /* Connect the connection(s) */
1113 fr_event_service(el);
1114
1115 TEST_CASE("dequeue on reconnect - TRUNK_REQUEST_STATE_PENDING");
1116
1117 TEST_CHECK_LEN(trunk_connection_count_by_state(trunk, TRUNK_CONN_ACTIVE), 2);
1118
1119 trunk_request_enqueue(&treq, trunk, NULL, preq, NULL);
1120 preq->treq = treq;
1121
1122 tconn = treq->pub.tconn; /* Store the conn the request was assigned to */
1123 TEST_CHECK_LEN(trunk_request_count_by_state(trunk, TRUNK_CONN_ALL, TRUNK_REQUEST_STATE_PENDING), 1);
1124
1125 trunk_connection_signal_reconnect(tconn, CONNECTION_FAILED);
1126
1127 /*
1128 * Should be reassigned to the other connection
1129 */
1130 TEST_CHECK(tconn != treq->pub.tconn);
1131 TEST_CHECK_LEN(trunk_request_count_by_state(trunk, TRUNK_CONN_ALL, TRUNK_REQUEST_STATE_PENDING), 1);
1132
1133 /*
1134 * Should be reassigned to the backlog
1135 */
1136 trunk_connection_signal_reconnect(treq->pub.tconn, CONNECTION_FAILED);
1137 TEST_CHECK_LEN(trunk_request_count_by_state(trunk, TRUNK_CONN_ALL, TRUNK_REQUEST_STATE_BACKLOG), 1);
1138 TEST_CHECK(!treq->pub.tconn);
1139
1140 TEST_CASE("cancel on reconnect - TRUNK_REQUEST_STATE_PARTIAL");
1141
1142 /*
1143 * Allow the connections to reconnect
1144 */
1145 test_time_base = fr_time_add_time_delta(test_time_base, fr_time_delta_from_sec(1));
1146 fr_event_corral(el, test_time_base, false);
1147 fr_event_service(el); /* run management function */
1148 fr_event_corral(el, test_time_base, false);
1149 fr_event_service(el); /* service any I/O callbacks */
1150
1151 /*
1152 * Request should now be assigned back to one of the reconnected
1153 * connections.
1154 */
1155 TEST_CHECK_LEN(trunk_request_count_by_state(trunk, TRUNK_CONN_ALL, TRUNK_REQUEST_STATE_PENDING), 1);
1156 TEST_CHECK(treq->pub.tconn != NULL);
1157
1158 test_time_base = fr_time_add_time_delta(test_time_base, fr_time_delta_from_sec(1));
1159 fr_event_corral(el, test_time_base, false); /* Send the request (partially) */
1160 fr_event_service(el);
1161
1162 TEST_CHECK_LEN(trunk_request_count_by_state(trunk, TRUNK_CONN_ALL, TRUNK_REQUEST_STATE_PARTIAL), 1);
1163
1164 /*
1165 * Reconnect the connection.
1166 *
1167 * preq should pass through the cancel function,
1168 * then be re-assigned.
1169 */
1170 tconn = treq->pub.tconn;
1171 trunk_connection_signal_reconnect(treq->pub.tconn, CONNECTION_FAILED);
1172
1173 TEST_CHECK(preq->completed == false);
1174 TEST_CHECK(preq->failed == false);
1175 TEST_CHECK(preq->cancelled == true);
1176 TEST_CHECK(preq->freed == false);
1177
1178 preq->cancelled = false; /* Reset */
1179
1180 TEST_CHECK_LEN(trunk_request_count_by_state(trunk, TRUNK_CONN_ALL, TRUNK_REQUEST_STATE_PENDING), 1);
1181 TEST_CHECK(tconn != treq->pub.tconn); /* Ensure it moved */
1182
1183 TEST_CASE("cancel on reconnect - TRUNK_REQUEST_STATE_SENT");
1184
1185 /*
1186 * Sent the request (fully)
1187 */
1188 fr_event_corral(el, test_time_base, false); /* Send the request (partially) */
1189 fr_event_service(el);
1190
1191 /*
1192 * The above indeed appears to send the request partially;
1193 * this appears to be required to send it fully, judging by
1194 * the following check, which fails without it.
1195 */
1196 fr_event_corral(el, test_time_base, false); /* Send the request (partially) */
1197 fr_event_service(el);
1198 TEST_CHECK_LEN(trunk_request_count_by_state(trunk, TRUNK_CONN_ALL, TRUNK_REQUEST_STATE_SENT), 1);
1199
1200 tconn = treq->pub.tconn;
1201 trunk_connection_signal_reconnect(treq->pub.tconn, CONNECTION_FAILED);
1202
1203 TEST_CHECK_LEN(trunk_request_count_by_state(trunk, TRUNK_CONN_ALL, TRUNK_REQUEST_STATE_PENDING), 1);
1204
1205 /*
1206 * Allow the connections to reconnect
1207 * and send the request.
1208 */
1209 test_time_base = fr_time_add_time_delta(test_time_base, fr_time_delta_from_sec(1));
1210 fr_event_corral(el, test_time_base, false);
1211 fr_event_service(el);
1212 TEST_CHECK(tconn != treq->pub.tconn); /* Ensure it moved */
1213
1214 TEST_CHECK(preq->completed == false);
1215 TEST_CHECK(preq->failed == false);
1216 TEST_CHECK(preq->cancelled == true);
1217 TEST_CHECK(preq->freed == false);
1218
1219 preq->cancelled = false; /* Reset */
1220
1221 TEST_CASE("free on reconnect - TRUNK_REQUEST_STATE_CANCEL");
1222
1223 /*
1224 * Signal the request should be cancelled
1225 */
1226 trunk_request_signal_cancel(treq);
1227 TEST_CHECK_LEN(trunk_request_count_by_state(trunk, TRUNK_CONN_ALL, TRUNK_REQUEST_STATE_CANCEL), 1);
1228
1229 /*
1230 * Requests in the cancel state, are
1231 * freed instead of being moved between
1232 * connections.
1233 */
1234 trunk_connection_signal_reconnect(tconn, CONNECTION_FAILED); /* treq->pub.tconn, now invalid due to cancel */
1235
1236 test_time_base = fr_time_add_time_delta(test_time_base, fr_time_delta_from_sec(1));
1237 fr_event_corral(el, test_time_base, false);
1238 fr_event_service(el);
1239
1240 test_time_base = fr_time_add_time_delta(test_time_base, fr_time_delta_from_sec(1));
1241 fr_event_corral(el, test_time_base, false);
1242 fr_event_service(el);
1243
1244 test_time_base = fr_time_add_time_delta(test_time_base, fr_time_delta_from_sec(1));
1245 fr_event_corral(el, test_time_base, false);
1246 fr_event_service(el);
1247
1248 TEST_CHECK(preq->completed == false);
1249 TEST_CHECK(preq->failed == false);
1250 TEST_CHECK(preq->cancelled == true);
1251 TEST_CHECK(preq->freed == true);
1252
1253 /*
1254 * Allow the connection we just reconnected
1255 * to open so it doesn't interfere with
1256 * the next test.
1257 */
1258 test_time_base = fr_time_add_time_delta(test_time_base, fr_time_delta_from_sec(1));
1259 fr_event_corral(el, test_time_base, false);
1260 fr_event_service(el);
1261
1262 TEST_CASE("free on reconnect - TRUNK_REQUEST_STATE_CANCEL_PARTIAL");
1263
1264 /*
1265 * Queue up a new request, and get it to the cancel-partial state.
1266 */
1267 preq = talloc_zero(ctx, test_proto_request_t);
1268 preq->signal_cancel_partial = true;
1269 treq = NULL;
1270 trunk_request_enqueue(&treq, trunk, NULL, preq, NULL);
1271 preq->treq = treq;
1272
1273 TEST_CHECK_LEN(trunk_request_count_by_state(trunk, TRUNK_CONN_ALL, TRUNK_REQUEST_STATE_PENDING), 1);
1274
1275 /*
1276 * Sent the request (fully)
1277 */
1278 test_time_base = fr_time_add_time_delta(test_time_base, fr_time_delta_from_sec(1));
1279 fr_event_corral(el, test_time_base, false); /* Send the request (fully) */
1280 fr_event_service(el);
1281
1282 TEST_CHECK_LEN(trunk_request_count_by_state(trunk, TRUNK_CONN_ALL, TRUNK_REQUEST_STATE_SENT), 1);
1283 trunk_request_signal_cancel(treq); /* Cancel the request */
1284
1285 TEST_CHECK_LEN(trunk_request_count_by_state(trunk, TRUNK_CONN_ALL, TRUNK_REQUEST_STATE_CANCEL), 1);
1286
1287 /*
1288 * Transition to cancel partial
1289 */
1290 test_time_base = fr_time_add_time_delta(test_time_base, fr_time_delta_from_sec(1));
1291 fr_event_corral(el, test_time_base, false);
1292 fr_event_service(el);
1293
1294 TEST_CHECK_LEN(trunk_request_count_by_state(trunk, TRUNK_CONN_ALL, TRUNK_REQUEST_STATE_CANCEL_PARTIAL), 1);
1295
1296 /*
1297 * Trigger a reconnection
1298 */
1299 trunk_connection_signal_reconnect(treq->pub.tconn, CONNECTION_FAILED);
1300
1301 test_time_base = fr_time_add_time_delta(test_time_base, fr_time_delta_from_sec(1));
1302 fr_event_corral(el, test_time_base, false);
1303 fr_event_service(el);
1304
1305 TEST_CHECK(preq->completed == false);
1306 TEST_CHECK(preq->failed == false);
1307 TEST_CHECK(preq->cancelled == true);
1308 TEST_CHECK(preq->freed == true);
1309
1310 /*
1311 * Allow the connection we just reconnected
1312 * top open so it doesn't interfere with
1313 * the next test.
1314 */
1315 test_time_base = fr_time_add_time_delta(test_time_base, fr_time_delta_from_sec(1));
1316 fr_event_corral(el, test_time_base, false);
1317 fr_event_service(el);
1318
1319 TEST_CASE("free on reconnect - TRUNK_REQUEST_STATE_CANCEL_SENT");
1320
1321 /*
1322 * Queue up a new request, and get it to the cancel-sent state.
1323 */
1324 preq = talloc_zero(NULL, test_proto_request_t);
1325 treq = NULL;
1326 trunk_request_enqueue(&treq, trunk, NULL, preq, NULL);
1327 preq->treq = treq;
1328
1329 TEST_CHECK_LEN(trunk_request_count_by_state(trunk, TRUNK_CONN_ALL, TRUNK_REQUEST_STATE_PENDING), 1);
1330
1331 /*
1332 * Sent the request (fully)
1333 */
1334 test_time_base = fr_time_add_time_delta(test_time_base, fr_time_delta_from_sec(1));
1335 fr_event_corral(el, test_time_base, false); /* Send the request (fully) */
1336 fr_event_service(el);
1337
1338 TEST_CHECK_LEN(trunk_request_count_by_state(trunk, TRUNK_CONN_ALL, TRUNK_REQUEST_STATE_SENT), 1);
1339 trunk_request_signal_cancel(treq); /* Cancel the request */
1340
1341 TEST_CHECK_LEN(trunk_request_count_by_state(trunk, TRUNK_CONN_ALL, TRUNK_REQUEST_STATE_CANCEL), 1);
1342
1343 /*
1344 * Transition to cancel
1345 */
1346 test_time_base = fr_time_add_time_delta(test_time_base, fr_time_delta_from_sec(1));
1347 fr_event_corral(el, test_time_base, false);
1348 fr_event_service(el);
1349
1350 TEST_CHECK_LEN(trunk_request_count_by_state(trunk, TRUNK_CONN_ALL, TRUNK_REQUEST_STATE_CANCEL_SENT), 1);
1351
1352 /*
1353 * Trigger a reconnection
1354 */
1355 trunk_connection_signal_reconnect(treq->pub.tconn, CONNECTION_FAILED);
1356
1357 test_time_base = fr_time_add_time_delta(test_time_base, fr_time_delta_from_sec(1));
1358 fr_event_corral(el, test_time_base, false);
1359 fr_event_service(el);
1360
1361 TEST_CHECK(preq->completed == false);
1362 TEST_CHECK(preq->failed == false);
1363 TEST_CHECK(preq->cancelled == true);
1364 TEST_CHECK(preq->freed == true);
1365
1366 talloc_free(preq);
1367
1368 talloc_free(ctx);
1369}
1370
1371static void test_connection_start_on_enqueue(void)
1372{
1373 TALLOC_CTX *ctx = talloc_init_const("test");
1374 trunk_t *trunk;
1375 fr_event_list_t *el;
1376 trunk_conf_t conf = {
1377 .start = 0,
1378 .min = 0, /* No connections on start */
1379 .manage_interval = fr_time_delta_from_nsec(NSEC * 0.5)
1380 };
1381 test_proto_request_t *preq;
1382 trunk_request_t *treq_a = NULL, *treq_b = NULL, *treq_c = NULL;
1383
1384 DEBUG_LVL_SET;
1385
1386 el = fr_event_list_alloc(ctx, NULL, NULL);
1387 fr_timer_list_set_time_func(el->tl, test_time);
1388
1389 /* Need to provide a timer starting value above zero */
1390 test_time_base = fr_time_add_time_delta(test_time_base, fr_time_delta_from_nsec(NSEC * 0.5));
1391
1392 trunk = test_setup_trunk(ctx, el, &conf, true, NULL);
1393 preq = talloc_zero(NULL, test_proto_request_t);
1394
1395 TEST_CASE("C0 - Enqueue should spawn");
1396 trunk_request_enqueue(&treq_a, trunk, NULL, preq, NULL);
1397
1398 /*
1399 * This causes the event associated with the request left on
1400 * the backlog queue to be handled, which (along with the other
1401 * corral; service sequence, makes the checks all pass.
1402 */
1403 fr_event_corral(el, test_time_base, false);
1404 fr_event_service(el);
1405
1406 TEST_CHECK(trunk_connection_count_by_state(trunk, TRUNK_CONN_CONNECTING) == 1);
1407
1408 TEST_CASE("C1 connecting, !max_req_per_conn - Enqueue MUST NOT spawn");
1409 trunk_request_enqueue(&treq_b, trunk, NULL, preq, NULL);
1410
1411 TEST_CHECK(trunk_connection_count_by_state(trunk, TRUNK_CONN_CONNECTING) == 1);
1412
1413 /*
1414 * Allow the connections to open
1415 */
1416 fr_event_corral(el, test_time_base, false);
1417 fr_event_service(el);
1418
1419 TEST_CHECK(trunk_connection_count_by_state(trunk, TRUNK_CONN_ACTIVE) == 1);
1420
1421 TEST_CASE("C1 active, !max_req_per_conn - Enqueue MUST NOT spawn");
1422 trunk_request_enqueue(&treq_c, trunk, NULL, preq, NULL);
1423
1424 TEST_CHECK(trunk_connection_count_by_state(trunk, TRUNK_CONN_ACTIVE) == 1);
1425 TEST_CHECK(trunk_request_count_by_state(trunk, TRUNK_CONN_ALL, TRUNK_REQUEST_STATE_PENDING) == 3);
1426
1427 talloc_free(ctx);
1428 talloc_free(preq);
1429}
1430
1431static void test_connection_rebalance_requests(void)
1432{
1433 TALLOC_CTX *ctx = talloc_init_const("test");
1434 trunk_t *trunk;
1435 fr_event_list_t *el;
1436 trunk_conf_t conf = {
1437 .start = 2,
1438 .min = 2, /* No connections on start */
1439 .manage_interval = fr_time_delta_from_nsec(NSEC * 0.5)
1440 };
1441 test_proto_request_t *preq;
1442 trunk_connection_t *tconn;
1443 trunk_request_t *treq_a = NULL, *treq_b = NULL, *treq_c = NULL;
1444
1445 DEBUG_LVL_SET;
1446
1447 el = fr_event_list_alloc(ctx, NULL, NULL);
1448 fr_timer_list_set_time_func(el->tl, test_time);
1449
1450 trunk = test_setup_trunk(ctx, el, &conf, true, NULL);
1451 preq = talloc_zero(NULL, test_proto_request_t);
1452 printf("Rebalance %p\n", preq);
1453
1454 /*
1455 * Allow the connections to open
1456 */
1457 fr_event_corral(el, test_time_base, false);
1458 fr_event_service(el);
1459
1460 /*
1461 * Mark one of the connections as full, and
1462 * enqueue three requests on the other.
1463 */
1464 tconn = fr_minmax_heap_min_peek(trunk->active);
1465
1466 TEST_CASE("C2 connected, R0 - Signal inactive");
1467 trunk_connection_signal_inactive(tconn);
1468
1469
1470 trunk_request_enqueue(&treq_a, trunk, NULL, preq, NULL);
1471 trunk_request_enqueue(&treq_b, trunk, NULL, preq, NULL);
1472 trunk_request_enqueue(&treq_c, trunk, NULL, preq, NULL);
1473
1474 TEST_CASE("C1 connected, C2 inactive, R3 - Enqueued");
1475 TEST_CHECK(trunk_request_count_by_state(trunk, TRUNK_CONN_ALL, TRUNK_REQUEST_STATE_PENDING) == 3);
1476 TEST_CHECK(trunk_request_count_by_connection(tconn, TRUNK_REQUEST_STATE_ALL) == 0);
1477
1478 /*
1479 * Now mark the previous connection as
1480 * active. It should receive at least
1481 * one of the requests.
1482 */
1483 TEST_CASE("C2 active, R3 - Signal active, should balance");
1484 trunk_connection_signal_active(tconn);
1485
1486 TEST_CHECK(trunk_request_count_by_state(trunk, TRUNK_CONN_ALL, TRUNK_REQUEST_STATE_PENDING) == 3);
1487 TEST_CHECK(trunk_request_count_by_connection(tconn, TRUNK_REQUEST_STATE_ALL) >= 1);
1488
1489 talloc_free(ctx);
1490 talloc_free(preq);
1491}
1492
1493#define ALLOC_REQ(_id) \
1494do { \
1495 treq_##_id = trunk_request_alloc(trunk, NULL); \
1496 preq_##_id = talloc_zero(ctx, test_proto_request_t); \
1497 preq_##_id->treq = treq_##_id; \
1498 preq_##_id->priority = next_prio++; \
1499} while (0)
1500
1501static void test_connection_levels_max(void)
1502{
1503 TALLOC_CTX *ctx = talloc_init_const("test");
1504 trunk_t *trunk;
1505 fr_event_list_t *el;
1506 trunk_conf_t conf = {
1507 .start = 0, /* No connections on start */
1508 .min = 0,
1509 .max = 2,
1510 .max_req_per_conn = 2,
1511 .target_req_per_conn = 2, /* One request per connection */
1512 .manage_interval = fr_time_delta_from_nsec(NSEC * 0.5)
1513 };
1514 test_proto_request_t *preq_a, *preq_b, *preq_c, *preq_d, *preq_e;
1515 trunk_request_t *treq_a = NULL, *treq_b = NULL, *treq_c = NULL, *treq_d = NULL, *treq_e = NULL;
1516 int next_prio = 0;
1517
1518 DEBUG_LVL_SET;
1519
1520 el = fr_event_list_alloc(ctx, NULL, NULL);
1521 fr_timer_list_set_time_func(el->tl, test_time);
1522
1523 /* Need to provide a timer starting value above zero */
1524 test_time_base = fr_time_add_time_delta(test_time_base, fr_time_delta_from_nsec(NSEC * 0.5));
1525
1526 trunk = test_setup_trunk(ctx, el, &conf, true, NULL);
1527 TRUNK_VERIFY(trunk);
1528
1529 /*
1530 * Queuing a request should start a connection.
1531 */
1532 TEST_CASE("C0, R1 - Enqueue should spawn");
1533 ALLOC_REQ(a);
1534 TEST_CHECK(trunk_request_enqueue(&treq_a, trunk, NULL, preq_a, NULL) == TRUNK_ENQUEUE_IN_BACKLOG);
1535 TRUNK_VERIFY(trunk);
1536
1537 /*
1538 * Like test_connection_start_on_enqueue(), you have to process the backlog
1539 * to start the chain of events.
1540 */
1541 test_time_base = fr_time_add_time_delta(test_time_base, fr_time_delta_from_sec(1));
1542 fr_event_corral(el, test_time_base, false);
1543 fr_event_service(el);
1544
1545 TEST_CHECK_LEN(trunk_connection_count_by_state(trunk, TRUNK_CONN_CONNECTING), 1);
1546 TRUNK_VERIFY(trunk);
1547
1548 /*
1549 * Queuing another request should *NOT* start another connection
1550 */
1551 TEST_CASE("C1 connecting, R2 - MUST NOT spawn");
1552 ALLOC_REQ(b);
1553 TEST_CHECK(trunk_request_enqueue(&treq_b, trunk, NULL, preq_b, NULL) == TRUNK_ENQUEUE_IN_BACKLOG);
1554 TEST_CHECK_LEN(trunk_connection_count_by_state(trunk, TRUNK_CONN_CONNECTING), 1);
1555 TRUNK_VERIFY(trunk);
1556
1557 TEST_CASE("C1 connecting, R3 - MUST NOT spawn");
1558 ALLOC_REQ(c);
1559 TEST_CHECK(trunk_request_enqueue(&treq_c, trunk, NULL, preq_c, NULL) == TRUNK_ENQUEUE_IN_BACKLOG);
1560 TEST_CHECK_LEN(trunk_connection_count_by_state(trunk, TRUNK_CONN_CONNECTING), 1);
1561 TRUNK_VERIFY(trunk);
1562
1563 TEST_CASE("C1 connecting, R4 - MUST NOT spawn");
1564 ALLOC_REQ(d);
1565 TEST_CHECK(trunk_request_enqueue(&treq_d, trunk, NULL, preq_d, NULL) == TRUNK_ENQUEUE_IN_BACKLOG);
1566 TEST_CHECK_LEN(trunk_connection_count_by_state(trunk, TRUNK_CONN_CONNECTING), 1);
1567 TRUNK_VERIFY(trunk);
1568
1569 TEST_CASE("C1 connecting, R5 - MUST NOT spawn, NO CAPACITY");
1570 ALLOC_REQ(e);
1571 TEST_CHECK(trunk_request_enqueue(&treq_e, trunk, NULL, preq_e, NULL) == TRUNK_ENQUEUE_NO_CAPACITY);
1572 TEST_CHECK_LEN(trunk_connection_count_by_state(trunk, TRUNK_CONN_CONNECTING), 1);
1573 TRUNK_VERIFY(trunk);
1574
1575 /*
1576 * Allowing connection to open
1577 */
1578 fr_event_corral(el, test_time_base, false);
1579 fr_event_service(el);
1580
1581 TEST_CASE("C1 active, R4 - Check pending 2");
1582 TEST_CHECK_LEN(trunk_request_count_by_state(trunk, TRUNK_CONN_ALL, TRUNK_REQUEST_STATE_PENDING), 2);
1583 TEST_CHECK_LEN(trunk_request_count_by_state(trunk, TRUNK_CONN_ALL, TRUNK_REQUEST_STATE_BACKLOG), 2);
1584 TRUNK_VERIFY(trunk);
1585
1586 /*
1587 * Sending requests
1588 */
1589 fr_event_corral(el, test_time_base, false);
1590 fr_event_service(el);
1591
1592 TEST_CASE("C1 active, R4 - Check sent 2");
1593 TEST_CHECK_LEN(trunk_request_count_by_state(trunk, TRUNK_CONN_ALL, TRUNK_REQUEST_STATE_SENT), 2);
1594 TRUNK_VERIFY(trunk);
1595
1596 /*
1597 * Looping I/O
1598 */
1599 test_time_base = fr_time_add_time_delta(test_time_base, fr_time_delta_from_sec(1));
1600 fr_event_corral(el, test_time_base, false);
1601 fr_event_service(el);
1602
1603 /*
1604 * Receiving responses
1605 */
1606 test_time_base = fr_time_add_time_delta(test_time_base, fr_time_delta_from_sec(2));
1607 fr_event_corral(el, test_time_base, false);
1608 fr_event_service(el);
1609
1610 TEST_CHECK(preq_a->completed == true);
1611 TEST_CHECK(preq_a->failed == false);
1612 TEST_CHECK(preq_a->cancelled == false);
1613 TEST_CHECK(preq_a->freed == true);
1614
1615 TEST_CHECK(preq_b->completed == true);
1616 TEST_CHECK(preq_b->failed == false);
1617 TEST_CHECK(preq_b->cancelled == false);
1618 TEST_CHECK(preq_b->freed == true);
1619
1620 TEST_CHECK_LEN(trunk_request_count_by_state(trunk, TRUNK_CONN_ALL, TRUNK_REQUEST_STATE_PENDING), 2);
1621 TEST_CHECK_LEN(trunk_request_count_by_state(trunk, TRUNK_CONN_ALL, TRUNK_REQUEST_STATE_BACKLOG), 0);
1622 TRUNK_VERIFY(trunk);
1623
1624 TEST_CASE("C1 active, R0 - Check complete 2, pending 0");
1625
1626 /*
1627 * Sending requests
1628 */
1629 fr_event_corral(el, test_time_base, false);
1630 fr_event_service(el);
1631
1632 /*
1633 * Looping I/O
1634 */
1635 fr_event_corral(el, test_time_base, false);
1636 fr_event_service(el);
1637
1638 /*
1639 * Receiving responses
1640 */
1641 fr_event_corral(el, test_time_base, false);
1642 fr_event_service(el);
1643
1644 TEST_CHECK(preq_c->completed == true);
1645 TEST_CHECK(preq_c->failed == false);
1646 TEST_CHECK(preq_c->cancelled == false);
1647 TEST_CHECK(preq_c->freed == true);
1648
1649 TEST_CHECK(preq_d->completed == true);
1650 TEST_CHECK(preq_d->failed == false);
1651 TEST_CHECK(preq_d->cancelled == false);
1652 TEST_CHECK(preq_d->freed == true);
1653
1654 TEST_CHECK(trunk_request_count_by_state(trunk, TRUNK_CONN_ALL, TRUNK_REQUEST_STATE_ALL) == 0);
1655 TRUNK_VERIFY(trunk);
1656
1657 talloc_free(trunk);
1658 talloc_free(ctx);
1659}
1660
1661static void test_connection_levels_alternating_edges(void)
1662{
1663 TALLOC_CTX *ctx = talloc_init_const("test");
1664 trunk_t *trunk;
1665 fr_event_list_t *el;
1666 trunk_conf_t conf = {
1667 .start = 0, /* No connections on start */
1668 .min = 0,
1669 .max = 0,
1670 .max_req_per_conn = 0,
1671 .target_req_per_conn = 2, /* One request per connection */
1672 .manage_interval = fr_time_delta_from_nsec(NSEC / 10)
1673 };
1674
1675 test_proto_request_t *preq_a, *preq_b, *preq_c;
1676 trunk_request_t *treq_a = NULL, *treq_b = NULL, *treq_c = NULL;
1677 test_proto_stats_t stats;
1678 int next_prio = 0;
1679
1680 DEBUG_LVL_SET;
1681
1682 el = fr_event_list_alloc(ctx, NULL, NULL);
1683 fr_timer_list_set_time_func(el->tl, test_time);
1684
1685 /* Need to provide a timer starting value above zero */
1686 test_time_base = fr_time_add_time_delta(test_time_base, fr_time_delta_from_nsec(NSEC * 0.5));
1687
1688 memset(&stats, 0, sizeof(stats));
1689 trunk = test_setup_trunk(ctx, el, &conf, true, &stats);
1690
1691 /*
1692 * Queuing a request should start a connection.
1693 */
1694 TEST_CASE("C0, R1 - Enqueue should spawn");
1695 ALLOC_REQ(a);
1696 TEST_CHECK(trunk_request_enqueue(&treq_a, trunk, NULL, preq_a, NULL) == TRUNK_ENQUEUE_IN_BACKLOG);
1697
1698 /*
1699 * Processing the event associated with the backlog creates
1700 * the connection in connecting state..
1701 */
1702 fr_event_corral(el, test_time_base, false);
1703 fr_event_service(el);
1704
1705 TEST_CHECK(trunk_connection_count_by_state(trunk, TRUNK_CONN_CONNECTING) == 1);
1706
1707 TEST_CASE("C1 connecting, R2 - MUST NOT spawn");
1708 ALLOC_REQ(b);
1709 TEST_CHECK(trunk_request_enqueue(&treq_b, trunk, NULL, preq_b, NULL) == TRUNK_ENQUEUE_IN_BACKLOG);
1710 TEST_CHECK(trunk_connection_count_by_state(trunk, TRUNK_CONN_CONNECTING) == 1);
1711 test_time_base = fr_time_add_time_delta(test_time_base, fr_time_delta_from_sec(1));
1712
1713 /*
1714 * Open connection
1715 */
1716 fr_event_corral(el, test_time_base, false);
1717 fr_event_service(el);
1718
1719 TEST_CHECK(trunk_request_count_by_state(trunk, TRUNK_CONN_ALL, TRUNK_REQUEST_STATE_PENDING) == 2);
1720
1721 TEST_CASE("C1 connected, R3 - should spawn");
1722 ALLOC_REQ(c);
1723 TEST_CHECK(trunk_request_enqueue(&treq_c, trunk, NULL, preq_c, NULL) == TRUNK_ENQUEUE_OK);
1724 test_time_base = fr_time_add_time_delta(test_time_base, fr_time_delta_from_sec(1));
1725
1726 fr_event_corral(el, test_time_base, false);
1727 fr_event_service(el);
1728
1729 TEST_CHECK(trunk_request_count_by_state(trunk, TRUNK_CONN_ALL, TRUNK_REQUEST_STATE_SENT) == 3);
1730 TEST_CHECK(trunk_connection_count_by_state(trunk, TRUNK_CONN_ACTIVE) == 1);
1731 TEST_CHECK(trunk_connection_count_by_state(trunk, TRUNK_CONN_CONNECTING) == 1);
1732
1733 /*
1734 * Complete requests
1735 */
1736 test_time_base = fr_time_add_time_delta(test_time_base, fr_time_delta_from_sec(1));
1737
1738 fr_event_corral(el, test_time_base, false);
1739 fr_event_service(el);
1740
1741 test_time_base = fr_time_add_time_delta(test_time_base, fr_time_delta_from_sec(1));
1742
1743 TEST_CASE("C1 connected, C2 connecting, R2 - MUST NOT spawn");
1744 TEST_CHECK(trunk_request_count_by_state(trunk, TRUNK_CONN_ALL, TRUNK_REQUEST_STATE_ALL) == 3);
1745 TEST_CHECK(trunk_connection_count_by_state(trunk, TRUNK_CONN_ACTIVE) == 2);
1746
1747 /*
1748 * Finish the last request, should close one connection
1749 */
1750 fr_event_corral(el, test_time_base, false);
1751 fr_event_service(el);
1752
1753 test_time_base = fr_time_add_time_delta(test_time_base, fr_time_delta_from_sec(1));
1754
1755 TEST_CASE("C1 connected, R0");
1756 TEST_CHECK(trunk_request_count_by_state(trunk, TRUNK_CONN_ALL, TRUNK_REQUEST_STATE_ALL) == 0);
1757 TEST_CHECK(trunk_connection_count_by_state(trunk, TRUNK_CONN_ACTIVE) == 1);
1758
1759 /*
1760 * Requests now done, should close another connection
1761 */
1762 fr_event_corral(el, test_time_base, false);
1763 fr_event_service(el);
1764
1765 test_time_base = fr_time_add_time_delta(test_time_base, fr_time_delta_from_sec(1));
1766
1767 TEST_CASE("C0, R0");
1768 TEST_CHECK(trunk_connection_count_by_state(trunk, TRUNK_CONN_ACTIVE) == 0);
1769
1770 TEST_CHECK(stats.completed == 3);
1771 TEST_CHECK(stats.failed == 0);
1772 TEST_CHECK(stats.cancelled == 0);
1773 TEST_CHECK(stats.freed == 3);
1774
1775 /*
1776 * Queuing a request should start a connection.
1777 */
1778 TEST_CASE("C0, R1 - Enqueue should spawn");
1779 ALLOC_REQ(a);
1780 TEST_CHECK(trunk_request_enqueue(&treq_a, trunk, NULL, preq_a, NULL) == TRUNK_ENQUEUE_IN_BACKLOG);
1781
1782 /*
1783 * ...once the event associated with the backlogged request is handled.
1784 */
1785 fr_event_corral(el, test_time_base, false);
1786 fr_event_service(el);
1787
1788 TEST_CHECK(trunk_connection_count_by_state(trunk, TRUNK_CONN_CONNECTING) == 1);
1789
1790 TEST_CASE("C1 connecting, R2 - MUST NOT spawn");
1791 ALLOC_REQ(b);
1792 TEST_CHECK(trunk_request_enqueue(&treq_b, trunk, NULL, preq_b, NULL) == TRUNK_ENQUEUE_IN_BACKLOG);
1793 TEST_CHECK(trunk_connection_count_by_state(trunk, TRUNK_CONN_CONNECTING) == 1);
1794 test_time_base = fr_time_add_time_delta(test_time_base, fr_time_delta_from_sec(1));
1795
1796 /*
1797 * Open connection
1798 */
1799 fr_event_corral(el, test_time_base, false);
1800 fr_event_service(el);
1801
1802 TEST_CHECK(trunk_request_count_by_state(trunk, TRUNK_CONN_ALL, TRUNK_REQUEST_STATE_PENDING) == 2);
1803
1804 TEST_CASE("C1 connected, R3 - should spawn");
1805 ALLOC_REQ(c);
1806 TEST_CHECK(trunk_request_enqueue(&treq_c, trunk, NULL, preq_c, NULL) == TRUNK_ENQUEUE_OK);
1807 test_time_base = fr_time_add_time_delta(test_time_base, fr_time_delta_from_sec(1));
1808
1809 fr_event_corral(el, test_time_base, false);
1810 fr_event_service(el);
1811
1812 TEST_CHECK(trunk_request_count_by_state(trunk, TRUNK_CONN_ALL, TRUNK_REQUEST_STATE_SENT) == 3);
1813 TEST_CHECK(trunk_connection_count_by_state(trunk, TRUNK_CONN_ACTIVE) == 1);
1814 TEST_CHECK(trunk_connection_count_by_state(trunk, TRUNK_CONN_CONNECTING) == 1);
1815
1816 talloc_free(trunk);
1817 talloc_free(ctx);
1818}
1819
1820#undef fr_time /* Need to the real time */
1821static void test_enqueue_and_io_speed(void)
1822{
1823 TALLOC_CTX *ctx = talloc_init_const("test");
1824 trunk_t *trunk;
1825 fr_event_list_t *el;
1826 int events;
1827 trunk_conf_t conf = {
1828 .start = 1,
1829 .min = 1,
1830 .max = 0,
1831 .max_req_per_conn = 0,
1832 .target_req_per_conn = 0, /* One request per connection */
1833 .req_pool_headers = 1,
1834 .req_pool_size = sizeof(test_proto_request_t),
1835 .manage_interval = fr_time_delta_from_nsec(NSEC * 0.5)
1836 };
1837 size_t i = 0, requests = 100000;
1838 fr_time_t enqueue_start, enqueue_stop, io_start, io_stop;
1839 fr_time_delta_t enqueue_time, io_time, total_time;
1840 trunk_request_t **treq_array;
1841 test_proto_request_t **preq_array;
1842 test_proto_stats_t stats;
1843
1844 DEBUG_LVL_SET;
1845
1846 el = fr_event_list_alloc(ctx, NULL, NULL);
1847 fr_timer_list_set_time_func(el->tl, test_time);
1848
1849 /* Need to provide a timer starting value above zero */
1850 test_time_base = fr_time_add_time_delta(test_time_base, fr_time_delta_from_nsec(NSEC * 0.5));
1851
1852 memset(&stats, 0, sizeof(stats));
1853 trunk = test_setup_trunk(ctx, el, &conf, true, &stats);
1854
1855 /*
1856 * Open the connections
1857 */
1858 fr_event_corral(el, test_time_base, false);
1859 fr_event_service(el);
1860
1861 /*
1862 * Build up a cache of requests
1863 * This prevents all mallocs on request enqueue.
1864 *
1865 * When the server's running, this does represent
1866 * close to what we'd have as a steady state.
1867 */
1868 MEM(treq_array = talloc_array(ctx, trunk_request_t *, requests));
1869 for (i = 0; i < requests; i++) treq_array[i] = trunk_request_alloc(trunk, NULL);
1870 for (i = 0; i < requests; i++) trunk_request_free(&treq_array[i]);
1871
1872 MEM(preq_array = talloc_array(ctx, test_proto_request_t *, requests));
1873
1874 DEBUG_LVL_SET;
1875
1876 TEST_CASE("Enqueue requests");
1877 enqueue_start = fr_time();
1878// ProfilerStart(getenv("FR_PROFILE"));
1879 for (i = 0; i < requests; i++) {
1880 trunk_request_t *treq;
1881 test_proto_request_t *preq = NULL;
1882
1883 treq = trunk_request_alloc(trunk, NULL);
1884 preq = talloc_zero(treq, test_proto_request_t);
1885 preq->treq = treq;
1886 trunk_request_enqueue(&treq, trunk, NULL, preq, NULL);
1887 }
1888 enqueue_stop = fr_time();
1889 enqueue_time = fr_time_sub(enqueue_stop, enqueue_start);
1890 if (acutest_verbose_level_ >= 1) {
1891 INFO("Enqueue time %pV (%u rps) (%"PRIu64"/%"PRIu64")",
1892 fr_box_time_delta(enqueue_time),
1893 (uint32_t)(requests / ((float)(fr_time_delta_unwrap(enqueue_time)) / NSEC)),
1894 trunk->pub.req_alloc_new, trunk->pub.req_alloc_reused);
1895 }
1896
1897 TEST_CASE("Perform I/O operations");
1898 io_start = fr_time();
1899 while (true) {
1900 events = fr_event_corral(el, test_time_base, false);
1901 if (!events) break;
1902 fr_event_service(el);
1903 test_time_base = fr_time_add_time_delta(test_time_base, fr_time_delta_from_nsec(NSEC * 0.25));
1904 }
1905 io_stop = fr_time();
1906 io_time = fr_time_sub(io_stop, io_start);
1907
1908 if (acutest_verbose_level_ >= 1) {
1909 INFO("I/O time %pV (%u rps)",
1910 fr_box_time_delta(io_time),
1911 (uint32_t)(requests / ((float)(fr_time_delta_unwrap(io_time)) / NSEC)));
1912 }
1913
1914 if (acutest_verbose_level_ >= 1) {
1915 total_time = fr_time_sub(io_stop, enqueue_start);
1916 INFO("Total time %pV (%u rps)",
1917 fr_box_time_delta(total_time),
1918 (uint32_t)(requests / ((float)(fr_time_delta_unwrap(total_time)) / NSEC)));
1919 }
1920
1921 TEST_CHECK_LEN(stats.completed, requests);
1922 TEST_CHECK_LEN(stats.failed, 0);
1923 TEST_CHECK_LEN(stats.cancelled, 0);
1924 TEST_CHECK_LEN(stats.freed, requests);
1925
1926// ProfilerStop();
1927
1928 talloc_free(ctx);
1929}
1930
1931/*
1932 * Connection spawning
1933 */
1934TEST_LIST = {
1935 /*
1936 * Basic tests
1937 */
1938 { "Basic - Alloc then free", test_socket_pair_alloc_then_free },
1939 { "Basic - Alloc then reconnect then free", test_socket_pair_alloc_then_reconnect_then_free },
1940
1941 /*
1942 * Connection timeout
1943 */
1944 { "Timeouts - Connection", test_socket_pair_alloc_then_connect_timeout },
1945 { "Timeouts - Reconnect delay", test_socket_pair_alloc_then_reconnect_check_delay },
1946
1947 /*
1948 * Basic enqueue/dequeue
1949 */
1950 { "Enqueue - Basic", test_enqueue_basic },
1951 { "Enqueue - Cancellation points", test_enqueue_cancellation_points },
1952 { "Enqueue - Partial state transitions", test_partial_to_complete_states },
1953 { "Requeue - On reconnect", test_requeue_on_reconnect },
1954
1955 /*
1956 * Rebalance
1957 */
1958 { "Rebalance - Connection rebalance", test_connection_rebalance_requests },
1959
1960 /*
1961 * Connection spawning tests
1962 */
1963 { "Spawn - Test connection start on enqueue", test_connection_start_on_enqueue },
1964 { "Spawn - Connection levels max", test_connection_levels_max },
1965 { "Spawn - Connection levels alternating edges",test_connection_levels_alternating_edges },
1966
1967 /*
1968 * Performance tests
1969 */
1970 { "Speed Test - Enqueue, and I/O", test_enqueue_and_io_speed },
1971 { NULL }
1972};
TEST_CHECK
#define TEST_CHECK(cond)
Definition acutest.h:85
acutest_verbose_level_
static int acutest_verbose_level_
Definition acutest.h:418
TEST_CASE
#define TEST_CASE(name)
Definition acutest.h:184
TEST_MSG
#define TEST_MSG(...)
Definition acutest.h:215
TEST_CHECK_LEN
#define TEST_CHECK_LEN(_got, _exp)
Definition acutest_helpers.h:30
CC_NO_UBSAN
#define CC_NO_UBSAN(_sanitize)
Definition build.h:428
CMP
#define CMP(_a, _b)
Same as CMP_PREFER_SMALLER use when you don't really care about ordering, you just want an ordering.
Definition build.h:112
UNUSED
#define UNUSED
Definition build.h:317
connection_state_t
connection_state_t
Definition connection.h:45
CONNECTION_STATE_CONNECTED
@ CONNECTION_STATE_CONNECTED
File descriptor is open (ready for writing).
Definition connection.h:52
CONNECTION_STATE_CONNECTING
@ CONNECTION_STATE_CONNECTING
Waiting for connection to establish.
Definition connection.h:50
CONNECTION_FAILED
@ CONNECTION_FAILED
Connection is being reconnected because it failed.
Definition connection.h:84
connection_conf_t
Definition connection.h:91
connection_funcs_t
Holds a complete set of functions for a connection.
Definition connection.h:186
fr_talloc_fault_setup
void fr_talloc_fault_setup(void)
Register talloc fault handlers.
Definition debug.c:1223
MEM
#define MEM(x)
Definition debug.h:36
fr_dlist_head
static void * fr_dlist_head(fr_dlist_head_t const *list_head)
Return the HEAD item of a list or NULL if the list is empty.
Definition dlist.h:486
fr_event_fd_insert
#define fr_event_fd_insert(...)
Definition event.h:248
FR_EVENT_FILTER_IO
@ FR_EVENT_FILTER_IO
Combined filter for read/write functions/.
Definition event.h:84
fr_event_service
void fr_event_service(fr_event_list_t *el)
Service any outstanding timer or file descriptor events.
Definition event.c:2194
fr_event_corral
int fr_event_corral(fr_event_list_t *el, fr_time_t now, bool wait)
Gather outstanding timer and file descriptor events.
Definition event.c:2059
fr_event_list_num_timers
uint64_t fr_event_list_num_timers(fr_event_list_t *el)
Return the number of timer events currently scheduled.
Definition event.c:560
talloc_free
talloc_free(reap)
fr_event_list_alloc
fr_event_list_t * fr_event_list_alloc(TALLOC_CTX *ctx, fr_event_status_cb_t status, void *status_uctx)
Initialise a new event list.
Definition event.c:2523
fr_event_fd_delete
int fr_event_fd_delete(fr_event_list_t *el, int fd, fr_event_filter_t filter)
Remove a file descriptor from the event loop.
Definition event.c:1203
fr_event_list_s
Stores all information relating to an event list.
Definition event.c:377
uint32_t
unsigned int uint32_t
Definition merged_model.c:33
ssize_t
long int ssize_t
Definition merged_model.c:24
uint8_t
unsigned char uint8_t
Definition merged_model.c:30
size_t
unsigned long int size_t
Definition merged_model.c:25
request_t
Definition merged_model.c:210
fr_minmax_heap_min_peek
void * fr_minmax_heap_min_peek(fr_minmax_heap_t *hp)
Definition minmax_heap.c:449
fr_nonblock
int fr_nonblock(UNUSED int fd)
Definition misc.c:293
fr_pointer_cmp
int8_t fr_pointer_cmp(void const *a, void const *b)
Compares two pointers.
Definition misc.c:417
io_funcs
static const trunk_io_funcs_t io_funcs
Definition bio.c:2397
fr_assert
#define fr_assert(_expr)
Definition rad_assert.h:38
INFO
#define INFO(fmt,...)
Definition radict.c:54
events
static fr_event_list_t * events
Definition radsniff.c:59
conf
static rs_t * conf
Definition radsniff.c:53
connection_get_num_timed_out
uint64_t connection_get_num_timed_out(connection_t const *conn)
Return the number of times this connection has timed out whilst connecting.
Definition connection.c:613
connection_get_num_reconnected
uint64_t connection_get_num_reconnected(connection_t const *conn)
Return the number of times we've attempted to establish or re-establish this connection.
Definition connection.c:601
connection_signal_reconnect
void connection_signal_reconnect(connection_t *conn, connection_reason_t reason)
Asynchronously signal the connection should be reconnected.
Definition connection.c:1167
connection_signal_on_fd
int connection_signal_on_fd(connection_t *conn, int fd)
Setup the connection to change states to connected or failed based on I/O events.
Definition connection.c:1405
connection_alloc
connection_t * connection_alloc(TALLOC_CTX *ctx, fr_event_list_t *el, connection_funcs_t const *funcs, connection_conf_t const *conf, char const *log_prefix, void const *uctx)
Allocate a new connection.
Definition connection.c:1511
connection_s
Definition connection.c:87
buff
static char buff[sizeof("18446744073709551615")+3]
Definition size_tests.c:41
test_time_base
static fr_time_t test_time_base
Definition slab_tests.c:42
count
return count
Definition module.c:155
test_time
fr_time_t test_time
Definition state_test.c:3
fr_time
#define fr_time()
Allow us to arbitrarily manipulate time.
Definition state_test.c:8
fr_syserror
char const * fr_syserror(int num)
Guaranteed to be thread-safe version of strerror.
Definition syserror.c:243
talloc_init_const
static TALLOC_CTX * talloc_init_const(char const *name)
Allocate a top level chunk with a constant name.
Definition talloc.h:112
fr_time_add_time_delta
static fr_time_t fr_time_add_time_delta(fr_time_t a, fr_time_delta_t b)
Definition time.h:173
fr_time_delta_unwrap
static int64_t fr_time_delta_unwrap(fr_time_delta_t time)
Definition time.h:154
fr_time_delta_from_sec
static fr_time_delta_t fr_time_delta_from_sec(int64_t sec)
Definition time.h:590
NSEC
#define NSEC
Definition time.h:379
fr_time_delta_from_nsec
static fr_time_delta_t fr_time_delta_from_nsec(int64_t nsec)
Definition time.h:563
fr_time_sub
#define fr_time_sub(_a, _b)
Subtract one time from another.
Definition time.h:229
fr_time_delta_s
A time delta, a difference in time measured in nanoseconds.
Definition time.h:80
fr_time_s
"server local" time.
Definition time.h:69
fr_timer_list_set_time_func
void fr_timer_list_set_time_func(fr_timer_list_t *tl, fr_event_time_source_t func)
Override event list time source.
Definition timer.c:1008
trunk.c
A management API for bonding multiple connections together.
trunk_connection_pop_cancellation
int trunk_connection_pop_cancellation(trunk_request_t **treq_out, trunk_connection_t *tconn)
Pop a cancellation request off a connection's cancellation queue.
Definition trunk.c:3834
trunk_reconnect
void trunk_reconnect(trunk_t *trunk, int states, connection_reason_t reason)
Force the trunk to re-establish its connections.
Definition trunk.c:4724
trunk_request_signal_partial
void trunk_request_signal_partial(trunk_request_t *treq)
Signal a partial write.
Definition trunk.c:2028
trunk_request_signal_cancel_sent
void trunk_request_signal_cancel_sent(trunk_request_t *treq)
Signal that a remote server has been notified of the cancellation.
Definition trunk.c:2259
trunk_connection_signal_readable
void trunk_connection_signal_readable(trunk_connection_t *tconn)
Signal that a trunk connection is readable.
Definition trunk.c:3920
trunk_request_alloc
trunk_request_t * trunk_request_alloc(trunk_t *trunk, request_t *request)
(Pre-)Allocate a new trunk request
Definition trunk.c:2473
trunk_request_count_by_connection
uint32_t trunk_request_count_by_connection(trunk_connection_t const *tconn, int req_state)
Return the count number of requests associated with a trunk connection.
Definition trunk.c:2878
trunk_request_s::pub
struct trunk_request_pub_s pub
Public fields in the trunk request.
Definition trunk.c:100
trunk_alloc
trunk_t * trunk_alloc(TALLOC_CTX *ctx, fr_event_list_t *el, trunk_io_funcs_t const *funcs, trunk_conf_t const *conf, char const *log_prefix, void const *uctx, bool delay_start)
Allocate a new collection of connections.
Definition trunk.c:4945
trunk_s::pub
struct trunk_pub_s pub
Public fields in the trunk connection.
Definition trunk.c:198
trunk_request_enqueue
trunk_enqueue_t trunk_request_enqueue(trunk_request_t **treq_out, trunk_t *trunk, request_t *request, void *preq, void *rctx)
Enqueue a request that needs data written to the trunk.
Definition trunk.c:2586
trunk_request_signal_cancel_complete
void trunk_request_signal_cancel_complete(trunk_request_t *treq)
Signal that a remote server acked our cancellation.
Definition trunk.c:2283
trunk_connection_pop_request
int trunk_connection_pop_request(trunk_request_t **treq_out, trunk_connection_t *tconn)
Pop a request off a connection's pending queue.
Definition trunk.c:3882
trunk_s::connecting
fr_dlist_head_t connecting
Connections which are not yet in the open state.
Definition trunk.c:224
trunk_request_signal_cancel
void trunk_request_signal_cancel(trunk_request_t *treq)
Cancel a trunk request.
Definition trunk.c:2151
trunk_connection_s::pub
struct trunk_connection_pub_s pub
Public fields in the trunk connection.
Definition trunk.c:134
trunk_connection_count_by_state
uint16_t trunk_connection_count_by_state(trunk_t *trunk, int conn_state)
Return the count number of connections in the specified states.
Definition trunk.c:2854
trunk_s::active
fr_minmax_heap_t * active
Connections which can service requests.
Definition trunk.c:226
trunk_request_free
void trunk_request_free(trunk_request_t **treq_to_free)
If the trunk request is freed then update the target requests.
Definition trunk.c:2321
trunk_connection_signal_active
void trunk_connection_signal_active(trunk_connection_t *tconn)
Signal a trunk connection is no longer full.
Definition trunk.c:3959
trunk_connection_signal_inactive
void trunk_connection_signal_inactive(trunk_connection_t *tconn)
Signal a trunk connection cannot accept more requests.
Definition trunk.c:3936
trunk_request_count_by_state
uint64_t trunk_request_count_by_state(trunk_t *trunk, int conn_state, int req_state)
Return a count of requests on a connection in a specific state.
Definition trunk.c:4521
trunk_request_signal_cancel_partial
void trunk_request_signal_cancel_partial(trunk_request_t *treq)
Signal a partial cancel write.
Definition trunk.c:2235
trunk_request_signal_sent
void trunk_request_signal_sent(trunk_request_t *treq)
Signal that the request was written to a connection successfully.
Definition trunk.c:2049
trunk_request_signal_complete
void trunk_request_signal_complete(trunk_request_t *treq)
Signal that a trunk request is complete.
Definition trunk.c:2093
trunk_connection_signal_reconnect
void trunk_connection_signal_reconnect(trunk_connection_t *tconn, connection_reason_t reason)
Signal a trunk connection is no longer viable.
Definition trunk.c:3998
trunk_connection_signal_writable
void trunk_connection_signal_writable(trunk_connection_t *tconn)
Signal that a trunk connection is writable.
Definition trunk.c:3902
trunk_connection_s
Associates request queues with a connection.
Definition trunk.c:133
trunk_request_s
Wraps a normal request.
Definition trunk.c:99
trunk_s
Main trunk management handle.
Definition trunk.c:197
TRUNK_VERIFY
#define TRUNK_VERIFY(_trunk)
Definition trunk.h:929
TRUNK_REQUEST_STATE_ALL
#define TRUNK_REQUEST_STATE_ALL
All request states.
Definition trunk.h:195
TRUNK_CONN_CONNECTING
@ TRUNK_CONN_CONNECTING
Connection is connecting.
Definition trunk.h:90
TRUNK_CONN_ACTIVE
@ TRUNK_CONN_ACTIVE
Connection is connected and ready to service requests.
Definition trunk.h:91
trunk_pub_s::req_alloc_reused
uint64_t _CONST req_alloc_reused
How many requests were reused.
Definition trunk.h:328
trunk_request_pub_s::state
trunk_request_state_t _CONST state
Which list the request is now located in.
Definition trunk.h:345
trunk_request_pub_s::tconn
trunk_connection_t *_CONST tconn
Connection this request belongs to.
Definition trunk.h:349
trunk_io_funcs_t::connection_alloc
trunk_connection_alloc_t connection_alloc
Allocate a new connection_t.
Definition trunk.h:733
trunk_connection_event_t
trunk_connection_event_t
What type of I/O events the trunk connection is currently interested in receiving.
Definition trunk.h:72
TRUNK_CONN_EVENT_BOTH
@ TRUNK_CONN_EVENT_BOTH
Trunk should be notified if a connection is readable or writable.
Definition trunk.h:79
TRUNK_CONN_EVENT_WRITE
@ TRUNK_CONN_EVENT_WRITE
Trunk should be notified if a connection is writable.
Definition trunk.h:77
TRUNK_CONN_EVENT_NONE
@ TRUNK_CONN_EVENT_NONE
Don't notify the trunk on connection state changes.
Definition trunk.h:73
TRUNK_CONN_EVENT_READ
@ TRUNK_CONN_EVENT_READ
Trunk should be notified if a connection is readable.
Definition trunk.h:75
TRUNK_CONN_ALL
#define TRUNK_CONN_ALL
All connection states.
Definition trunk.h:111
trunk_cancel_reason_t
trunk_cancel_reason_t
Reasons for a request being cancelled.
Definition trunk.h:55
trunk_pub_s::req_alloc_new
uint64_t _CONST req_alloc_new
How many requests we've allocated.
Definition trunk.h:326
trunk_connection_pub_s::conn
connection_t *_CONST conn
The underlying connection.
Definition trunk.h:369
trunk_enqueue_t
trunk_enqueue_t
Definition trunk.h:148
TRUNK_ENQUEUE_OK
@ TRUNK_ENQUEUE_OK
Operation was successful.
Definition trunk.h:150
TRUNK_ENQUEUE_NO_CAPACITY
@ TRUNK_ENQUEUE_NO_CAPACITY
At maximum number of connections, and no connection has capacity.
Definition trunk.h:151
TRUNK_ENQUEUE_IN_BACKLOG
@ TRUNK_ENQUEUE_IN_BACKLOG
Request should be enqueued in backlog.
Definition trunk.h:149
trunk_request_pub_s::preq
void *_CONST preq
Data for the muxer to write to the connection.
Definition trunk.h:351
trunk_io_funcs_t::request_cancel_mux
trunk_request_cancel_mux_t request_cancel_mux
!< Read one or more requests from a connection.
Definition trunk.h:746
trunk_request_state_t
trunk_request_state_t
Used for sanity checks and to simplify freeing.
Definition trunk.h:161
TRUNK_REQUEST_STATE_PARTIAL
@ TRUNK_REQUEST_STATE_PARTIAL
Some of the request was written to the socket, more of it should be written later.
Definition trunk.h:170
TRUNK_REQUEST_STATE_CANCEL_SENT
@ TRUNK_REQUEST_STATE_CANCEL_SENT
We've informed the remote server that the request has been cancelled.
Definition trunk.h:185
TRUNK_REQUEST_STATE_CANCEL
@ TRUNK_REQUEST_STATE_CANCEL
A request on a particular socket was cancel.
Definition trunk.h:184
TRUNK_REQUEST_STATE_CANCEL_PARTIAL
@ TRUNK_REQUEST_STATE_CANCEL_PARTIAL
We partially wrote a cancellation request.
Definition trunk.h:187
TRUNK_REQUEST_STATE_BACKLOG
@ TRUNK_REQUEST_STATE_BACKLOG
In the backlog.
Definition trunk.h:167
TRUNK_REQUEST_STATE_PENDING
@ TRUNK_REQUEST_STATE_PENDING
In the queue of a connection and is pending writing.
Definition trunk.h:168
TRUNK_REQUEST_STATE_SENT
@ TRUNK_REQUEST_STATE_SENT
Was written to a socket. Waiting for a response.
Definition trunk.h:172
trunk_conf_t
Common configuration parameters for a trunk.
Definition trunk.h:224
trunk_io_funcs_t
I/O functions to pass to trunk_alloc.
Definition trunk.h:732
test_proto_request_t::treq
trunk_request_t * treq
Trunk request.
Definition trunk_tests.c:11
DEBUG_LVL_SET
#define DEBUG_LVL_SET
Definition trunk_tests.c:28
TEST_LIST
TEST_LIST
Definition trunk_tests.c:1934
test_demux
static void test_demux(UNUSED fr_event_list_t *el, UNUSED trunk_connection_t *tconn, connection_t *conn, UNUSED void *uctx)
Definition trunk_tests.c:99
test_proto_stats_t::cancelled
uint64_t cancelled
Count of tests in this run that were cancelled.
Definition trunk_tests.c:22
test_proto_stats_t::freed
uint64_t freed
Count of tests in this run that were freed.
Definition trunk_tests.c:25
test_setup_socket_pair_connection_alloc
static connection_t * test_setup_socket_pair_connection_alloc(trunk_connection_t *tconn, fr_event_list_t *el, connection_conf_t const *conn_conf, char const *log_prefix, UNUSED void *uctx)
Definition trunk_tests.c:328
test_enqueue_and_io_speed
static void test_enqueue_and_io_speed(void)
Definition trunk_tests.c:1821
test_proto_request_t::cancelled
bool cancelled
Seen by the cancelled callback.
Definition trunk_tests.c:12
_conn_io_error
static void _conn_io_error(UNUSED fr_event_list_t *el, UNUSED int fd, UNUSED int flags, UNUSED int fd_errno, void *uctx)
Definition trunk_tests.c:150
_conn_io_loopback
static void _conn_io_loopback(UNUSED fr_event_list_t *el, int fd, UNUSED int flags, void *uctx)
Whenever the second socket in a socket pair is readable, read all pending data, and write it back.
Definition trunk_tests.c:251
test_mux
static void test_mux(UNUSED fr_event_list_t *el, trunk_connection_t *tconn, connection_t *conn, UNUSED void *uctx)
Definition trunk_tests.c:30
test_socket_pair_alloc_then_connect_timeout
static void test_socket_pair_alloc_then_connect_timeout(void)
Definition trunk_tests.c:508
test_cancel_mux
static void test_cancel_mux(UNUSED fr_event_list_t *el, trunk_connection_t *tconn, connection_t *conn, UNUSED void *uctx)
Definition trunk_tests.c:62
_conn_io_write
static void _conn_io_write(UNUSED fr_event_list_t *el, UNUSED int fd, UNUSED int flags, void *uctx)
Definition trunk_tests.c:165
test_partial_to_complete_states
static void test_partial_to_complete_states(void)
Definition trunk_tests.c:1008
test_setup_socket_pair_1s_timeout_connection_alloc
static connection_t * test_setup_socket_pair_1s_timeout_connection_alloc(trunk_connection_t *tconn, fr_event_list_t *el, UNUSED connection_conf_t const *conf, char const *log_prefix, void *uctx)
Definition trunk_tests.c:490
test_request_free
static void test_request_free(UNUSED request_t *request, void *preq, void *uctx)
Definition trunk_tests.c:236
test_socket_pair_alloc_then_free
static void test_socket_pair_alloc_then_free(void)
Definition trunk_tests.c:378
test_proto_request_t::failed
bool failed
Seen by the failed callback.
Definition trunk_tests.c:14
test_request_fail
static void test_request_fail(UNUSED request_t *request, void *preq, UNUSED void *rctx, UNUSED trunk_request_state_t state, void *uctx)
Definition trunk_tests.c:224
test_connection_rebalance_requests
static void test_connection_rebalance_requests(void)
Definition trunk_tests.c:1431
_conn_init_no_signal
static connection_state_t _conn_init_no_signal(void **h_out, connection_t *conn, UNUSED void *uctx)
Definition trunk_tests.c:479
test_setup_socket_pair_1s_reconnection_delay_alloc
static connection_t * test_setup_socket_pair_1s_reconnection_delay_alloc(trunk_connection_t *tconn, fr_event_list_t *el, UNUSED connection_conf_t const *conn_conf, char const *log_prefix, void *uctx)
Definition trunk_tests.c:568
test_connection_levels_max
static void test_connection_levels_max(void)
Definition trunk_tests.c:1501
test_socket_pair_alloc_then_reconnect_check_delay
static void test_socket_pair_alloc_then_reconnect_check_delay(void)
Definition trunk_tests.c:586
test_proto_request_t::freed
bool freed
Seen by the free callback.
Definition trunk_tests.c:15
test_proto_stats_t::failed
uint64_t failed
Count of tests in this run that failed.
Definition trunk_tests.c:24
_conn_io_read
static void _conn_io_read(UNUSED fr_event_list_t *el, UNUSED int fd, UNUSED int flags, void *uctx)
Definition trunk_tests.c:159
test_proto_request_t::completed
bool completed
Seen by the complete callback.
Definition trunk_tests.c:13
_conn_notify
static void _conn_notify(trunk_connection_t *tconn, connection_t *conn, fr_event_list_t *el, trunk_connection_event_t notify_on, UNUSED void *uctx)
Definition trunk_tests.c:171
ALLOC_REQ
#define ALLOC_REQ(_id)
Definition trunk_tests.c:1493
test_proto_request_t::priority
int priority
Priority of request.
Definition trunk_tests.c:18
test_socket_pair_alloc_then_reconnect_then_free
static void test_socket_pair_alloc_then_reconnect_then_free(void)
Definition trunk_tests.c:417
test_setup_trunk
static trunk_t * test_setup_trunk(TALLOC_CTX *ctx, fr_event_list_t *el, trunk_conf_t *conf, bool with_cancel_mux, void *uctx)
Definition trunk_tests.c:356
_conn_open
static connection_state_t _conn_open(fr_event_list_t *el, void *h, UNUSED void *uctx)
Insert I/O handlers that loop any data back round.
Definition trunk_tests.c:297
test_enqueue_cancellation_points
static void test_enqueue_cancellation_points(void)
Definition trunk_tests.c:761
test_requeue_on_reconnect
static void test_requeue_on_reconnect(void)
Definition trunk_tests.c:1083
test_connection_start_on_enqueue
static void test_connection_start_on_enqueue(void)
Definition trunk_tests.c:1371
test_preq_cmp
static int8_t test_preq_cmp(void const *a, void const *b)
Definition trunk_tests.c:349
test_proto_request_t::signal_partial
bool signal_partial
Muxer should signal that this request is partially written.
Definition trunk_tests.c:16
test_request_complete
static void test_request_complete(UNUSED request_t *request, void *preq, UNUSED void *rctx, void *uctx)
Definition trunk_tests.c:212
test_request_cancel
static void test_request_cancel(UNUSED connection_t *conn, void *preq, UNUSED trunk_cancel_reason_t reason, void *uctx)
Definition trunk_tests.c:199
test_enqueue_basic
static void test_enqueue_basic(void)
Definition trunk_tests.c:660
test_proto_stats_t::completed
uint64_t completed
Count of tests in this run that completed.
Definition trunk_tests.c:23
test_connection_levels_alternating_edges
static void test_connection_levels_alternating_edges(void)
Definition trunk_tests.c:1661
_conn_close
static void _conn_close(UNUSED fr_event_list_t *el, void *h, UNUSED void *uctx)
Definition trunk_tests.c:282
_conn_init
static connection_state_t _conn_init(void **h_out, connection_t *conn, UNUSED void *uctx)
Allocate a basic socket pair.
Definition trunk_tests.c:313
test_proto_request_t::signal_cancel_partial
bool signal_cancel_partial
Muxer should signal that this request is partially cancelled.
Definition trunk_tests.c:17
test_proto_request_t
Definition trunk_tests.c:10
test_proto_stats_t
Definition trunk_tests.c:21
close
close(uq->fd)
el
static fr_event_list_t * el
Definition unit_test_attribute.c:279
fr_perror
void fr_perror(char const *fmt,...)
Print the current error to stderr with a prefix.
Definition strerror.c:732
fr_box_time_delta
#define fr_box_time_delta(_val)
Definition value.h:354
Generated by   doxygen 1.9.8