};
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);
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;
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
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 */
/*
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;
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
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);
/*
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;
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;
}
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);
/*
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 */
}
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 */
}
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;
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 */
}
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 - "
* 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;
* 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) {
/*
* ...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);
/*
* 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) {
/*
* 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);
/*
* 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
* 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;
"%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;
"%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;
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;
/** 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.
*/
* 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.
*
* 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;
/*
"%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;
"%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;
__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;
* 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:
* 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;
{
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);
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);
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;
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;
/*
{
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;
}
* 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);
}
}
/*
* 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);
}
* 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);
}
*/
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;
}
* 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
* 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);
}
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:
* 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);
* 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
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:
* 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
* 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);
*/
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...
/*
* 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;
* 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
*/
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);
* 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");
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;
}
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
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;
}
* 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
/** 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
* 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.
*
* @{
* 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;
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
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
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
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);
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 */
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;
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);
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;
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 */
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;
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);
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;
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 */
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;
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);
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;
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);
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;
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);
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);
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;
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);
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);
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);
* 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
* 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.
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)
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
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
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.
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)
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
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
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.
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)
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
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
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);
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
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);
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
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
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");
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);
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);
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);
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);
/*
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);
/*
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);
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);
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;
}
* 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);
}
projects / thirdparty / freeradius-server.git / commitdiff
