void qdr_core_bind_address_link_CT(qdr_core_t *core, qdr_address_t *addr, qdr_link_t *link)
{
const char *key = (const char*) qd_hash_key_by_handle(addr->hash_handle);
link->owning_addr = addr;
if (key && (*key == QD_ITER_HASH_PREFIX_MOBILE))
link->phase = (int) (key[1] - '0');
if (link->link_direction == QD_OUTGOING) {
qdr_add_link_ref(&addr->rlinks, link, QDR_LINK_LIST_CLASS_ADDRESS);
if (DEQ_SIZE(addr->rlinks) == 1) {
if (key && (*key == QD_ITER_HASH_PREFIX_EDGE_SUMMARY || *key == QD_ITER_HASH_PREFIX_MOBILE))
qdr_post_mobile_added_CT(core, key, addr->treatment);
qdr_addr_start_inlinks_CT(core, addr);
qdrc_event_addr_raise(core, QDRC_EVENT_ADDR_BECAME_LOCAL_DEST, addr);
} else if (DEQ_SIZE(addr->rlinks) == 2 && qd_bitmask_cardinality(addr->rnodes) == 0)
qdrc_event_addr_raise(core, QDRC_EVENT_ADDR_TWO_DEST, addr);
} else { // link->link_direction == QD_INCOMING
qdr_add_link_ref(&addr->inlinks, link, QDR_LINK_LIST_CLASS_ADDRESS);
if (DEQ_SIZE(addr->inlinks) == 1) {
qdrc_event_addr_raise(core, QDRC_EVENT_ADDR_BECAME_SOURCE, addr);
if (!!addr->fallback && !link->fallback)
qdrc_event_addr_raise(core, QDRC_EVENT_ADDR_BECAME_SOURCE, addr->fallback);
} else if (DEQ_SIZE(addr->inlinks) == 2) {
qdrc_event_addr_raise(core, QDRC_EVENT_ADDR_TWO_SOURCE, addr);
if (!!addr->fallback && !link->fallback)
qdrc_event_addr_raise(core, QDRC_EVENT_ADDR_TWO_SOURCE, addr->fallback);
}
}
}
void qdr_core_unbind_address_link_CT(qdr_core_t *core, qdr_address_t *addr, qdr_link_t *link)
{
link->owning_addr = 0;
if (link->link_direction == QD_OUTGOING) {
qdr_del_link_ref(&addr->rlinks, link, QDR_LINK_LIST_CLASS_ADDRESS);
if (DEQ_SIZE(addr->rlinks) == 0) {
const char *key = (const char*) qd_hash_key_by_handle(addr->hash_handle);
if (key && (*key == QD_ITER_HASH_PREFIX_MOBILE || *key == QD_ITER_HASH_PREFIX_EDGE_SUMMARY))
qdr_post_mobile_removed_CT(core, key);
qdrc_event_addr_raise(core, QDRC_EVENT_ADDR_NO_LONGER_LOCAL_DEST, addr);
} else if (DEQ_SIZE(addr->rlinks) == 1 && qd_bitmask_cardinality(addr->rnodes) == 0)
qdrc_event_addr_raise(core, QDRC_EVENT_ADDR_ONE_LOCAL_DEST, addr);
} else {
bool removed = qdr_del_link_ref(&addr->inlinks, link, QDR_LINK_LIST_CLASS_ADDRESS);
if (removed) {
if (DEQ_SIZE(addr->inlinks) == 0) {
qdrc_event_addr_raise(core, QDRC_EVENT_ADDR_NO_LONGER_SOURCE, addr);
if (!!addr->fallback && !link->fallback)
qdrc_event_addr_raise(core, QDRC_EVENT_ADDR_NO_LONGER_SOURCE, addr->fallback);
} else if (DEQ_SIZE(addr->inlinks) == 1) {
qdrc_event_addr_raise(core, QDRC_EVENT_ADDR_ONE_SOURCE, addr);
if (!!addr->fallback && !link->fallback)
qdrc_event_addr_raise(core, QDRC_EVENT_ADDR_ONE_SOURCE, addr->fallback);
}
}
}
}
void dx_dealloc(dx_alloc_type_desc_t *desc, dx_alloc_pool_t **tpool, void *p)
{
item_t *item = ((item_t*) p) - 1;
int idx;
//
// If this is the thread's first pass through here, allocate the
// thread-local pool for this type.
//
if (*tpool == 0) {
*tpool = NEW(dx_alloc_pool_t);
DEQ_INIT((*tpool)->free_list);
}
dx_alloc_pool_t *pool = *tpool;
DEQ_INSERT_TAIL(pool->free_list, item);
if (DEQ_SIZE(pool->free_list) <= desc->config->local_free_list_max)
return;
//
// We've exceeded the maximum size of the local free list. A batch must be
// rebalanced back to the global list.
//
sys_mutex_lock(desc->lock);
desc->stats->batches_rebalanced_to_global++;
desc->stats->held_by_threads -= desc->config->transfer_batch_size;
for (idx = 0; idx < desc->config->transfer_batch_size; idx++) {
item = DEQ_HEAD(pool->free_list);
DEQ_REMOVE_HEAD(pool->free_list);
DEQ_INSERT_TAIL(desc->global_pool->free_list, item);
}
//
// If there's a global_free_list size limit, remove items until the limit is
// not exceeded.
//
if (desc->config->global_free_list_max != 0) {
while (DEQ_SIZE(desc->global_pool->free_list) > desc->config->global_free_list_max) {
item = DEQ_HEAD(desc->global_pool->free_list);
DEQ_REMOVE_HEAD(desc->global_pool->free_list);
free(item);
desc->stats->total_free_to_heap++;
}
}
sys_mutex_unlock(desc->lock);
}
void qd_log_impl(qd_log_source_t *source, qd_log_level_t level, const char *file, int line, const char *fmt, ...)
{
if (!qd_log_enabled(source, level)) return;
qd_log_entry_t *entry = new_qd_log_entry_t();
DEQ_ITEM_INIT(entry);
entry->module = source->module;
entry->level = level;
entry->file = file ? strdup(file) : 0;
entry->line = line;
time(&entry->time);
va_list ap;
va_start(ap, fmt);
vsnprintf(entry->text, TEXT_MAX, fmt, ap);
va_end(ap);
write_log(source, entry);
// Bounded buffer of log entries, keep most recent.
sys_mutex_lock(log_lock);
DEQ_INSERT_TAIL(entries, entry);
if (DEQ_SIZE(entries) > LIST_MAX)
qd_log_entry_free_lh(DEQ_HEAD(entries));
sys_mutex_unlock(log_lock);
}
static char* list_well_formed(item_list_t list, char *key)
{
item_t *ptr;
item_t *last = 0;
int size = DEQ_SIZE(list);
int count = 0;
char str[32];
ptr = DEQ_HEAD(list);
while (ptr) {
str[count] = ptr->letter;
count++;
if (DEQ_PREV(ptr) != last) return "Corrupt previous link";
last = ptr;
ptr = DEQ_NEXT(ptr);
}
str[count] = '\0';
if (strcmp(str, key) != 0) return "Invalid key";
if (count != size) return "Size different from number of items (forward)";
count = 0;
last = 0;
ptr = DEQ_TAIL(list);
while (ptr) {
count++;
if (DEQ_NEXT(ptr) != last) return "Corrupt next link";
last = ptr;
ptr = DEQ_PREV(ptr);
}
if (count != size) return "Size different from number of items (backward)";
return 0;
}
void qdra_config_auto_link_get_next_CT(qdr_core_t *core, qdr_query_t *query)
{
qdr_auto_link_t *al = 0;
if (query->next_offset < DEQ_SIZE(core->auto_links)) {
al = DEQ_HEAD(core->auto_links);
for (int i = 0; i < query->next_offset && al; i++)
al = DEQ_NEXT(al);
}
if (al) {
//
// Write the columns of the addr entity into the response body.
//
qdr_agent_write_config_auto_link_CT(query, al);
//
// Advance to the next object
//
qdr_manage_advance_config_auto_link_CT(query, al);
} else
query->more = false;
//
// Enqueue the response.
//
qdr_agent_enqueue_response_CT(core, query);
}
void qdra_link_get_next_CT(qdr_core_t *core, qdr_query_t *query)
{
qdr_link_t *link = 0;
if (query->next_offset < DEQ_SIZE(core->open_links)) {
link = DEQ_HEAD(core->open_links);
for (int i = 0; i < query->next_offset && link; i++)
link = DEQ_NEXT(link);
}
if (link) {
//
// Write the columns of the link entity into the response body.
//
qdr_agent_write_link_CT(query, link);
//
// Advance to the next link
//
qdr_manage_advance_link_CT(query, link);
} else
query->more = false;
//
// Enqueue the response.
//
qdr_agent_enqueue_response_CT(core, query);
}
/**
* Outgoing Link Writable Handler
*/
static int router_writable_link_handler(void* context, dx_link_t *link)
{
dx_router_t *router = (dx_router_t*) context;
int grant_delivery = 0;
pn_delivery_t *delivery;
dx_router_link_t *rlink = (dx_router_link_t*) dx_link_get_context(link);
pn_link_t *pn_link = dx_link_pn(link);
uint64_t tag;
sys_mutex_lock(router->lock);
if (DEQ_SIZE(rlink->out_fifo) > 0) {
grant_delivery = 1;
tag = router->dtag++;
}
sys_mutex_unlock(router->lock);
if (grant_delivery) {
pn_delivery(pn_link, pn_dtag((char*) &tag, 8));
delivery = pn_link_current(pn_link);
if (delivery) {
router_tx_handler(context, link, delivery);
return 1;
}
}
return 0;
}
void qdra_config_link_route_get_next_CT(qdr_core_t *core, qdr_query_t *query)
{
qdr_link_route_t *lr = 0;
if (query->next_offset < DEQ_SIZE(core->link_routes)) {
lr = DEQ_HEAD(core->link_routes);
for (int i = 0; i < query->next_offset && lr; i++)
lr = DEQ_NEXT(lr);
}
if (lr) {
//
// Write the columns of the addr entity into the response body.
//
qdr_agent_write_config_link_route_CT(query, lr);
//
// Advance to the next object
//
qdr_manage_advance_config_link_route_CT(query, lr);
} else
query->more = false;
//
// Enqueue the response.
//
qdr_agent_enqueue_response_CT(core, query);
}
static void release_buffer_chain(qd_buffer_list_t *chain)
{
while (DEQ_SIZE(*chain)) {
qd_buffer_t *buf = DEQ_HEAD(*chain);
DEQ_REMOVE_HEAD(*chain);
qd_buffer_free(buf);
}
}
void work_queue_put(work_queue_t *w, pn_connector_t *conn)
{
work_item_t *item;
if (!w)
return;
if (DEQ_SIZE(w->free_list) == 0)
allocate_batch(w);
if (DEQ_SIZE(w->free_list) == 0)
return;
item = DEQ_HEAD(w->free_list);
DEQ_REMOVE_HEAD(w->free_list);
item->conn = conn;
DEQ_INSERT_TAIL(w->items, item);
}
uint32_t qd_parse_sub_count(qd_parsed_field_t *field)
{
uint32_t count = DEQ_SIZE(field->children);
if (field->tag == QD_AMQP_MAP8 || field->tag == QD_AMQP_MAP32)
count = count >> 1;
return count;
}
void qdr_core_bind_address_conn_CT(qdr_core_t *core, qdr_address_t *addr, qdr_connection_t *conn)
{
qdr_add_connection_ref(&addr->conns, conn);
if (DEQ_SIZE(addr->conns) == 1) {
const char *key = (const char*) qd_hash_key_by_handle(addr->hash_handle);
qdr_post_mobile_added_CT(core, key, addr->treatment);
qdrc_event_addr_raise(core, QDRC_EVENT_ADDR_BECAME_LOCAL_DEST, addr);
}
}
void qdr_agent_enqueue_response_CT(qdr_core_t *core, qdr_query_t *query)
{
sys_mutex_lock(core->query_lock);
DEQ_INSERT_TAIL(core->outgoing_query_list, query);
bool notify = DEQ_SIZE(core->outgoing_query_list) == 1;
sys_mutex_unlock(core->query_lock);
if (notify)
qd_timer_schedule(core->agent_timer, 0);
}
static void qdr_global_stats_request_CT(qdr_core_t *core, qdr_action_t *action, bool discard)
{
qdr_global_stats_t *stats = action->args.stats_request.stats;
if (stats) {
stats->addrs = DEQ_SIZE(core->addrs);
stats->links = DEQ_SIZE(core->open_links);
stats->routers = DEQ_SIZE(core->routers);
stats->connections = DEQ_SIZE(core->open_connections);
stats->link_routes = DEQ_SIZE(core->link_routes);
stats->auto_links = DEQ_SIZE(core->auto_links);
stats->presettled_deliveries = core->presettled_deliveries;
stats->dropped_presettled_deliveries = core->dropped_presettled_deliveries;
stats->accepted_deliveries = core->accepted_deliveries;
stats->rejected_deliveries = core->rejected_deliveries;
stats->released_deliveries = core->released_deliveries;
stats->modified_deliveries = core->modified_deliveries;
stats->deliveries_ingress = core->deliveries_ingress;
stats->deliveries_egress = core->deliveries_egress;
stats->deliveries_transit = core->deliveries_transit;
stats->deliveries_ingress_route_container = core->deliveries_ingress_route_container;
stats->deliveries_egress_route_container = core->deliveries_egress_route_container;
stats->deliveries_delayed_1sec = core->deliveries_delayed_1sec;
stats->deliveries_delayed_1sec = core->deliveries_delayed_10sec;
stats->deliveries_redirected_to_fallback = core->deliveries_redirected;
}
qdr_general_work_t *work = qdr_general_work(qdr_post_global_stats_response);
work->stats_handler = action->args.stats_request.handler;
work->context = action->args.stats_request.context;
qdr_post_general_work_CT(core, work);
}
void qdr_post_general_work_CT(qdr_core_t *core, qdr_general_work_t *work)
{
bool notify;
sys_mutex_lock(core->work_lock);
DEQ_ITEM_INIT(work);
DEQ_INSERT_TAIL(core->work_list, work);
notify = DEQ_SIZE(core->work_list) == 1;
sys_mutex_unlock(core->work_lock);
if (notify)
qd_timer_schedule(core->work_timer, 0);
}
static int fire_head()
{
sys_mutex_lock(lock);
int result = DEQ_SIZE(pending_timers);
nx_timer_t *timer = DEQ_HEAD(pending_timers);
if (timer) {
DEQ_REMOVE_HEAD(pending_timers);
nx_timer_idle_LH(timer);
fire_mask |= (unsigned long) timer->context;
}
sys_mutex_unlock(lock);
return result;
}
qd_error_t qd_entity_refresh_connector(qd_entity_t* entity, void *impl)
{
qd_connector_t *ct = (qd_connector_t*) impl;
if (DEQ_SIZE(ct->conn_info_list) > 1) {
qd_failover_item_list_t conn_info_list = ct->conn_info_list;
qd_failover_item_t *item = DEQ_HEAD(conn_info_list);
//
// As you can see we are skipping the head of the list. The
// first item in the list is always the original connection information
// and we dont want to display that information as part of the failover list.
//
int arr_length = get_failover_info_length(conn_info_list);
char failover_info[arr_length];
memset(failover_info, 0, sizeof(failover_info));
item = DEQ_NEXT(item);
while(item) {
if (item->scheme) {
strcat(failover_info, item->scheme);
strcat(failover_info, "://");
}
if (item->host_port) {
strcat(failover_info, item->host_port);
}
item = DEQ_NEXT(item);
if (item) {
strcat(failover_info, ", ");
}
}
if (qd_entity_set_string(entity, "failoverList", failover_info) == 0)
return QD_ERROR_NONE;
}
else {
if (qd_entity_clear(entity, "failoverList") == 0)
return QD_ERROR_NONE;
}
return qd_error_code();
}
static void qdr_link_route_activate_CT(qdr_core_t *core, qdr_link_route_t *lr, qdr_connection_t *conn)
{
const char *key;
qdr_route_log_CT(core, "Link Route Activated", lr->name, lr->identity, conn);
//
// Activate the address for link-routed destinations. If this is the first
// activation for this address, notify the router module of the added address.
//
if (lr->addr) {
qdr_add_connection_ref(&lr->addr->conns, conn);
if (DEQ_SIZE(lr->addr->conns) == 1) {
key = (const char*) qd_hash_key_by_handle(lr->addr->hash_handle);
if (key)
qdr_post_mobile_added_CT(core, key);
}
}
}
void qdra_address_get_next_CT(qdr_core_t *core, qdr_query_t *query)
{
qdr_address_t *addr = 0;
//
// Use the stored key to try to find the next entry in the table.
//
if (query->next_key) {
qd_hash_retrieve(core->addr_hash, query->next_key->iterator, (void**) &addr);
qdr_field_free(query->next_key);
query->next_key = 0;
}
if (!addr) {
//
// If the address was removed in the time between this get and the previous one,
// we need to use the saved offset, which is less efficient.
//
if (query->next_offset < DEQ_SIZE(core->addrs)) {
addr = DEQ_HEAD(core->addrs);
for (int i = 0; i < query->next_offset && addr; i++)
addr = DEQ_NEXT(addr);
}
}
if (addr) {
//
// Write the columns of the address entity into the response body.
//
qdr_manage_write_address_list_CT(core, query, addr);
//
// Advance to the next address
//
qdr_manage_advance_address_CT(query, addr);
} else
query->more = false;
//
// Enqueue the response.
//
qdr_agent_enqueue_response_CT(core, query);
}
void qdra_conn_link_route_get_first_CT(qdr_core_t *core, qdr_query_t *query, int offset)
{
query->status = QD_AMQP_OK;
qdr_connection_t *conn = _find_conn_CT(core, query->in_conn);
if (!conn || offset >= DEQ_SIZE(conn->conn_link_routes)) {
query->more = false;
} else {
// Find the lr at the offset.
//
qdr_link_route_t *lr = DEQ_HEAD(conn->conn_link_routes);
for (int i = 0; i < offset && lr; i++)
lr = DEQ_NEXT(lr);
assert(lr);
// write the lr into the response and advance to next
_write_as_list_CT(query, lr);
query->next_offset = offset + 1;
query->more = DEQ_NEXT(lr) != NULL;
}
qdr_agent_enqueue_response_CT(core, query);
}
void qdra_link_get_first_CT(qdr_core_t *core, qdr_query_t *query, int offset)
{
//
// Queries that get this far will always succeed.
//
query->status = QD_AMQP_OK;
//
// If the offset goes beyond the set of links, end the query now.
//
if (offset >= DEQ_SIZE(core->open_links)) {
query->more = false;
qdr_agent_enqueue_response_CT(core, query);
return;
}
//
// Run to the address at the offset.
//
qdr_link_t *link = DEQ_HEAD(core->open_links);
for (int i = 0; i < offset && link; i++)
link = DEQ_NEXT(link);
assert(link);
//
// Write the columns of the link into the response body.
//
qdr_agent_write_link_CT(query, link);
//
// Advance to the next address
//
query->next_offset = offset;
qdr_manage_advance_link_CT(query, link);
//
// Enqueue the response.
//
qdr_agent_enqueue_response_CT(core, query);
}
void qdra_config_auto_link_get_first_CT(qdr_core_t *core, qdr_query_t *query, int offset)
{
//
// Queries that get this far will always succeed.
//
query->status = QD_AMQP_OK;
//
// If the offset goes beyond the set of objects, end the query now.
//
if (offset >= DEQ_SIZE(core->auto_links)) {
query->more = false;
qdr_agent_enqueue_response_CT(core, query);
return;
}
//
// Run to the object at the offset.
//
qdr_auto_link_t *al = DEQ_HEAD(core->auto_links);
for (int i = 0; i < offset && al; i++)
al = DEQ_NEXT(al);
assert(al);
//
// Write the columns of the object into the response body.
//
qdr_agent_write_config_auto_link_CT(query, al);
//
// Advance to the next auto_link
//
query->next_offset = offset;
qdr_manage_advance_config_auto_link_CT(query, al);
//
// Enqueue the response.
//
qdr_agent_enqueue_response_CT(core, query);
}
static void qdr_agent_response_handler(void *context)
{
qdr_core_t *core = (qdr_core_t*) context;
qdr_query_t *query;
bool done = false;
while (!done) {
sys_mutex_lock(core->query_lock);
query = DEQ_HEAD(core->outgoing_query_list);
if (query)
DEQ_REMOVE_HEAD(core->outgoing_query_list);
done = DEQ_SIZE(core->outgoing_query_list) == 0;
sys_mutex_unlock(core->query_lock);
if (query) {
bool more = query->more;
core->agent_response_handler(query->context, &query->status, more);
if (!more)
qdr_query_free(query);
}
}
}
void qdra_conn_link_route_get_next_CT(qdr_core_t *core, qdr_query_t *query)
{
qdr_connection_t *conn = _find_conn_CT(core, query->in_conn);
if (!conn || query->next_offset >= DEQ_SIZE(conn->conn_link_routes)) {
query->more = false;
} else {
// find the lr at the offset
//
qdr_link_route_t *lr = DEQ_HEAD(conn->conn_link_routes);
for (int i = 0; i < query->next_offset && lr; i++)
lr = DEQ_NEXT(lr);
if (lr) {
// write response and advance to next
_write_as_list_CT(query, lr);
++query->next_offset;
query->more = DEQ_NEXT(lr) != NULL;
} else
query->more = false;
}
qdr_agent_enqueue_response_CT(core, query);
}
/**
* Outbound Delivery Handler
*/
static void router_tx_handler(void* context, dx_link_t *link, pn_delivery_t *delivery)
{
dx_router_t *router = (dx_router_t*) context;
pn_link_t *pn_link = pn_delivery_link(delivery);
dx_router_link_t *rlink = (dx_router_link_t*) dx_link_get_context(link);
dx_message_t *msg;
size_t size;
sys_mutex_lock(router->lock);
msg = DEQ_HEAD(rlink->out_fifo);
if (!msg) {
// TODO - Recind the delivery
sys_mutex_unlock(router->lock);
return;
}
DEQ_REMOVE_HEAD(rlink->out_fifo);
size = (DEQ_SIZE(rlink->out_fifo));
sys_mutex_unlock(router->lock);
dx_message_send(msg, pn_link);
//
// If there is no incoming delivery, it was pre-settled. In this case,
// we must pre-settle the outgoing delivery as well.
//
if (dx_message_in_delivery(msg)) {
pn_delivery_set_context(delivery, (void*) msg);
dx_message_set_out_delivery(msg, delivery);
} else {
pn_delivery_settle(delivery);
dx_free_message(msg);
}
pn_link_advance(pn_link);
pn_link_offered(pn_link, size);
}
static void qdr_agent_write_column_CT(qd_composed_field_t *body, int col, qdr_link_t *link)
{
char *text = 0;
switch(col) {
case QDR_LINK_NAME: {
if (link->name)
qd_compose_insert_string(body, link->name);
else
qd_compose_insert_null(body);
break;
}
case QDR_LINK_IDENTITY: {
char id[100];
snprintf(id, 100, "%"PRId64, link->identity);
qd_compose_insert_string(body, id);
break;
}
case QDR_LINK_TYPE:
qd_compose_insert_string(body, "org.apache.qpid.dispatch.router.link");
break;
case QDR_LINK_LINK_NAME:
qd_compose_insert_string(body, link->name);
break;
case QDR_LINK_LINK_TYPE:
qd_compose_insert_string(body, qd_link_type_name(link->link_type));
break;
case QDR_LINK_LINK_DIR:
qd_compose_insert_string(body, link->link_direction == QD_INCOMING ? "in" : "out");
break;
case QDR_LINK_OWNING_ADDR:
if (link->owning_addr)
qd_compose_insert_string(body, address_key(link->owning_addr));
else
qd_compose_insert_null(body);
break;
case QDR_LINK_CAPACITY:
qd_compose_insert_uint(body, link->capacity);
break;
case QDR_LINK_PEER:
if (link->connected_link) {
char id[100];
snprintf(id, 100, "%"PRId64, link->connected_link->identity);
qd_compose_insert_string(body, id);
} else
qd_compose_insert_null(body);
break;
case QDR_LINK_UNDELIVERED_COUNT:
qd_compose_insert_ulong(body, DEQ_SIZE(link->undelivered));
break;
case QDR_LINK_UNSETTLED_COUNT:
qd_compose_insert_ulong(body, DEQ_SIZE(link->unsettled));
break;
case QDR_LINK_DELIVERY_COUNT:
qd_compose_insert_ulong(body, link->total_deliveries);
break;
case QDR_LINK_CONNECTION_ID:
qd_compose_insert_ulong(body, link->conn->management_id);
break;
case QDR_LINK_ADMIN_STATE:
text = link->admin_enabled ? "enabled" : "disabled";
qd_compose_insert_string(body, text);
break;
case QDR_LINK_OPER_STATE:
switch (link->oper_status) {
case QDR_LINK_OPER_UP: text = "up"; break;
case QDR_LINK_OPER_DOWN: text = "down"; break;
case QDR_LINK_OPER_QUIESCING: text = "quiescing"; break;
case QDR_LINK_OPER_IDLE: text = "idle"; break;
default:
text = 0;
}
if (!!text)
qd_compose_insert_string(body, text);
else
qd_compose_insert_null(body);
break;
case QDR_LINK_PRESETTLED_COUNT:
qd_compose_insert_ulong(body, link->presettled_deliveries);
break;
case QDR_LINK_ACCEPTED_COUNT:
qd_compose_insert_ulong(body, link->accepted_deliveries);
break;
case QDR_LINK_REJECTED_COUNT:
qd_compose_insert_ulong(body, link->rejected_deliveries);
break;
case QDR_LINK_RELEASED_COUNT:
qd_compose_insert_ulong(body, link->released_deliveries);
break;
case QDR_LINK_MODIFIED_COUNT:
qd_compose_insert_ulong(body, link->modified_deliveries);
break;
default:
qd_compose_insert_null(body);
break;
}
}
static char* test_deq_basic(void *context)
{
item_list_t list;
item_t item[10];
item_t *ptr;
int idx;
char *subtest;
DEQ_INIT(list);
if (DEQ_SIZE(list) != 0) return "Expected zero initial size";
for (idx = 0; idx < 10; idx++) {
DEQ_ITEM_INIT(&item[idx]);
item[idx].letter = 'A' + idx;
DEQ_INSERT_TAIL(list, &item[idx]);
}
if (DEQ_SIZE(list) != 10) return "Expected 10 items in list";
ptr = DEQ_HEAD(list);
if (!ptr) return "Expected valid head item";
if (DEQ_PREV(ptr)) return "Head item has non-null previous link";
if (ptr->letter != 'A') return "Expected item A at the head";
if (DEQ_NEXT(ptr) == 0) return "Head item has null next link";
subtest = list_well_formed(list, "ABCDEFGHIJ");
if (subtest) return subtest;
DEQ_REMOVE_HEAD(list);
if (DEQ_SIZE(list) != 9) return "Expected 9 items in list";
ptr = DEQ_HEAD(list);
if (ptr->letter != 'B') return "Expected item B at the head";
subtest = list_well_formed(list, "BCDEFGHIJ");
if (subtest) return subtest;
DEQ_REMOVE_TAIL(list);
if (DEQ_SIZE(list) != 8) return "Expected 8 items in list";
ptr = DEQ_TAIL(list);
if (ptr->letter != 'I') return "Expected item I at the tail";
subtest = list_well_formed(list, "BCDEFGHI");
if (subtest) return subtest;
DEQ_REMOVE(list, &item[4]);
if (DEQ_SIZE(list) != 7) return "Expected 7 items in list";
subtest = list_well_formed(list, "BCDFGHI");
if (subtest) return subtest;
DEQ_REMOVE(list, &item[1]);
if (DEQ_SIZE(list) != 6) return "Expected 6 items in list";
subtest = list_well_formed(list, "CDFGHI");
if (subtest) return subtest;
DEQ_REMOVE(list, &item[8]);
if (DEQ_SIZE(list) != 5) return "Expected 5 items in list";
subtest = list_well_formed(list, "CDFGH");
if (subtest) return subtest;
DEQ_INSERT_HEAD(list, &item[8]);
if (DEQ_SIZE(list) != 6) return "Expected 6 items in list";
ptr = DEQ_HEAD(list);
if (ptr->letter != 'I') return "Expected item I at the head";
subtest = list_well_formed(list, "ICDFGH");
if (subtest) return subtest;
DEQ_INSERT_AFTER(list, &item[4], &item[7]);
if (DEQ_SIZE(list) != 7) return "Expected 7 items in list";
ptr = DEQ_TAIL(list);
if (ptr->letter != 'E') return "Expected item E at the head";
subtest = list_well_formed(list, "ICDFGHE");
if (subtest) return subtest;
DEQ_INSERT_AFTER(list, &item[1], &item[5]);
if (DEQ_SIZE(list) != 8) return "Expected 8 items in list";
subtest = list_well_formed(list, "ICDFBGHE");
if (subtest) return subtest;
if (item[0].prev || item[0].next) return "Unlisted item A has non-null pointers";
if (item[9].prev || item[9].next) return "Unlisted item J has non-null pointers";
return 0;
}
int qd_parse_is_scalar(qd_parsed_field_t *field)
{
return DEQ_SIZE(field->children) == 0;
}
static void qdr_agent_write_column_CT(qd_composed_field_t *body, int col, qdr_core_t *core)
{
switch(col) {
case QDR_ROUTER_IDENTITY:
// There is only one instance of router. Just give it an identity of 1
qd_compose_insert_string(body, "1");
break;
case QDR_ROUTER_TYPE:
qd_compose_insert_string(body, "org.apache.qpid.dispatch.router");
break;
case QDR_ROUTER_MODE:
qd_compose_insert_string(body, router_mode(core->router_mode));
break;
case QDR_ROUTER_AREA:
if (core->router_area)
qd_compose_insert_string(body, core->router_area);
else
qd_compose_insert_null(body);
break;
case QDR_ROUTER_VERSION:
qd_compose_insert_string(body, QPID_DISPATCH_VERSION);
break;
case QDR_ROUTER_HELLO_INTERVAL:
qd_compose_insert_null(body);
break;
case QDR_ROUTER_ADDR_COUNT:
qd_compose_insert_ulong(body, DEQ_SIZE(core->addrs));
break;
case QDR_ROUTER_LINK_COUNT:
qd_compose_insert_ulong(body, DEQ_SIZE(core->open_links));
break;
case QDR_ROUTER_NODE_COUNT:
qd_compose_insert_ulong(body, DEQ_SIZE(core->routers));
break;
case QDR_ROUTER_CONNECTION_COUNT:
qd_compose_insert_ulong(body, DEQ_SIZE(core->open_connections));
break;
case QDR_ROUTER_LINK_ROUTE_COUNT:
qd_compose_insert_ulong(body, DEQ_SIZE(core->link_routes));
break;
case QDR_ROUTER_AUTO_LINK_COUNT:
qd_compose_insert_ulong(body, DEQ_SIZE(core->auto_links));
break;
case QDR_ROUTER_ROUTER_ID:
case QDR_ROUTER_ID:
case QDR_ROUTER_NAME:
if (core->router_id)
qd_compose_insert_string(body, core->router_id);
else
qd_compose_insert_null(body);
break;
default:
qd_compose_insert_null(body);
break;
}
}
