/// Return the log buffer up to limit as a python list. Called by management agent.
PyObject *qd_log_recent_py(long limit) {
if (PyErr_Occurred()) return NULL;
PyObject *list = PyList_New(0);
PyObject *py_entry = NULL;
if (!list) goto error;
qd_log_entry_t *entry = DEQ_TAIL(entries);
while (entry && limit) {
const int ENTRY_SIZE=6;
py_entry = PyList_New(ENTRY_SIZE);
if (!py_entry) goto error;
int i = 0;
// NOTE: PyList_SetItem steals a reference so no leak here.
PyList_SetItem(py_entry, i++, PyString_FromString(entry->module));
const char* level = level_name(entry->level);
PyList_SetItem(py_entry, i++, level ? PyString_FromString(level) : inc_none());
PyList_SetItem(py_entry, i++, PyString_FromString(entry->text));
PyList_SetItem(py_entry, i++, entry->file ? PyString_FromString(entry->file) : inc_none());
PyList_SetItem(py_entry, i++, entry->file ? PyLong_FromLong(entry->line) : inc_none());
PyList_SetItem(py_entry, i++, PyLong_FromLongLong((PY_LONG_LONG)entry->time));
assert(i == ENTRY_SIZE);
if (PyErr_Occurred()) goto error;
PyList_Insert(list, 0, py_entry);
Py_DECREF(py_entry);
if (limit > 0) --limit;
entry = DEQ_PREV(entry);
}
return list;
error:
Py_XDECREF(list);
Py_XDECREF(py_entry);
return NULL;
}
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;
}
bool qd_iterator_next_segment(qd_iterator_t *iter, uint32_t *hash)
{
qd_hash_segment_t *hash_segment = DEQ_TAIL(iter->hash_segments);
if (!hash_segment)
return false;
*hash = hash_segment->hash;
qd_iterator_trim_view(iter, hash_segment->segment_length);
DEQ_REMOVE_TAIL(iter->hash_segments);
free_qd_hash_segment_t(hash_segment);
return true;
}
bool qd_iterator_hash_and_reset(qd_field_iterator_t *iter, uint32_t *hash)
{
qd_hash_segment_t *hash_segment = DEQ_TAIL(iter->hash_segments);
if (!hash_segment)
return false;
*hash = hash_segment->hash;
// Get the length of the hashed segment and set it on the iterator so that the iterator can only advance till that length
// Check for a non empty iter->prefix and reduce the segment length by 1
if (iter->view_prefix) {
if (iter->prefix == 'M')
iter->view_start_pointer.length = hash_segment->segment_length - 2;
else
iter->view_start_pointer.length = hash_segment->segment_length - 1;
}
// Remove the tail from the hash segments since we have already compared it.
DEQ_REMOVE_TAIL(iter->hash_segments);
free_qd_hash_segment_t(hash_segment);
return true;
}
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;
}
qd_message_t *qd_message_receive(pn_delivery_t *delivery)
{
pn_link_t *link = pn_delivery_link(delivery);
ssize_t rc;
qd_buffer_t *buf;
qd_message_pvt_t *msg = (qd_message_pvt_t*) pn_delivery_get_context(delivery);
//
// If there is no message associated with the delivery, this is the first time
// we've received anything on this delivery. Allocate a message descriptor and
// link it and the delivery together.
//
if (!msg) {
msg = (qd_message_pvt_t*) qd_message();
pn_delivery_set_context(delivery, (void*) msg);
}
//
// Get a reference to the tail buffer on the message. This is the buffer into which
// we will store incoming message data. If there is no buffer in the message, allocate
// an empty one and add it to the message.
//
buf = DEQ_TAIL(msg->content->buffers);
if (!buf) {
buf = qd_buffer();
DEQ_INSERT_TAIL(msg->content->buffers, buf);
}
while (1) {
//
// Try to receive enough data to fill the remaining space in the tail buffer.
//
rc = pn_link_recv(link, (char*) qd_buffer_cursor(buf), qd_buffer_capacity(buf));
//
// If we receive PN_EOS, we have come to the end of the message.
//
if (rc == PN_EOS) {
//
// If the last buffer in the list is empty, remove it and free it. This
// will only happen if the size of the message content is an exact multiple
// of the buffer size.
//
if (qd_buffer_size(buf) == 0) {
DEQ_REMOVE_TAIL(msg->content->buffers);
qd_buffer_free(buf);
}
pn_delivery_set_context(delivery, 0);
char repr[qd_message_repr_len()];
qd_log(log_source, QD_LOG_TRACE, "Received %s on link %s",
qd_message_repr((qd_message_t*)msg, repr, sizeof(repr)),
pn_link_name(link));
return (qd_message_t*) msg;
}
if (rc > 0) {
//
// We have received a positive number of bytes for the message. Advance
// the cursor in the buffer.
//
qd_buffer_insert(buf, rc);
//
// If the buffer is full, allocate a new empty buffer and append it to the
// tail of the message's list.
//
if (qd_buffer_capacity(buf) == 0) {
buf = qd_buffer();
DEQ_INSERT_TAIL(msg->content->buffers, buf);
}
} else
//
// We received zero bytes, and no PN_EOS. This means that we've received
// all of the data available up to this point, but it does not constitute
// the entire message. We'll be back later to finish it up.
//
break;
}
return 0;
}