From: Arran Cudbard-Bell Date: Fri, 14 Feb 2020 18:04:21 +0000 (-0600) Subject: Make type name agree with enum values X-Git-Url: http://git.ipfire.org/cgi-bin/gitweb.cgi?a=commitdiff_plain;h=b0a4620da978ac4f243cb0889dbe97691449fe2a;p=thirdparty%2Ffreeradius-server.git Make type name agree with enum values --- diff --git a/src/lib/server/trunk.c b/src/lib/server/trunk.c index 3d806866b46..71fb601e28d 100644 --- a/src/lib/server/trunk.c +++ b/src/lib/server/trunk.c @@ -285,17 +285,17 @@ CONF_PARSER const fr_trunk_config[] = { }; static fr_table_num_ordered_t const fr_trunk_request_states[] = { - { "UNASSIGNED", FR_TRUNK_REQUEST_UNASSIGNED }, - { "BACKLOG", FR_TRUNK_REQUEST_BACKLOG }, - { "PENDING", FR_TRUNK_REQUEST_PENDING }, - { "PARTIAL", FR_TRUNK_REQUEST_PARTIAL }, - { "SENT", FR_TRUNK_REQUEST_SENT }, - { "COMPLETE", FR_TRUNK_REQUEST_COMPLETE }, - { "FAILED", FR_TRUNK_REQUEST_FAILED }, - { "CANCEL", FR_TRUNK_REQUEST_CANCEL }, - { "CANCEL-SENT", FR_TRUNK_REQUEST_CANCEL_SENT }, - { "CANCEL-PARTIAL", FR_TRUNK_REQUEST_CANCEL_PARTIAL }, - { "CANCEL-COMPLETE", FR_TRUNK_REQUEST_CANCEL_COMPLETE} + { "UNASSIGNED", FR_TRUNK_REQUEST_STATE_UNASSIGNED }, + { "BACKLOG", FR_TRUNK_REQUEST_STATE_BACKLOG }, + { "PENDING", FR_TRUNK_REQUEST_STATE_PENDING }, + { "PARTIAL", FR_TRUNK_REQUEST_STATE_PARTIAL }, + { "SENT", FR_TRUNK_REQUEST_STATE_SENT }, + { "COMPLETE", FR_TRUNK_REQUEST_STATE_COMPLETE }, + { "FAILED", FR_TRUNK_REQUEST_STATE_FAILED }, + { "CANCEL", FR_TRUNK_REQUEST_STATE_CANCEL }, + { "CANCEL-SENT", FR_TRUNK_REQUEST_STATE_CANCEL_SENT }, + { "CANCEL-PARTIAL", FR_TRUNK_REQUEST_STATE_CANCEL_PARTIAL }, + { "CANCEL-COMPLETE", FR_TRUNK_REQUEST_STATE_CANCEL_COMPLETE} }; static size_t fr_trunk_request_states_len = NUM_ELEMENTS(fr_trunk_request_states); @@ -638,30 +638,30 @@ static void trunk_request_remove_from_conn(fr_trunk_request_t *treq) if (!fr_cond_assert(!tconn || (tconn->pub.trunk == trunk))) return; switch (treq->state) { - case FR_TRUNK_REQUEST_UNASSIGNED: + case FR_TRUNK_REQUEST_STATE_UNASSIGNED: return; /* Not associated with connection */ - case FR_TRUNK_REQUEST_PENDING: + case FR_TRUNK_REQUEST_STATE_PENDING: REQUEST_EXTRACT_PENDING(treq); break; - case FR_TRUNK_REQUEST_PARTIAL: + case FR_TRUNK_REQUEST_STATE_PARTIAL: REQUEST_EXTRACT_PARTIAL(treq); break; - case FR_TRUNK_REQUEST_SENT: + case FR_TRUNK_REQUEST_STATE_SENT: REQUEST_EXTRACT_SENT(treq); break; - case FR_TRUNK_REQUEST_CANCEL: + case FR_TRUNK_REQUEST_STATE_CANCEL: REQUEST_EXTRACT_CANCEL(treq); break; - case FR_TRUNK_REQUEST_CANCEL_PARTIAL: + case FR_TRUNK_REQUEST_STATE_CANCEL_PARTIAL: REQUEST_EXTRACT_CANCEL_PARTIAL(treq); break; - case FR_TRUNK_REQUEST_CANCEL_SENT: + case FR_TRUNK_REQUEST_STATE_CANCEL_SENT: REQUEST_EXTRACT_CANCEL_SENT(treq); break; @@ -704,25 +704,25 @@ static void trunk_request_enter_unassigned(fr_trunk_request_t *treq) fr_trunk_t *trunk = treq->pub.trunk; switch (treq->state) { - case FR_TRUNK_REQUEST_UNASSIGNED: + case FR_TRUNK_REQUEST_STATE_UNASSIGNED: return; - case FR_TRUNK_REQUEST_BACKLOG: + case FR_TRUNK_REQUEST_STATE_BACKLOG: REQUEST_EXTRACT_BACKLOG(treq); break; - case FR_TRUNK_REQUEST_PENDING: - case FR_TRUNK_REQUEST_CANCEL: - case FR_TRUNK_REQUEST_CANCEL_PARTIAL: - case FR_TRUNK_REQUEST_CANCEL_SENT: + case FR_TRUNK_REQUEST_STATE_PENDING: + case FR_TRUNK_REQUEST_STATE_CANCEL: + case FR_TRUNK_REQUEST_STATE_CANCEL_PARTIAL: + case FR_TRUNK_REQUEST_STATE_CANCEL_SENT: trunk_request_remove_from_conn(treq); break; default: - REQUEST_BAD_STATE_TRANSITION(FR_TRUNK_REQUEST_UNASSIGNED); + REQUEST_BAD_STATE_TRANSITION(FR_TRUNK_REQUEST_STATE_UNASSIGNED); } - REQUEST_STATE_TRANSITION(FR_TRUNK_REQUEST_UNASSIGNED); + REQUEST_STATE_TRANSITION(FR_TRUNK_REQUEST_STATE_UNASSIGNED); } /** Transition a request to the backlog state, adding it to the backlog of the trunk @@ -735,22 +735,22 @@ static void trunk_request_enter_backlog(fr_trunk_request_t *treq) fr_trunk_t *trunk = treq->pub.trunk;; switch (treq->state) { - case FR_TRUNK_REQUEST_UNASSIGNED: + case FR_TRUNK_REQUEST_STATE_UNASSIGNED: break; - case FR_TRUNK_REQUEST_PENDING: + case FR_TRUNK_REQUEST_STATE_PENDING: REQUEST_EXTRACT_PENDING(treq); break; - case FR_TRUNK_REQUEST_CANCEL: + case FR_TRUNK_REQUEST_STATE_CANCEL: REQUEST_EXTRACT_CANCEL(treq); break; default: - REQUEST_BAD_STATE_TRANSITION(FR_TRUNK_REQUEST_BACKLOG); + REQUEST_BAD_STATE_TRANSITION(FR_TRUNK_REQUEST_STATE_BACKLOG); } - REQUEST_STATE_TRANSITION(FR_TRUNK_REQUEST_BACKLOG); + REQUEST_STATE_TRANSITION(FR_TRUNK_REQUEST_STATE_BACKLOG); fr_heap_insert(trunk->backlog, treq); /* Insert into the backlog heap */ /* @@ -794,22 +794,22 @@ static void trunk_request_enter_pending(fr_trunk_request_t *treq, fr_trunk_conne rad_assert(tconn->state == FR_TRUNK_CONN_ACTIVE); switch (treq->state) { - case FR_TRUNK_REQUEST_UNASSIGNED: + case FR_TRUNK_REQUEST_STATE_UNASSIGNED: break; - case FR_TRUNK_REQUEST_BACKLOG: + case FR_TRUNK_REQUEST_STATE_BACKLOG: REQUEST_EXTRACT_BACKLOG(treq); break; - case FR_TRUNK_REQUEST_CANCEL: /* Moved from another connection */ + case FR_TRUNK_REQUEST_STATE_CANCEL: /* Moved from another connection */ REQUEST_EXTRACT_CANCEL(treq); break; default: - REQUEST_BAD_STATE_TRANSITION(FR_TRUNK_REQUEST_PENDING); + REQUEST_BAD_STATE_TRANSITION(FR_TRUNK_REQUEST_STATE_PENDING); } - REQUEST_STATE_TRANSITION(FR_TRUNK_REQUEST_PENDING); + REQUEST_STATE_TRANSITION(FR_TRUNK_REQUEST_STATE_PENDING); DEBUG4("[%" PRIu64 "] Trunk connection assigned request %"PRIu64, tconn->pub.conn->id, treq->id); fr_heap_insert(tconn->pending, treq); treq->pub.tconn = tconn; @@ -845,21 +845,21 @@ static void trunk_request_enter_partial(fr_trunk_request_t *treq) if (!fr_cond_assert(!tconn || (tconn->pub.trunk == trunk))) return; switch (treq->state) { - case FR_TRUNK_REQUEST_UNASSIGNED: + case FR_TRUNK_REQUEST_STATE_UNASSIGNED: break; - case FR_TRUNK_REQUEST_PENDING: + case FR_TRUNK_REQUEST_STATE_PENDING: REQUEST_EXTRACT_PENDING(treq); break; default: - REQUEST_BAD_STATE_TRANSITION(FR_TRUNK_REQUEST_PARTIAL); + REQUEST_BAD_STATE_TRANSITION(FR_TRUNK_REQUEST_STATE_PARTIAL); } rad_assert(!tconn->partial); tconn->partial = treq; - REQUEST_STATE_TRANSITION(FR_TRUNK_REQUEST_PARTIAL); + REQUEST_STATE_TRANSITION(FR_TRUNK_REQUEST_STATE_PARTIAL); } /** Transition a request to the sent state, indicating that it's been sent in its entirety @@ -874,19 +874,19 @@ static void trunk_request_enter_sent(fr_trunk_request_t *treq) if (!fr_cond_assert(!tconn || (tconn->pub.trunk == trunk))) return; switch (treq->state) { - case FR_TRUNK_REQUEST_PENDING: + case FR_TRUNK_REQUEST_STATE_PENDING: REQUEST_EXTRACT_PENDING(treq); break; - case FR_TRUNK_REQUEST_PARTIAL: + case FR_TRUNK_REQUEST_STATE_PARTIAL: REQUEST_EXTRACT_PARTIAL(treq); break; default: - REQUEST_BAD_STATE_TRANSITION(FR_TRUNK_REQUEST_SENT); + REQUEST_BAD_STATE_TRANSITION(FR_TRUNK_REQUEST_STATE_SENT); } - REQUEST_STATE_TRANSITION(FR_TRUNK_REQUEST_SENT); + REQUEST_STATE_TRANSITION(FR_TRUNK_REQUEST_STATE_SENT); fr_dlist_insert_tail(&tconn->sent, treq); /* @@ -940,19 +940,19 @@ static void trunk_request_enter_cancel(fr_trunk_request_t *treq, fr_trunk_cancel if (!fr_cond_assert(!tconn || (tconn->pub.trunk == trunk))) return; switch (treq->state) { - case FR_TRUNK_REQUEST_PARTIAL: + case FR_TRUNK_REQUEST_STATE_PARTIAL: REQUEST_EXTRACT_PARTIAL(treq); break; - case FR_TRUNK_REQUEST_SENT: + case FR_TRUNK_REQUEST_STATE_SENT: REQUEST_EXTRACT_SENT(treq); break; default: - REQUEST_BAD_STATE_TRANSITION(FR_TRUNK_REQUEST_CANCEL); + REQUEST_BAD_STATE_TRANSITION(FR_TRUNK_REQUEST_STATE_CANCEL); } - REQUEST_STATE_TRANSITION(FR_TRUNK_REQUEST_CANCEL); + REQUEST_STATE_TRANSITION(FR_TRUNK_REQUEST_STATE_CANCEL); fr_dlist_insert_tail(&tconn->cancel, treq); treq->cancel_reason = reason; @@ -989,15 +989,15 @@ static void trunk_request_enter_cancel_partial(fr_trunk_request_t *treq) rad_assert(treq->cancel_reason == FR_TRUNK_CANCEL_REASON_SIGNAL); switch (treq->state) { - case FR_TRUNK_REQUEST_CANCEL: /* The only valid state cancel_sent can be reached from */ + case FR_TRUNK_REQUEST_STATE_CANCEL: /* The only valid state cancel_sent can be reached from */ REQUEST_EXTRACT_CANCEL(treq); break; default: - REQUEST_BAD_STATE_TRANSITION(FR_TRUNK_REQUEST_CANCEL_PARTIAL); + REQUEST_BAD_STATE_TRANSITION(FR_TRUNK_REQUEST_STATE_CANCEL_PARTIAL); } - REQUEST_STATE_TRANSITION(FR_TRUNK_REQUEST_CANCEL_PARTIAL); + REQUEST_STATE_TRANSITION(FR_TRUNK_REQUEST_STATE_CANCEL_PARTIAL); rad_assert(!tconn->partial); tconn->cancel_partial = treq; } @@ -1020,19 +1020,19 @@ static void trunk_request_enter_cancel_sent(fr_trunk_request_t *treq) rad_assert(treq->cancel_reason == FR_TRUNK_CANCEL_REASON_SIGNAL); switch (treq->state) { - case FR_TRUNK_REQUEST_CANCEL_PARTIAL: + case FR_TRUNK_REQUEST_STATE_CANCEL_PARTIAL: REQUEST_EXTRACT_CANCEL_PARTIAL(treq); break; - case FR_TRUNK_REQUEST_CANCEL: + case FR_TRUNK_REQUEST_STATE_CANCEL: REQUEST_EXTRACT_CANCEL(treq); break; default: - REQUEST_BAD_STATE_TRANSITION(FR_TRUNK_REQUEST_CANCEL_SENT); + REQUEST_BAD_STATE_TRANSITION(FR_TRUNK_REQUEST_STATE_CANCEL_SENT); } - REQUEST_STATE_TRANSITION(FR_TRUNK_REQUEST_CANCEL_SENT); + REQUEST_STATE_TRANSITION(FR_TRUNK_REQUEST_STATE_CANCEL_SENT); fr_dlist_insert_tail(&tconn->cancel_sent, treq); /* @@ -1059,17 +1059,17 @@ static void trunk_request_enter_cancel_complete(fr_trunk_request_t *treq) if (!fr_cond_assert(!treq->pub.request)) return; /* Only a valid state for REQUEST * which have been cancelled */ switch (treq->state) { - case FR_TRUNK_REQUEST_CANCEL_SENT: + case FR_TRUNK_REQUEST_STATE_CANCEL_SENT: REQUEST_EXTRACT_CANCEL_SENT(treq); break; default: - REQUEST_BAD_STATE_TRANSITION(FR_TRUNK_REQUEST_CANCEL_COMPLETE); + REQUEST_BAD_STATE_TRANSITION(FR_TRUNK_REQUEST_STATE_CANCEL_COMPLETE); } trunk_request_remove_from_conn(treq); - REQUEST_STATE_TRANSITION(FR_TRUNK_REQUEST_CANCEL_COMPLETE); + REQUEST_STATE_TRANSITION(FR_TRUNK_REQUEST_STATE_CANCEL_COMPLETE); fr_trunk_request_free(treq); /* Free the request */ } @@ -1085,15 +1085,15 @@ static void trunk_request_enter_complete(fr_trunk_request_t *treq) if (!fr_cond_assert(!tconn || (tconn->pub.trunk == trunk))) return; switch (treq->state) { - case FR_TRUNK_REQUEST_SENT: + case FR_TRUNK_REQUEST_STATE_SENT: trunk_request_remove_from_conn(treq); break; default: - REQUEST_BAD_STATE_TRANSITION(FR_TRUNK_REQUEST_COMPLETE); + REQUEST_BAD_STATE_TRANSITION(FR_TRUNK_REQUEST_STATE_COMPLETE); } - REQUEST_STATE_TRANSITION(FR_TRUNK_REQUEST_COMPLETE); + REQUEST_STATE_TRANSITION(FR_TRUNK_REQUEST_STATE_COMPLETE); DO_REQUEST_COMPLETE(treq); fr_trunk_request_free(treq); /* Free the request */ } @@ -1110,7 +1110,7 @@ static void trunk_request_enter_failed(fr_trunk_request_t *treq) if (!fr_cond_assert(!tconn || (tconn->pub.trunk == trunk))) return; switch (treq->state) { - case FR_TRUNK_REQUEST_BACKLOG: + case FR_TRUNK_REQUEST_STATE_BACKLOG: REQUEST_EXTRACT_BACKLOG(treq); break; @@ -1119,7 +1119,7 @@ static void trunk_request_enter_failed(fr_trunk_request_t *treq) break; } - REQUEST_STATE_TRANSITION(FR_TRUNK_REQUEST_FAILED); + REQUEST_STATE_TRANSITION(FR_TRUNK_REQUEST_STATE_FAILED); DO_REQUEST_FAIL(treq); fr_trunk_request_free(treq); /* Free the request */ } @@ -1177,7 +1177,7 @@ static fr_trunk_enqueue_t trunk_request_check_enqueue(fr_trunk_connection_t **tc if (trunk->conf.max_req_per_conn > 0) { uint64_t total_reqs; - total_reqs = fr_trunk_request_count_by_state(trunk, FR_TRUNK_CONN_ALL, FR_TRUNK_REQUEST_ALL) + 1; + total_reqs = fr_trunk_request_count_by_state(trunk, FR_TRUNK_CONN_ALL, FR_TRUNK_REQUEST_STATE_ALL) + 1; limit = trunk->conf.max * (uint64_t)trunk->conf.max_req_per_conn; if ((limit > 0) && (total_reqs > limit)) { ROPTIONAL(RWARN, WARN, "Refusing to enqueue requests - " @@ -1227,7 +1227,7 @@ static fr_trunk_enqueue_t trunk_request_enqueue_existing(fr_trunk_request_t *tre * Signal our caller it should stop * trying to drain the backlog. */ - if (treq->state == FR_TRUNK_REQUEST_BACKLOG) return FR_TRUNK_ENQUEUE_NO_CAPACITY; + if (treq->state == FR_TRUNK_REQUEST_STATE_BACKLOG) return FR_TRUNK_ENQUEUE_NO_CAPACITY; trunk_request_enter_backlog(treq); break; @@ -1273,17 +1273,17 @@ static uint64_t trunk_connection_requests_dequeue(fr_dlist_head_t *out, fr_trunk * Don't need to do anything with * cancellation requests. */ - if (states & FR_TRUNK_REQUEST_CANCEL) DEQUEUE_ALL(&tconn->cancel); + if (states & FR_TRUNK_REQUEST_STATE_CANCEL) DEQUEUE_ALL(&tconn->cancel); /* * ...same with cancel inform */ - if (states & FR_TRUNK_REQUEST_CANCEL_SENT) DEQUEUE_ALL(&tconn->cancel_sent); + if (states & FR_TRUNK_REQUEST_STATE_CANCEL_SENT) DEQUEUE_ALL(&tconn->cancel_sent); /* * ....same with cancel partial */ - if (states & FR_TRUNK_REQUEST_CANCEL_PARTIAL) { + if (states & FR_TRUNK_REQUEST_STATE_CANCEL_PARTIAL) { OVER_MAX_CHECK; treq = tconn->cancel_partial; if (treq) { @@ -1295,7 +1295,7 @@ static uint64_t trunk_connection_requests_dequeue(fr_dlist_head_t *out, fr_trunk /* * ...and pending. */ - if (states & FR_TRUNK_REQUEST_PENDING) { + if (states & FR_TRUNK_REQUEST_STATE_PENDING) { while ((treq = fr_heap_peek(tconn->pending))) { OVER_MAX_CHECK; trunk_request_enter_unassigned(treq); @@ -1306,7 +1306,7 @@ static uint64_t trunk_connection_requests_dequeue(fr_dlist_head_t *out, fr_trunk /* * Cancel partially sent requests */ - if (states & FR_TRUNK_REQUEST_PARTIAL) { + if (states & FR_TRUNK_REQUEST_STATE_PARTIAL) { OVER_MAX_CHECK; treq = tconn->partial; if (treq) { @@ -1319,7 +1319,7 @@ static uint64_t trunk_connection_requests_dequeue(fr_dlist_head_t *out, fr_trunk /* * Cancel sent requests */ - if (states & FR_TRUNK_REQUEST_SENT) { + if (states & FR_TRUNK_REQUEST_STATE_SENT) { while ((treq = fr_dlist_head(&tconn->sent))) { OVER_MAX_CHECK; trunk_request_enter_cancel(treq, FR_TRUNK_CANCEL_REASON_MOVE); @@ -1353,7 +1353,7 @@ static uint64_t trunk_connection_requests_requeue(fr_trunk_connection_t *tconn, /* * Remove non-cancelled requests from the connection */ - moved += trunk_connection_requests_dequeue(&to_process, tconn, states & ~FR_TRUNK_REQUEST_CANCEL_ALL, max); + moved += trunk_connection_requests_dequeue(&to_process, tconn, states & ~FR_TRUNK_REQUEST_STATE_CANCEL_ALL, max); /* * Prevent requests being requeued on the same trunk @@ -1419,7 +1419,7 @@ static uint64_t trunk_connection_requests_requeue(fr_trunk_connection_t *tconn, * just means freeing them. */ moved += trunk_connection_requests_dequeue(&to_process, tconn, - states & FR_TRUNK_REQUEST_CANCEL_ALL, max - moved); + states & FR_TRUNK_REQUEST_STATE_CANCEL_ALL, max - moved); while ((treq = fr_dlist_next(&to_process, treq))) { fr_trunk_request_t *prev; @@ -1474,7 +1474,7 @@ void fr_trunk_request_signal_partial(fr_trunk_request_t *treq) "%s can only be called from within request_mux handler", __FUNCTION__)) return; switch (treq->state) { - case FR_TRUNK_REQUEST_PENDING: + case FR_TRUNK_REQUEST_STATE_PENDING: trunk_request_enter_partial(treq); break; @@ -1493,8 +1493,8 @@ void fr_trunk_request_signal_sent(fr_trunk_request_t *treq) "%s can only be called from within request_mux handler", __FUNCTION__)) return; switch (treq->state) { - case FR_TRUNK_REQUEST_PENDING: - case FR_TRUNK_REQUEST_PARTIAL: + case FR_TRUNK_REQUEST_STATE_PENDING: + case FR_TRUNK_REQUEST_STATE_PARTIAL: trunk_request_enter_sent(treq); break; @@ -1510,8 +1510,8 @@ void fr_trunk_request_signal_sent(fr_trunk_request_t *treq) void fr_trunk_request_signal_complete(fr_trunk_request_t *treq) { switch (treq->state) { - case FR_TRUNK_REQUEST_SENT: - case FR_TRUNK_REQUEST_PENDING: /* Got immediate response, i.e. cached */ + case FR_TRUNK_REQUEST_STATE_SENT: + case FR_TRUNK_REQUEST_STATE_PENDING: /* Got immediate response, i.e. cached */ trunk_request_enter_complete(treq); break; @@ -1532,7 +1532,7 @@ void fr_trunk_request_signal_fail(fr_trunk_request_t *treq) /** Cancel a trunk request * * Request can be in any state, but requests to cancel if the request is not in - * the FR_TRUNK_REQUEST_PARTIAL or FR_TRUNK_REQUEST_SENT state will be ignored. + * the FR_TRUNK_REQUEST_STATE_PARTIAL or FR_TRUNK_REQUEST_STATE_SENT state will be ignored. * * @param[in] treq to signal state change for. */ @@ -1548,12 +1548,12 @@ void fr_trunk_request_signal_cancel(fr_trunk_request_t *treq) * We don't call the complete or failed callbacks * as the request and rctx are no longer viable. */ - case FR_TRUNK_REQUEST_PARTIAL: - case FR_TRUNK_REQUEST_SENT: + case FR_TRUNK_REQUEST_STATE_PARTIAL: + case FR_TRUNK_REQUEST_STATE_SENT: trunk_request_enter_cancel(treq, FR_TRUNK_CANCEL_REASON_SIGNAL); switch (treq->state) { - case FR_TRUNK_REQUEST_CANCEL: + case FR_TRUNK_REQUEST_STATE_CANCEL: /* * No cancel muxer. We're done. * @@ -1580,10 +1580,10 @@ void fr_trunk_request_signal_cancel(fr_trunk_request_t *treq) * We're already in the process of cancelling a * request, so ignore duplicate signals. */ - case FR_TRUNK_REQUEST_CANCEL: - case FR_TRUNK_REQUEST_CANCEL_PARTIAL: - case FR_TRUNK_REQUEST_CANCEL_SENT: - case FR_TRUNK_REQUEST_CANCEL_COMPLETE: + case FR_TRUNK_REQUEST_STATE_CANCEL: + case FR_TRUNK_REQUEST_STATE_CANCEL_PARTIAL: + case FR_TRUNK_REQUEST_STATE_CANCEL_SENT: + case FR_TRUNK_REQUEST_STATE_CANCEL_COMPLETE: break; /* @@ -1609,7 +1609,7 @@ void fr_trunk_request_signal_cancel_partial(fr_trunk_request_t *treq) "%s can only be called from within request_cancel_mux handler", __FUNCTION__)) return; switch (treq->state) { - case FR_TRUNK_REQUEST_CANCEL: + case FR_TRUNK_REQUEST_STATE_CANCEL: trunk_request_enter_cancel_partial(treq); break; @@ -1631,8 +1631,8 @@ void fr_trunk_request_signal_cancel_sent(fr_trunk_request_t *treq) "%s can only be called from within request_cancel_mux handler", __FUNCTION__)) return; switch (treq->state) { - case FR_TRUNK_REQUEST_CANCEL: - case FR_TRUNK_REQUEST_CANCEL_PARTIAL: + case FR_TRUNK_REQUEST_STATE_CANCEL: + case FR_TRUNK_REQUEST_STATE_CANCEL_PARTIAL: trunk_request_enter_cancel_sent(treq); break; @@ -1654,7 +1654,7 @@ void fr_trunk_request_signal_cancel_complete(fr_trunk_request_t *treq) __FUNCTION__)) return; switch (treq->state) { - case FR_TRUNK_REQUEST_CANCEL_SENT: + case FR_TRUNK_REQUEST_STATE_CANCEL_SENT: trunk_request_enter_cancel_complete(treq); break; @@ -1679,12 +1679,12 @@ void fr_trunk_request_free(fr_trunk_request_t *treq) * freed from. */ switch (treq->state) { - case FR_TRUNK_REQUEST_UNASSIGNED: - case FR_TRUNK_REQUEST_COMPLETE: - case FR_TRUNK_REQUEST_FAILED: + case FR_TRUNK_REQUEST_STATE_UNASSIGNED: + case FR_TRUNK_REQUEST_STATE_COMPLETE: + case FR_TRUNK_REQUEST_STATE_FAILED: break; - case FR_TRUNK_REQUEST_CANCEL_COMPLETE: + case FR_TRUNK_REQUEST_STATE_CANCEL_COMPLETE: break; default: @@ -1709,7 +1709,7 @@ void fr_trunk_request_free(fr_trunk_request_t *treq) * Otherwise return the trunk request back * to the unassigned list. */ - treq->state = FR_TRUNK_REQUEST_UNASSIGNED; + treq->state = FR_TRUNK_REQUEST_STATE_UNASSIGNED; treq->pub.preq = NULL; treq->pub.rctx = NULL; treq->cancel_reason = FR_TRUNK_CANCEL_REASON_NONE; @@ -1730,7 +1730,7 @@ static int _trunk_request_free(fr_trunk_request_t *treq) { fr_trunk_t *trunk = treq->pub.trunk; - rad_assert(treq->state == FR_TRUNK_REQUEST_UNASSIGNED); + rad_assert(treq->state == FR_TRUNK_REQUEST_STATE_UNASSIGNED); fr_dlist_remove(&trunk->unassigned, treq); @@ -1757,7 +1757,7 @@ fr_trunk_request_t *fr_trunk_request_alloc(fr_trunk_t *trunk, REQUEST *request) treq = fr_dlist_head(&trunk->unassigned); if (treq) { fr_dlist_remove(&trunk->unassigned, treq); - rad_assert(treq->state == FR_TRUNK_REQUEST_UNASSIGNED); + rad_assert(treq->state == FR_TRUNK_REQUEST_STATE_UNASSIGNED); rad_assert(treq->pub.trunk == trunk); rad_assert(treq->pub.tconn == NULL); rad_assert(treq->cancel_reason == FR_TRUNK_CANCEL_REASON_NONE); @@ -1767,7 +1767,7 @@ fr_trunk_request_t *fr_trunk_request_alloc(fr_trunk_t *trunk, REQUEST *request) MEM(treq = talloc_pooled_object(trunk, fr_trunk_request_t, trunk->conf.req_pool_headers, trunk->conf.req_pool_size)); talloc_set_destructor(treq, _trunk_request_free); - treq->state = FR_TRUNK_REQUEST_UNASSIGNED; + treq->state = FR_TRUNK_REQUEST_STATE_UNASSIGNED; treq->pub.trunk = trunk; treq->pub.tconn = NULL; treq->cancel_reason = FR_TRUNK_CANCEL_REASON_NONE; @@ -1863,7 +1863,7 @@ fr_trunk_enqueue_t fr_trunk_request_enqueue(fr_trunk_request_t **treq_out, fr_tr if (!fr_cond_assert_msg(!IN_HANDLER(trunk), "%s cannot be called within a handler", __FUNCTION__)) return FR_TRUNK_ENQUEUE_FAIL; - if (!fr_cond_assert_msg(!*treq_out || ((*treq_out)->state == FR_TRUNK_REQUEST_UNASSIGNED), + if (!fr_cond_assert_msg(!*treq_out || ((*treq_out)->state == FR_TRUNK_REQUEST_STATE_UNASSIGNED), "%s requests must be in \"unassigned\" state", __FUNCTION__)) return FR_TRUNK_ENQUEUE_FAIL; /* @@ -1941,12 +1941,12 @@ uint32_t fr_trunk_request_count_by_connection(fr_trunk_connection_t const *tconn { uint32_t count = 0; - if (req_state & FR_TRUNK_REQUEST_PENDING) count += fr_heap_num_elements(tconn->pending); - if (req_state & FR_TRUNK_REQUEST_PARTIAL) count += tconn->partial ? 1 : 0; - if (req_state & FR_TRUNK_REQUEST_SENT) count += fr_dlist_num_elements(&tconn->sent); - if (req_state & FR_TRUNK_REQUEST_CANCEL) count += fr_dlist_num_elements(&tconn->cancel); - if (req_state & FR_TRUNK_REQUEST_CANCEL_PARTIAL) count += tconn->cancel_partial ? 1 : 0; - if (req_state & FR_TRUNK_REQUEST_CANCEL_SENT) count += fr_dlist_num_elements(&tconn->cancel_sent); + if (req_state & FR_TRUNK_REQUEST_STATE_PENDING) count += fr_heap_num_elements(tconn->pending); + if (req_state & FR_TRUNK_REQUEST_STATE_PARTIAL) count += tconn->partial ? 1 : 0; + if (req_state & FR_TRUNK_REQUEST_STATE_SENT) count += fr_dlist_num_elements(&tconn->sent); + if (req_state & FR_TRUNK_REQUEST_STATE_CANCEL) count += fr_dlist_num_elements(&tconn->cancel); + if (req_state & FR_TRUNK_REQUEST_STATE_CANCEL_PARTIAL) count += tconn->cancel_partial ? 1 : 0; + if (req_state & FR_TRUNK_REQUEST_STATE_CANCEL_SENT) count += fr_dlist_num_elements(&tconn->cancel_sent); return count; } @@ -1966,7 +1966,7 @@ static inline void trunk_connection_auto_inactive(fr_trunk_connection_t *tconn) * Enforces max_req_per_conn */ if (trunk->conf.max_req_per_conn > 0) { - count = fr_trunk_request_count_by_connection(tconn, FR_TRUNK_REQUEST_ALL); + count = fr_trunk_request_count_by_connection(tconn, FR_TRUNK_REQUEST_STATE_ALL); if (count >= trunk->conf.max_req_per_conn) trunk_connection_enter_inactive(tconn); } } @@ -1989,7 +1989,7 @@ static inline void trunk_connection_auto_reactivate(fr_trunk_connection_t *tconn /* * Enforces max_req_per_conn */ - count = fr_trunk_request_count_by_connection(tconn, FR_TRUNK_REQUEST_ALL); + count = fr_trunk_request_count_by_connection(tconn, FR_TRUNK_REQUEST_STATE_ALL); if ((trunk->conf.max_req_per_conn == 0) || (count < trunk->conf.max_req_per_conn)) { trunk_connection_enter_active(tconn); } @@ -2018,13 +2018,13 @@ static inline void trunk_connection_writable(fr_trunk_connection_t *tconn) * care about the result */ if (trunk->funcs.request_cancel_mux && fr_trunk_request_count_by_connection(tconn, - FR_TRUNK_REQUEST_CANCEL | - FR_TRUNK_REQUEST_CANCEL_PARTIAL)) { + FR_TRUNK_REQUEST_STATE_CANCEL | + FR_TRUNK_REQUEST_STATE_CANCEL_PARTIAL)) { DO_REQUEST_CANCEL_MUX(tconn); } if (!fr_trunk_request_count_by_connection(tconn, - FR_TRUNK_REQUEST_PENDING | - FR_TRUNK_REQUEST_PARTIAL)) return; + FR_TRUNK_REQUEST_STATE_PENDING | + FR_TRUNK_REQUEST_STATE_PARTIAL)) return; DO_REQUEST_MUX(tconn); } @@ -2054,18 +2054,18 @@ static void trunk_connection_event_update(fr_trunk_connection_t *tconn) */ if (!trunk->conf.always_writable && fr_trunk_request_count_by_connection(tconn, - FR_TRUNK_REQUEST_PARTIAL | - FR_TRUNK_REQUEST_PENDING | + FR_TRUNK_REQUEST_STATE_PARTIAL | + FR_TRUNK_REQUEST_STATE_PENDING | (trunk->funcs.request_cancel_mux ? - FR_TRUNK_REQUEST_CANCEL | - FR_TRUNK_REQUEST_CANCEL_PARTIAL : 0)) > 0) { + FR_TRUNK_REQUEST_STATE_CANCEL | + FR_TRUNK_REQUEST_STATE_CANCEL_PARTIAL : 0)) > 0) { events |= FR_TRUNK_CONN_EVENT_WRITE; } if (fr_trunk_request_count_by_connection(tconn, - FR_TRUNK_REQUEST_SENT | + FR_TRUNK_REQUEST_STATE_SENT | (trunk->funcs.request_cancel_mux ? - FR_TRUNK_REQUEST_CANCEL_SENT : 0)) > 0) { + FR_TRUNK_REQUEST_STATE_CANCEL_SENT : 0)) > 0) { events |= FR_TRUNK_CONN_EVENT_READ; } @@ -2139,7 +2139,7 @@ static void trunk_connection_enter_draining(fr_trunk_connection_t *tconn) * requests, so the connection is drained * quicker. */ - trunk_connection_requests_requeue(tconn, FR_TRUNK_REQUEST_PENDING, 0); + trunk_connection_requests_requeue(tconn, FR_TRUNK_REQUEST_STATE_PENDING, 0); } /** Transition a connection to the draining-to-reconnect state @@ -2178,7 +2178,7 @@ static void trunk_connection_enter_draining_to_free(fr_trunk_connection_t *tconn * requests, so the connection is drained * quicker. */ - trunk_connection_requests_requeue(tconn, FR_TRUNK_REQUEST_PENDING, 0); + trunk_connection_requests_requeue(tconn, FR_TRUNK_REQUEST_STATE_PENDING, 0); } @@ -2203,7 +2203,7 @@ static void trunk_connection_enter_active(fr_trunk_connection_t *tconn) case FR_TRUNK_CONN_CONNECTING: fr_dlist_remove(&trunk->connecting, tconn); - rad_assert(fr_trunk_request_count_by_connection(tconn, FR_TRUNK_REQUEST_ALL) == 0); + rad_assert(fr_trunk_request_count_by_connection(tconn, FR_TRUNK_REQUEST_STATE_ALL) == 0); break; default: @@ -2286,7 +2286,7 @@ static void _trunk_connection_on_connecting(UNUSED fr_connection_t *conn, UNUSED * connecting state, it should have * no requests associated with it. */ - rad_assert(fr_trunk_request_count_by_connection(tconn, FR_TRUNK_REQUEST_ALL) == 0); + rad_assert(fr_trunk_request_count_by_connection(tconn, FR_TRUNK_REQUEST_STATE_ALL) == 0); fr_dlist_insert_head(&trunk->connecting, tconn); /* MUST remain a head insertion for reconnect logic */ CONN_STATE_TRANSITION(FR_TRUNK_CONN_CONNECTING); @@ -2359,7 +2359,7 @@ static void _trunk_connection_on_connected(UNUSED fr_connection_t *conn, UNUSED * it should have no requests associated * with it. */ - rad_assert(fr_trunk_request_count_by_connection(tconn, FR_TRUNK_REQUEST_ALL) == 0); + rad_assert(fr_trunk_request_count_by_connection(tconn, FR_TRUNK_REQUEST_STATE_ALL) == 0); /* * Set here, as the active state can @@ -2413,7 +2413,7 @@ static void _trunk_connection_on_closed(UNUSED fr_connection_t *conn, UNUSED fr_ case FR_TRUNK_CONN_CONNECTING: fr_dlist_remove(&trunk->connecting, tconn); - rad_assert(fr_trunk_request_count_by_connection(tconn, FR_TRUNK_REQUEST_ALL) == 0); + rad_assert(fr_trunk_request_count_by_connection(tconn, FR_TRUNK_REQUEST_STATE_ALL) == 0); break; case FR_TRUNK_CONN_INACTIVE: @@ -2447,14 +2447,14 @@ static void _trunk_connection_on_closed(UNUSED fr_connection_t *conn, UNUSED fr_ * removed from the active, pool * re-enqueue the requests. */ - if (need_requeue) trunk_connection_requests_requeue(tconn, FR_TRUNK_REQUEST_ALL, 0); + if (need_requeue) trunk_connection_requests_requeue(tconn, FR_TRUNK_REQUEST_STATE_ALL, 0); /* * There should be no requests left on this * connection. They should have all been * moved off or failed. */ - rad_assert(fr_trunk_request_count_by_connection(tconn, FR_TRUNK_REQUEST_ALL) == 0); + rad_assert(fr_trunk_request_count_by_connection(tconn, FR_TRUNK_REQUEST_STATE_ALL) == 0); /* * Clear statistics and flags @@ -2493,7 +2493,7 @@ static void _trunk_connection_on_failed(UNUSED fr_connection_t *conn, UNUSED fr_ * As the connection never actually connected * it shouldn't have any requests. */ - rad_assert(fr_trunk_request_count_by_connection(tconn, FR_TRUNK_REQUEST_ALL) == 0); + rad_assert(fr_trunk_request_count_by_connection(tconn, FR_TRUNK_REQUEST_STATE_ALL) == 0); fr_dlist_insert_head(&trunk->failed, tconn); CONN_STATE_TRANSITION(FR_TRUNK_CONN_FAILED); @@ -2569,14 +2569,14 @@ static void _trunk_connection_on_halted(UNUSED fr_connection_t *conn, UNUSED fr_ */ CONN_STATE_TRANSITION(FR_TRUNK_CONN_HALTED); - if (need_requeue) trunk_connection_requests_requeue(tconn, FR_TRUNK_REQUEST_ALL, 0); + if (need_requeue) trunk_connection_requests_requeue(tconn, FR_TRUNK_REQUEST_STATE_ALL, 0); /* * There should be no requests left on this * connection. They should have all been * moved off or failed. */ - rad_assert(fr_trunk_request_count_by_connection(tconn, FR_TRUNK_REQUEST_ALL) == 0); + rad_assert(fr_trunk_request_count_by_connection(tconn, FR_TRUNK_REQUEST_STATE_ALL) == 0); /* * And free the connection... @@ -2611,7 +2611,7 @@ static int _trunk_connection_free(fr_trunk_connection_t *tconn) /* * Remove requests from this connection */ - trunk_connection_requests_dequeue(&to_fail, tconn, FR_TRUNK_REQUEST_ALL, 0); + trunk_connection_requests_dequeue(&to_fail, tconn, FR_TRUNK_REQUEST_STATE_ALL, 0); while ((treq = fr_dlist_next(&to_fail, treq))) { fr_trunk_request_t *prev; @@ -2901,7 +2901,7 @@ static void trunk_rebalance(fr_trunk_t *trunk) * position. */ while ((fr_heap_peek(trunk->active) == head) && - trunk_connection_requests_requeue(fr_heap_peek_tail(trunk->active), FR_TRUNK_REQUEST_PENDING, 1)); + trunk_connection_requests_requeue(fr_heap_peek_tail(trunk->active), FR_TRUNK_REQUEST_STATE_PENDING, 1)); } /** Implements the algorithm we use to manage requests per connection levels @@ -2967,7 +2967,7 @@ static void trunk_manage(fr_trunk_t *trunk, fr_time_t now, char const *caller) */ tconn = NULL; while ((tconn = fr_dlist_next(&trunk->draining, tconn))) { - if (fr_trunk_request_count_by_connection(tconn, FR_TRUNK_REQUEST_ALL) == 0) { + if (fr_trunk_request_count_by_connection(tconn, FR_TRUNK_REQUEST_STATE_ALL) == 0) { fr_trunk_connection_t *prev; prev = fr_dlist_prev(&trunk->draining, tconn); @@ -2995,7 +2995,7 @@ static void trunk_manage(fr_trunk_t *trunk, fr_time_t now, char const *caller) * reactivated. */ while ((tconn = fr_dlist_next(&trunk->draining_to_free, tconn))) { - if (fr_trunk_request_count_by_connection(tconn, FR_TRUNK_REQUEST_ALL) == 0) { + if (fr_trunk_request_count_by_connection(tconn, FR_TRUNK_REQUEST_STATE_ALL) == 0) { fr_trunk_connection_t *prev; DEBUG4("Closing DRAINING-TO-FREE connection with no requests"); @@ -3271,7 +3271,7 @@ do { \ COUNT_BY_STATE(FR_TRUNK_CONN_DRAINING, draining); COUNT_BY_STATE(FR_TRUNK_CONN_DRAINING_TO_FREE, draining_to_free); - if (req_state & FR_TRUNK_REQUEST_BACKLOG) count += fr_heap_num_elements(trunk->backlog); + if (req_state & FR_TRUNK_REQUEST_STATE_BACKLOG) count += fr_heap_num_elements(trunk->backlog); return count; } @@ -3332,7 +3332,7 @@ static uint32_t trunk_requests_per_connnection(uint16_t *conn_count_out, uint32_ FR_TRUNK_CONN_ALL ^ (FR_TRUNK_CONN_DRAINING_TO_FREE | FR_TRUNK_CONN_FAILED | - FR_TRUNK_CONN_CLOSED), FR_TRUNK_REQUEST_ALL); + FR_TRUNK_CONN_CLOSED), FR_TRUNK_REQUEST_STATE_ALL); /* * No connections, but we do have requests @@ -3527,10 +3527,10 @@ static int8_t _trunk_connection_order_by_shortest_queue(void const *one, void co fr_trunk_connection_t const *a = talloc_get_type_abort_const(one, fr_trunk_connection_t); fr_trunk_connection_t const *b = talloc_get_type_abort_const(two, fr_trunk_connection_t); - if (fr_trunk_request_count_by_connection(a, FR_TRUNK_REQUEST_ALL) > - fr_trunk_request_count_by_connection(b, FR_TRUNK_REQUEST_ALL)) return +1; - if (fr_trunk_request_count_by_connection(a, FR_TRUNK_REQUEST_ALL) < - fr_trunk_request_count_by_connection(b, FR_TRUNK_REQUEST_ALL)) return -1; + if (fr_trunk_request_count_by_connection(a, FR_TRUNK_REQUEST_STATE_ALL) > + fr_trunk_request_count_by_connection(b, FR_TRUNK_REQUEST_STATE_ALL)) return +1; + if (fr_trunk_request_count_by_connection(a, FR_TRUNK_REQUEST_STATE_ALL) < + fr_trunk_request_count_by_connection(b, FR_TRUNK_REQUEST_STATE_ALL)) return -1; return 0; } diff --git a/src/lib/server/trunk.h b/src/lib/server/trunk.h index 43bbeb4b31b..737c8d9fa22 100644 --- a/src/lib/server/trunk.h +++ b/src/lib/server/trunk.h @@ -117,48 +117,48 @@ typedef enum { * Allows us to track which */ typedef enum { - FR_TRUNK_REQUEST_UNASSIGNED = 0x0000, //!< Initial state. - FR_TRUNK_REQUEST_BACKLOG = 0x0001, //!< In the backlog. - FR_TRUNK_REQUEST_PENDING = 0x0002, //!< In the queue of a connection - ///< and is pending writing. - FR_TRUNK_REQUEST_PARTIAL = 0x0004, //!< Some of the request was written to the socket, - ///< more of it should be written later. - FR_TRUNK_REQUEST_SENT = 0x0008, //!< Was written to a socket. Waiting for a response. - FR_TRUNK_REQUEST_COMPLETE = 0x0080, //!< The request is complete. - FR_TRUNK_REQUEST_FAILED = 0x0100, //!< The request failed. - FR_TRUNK_REQUEST_CANCEL = 0x0200, //!< A request on a particular socket was cancel. - FR_TRUNK_REQUEST_CANCEL_SENT = 0x0400, //!< We've informed the remote server that - ///< the request has been cancelled. - FR_TRUNK_REQUEST_CANCEL_PARTIAL = 0x0800, //!< We partially wrote a cancellation request. - FR_TRUNK_REQUEST_CANCEL_COMPLETE= 0x1000, //!< Remote server has acknowledged our cancellation. + FR_TRUNK_REQUEST_STATE_UNASSIGNED = 0x0000, //!< Initial state. + FR_TRUNK_REQUEST_STATE_BACKLOG = 0x0001, //!< In the backlog. + FR_TRUNK_REQUEST_STATE_PENDING = 0x0002, //!< In the queue of a connection + ///< and is pending writing. + FR_TRUNK_REQUEST_STATE_PARTIAL = 0x0004, //!< Some of the request was written to the socket, + ///< more of it should be written later. + FR_TRUNK_REQUEST_STATE_SENT = 0x0008, //!< Was written to a socket. Waiting for a response. + FR_TRUNK_REQUEST_STATE_COMPLETE = 0x0080, //!< The request is complete. + FR_TRUNK_REQUEST_STATE_FAILED = 0x0100, //!< The request failed. + FR_TRUNK_REQUEST_STATE_CANCEL = 0x0200, //!< A request on a particular socket was cancel. + FR_TRUNK_REQUEST_STATE_CANCEL_SENT = 0x0400, //!< We've informed the remote server that + ///< the request has been cancelled. + FR_TRUNK_REQUEST_STATE_CANCEL_PARTIAL = 0x0800, //!< We partially wrote a cancellation request. + FR_TRUNK_REQUEST_STATE_CANCEL_COMPLETE = 0x1000, //!< Remote server has acknowledged our cancellation. } fr_trunk_request_state_t; /** All request states * */ -#define FR_TRUNK_REQUEST_ALL \ +#define FR_TRUNK_REQUEST_STATE_ALL \ (\ - FR_TRUNK_REQUEST_BACKLOG | \ - FR_TRUNK_REQUEST_PENDING | \ - FR_TRUNK_REQUEST_PARTIAL | \ - FR_TRUNK_REQUEST_SENT | \ - FR_TRUNK_REQUEST_COMPLETE | \ - FR_TRUNK_REQUEST_FAILED | \ - FR_TRUNK_REQUEST_CANCEL | \ - FR_TRUNK_REQUEST_CANCEL_PARTIAL | \ - FR_TRUNK_REQUEST_CANCEL_SENT | \ - FR_TRUNK_REQUEST_CANCEL_COMPLETE \ + FR_TRUNK_REQUEST_STATE_BACKLOG | \ + FR_TRUNK_REQUEST_STATE_PENDING | \ + FR_TRUNK_REQUEST_STATE_PARTIAL | \ + FR_TRUNK_REQUEST_STATE_SENT | \ + FR_TRUNK_REQUEST_STATE_COMPLETE | \ + FR_TRUNK_REQUEST_STATE_FAILED | \ + FR_TRUNK_REQUEST_STATE_CANCEL | \ + FR_TRUNK_REQUEST_STATE_CANCEL_PARTIAL | \ + FR_TRUNK_REQUEST_STATE_CANCEL_SENT | \ + FR_TRUNK_REQUEST_STATE_CANCEL_COMPLETE \ ) /** All requests in various cancellation states * */ -#define FR_TRUNK_REQUEST_CANCEL_ALL \ +#define FR_TRUNK_REQUEST_STATE_CANCEL_ALL \ (\ - FR_TRUNK_REQUEST_CANCEL | \ - FR_TRUNK_REQUEST_CANCEL_PARTIAL | \ - FR_TRUNK_REQUEST_CANCEL_SENT | \ - FR_TRUNK_REQUEST_CANCEL_COMPLETE \ + FR_TRUNK_REQUEST_STATE_CANCEL | \ + FR_TRUNK_REQUEST_STATE_CANCEL_PARTIAL | \ + FR_TRUNK_REQUEST_STATE_CANCEL_SENT | \ + FR_TRUNK_REQUEST_STATE_CANCEL_COMPLETE \ ) /** Common configuration parameters for a trunk @@ -448,8 +448,8 @@ typedef void (*fr_trunk_request_cancel_mux_t)(fr_trunk_connection_t *tconn, fr_c /** Remove an outstanding request from a tracking/matching structure * - * If the treq (trunk request) is in the FR_TRUNK_REQUEST_PARTIAL or - * FR_TRUNK_REQUEST_SENT states, this callback will be called prior + * If the treq (trunk request) is in the FR_TRUNK_REQUEST_STATE_PARTIAL or + * FR_TRUNK_REQUEST_STATE_SENT states, this callback will be called prior * to moving the treq to a new connection or freeing it. * * The treq, and any associated resources, should be @@ -670,7 +670,7 @@ fr_trunk_request_t *fr_trunk_connection_pop_request(fr_trunk_connection_t *tconn * If #fr_trunk_connection_signal_inactive is being used to remove a congested * connection from the active list (i.e. on receipt of an explicit protocol level * congestion notification), consider calling #fr_trunk_connection_requests_requeue - * with the FR_TRUNK_REQUEST_PENDING state to redistribute that connection's + * with the FR_TRUNK_REQUEST_STATE_PENDING state to redistribute that connection's * backlog to other connections in the trunk. * * @{ diff --git a/src/lib/server/trunk_tests.c b/src/lib/server/trunk_tests.c index 2e980d26888..891fc937fb5 100644 --- a/src/lib/server/trunk_tests.c +++ b/src/lib/server/trunk_tests.c @@ -114,14 +114,14 @@ static void test_demux(UNUSED fr_trunk_connection_t *tconn, fr_connection_t *con * Demuxer can handle both normal requests and cancelled ones */ switch (preq->treq->state) { - case FR_TRUNK_REQUEST_CANCEL: + case FR_TRUNK_REQUEST_STATE_CANCEL: break; /* Hack - just ignore it */ - case FR_TRUNK_REQUEST_CANCEL_SENT: + case FR_TRUNK_REQUEST_STATE_CANCEL_SENT: fr_trunk_request_signal_cancel_complete(preq->treq); break; - case FR_TRUNK_REQUEST_SENT: + case FR_TRUNK_REQUEST_STATE_SENT: fr_trunk_request_signal_complete(preq->treq); break; @@ -673,7 +673,7 @@ static void test_enqueue_basic(void) preq->treq = treq; TEST_CHECK(rcode == FR_TRUNK_ENQUEUE_IN_BACKLOG); - TEST_CHECK(fr_trunk_request_count_by_state(trunk, FR_TRUNK_CONN_ALL, FR_TRUNK_REQUEST_BACKLOG) == 1); + TEST_CHECK(fr_trunk_request_count_by_state(trunk, FR_TRUNK_CONN_ALL, FR_TRUNK_REQUEST_STATE_BACKLOG) == 1); /* * Allow the connection to establish @@ -681,8 +681,8 @@ static void test_enqueue_basic(void) fr_event_corral(el, test_time_base, false); fr_event_service(el); - TEST_CHECK(fr_trunk_request_count_by_state(trunk, FR_TRUNK_CONN_ALL, FR_TRUNK_REQUEST_BACKLOG) == 0); - TEST_CHECK(fr_trunk_request_count_by_state(trunk, FR_TRUNK_CONN_ALL, FR_TRUNK_REQUEST_PENDING) == 1); + TEST_CHECK(fr_trunk_request_count_by_state(trunk, FR_TRUNK_CONN_ALL, FR_TRUNK_REQUEST_STATE_BACKLOG) == 0); + TEST_CHECK(fr_trunk_request_count_by_state(trunk, FR_TRUNK_CONN_ALL, FR_TRUNK_REQUEST_STATE_PENDING) == 1); /* * Should now be active and have a write event @@ -701,7 +701,7 @@ static void test_enqueue_basic(void) fr_event_corral(el, test_time_base, false); fr_event_service(el); - TEST_CHECK(fr_trunk_request_count_by_state(trunk, FR_TRUNK_CONN_ALL, FR_TRUNK_REQUEST_SENT) == 1); + TEST_CHECK(fr_trunk_request_count_by_state(trunk, FR_TRUNK_CONN_ALL, FR_TRUNK_REQUEST_STATE_SENT) == 1); /* * Gives the loopback function a chance @@ -756,7 +756,7 @@ static void test_enqueue_cancellation_points(void) preq = talloc_zero(NULL, test_proto_request_t); fr_trunk_request_enqueue(&treq, trunk, NULL, preq, NULL); - TEST_CASE("cancellation via trunk free - FR_TRUNK_REQUEST_BACKLOG"); + TEST_CASE("cancellation via trunk free - FR_TRUNK_REQUEST_STATE_BACKLOG"); talloc_free(trunk); TEST_CHECK(preq->completed == false); TEST_CHECK(preq->failed == true); @@ -764,14 +764,14 @@ static void test_enqueue_cancellation_points(void) TEST_CHECK(preq->freed == true); talloc_free(preq); - TEST_CASE("cancellation via signal - FR_TRUNK_REQUEST_BACKLOG"); + TEST_CASE("cancellation via signal - FR_TRUNK_REQUEST_STATE_BACKLOG"); trunk = test_setup_trunk(ctx, el, &conf, false, NULL); preq = talloc_zero(NULL, test_proto_request_t); treq = NULL; fr_trunk_request_enqueue(&treq, trunk, NULL, preq, NULL); preq->treq = treq; fr_trunk_request_signal_cancel(treq); - TEST_CHECK(fr_trunk_request_count_by_state(trunk, FR_TRUNK_CONN_ALL, FR_TRUNK_REQUEST_ALL) == 0); + TEST_CHECK(fr_trunk_request_count_by_state(trunk, FR_TRUNK_CONN_ALL, FR_TRUNK_REQUEST_STATE_ALL) == 0); TEST_CHECK(preq->completed == false); TEST_CHECK(preq->failed == false); /* Request/rctx not guaranteed after signal, so can't call fail */ @@ -780,7 +780,7 @@ static void test_enqueue_cancellation_points(void) talloc_free(preq); talloc_free(trunk); - TEST_CASE("cancellation via trunk free - FR_TRUNK_REQUEST_PARTIAL"); + TEST_CASE("cancellation via trunk free - FR_TRUNK_REQUEST_STATE_PARTIAL"); trunk = test_setup_trunk(ctx, el, &conf, false, NULL); preq = talloc_zero(NULL, test_proto_request_t); preq->signal_partial = true; @@ -794,7 +794,7 @@ static void test_enqueue_cancellation_points(void) fr_event_corral(el, test_time_base, false); /* Send the request */ fr_event_service(el); - TEST_CHECK(fr_trunk_request_count_by_state(trunk, FR_TRUNK_CONN_ALL, FR_TRUNK_REQUEST_PARTIAL)); + TEST_CHECK(fr_trunk_request_count_by_state(trunk, FR_TRUNK_CONN_ALL, FR_TRUNK_REQUEST_STATE_PARTIAL)); talloc_free(trunk); @@ -804,7 +804,7 @@ static void test_enqueue_cancellation_points(void) TEST_CHECK(preq->freed == true); talloc_free(preq); - TEST_CASE("cancellation via signal - FR_TRUNK_REQUEST_PARTIAL"); + TEST_CASE("cancellation via signal - FR_TRUNK_REQUEST_STATE_PARTIAL"); trunk = test_setup_trunk(ctx, el, &conf, false, NULL); preq = talloc_zero(NULL, test_proto_request_t); preq->signal_partial = true; @@ -818,9 +818,9 @@ static void test_enqueue_cancellation_points(void) fr_event_corral(el, test_time_base, false); /* Send the request */ fr_event_service(el); - TEST_CHECK(fr_trunk_request_count_by_state(trunk, FR_TRUNK_CONN_ALL, FR_TRUNK_REQUEST_PARTIAL) == 1); + TEST_CHECK(fr_trunk_request_count_by_state(trunk, FR_TRUNK_CONN_ALL, FR_TRUNK_REQUEST_STATE_PARTIAL) == 1); fr_trunk_request_signal_cancel(treq); - TEST_CHECK(fr_trunk_request_count_by_state(trunk, FR_TRUNK_CONN_ALL, FR_TRUNK_REQUEST_ALL) == 0); + TEST_CHECK(fr_trunk_request_count_by_state(trunk, FR_TRUNK_CONN_ALL, FR_TRUNK_REQUEST_STATE_ALL) == 0); TEST_CHECK(preq->completed == false); TEST_CHECK(preq->failed == false); /* Request/rctx not guaranteed after signal, so can't call fail */ @@ -829,7 +829,7 @@ static void test_enqueue_cancellation_points(void) talloc_free(preq); talloc_free(trunk); - TEST_CASE("cancellation via trunk free - FR_TRUNK_REQUEST_SENT"); + TEST_CASE("cancellation via trunk free - FR_TRUNK_REQUEST_STATE_SENT"); trunk = test_setup_trunk(ctx, el, &conf, false, NULL); preq = talloc_zero(NULL, test_proto_request_t); treq = NULL; @@ -842,7 +842,7 @@ static void test_enqueue_cancellation_points(void) fr_event_corral(el, test_time_base, false); /* Send the request */ fr_event_service(el); - TEST_CHECK(fr_trunk_request_count_by_state(trunk, FR_TRUNK_CONN_ALL, FR_TRUNK_REQUEST_SENT) == 1); + TEST_CHECK(fr_trunk_request_count_by_state(trunk, FR_TRUNK_CONN_ALL, FR_TRUNK_REQUEST_STATE_SENT) == 1); talloc_free(trunk); TEST_CHECK(preq->completed == false); @@ -851,7 +851,7 @@ static void test_enqueue_cancellation_points(void) TEST_CHECK(preq->freed == true); talloc_free(preq); - TEST_CASE("cancellation via signal - FR_TRUNK_REQUEST_SENT"); + TEST_CASE("cancellation via signal - FR_TRUNK_REQUEST_STATE_SENT"); trunk = test_setup_trunk(ctx, el, &conf, false, NULL); preq = talloc_zero(NULL, test_proto_request_t); treq = NULL; @@ -864,9 +864,9 @@ static void test_enqueue_cancellation_points(void) fr_event_corral(el, test_time_base, false); /* Send the request */ fr_event_service(el); - TEST_CHECK(fr_trunk_request_count_by_state(trunk, FR_TRUNK_CONN_ALL, FR_TRUNK_REQUEST_SENT) == 1); + TEST_CHECK(fr_trunk_request_count_by_state(trunk, FR_TRUNK_CONN_ALL, FR_TRUNK_REQUEST_STATE_SENT) == 1); fr_trunk_request_signal_cancel(treq); - TEST_CHECK(fr_trunk_request_count_by_state(trunk, FR_TRUNK_CONN_ALL, FR_TRUNK_REQUEST_ALL) == 0); + TEST_CHECK(fr_trunk_request_count_by_state(trunk, FR_TRUNK_CONN_ALL, FR_TRUNK_REQUEST_STATE_ALL) == 0); TEST_CHECK(preq->completed == false); TEST_CHECK(preq->failed == false); /* Request/rctx not guaranteed after signal, so can't call fail */ @@ -875,7 +875,7 @@ static void test_enqueue_cancellation_points(void) talloc_free(preq); talloc_free(trunk); - TEST_CASE("cancellation via trunk free - FR_TRUNK_REQUEST_CANCEL_PARTIAL"); + TEST_CASE("cancellation via trunk free - FR_TRUNK_REQUEST_STATE_CANCEL_PARTIAL"); trunk = test_setup_trunk(ctx, el, &conf, true, NULL); preq = talloc_zero(NULL, test_proto_request_t); preq->signal_cancel_partial = true; @@ -889,14 +889,14 @@ static void test_enqueue_cancellation_points(void) fr_event_corral(el, test_time_base, false); /* Send the request */ fr_event_service(el); - TEST_CHECK(fr_trunk_request_count_by_state(trunk, FR_TRUNK_CONN_ALL, FR_TRUNK_REQUEST_SENT) == 1); + TEST_CHECK(fr_trunk_request_count_by_state(trunk, FR_TRUNK_CONN_ALL, FR_TRUNK_REQUEST_STATE_SENT) == 1); fr_trunk_request_signal_cancel(treq); - TEST_CHECK(fr_trunk_request_count_by_state(trunk, FR_TRUNK_CONN_ALL, FR_TRUNK_REQUEST_CANCEL) == 1); + TEST_CHECK(fr_trunk_request_count_by_state(trunk, FR_TRUNK_CONN_ALL, FR_TRUNK_REQUEST_STATE_CANCEL) == 1); fr_event_corral(el, test_time_base, false); /* Send the cancellation request */ fr_event_service(el); - TEST_CHECK(fr_trunk_request_count_by_state(trunk, FR_TRUNK_CONN_ALL, FR_TRUNK_REQUEST_CANCEL_PARTIAL) == 1); + TEST_CHECK(fr_trunk_request_count_by_state(trunk, FR_TRUNK_CONN_ALL, FR_TRUNK_REQUEST_STATE_CANCEL_PARTIAL) == 1); talloc_free(trunk); @@ -906,7 +906,7 @@ static void test_enqueue_cancellation_points(void) TEST_CHECK(preq->freed == true); talloc_free(preq); - TEST_CASE("cancellation via trunk free - FR_TRUNK_REQUEST_CANCEL_SENT"); + TEST_CASE("cancellation via trunk free - FR_TRUNK_REQUEST_STATE_CANCEL_SENT"); trunk = test_setup_trunk(ctx, el, &conf, true, NULL); preq = talloc_zero(NULL, test_proto_request_t); treq = NULL; @@ -919,14 +919,14 @@ static void test_enqueue_cancellation_points(void) fr_event_corral(el, test_time_base, false); /* Send the request */ fr_event_service(el); - TEST_CHECK(fr_trunk_request_count_by_state(trunk, FR_TRUNK_CONN_ALL, FR_TRUNK_REQUEST_SENT) == 1); + TEST_CHECK(fr_trunk_request_count_by_state(trunk, FR_TRUNK_CONN_ALL, FR_TRUNK_REQUEST_STATE_SENT) == 1); fr_trunk_request_signal_cancel(treq); - TEST_CHECK(fr_trunk_request_count_by_state(trunk, FR_TRUNK_CONN_ALL, FR_TRUNK_REQUEST_CANCEL) == 1); + TEST_CHECK(fr_trunk_request_count_by_state(trunk, FR_TRUNK_CONN_ALL, FR_TRUNK_REQUEST_STATE_CANCEL) == 1); fr_event_corral(el, test_time_base, false); /* Send the cancellation request */ fr_event_service(el); - TEST_CHECK(fr_trunk_request_count_by_state(trunk, FR_TRUNK_CONN_ALL, FR_TRUNK_REQUEST_CANCEL_SENT) == 1); + TEST_CHECK(fr_trunk_request_count_by_state(trunk, FR_TRUNK_CONN_ALL, FR_TRUNK_REQUEST_STATE_CANCEL_SENT) == 1); talloc_free(trunk); @@ -936,7 +936,7 @@ static void test_enqueue_cancellation_points(void) TEST_CHECK(preq->freed == true); talloc_free(preq); - TEST_CASE("trunk free after FR_TRUNK_REQUEST_CANCEL_COMPLETE"); + TEST_CASE("trunk free after FR_TRUNK_REQUEST_STATE_CANCEL_COMPLETE"); trunk = test_setup_trunk(ctx, el, &conf, true, NULL); preq = talloc_zero(NULL, test_proto_request_t); treq = NULL; @@ -949,14 +949,14 @@ static void test_enqueue_cancellation_points(void) fr_event_corral(el, test_time_base, false); /* Send the request */ fr_event_service(el); - TEST_CHECK(fr_trunk_request_count_by_state(trunk, FR_TRUNK_CONN_ALL, FR_TRUNK_REQUEST_SENT) == 1); + TEST_CHECK(fr_trunk_request_count_by_state(trunk, FR_TRUNK_CONN_ALL, FR_TRUNK_REQUEST_STATE_SENT) == 1); fr_trunk_request_signal_cancel(treq); - TEST_CHECK(fr_trunk_request_count_by_state(trunk, FR_TRUNK_CONN_ALL, FR_TRUNK_REQUEST_CANCEL) == 1); + TEST_CHECK(fr_trunk_request_count_by_state(trunk, FR_TRUNK_CONN_ALL, FR_TRUNK_REQUEST_STATE_CANCEL) == 1); fr_event_corral(el, test_time_base, false); /* Send the cancellation request */ fr_event_service(el); - TEST_CHECK(fr_trunk_request_count_by_state(trunk, FR_TRUNK_CONN_ALL, FR_TRUNK_REQUEST_CANCEL_SENT) == 1); + TEST_CHECK(fr_trunk_request_count_by_state(trunk, FR_TRUNK_CONN_ALL, FR_TRUNK_REQUEST_STATE_CANCEL_SENT) == 1); fr_event_corral(el, test_time_base, false); /* Loop the cancel request back round */ fr_event_service(el); @@ -964,7 +964,7 @@ static void test_enqueue_cancellation_points(void) fr_event_corral(el, test_time_base, false); /* Read the cancel ACK (such that it is) */ fr_event_service(el); - TEST_CHECK(fr_trunk_request_count_by_state(trunk, FR_TRUNK_CONN_ALL, FR_TRUNK_REQUEST_ALL) == 0); + TEST_CHECK(fr_trunk_request_count_by_state(trunk, FR_TRUNK_CONN_ALL, FR_TRUNK_REQUEST_STATE_ALL) == 0); talloc_free(trunk); @@ -1004,7 +1004,7 @@ static void test_partial_to_complete_states(void) preq->signal_partial = true; preq->signal_cancel_partial = true; - TEST_CASE("FR_TRUNK_REQUEST_PARTIAL -> FR_TRUNK_REQUEST_SENT"); + TEST_CASE("FR_TRUNK_REQUEST_STATE_PARTIAL -> FR_TRUNK_REQUEST_STATE_SENT"); fr_trunk_request_enqueue(&treq, trunk, NULL, preq, NULL); preq->treq = treq; @@ -1015,32 +1015,32 @@ static void test_partial_to_complete_states(void) fr_event_corral(el, test_time_base, false); /* Send the request */ fr_event_service(el); - TEST_CHECK(fr_trunk_request_count_by_state(trunk, FR_TRUNK_CONN_ALL, FR_TRUNK_REQUEST_PARTIAL) == 1); + TEST_CHECK(fr_trunk_request_count_by_state(trunk, FR_TRUNK_CONN_ALL, FR_TRUNK_REQUEST_STATE_PARTIAL) == 1); fr_event_corral(el, test_time_base, false); /* Complete the partial request */ fr_event_service(el); - TEST_CHECK(fr_trunk_request_count_by_state(trunk, FR_TRUNK_CONN_ALL, FR_TRUNK_REQUEST_SENT) == 1); + TEST_CHECK(fr_trunk_request_count_by_state(trunk, FR_TRUNK_CONN_ALL, FR_TRUNK_REQUEST_STATE_SENT) == 1); fr_trunk_request_signal_cancel(treq); - TEST_CHECK(fr_trunk_request_count_by_state(trunk, FR_TRUNK_CONN_ALL, FR_TRUNK_REQUEST_CANCEL) == 1); + TEST_CHECK(fr_trunk_request_count_by_state(trunk, FR_TRUNK_CONN_ALL, FR_TRUNK_REQUEST_STATE_CANCEL) == 1); - TEST_CASE("FR_TRUNK_REQUEST_CANCEL_PARTIAL -> FR_TRUNK_REQUEST_CANCEL_SENT"); + TEST_CASE("FR_TRUNK_REQUEST_STATE_CANCEL_PARTIAL -> FR_TRUNK_REQUEST_STATE_CANCEL_SENT"); fr_event_corral(el, test_time_base, false); /* Send partial cancel request */ fr_event_service(el); - TEST_CHECK(fr_trunk_request_count_by_state(trunk, FR_TRUNK_CONN_ALL, FR_TRUNK_REQUEST_CANCEL_PARTIAL) == 1); + TEST_CHECK(fr_trunk_request_count_by_state(trunk, FR_TRUNK_CONN_ALL, FR_TRUNK_REQUEST_STATE_CANCEL_PARTIAL) == 1); fr_event_corral(el, test_time_base, false); /* Complete the partial cancellation */ fr_event_service(el); - TEST_CHECK(fr_trunk_request_count_by_state(trunk, FR_TRUNK_CONN_ALL, FR_TRUNK_REQUEST_CANCEL_SENT) == 1); + TEST_CHECK(fr_trunk_request_count_by_state(trunk, FR_TRUNK_CONN_ALL, FR_TRUNK_REQUEST_STATE_CANCEL_SENT) == 1); fr_event_corral(el, test_time_base, false); /* Loop the cancellation request back */ fr_event_service(el); - TEST_CHECK(fr_trunk_request_count_by_state(trunk, FR_TRUNK_CONN_ALL, FR_TRUNK_REQUEST_ALL) == 0); + TEST_CHECK(fr_trunk_request_count_by_state(trunk, FR_TRUNK_CONN_ALL, FR_TRUNK_REQUEST_STATE_ALL) == 0); talloc_free(trunk); @@ -1087,7 +1087,7 @@ static void test_requeue_on_reconnect(void) fr_event_corral(el, test_time_base, false); /* Connect the connection(s) */ fr_event_service(el); - TEST_CASE("dequeue on reconnect - FR_TRUNK_REQUEST_PENDING"); + TEST_CASE("dequeue on reconnect - FR_TRUNK_REQUEST_STATE_PENDING"); TEST_CHECK(fr_trunk_connection_count_by_state(trunk, FR_TRUNK_CONN_ACTIVE) == 2); @@ -1095,7 +1095,7 @@ static void test_requeue_on_reconnect(void) preq->treq = treq; tconn = treq->pub.tconn; /* Store the conn the request was assigned to */ - TEST_CHECK(fr_trunk_request_count_by_state(trunk, FR_TRUNK_CONN_ALL, FR_TRUNK_REQUEST_PENDING) == 1); + TEST_CHECK(fr_trunk_request_count_by_state(trunk, FR_TRUNK_CONN_ALL, FR_TRUNK_REQUEST_STATE_PENDING) == 1); fr_trunk_connection_signal_reconnect(tconn, FR_CONNECTION_FAILED); @@ -1103,16 +1103,16 @@ static void test_requeue_on_reconnect(void) * Should be reassigned to the other connection */ TEST_CHECK(tconn != treq->pub.tconn); - TEST_CHECK(fr_trunk_request_count_by_state(trunk, FR_TRUNK_CONN_ALL, FR_TRUNK_REQUEST_PENDING) == 1); + TEST_CHECK(fr_trunk_request_count_by_state(trunk, FR_TRUNK_CONN_ALL, FR_TRUNK_REQUEST_STATE_PENDING) == 1); /* * Should be reassigned to the backlog */ fr_trunk_connection_signal_reconnect(treq->pub.tconn, FR_CONNECTION_FAILED); - TEST_CHECK(fr_trunk_request_count_by_state(trunk, FR_TRUNK_CONN_ALL, FR_TRUNK_REQUEST_BACKLOG) == 1); + TEST_CHECK(fr_trunk_request_count_by_state(trunk, FR_TRUNK_CONN_ALL, FR_TRUNK_REQUEST_STATE_BACKLOG) == 1); TEST_CHECK(!treq->pub.tconn); - TEST_CASE("cancel on reconnect - FR_TRUNK_REQUEST_PARTIAL"); + TEST_CASE("cancel on reconnect - FR_TRUNK_REQUEST_STATE_PARTIAL"); /* * Allow the connections to reconnect @@ -1125,14 +1125,14 @@ static void test_requeue_on_reconnect(void) * Request should now be assigned back to one of the reconnected * connections. */ - TEST_CHECK(fr_trunk_request_count_by_state(trunk, FR_TRUNK_CONN_ALL, FR_TRUNK_REQUEST_PENDING) == 1); + TEST_CHECK(fr_trunk_request_count_by_state(trunk, FR_TRUNK_CONN_ALL, FR_TRUNK_REQUEST_STATE_PENDING) == 1); TEST_CHECK(treq->pub.tconn != NULL); test_time_base += NSEC * 1; fr_event_corral(el, test_time_base, false); /* Send the request (partially) */ fr_event_service(el); - TEST_CHECK(fr_trunk_request_count_by_state(trunk, FR_TRUNK_CONN_ALL, FR_TRUNK_REQUEST_PARTIAL) == 1); + TEST_CHECK(fr_trunk_request_count_by_state(trunk, FR_TRUNK_CONN_ALL, FR_TRUNK_REQUEST_STATE_PARTIAL) == 1); /* * Reconnect the connection. @@ -1150,10 +1150,10 @@ static void test_requeue_on_reconnect(void) preq->cancelled = false; /* Reset */ - TEST_CHECK(fr_trunk_request_count_by_state(trunk, FR_TRUNK_CONN_ALL, FR_TRUNK_REQUEST_PENDING) == 1); + TEST_CHECK(fr_trunk_request_count_by_state(trunk, FR_TRUNK_CONN_ALL, FR_TRUNK_REQUEST_STATE_PENDING) == 1); TEST_CHECK(tconn != treq->pub.tconn); /* Ensure it moved */ - TEST_CASE("cancel on reconnect - FR_TRUNK_REQUEST_SENT"); + TEST_CASE("cancel on reconnect - FR_TRUNK_REQUEST_STATE_SENT"); /* * Sent the request (fully) @@ -1161,12 +1161,12 @@ static void test_requeue_on_reconnect(void) fr_event_corral(el, test_time_base, false); /* Send the request (partially) */ fr_event_service(el); - TEST_CHECK(fr_trunk_request_count_by_state(trunk, FR_TRUNK_CONN_ALL, FR_TRUNK_REQUEST_SENT) == 1); + TEST_CHECK(fr_trunk_request_count_by_state(trunk, FR_TRUNK_CONN_ALL, FR_TRUNK_REQUEST_STATE_SENT) == 1); tconn = treq->pub.tconn; fr_trunk_connection_signal_reconnect(treq->pub.tconn, FR_CONNECTION_FAILED); - TEST_CHECK(fr_trunk_request_count_by_state(trunk, FR_TRUNK_CONN_ALL, FR_TRUNK_REQUEST_PENDING) == 1); + TEST_CHECK(fr_trunk_request_count_by_state(trunk, FR_TRUNK_CONN_ALL, FR_TRUNK_REQUEST_STATE_PENDING) == 1); /* * Allow the connections to reconnect @@ -1184,13 +1184,13 @@ static void test_requeue_on_reconnect(void) preq->cancelled = false; /* Reset */ - TEST_CASE("free on reconnect - FR_TRUNK_REQUEST_CANCEL"); + TEST_CASE("free on reconnect - FR_TRUNK_REQUEST_STATE_CANCEL"); /* * Signal the request should be cancelled */ fr_trunk_request_signal_cancel(treq); - TEST_CHECK(fr_trunk_request_count_by_state(trunk, FR_TRUNK_CONN_ALL, FR_TRUNK_REQUEST_CANCEL) == 1); + TEST_CHECK(fr_trunk_request_count_by_state(trunk, FR_TRUNK_CONN_ALL, FR_TRUNK_REQUEST_STATE_CANCEL) == 1); /* * Requests in the cancel state, are @@ -1215,7 +1215,7 @@ static void test_requeue_on_reconnect(void) fr_event_corral(el, test_time_base, false); fr_event_service(el); - TEST_CASE("free on reconnect - FR_TRUNK_REQUEST_CANCEL_PARTIAL"); + TEST_CASE("free on reconnect - FR_TRUNK_REQUEST_STATE_CANCEL_PARTIAL"); /* * Queue up a new request, and get it to the cancel-partial state. @@ -1225,7 +1225,7 @@ static void test_requeue_on_reconnect(void) treq = NULL; fr_trunk_request_enqueue(&treq, trunk, NULL, preq, NULL); - TEST_CHECK(fr_trunk_request_count_by_state(trunk, FR_TRUNK_CONN_ALL, FR_TRUNK_REQUEST_PENDING) == 1); + TEST_CHECK(fr_trunk_request_count_by_state(trunk, FR_TRUNK_CONN_ALL, FR_TRUNK_REQUEST_STATE_PENDING) == 1); /* * Sent the request (fully) @@ -1234,10 +1234,10 @@ static void test_requeue_on_reconnect(void) fr_event_corral(el, test_time_base, false); /* Send the request (fully) */ fr_event_service(el); - TEST_CHECK(fr_trunk_request_count_by_state(trunk, FR_TRUNK_CONN_ALL, FR_TRUNK_REQUEST_SENT) == 1); + TEST_CHECK(fr_trunk_request_count_by_state(trunk, FR_TRUNK_CONN_ALL, FR_TRUNK_REQUEST_STATE_SENT) == 1); fr_trunk_request_signal_cancel(treq); /* Cancel the request */ - TEST_CHECK(fr_trunk_request_count_by_state(trunk, FR_TRUNK_CONN_ALL, FR_TRUNK_REQUEST_CANCEL) == 1); + TEST_CHECK(fr_trunk_request_count_by_state(trunk, FR_TRUNK_CONN_ALL, FR_TRUNK_REQUEST_STATE_CANCEL) == 1); /* * Transition to cancel partial @@ -1246,7 +1246,7 @@ static void test_requeue_on_reconnect(void) fr_event_corral(el, test_time_base, false); fr_event_service(el); - TEST_CHECK(fr_trunk_request_count_by_state(trunk, FR_TRUNK_CONN_ALL, FR_TRUNK_REQUEST_CANCEL_PARTIAL) == 1); + TEST_CHECK(fr_trunk_request_count_by_state(trunk, FR_TRUNK_CONN_ALL, FR_TRUNK_REQUEST_STATE_CANCEL_PARTIAL) == 1); /* * Trigger a reconnection @@ -1269,7 +1269,7 @@ static void test_requeue_on_reconnect(void) fr_event_corral(el, test_time_base, false); fr_event_service(el); - TEST_CASE("free on reconnect - FR_TRUNK_REQUEST_CANCEL_SENT"); + TEST_CASE("free on reconnect - FR_TRUNK_REQUEST_STATE_CANCEL_SENT"); /* * Queue up a new request, and get it to the cancel-sent state. @@ -1278,7 +1278,7 @@ static void test_requeue_on_reconnect(void) treq = NULL; fr_trunk_request_enqueue(&treq, trunk, NULL, preq, NULL); - TEST_CHECK(fr_trunk_request_count_by_state(trunk, FR_TRUNK_CONN_ALL, FR_TRUNK_REQUEST_PENDING) == 1); + TEST_CHECK(fr_trunk_request_count_by_state(trunk, FR_TRUNK_CONN_ALL, FR_TRUNK_REQUEST_STATE_PENDING) == 1); /* * Sent the request (fully) @@ -1287,10 +1287,10 @@ static void test_requeue_on_reconnect(void) fr_event_corral(el, test_time_base, false); /* Send the request (fully) */ fr_event_service(el); - TEST_CHECK(fr_trunk_request_count_by_state(trunk, FR_TRUNK_CONN_ALL, FR_TRUNK_REQUEST_SENT) == 1); + TEST_CHECK(fr_trunk_request_count_by_state(trunk, FR_TRUNK_CONN_ALL, FR_TRUNK_REQUEST_STATE_SENT) == 1); fr_trunk_request_signal_cancel(treq); /* Cancel the request */ - TEST_CHECK(fr_trunk_request_count_by_state(trunk, FR_TRUNK_CONN_ALL, FR_TRUNK_REQUEST_CANCEL) == 1); + TEST_CHECK(fr_trunk_request_count_by_state(trunk, FR_TRUNK_CONN_ALL, FR_TRUNK_REQUEST_STATE_CANCEL) == 1); /* * Transition to cancel @@ -1299,7 +1299,7 @@ static void test_requeue_on_reconnect(void) fr_event_corral(el, test_time_base, false); fr_event_service(el); - TEST_CHECK(fr_trunk_request_count_by_state(trunk, FR_TRUNK_CONN_ALL, FR_TRUNK_REQUEST_CANCEL_SENT) == 1); + TEST_CHECK(fr_trunk_request_count_by_state(trunk, FR_TRUNK_CONN_ALL, FR_TRUNK_REQUEST_STATE_CANCEL_SENT) == 1); /* * Trigger a reconnection @@ -1365,7 +1365,7 @@ static void test_connection_start_on_enqueue(void) fr_trunk_request_enqueue(&treq_c, trunk, NULL, preq, NULL); TEST_CHECK(fr_trunk_connection_count_by_state(trunk, FR_TRUNK_CONN_ACTIVE) == 1); - TEST_CHECK(fr_trunk_request_count_by_state(trunk, FR_TRUNK_CONN_ALL, FR_TRUNK_REQUEST_PENDING) == 3); + TEST_CHECK(fr_trunk_request_count_by_state(trunk, FR_TRUNK_CONN_ALL, FR_TRUNK_REQUEST_STATE_PENDING) == 3); talloc_free(ctx); talloc_free(preq); @@ -1415,8 +1415,8 @@ static void test_connection_rebalance_requests(void) fr_trunk_request_enqueue(&treq_c, trunk, NULL, preq, NULL); TEST_CASE("C1 connected, C2 inactive, R3 - Enqueued"); - TEST_CHECK(fr_trunk_request_count_by_state(trunk, FR_TRUNK_CONN_ALL, FR_TRUNK_REQUEST_PENDING) == 3); - TEST_CHECK(fr_trunk_request_count_by_connection(tconn, FR_TRUNK_REQUEST_ALL) == 0); + TEST_CHECK(fr_trunk_request_count_by_state(trunk, FR_TRUNK_CONN_ALL, FR_TRUNK_REQUEST_STATE_PENDING) == 3); + TEST_CHECK(fr_trunk_request_count_by_connection(tconn, FR_TRUNK_REQUEST_STATE_ALL) == 0); /* * Now mark the previous connection as @@ -1426,8 +1426,8 @@ static void test_connection_rebalance_requests(void) TEST_CASE("C2 active, R3 - Signal active, should balance"); fr_trunk_connection_signal_active(tconn); - TEST_CHECK(fr_trunk_request_count_by_state(trunk, FR_TRUNK_CONN_ALL, FR_TRUNK_REQUEST_PENDING) == 3); - TEST_CHECK(fr_trunk_request_count_by_connection(tconn, FR_TRUNK_REQUEST_ALL) >= 1); + TEST_CHECK(fr_trunk_request_count_by_state(trunk, FR_TRUNK_CONN_ALL, FR_TRUNK_REQUEST_STATE_PENDING) == 3); + TEST_CHECK(fr_trunk_request_count_by_connection(tconn, FR_TRUNK_REQUEST_STATE_ALL) >= 1); talloc_free(ctx); talloc_free(preq); @@ -1503,8 +1503,8 @@ static void test_connection_levels_max(void) fr_event_service(el); TEST_CASE("C1 active, R4 - Check pending 2"); - TEST_CHECK(fr_trunk_request_count_by_state(trunk, FR_TRUNK_CONN_ALL, FR_TRUNK_REQUEST_PENDING) == 2); - TEST_CHECK(fr_trunk_request_count_by_state(trunk, FR_TRUNK_CONN_ALL, FR_TRUNK_REQUEST_BACKLOG) == 2); + TEST_CHECK(fr_trunk_request_count_by_state(trunk, FR_TRUNK_CONN_ALL, FR_TRUNK_REQUEST_STATE_PENDING) == 2); + TEST_CHECK(fr_trunk_request_count_by_state(trunk, FR_TRUNK_CONN_ALL, FR_TRUNK_REQUEST_STATE_BACKLOG) == 2); /* * Sending requests @@ -1513,7 +1513,7 @@ static void test_connection_levels_max(void) fr_event_service(el); TEST_CASE("C1 active, R4 - Check sent 2"); - TEST_CHECK(fr_trunk_request_count_by_state(trunk, FR_TRUNK_CONN_ALL, FR_TRUNK_REQUEST_SENT) == 2); + TEST_CHECK(fr_trunk_request_count_by_state(trunk, FR_TRUNK_CONN_ALL, FR_TRUNK_REQUEST_STATE_SENT) == 2); /* * Looping I/O @@ -1537,8 +1537,8 @@ static void test_connection_levels_max(void) TEST_CHECK(preq_b->cancelled == false); TEST_CHECK(preq_b->freed == true); - TEST_CHECK(fr_trunk_request_count_by_state(trunk, FR_TRUNK_CONN_ALL, FR_TRUNK_REQUEST_PENDING) == 2); - TEST_CHECK(fr_trunk_request_count_by_state(trunk, FR_TRUNK_CONN_ALL, FR_TRUNK_REQUEST_BACKLOG) == 0); + TEST_CHECK(fr_trunk_request_count_by_state(trunk, FR_TRUNK_CONN_ALL, FR_TRUNK_REQUEST_STATE_PENDING) == 2); + TEST_CHECK(fr_trunk_request_count_by_state(trunk, FR_TRUNK_CONN_ALL, FR_TRUNK_REQUEST_STATE_BACKLOG) == 0); TEST_CASE("C1 active, R0 - Check complete 2, pending 0"); @@ -1570,7 +1570,7 @@ static void test_connection_levels_max(void) TEST_CHECK(preq_d->cancelled == false); TEST_CHECK(preq_d->freed == true); - TEST_CHECK(fr_trunk_request_count_by_state(trunk, FR_TRUNK_CONN_ALL, FR_TRUNK_REQUEST_ALL) == 0); + TEST_CHECK(fr_trunk_request_count_by_state(trunk, FR_TRUNK_CONN_ALL, FR_TRUNK_REQUEST_STATE_ALL) == 0); talloc_free(trunk); talloc_free(ctx); @@ -1625,7 +1625,7 @@ static void test_connection_levels_alternating_edges(void) fr_event_corral(el, test_time_base, false); fr_event_service(el); - TEST_CHECK(fr_trunk_request_count_by_state(trunk, FR_TRUNK_CONN_ALL, FR_TRUNK_REQUEST_PENDING) == 2); + TEST_CHECK(fr_trunk_request_count_by_state(trunk, FR_TRUNK_CONN_ALL, FR_TRUNK_REQUEST_STATE_PENDING) == 2); TEST_CASE("C1 connected, R3 - should spawn"); ALLOC_REQ(c); @@ -1635,7 +1635,7 @@ static void test_connection_levels_alternating_edges(void) fr_event_corral(el, test_time_base, false); fr_event_service(el); - TEST_CHECK(fr_trunk_request_count_by_state(trunk, FR_TRUNK_CONN_ALL, FR_TRUNK_REQUEST_SENT) == 3); + TEST_CHECK(fr_trunk_request_count_by_state(trunk, FR_TRUNK_CONN_ALL, FR_TRUNK_REQUEST_STATE_SENT) == 3); TEST_CHECK(fr_trunk_connection_count_by_state(trunk, FR_TRUNK_CONN_ACTIVE) == 1); TEST_CHECK(fr_trunk_connection_count_by_state(trunk, FR_TRUNK_CONN_CONNECTING) == 1); @@ -1650,7 +1650,7 @@ static void test_connection_levels_alternating_edges(void) test_time_base += NSEC * 1; TEST_CASE("C1 connected, C2 connecting, R2 - MUST NOT spawn"); - TEST_CHECK(fr_trunk_request_count_by_state(trunk, FR_TRUNK_CONN_ALL, FR_TRUNK_REQUEST_ALL) == 3); + TEST_CHECK(fr_trunk_request_count_by_state(trunk, FR_TRUNK_CONN_ALL, FR_TRUNK_REQUEST_STATE_ALL) == 3); TEST_CHECK(fr_trunk_connection_count_by_state(trunk, FR_TRUNK_CONN_ACTIVE) == 2); /* @@ -1662,7 +1662,7 @@ static void test_connection_levels_alternating_edges(void) test_time_base += NSEC * 1; TEST_CASE("C1 connected, R0"); - TEST_CHECK(fr_trunk_request_count_by_state(trunk, FR_TRUNK_CONN_ALL, FR_TRUNK_REQUEST_ALL) == 0); + TEST_CHECK(fr_trunk_request_count_by_state(trunk, FR_TRUNK_CONN_ALL, FR_TRUNK_REQUEST_STATE_ALL) == 0); TEST_CHECK(fr_trunk_connection_count_by_state(trunk, FR_TRUNK_CONN_ACTIVE) == 1); /* @@ -1702,7 +1702,7 @@ static void test_connection_levels_alternating_edges(void) fr_event_corral(el, test_time_base, false); fr_event_service(el); - TEST_CHECK(fr_trunk_request_count_by_state(trunk, FR_TRUNK_CONN_ALL, FR_TRUNK_REQUEST_PENDING) == 2); + TEST_CHECK(fr_trunk_request_count_by_state(trunk, FR_TRUNK_CONN_ALL, FR_TRUNK_REQUEST_STATE_PENDING) == 2); TEST_CASE("C1 connected, R3 - should spawn"); ALLOC_REQ(c); @@ -1712,7 +1712,7 @@ static void test_connection_levels_alternating_edges(void) fr_event_corral(el, test_time_base, false); fr_event_service(el); - TEST_CHECK(fr_trunk_request_count_by_state(trunk, FR_TRUNK_CONN_ALL, FR_TRUNK_REQUEST_SENT) == 3); + TEST_CHECK(fr_trunk_request_count_by_state(trunk, FR_TRUNK_CONN_ALL, FR_TRUNK_REQUEST_STATE_SENT) == 3); TEST_CHECK(fr_trunk_connection_count_by_state(trunk, FR_TRUNK_CONN_ACTIVE) == 1); TEST_CHECK(fr_trunk_connection_count_by_state(trunk, FR_TRUNK_CONN_CONNECTING) == 1); diff --git a/src/modules/rlm_radius/rlm_radius_udp.c b/src/modules/rlm_radius/rlm_radius_udp.c index aeb34c03a72..59369f975d3 100644 --- a/src/modules/rlm_radius/rlm_radius_udp.c +++ b/src/modules/rlm_radius/rlm_radius_udp.c @@ -1079,7 +1079,7 @@ static void check_for_zombie(fr_event_list_t *el, udp_handle_t *h, fr_time_t now return; } - (void) fr_trunk_connection_requests_requeue(h->c->tconn, FR_TRUNK_REQUEST_ALL, 0); + (void) fr_trunk_connection_requests_requeue(h->c->tconn, FR_TRUNK_REQUEST_STATE_ALL, 0); return; } @@ -1094,7 +1094,7 @@ static void check_for_zombie(fr_event_list_t *el, udp_handle_t *h, fr_time_t now * Move ALL requests to other connections! */ fr_trunk_connection_signal_inactive(h->c->tconn); - fr_trunk_connection_requests_requeue(h->c->tconn, FR_TRUNK_REQUEST_ALL, 0); + fr_trunk_connection_requests_requeue(h->c->tconn, FR_TRUNK_REQUEST_STATE_ALL, 0); status_check_timer(el, 0, u); }