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; } }