void replyto_dispatch(pn_handler_t *h, pn_event_t *event, pn_event_type_t type) {
sender_context_t *sc = replyto_sender_context(h);
switch (type) {
case PN_DELIVERY:
{
check(sc->opts->get_replies, "Unexpected reply message");
pn_link_t *recv_link = pn_event_link(event);
pn_delivery_t *dlv = pn_event_delivery(event);
if (pn_link_is_receiver(recv_link) && !pn_delivery_partial(dlv)) {
size_t encoded_size = pn_delivery_pending(dlv);
check(encoded_size <= sc->encoded_data_size, "decoding buffer too small");
ssize_t n = pn_link_recv(recv_link, sc->encoded_data, encoded_size);
check(n == (ssize_t)encoded_size, "read fail on reply link");
pn_message_t *msg = sc->reply_message;
int err = pn_message_decode(msg, sc->encoded_data, n);
check(err == 0, "message decode error");
statistics_msg_received(sc->stats, msg);
sc->received++;
pn_delivery_settle(dlv);
}
if (sc->received == sc->opts->msg_count) {
pn_link_close(recv_link);
pn_connection_t *conn = pn_event_connection(event);
pn_connection_close(conn);
}
}
break;
default:
break;
}
}
void ConnectionContext::close()
{
qpid::sys::ScopedLock<qpid::sys::Monitor> l(lock);
if (state != CONNECTED) return;
if (!(pn_connection_state(connection) & PN_LOCAL_CLOSED)) {
for (SessionMap::iterator i = sessions.begin(); i != sessions.end(); ++i) {
//wait for outstanding sends to settle
while (!i->second->settled()) {
QPID_LOG(debug, "Waiting for sends to settle before closing");
wait();//wait until message has been confirmed
}
if (!(pn_session_state(i->second->session) & PN_LOCAL_CLOSED)) {
pn_session_close(i->second->session);
}
}
pn_connection_close(connection);
wakeupDriver();
//wait for close to be confirmed by peer?
while (!(pn_connection_state(connection) & PN_REMOTE_CLOSED)) {
wait();
}
sessions.clear();
}
transport->close();
while (state != DISCONNECTED) {
lock.wait();
}
}
static int close_handler(qd_container_t *container, void* conn_context, pn_connection_t *conn, qd_connection_t* qd_conn)
{
//
// Close all links, passing QD_LOST as the reason. These links are not
// being properly 'detached'. They are being orphaned.
//
pn_link_t *pn_link = pn_link_head(conn, 0);
while (pn_link) {
qd_link_t *link = (qd_link_t*) pn_link_get_context(pn_link);
if (link) {
qd_node_t *node = link->node;
if (node) {
node->ntype->link_detach_handler(node->context, link, QD_LOST);
}
}
pn_link_close(pn_link);
pn_link = pn_link_next(pn_link, 0);
}
// teardown all sessions
pn_session_t *ssn = pn_session_head(conn, 0);
while (ssn) {
pn_session_close(ssn);
ssn = pn_session_next(ssn, 0);
}
// close the connection
pn_connection_close(conn);
notify_closed(container, qd_conn, conn_context);
return 0;
}
int pn_messenger_stop(pn_messenger_t *messenger)
{
if (!messenger) return PN_ARG_ERR;
for (int i = 0; i < messenger->size; i++) {
pn_connector_t *ctor = messenger->connectors[i];
pn_connection_t *conn = pn_connector_connection(ctor);
pn_link_t *link = pn_link_head(conn, PN_LOCAL_ACTIVE);
while (link) {
pn_link_close(link);
link = pn_link_next(link, PN_LOCAL_ACTIVE);
}
pn_connection_close(conn);
}
pn_listener_t *l = pn_listener_head(messenger->driver);
while (l) {
pn_listener_close(l);
pn_listener_t *prev = l;
l = pn_listener_next(l);
pn_listener_free(prev);
}
return pn_messenger_sync(messenger, pn_messenger_stopped);
}
// Close the sender and its parent session and connection
static void _close_connection(protocolState_t *ps)
{
if (ps->sender) {
pn_link_close(ps->sender);
pn_session_close(pn_link_session(ps->sender));
}
if (ps->conn) pn_connection_close(ps->conn);
}
void messaging_adapter::on_connection_error(event &e) {
delegate_.on_connection_error(e);
proton_event *pe = dynamic_cast<proton_event*>(&e);
if (pe) {
pn_connection_t *connection = pn_event_connection(pe->pn_event());
pn_connection_close(connection);
}
}
void qd_policy_private_deny_amqp_connection(pn_connection_t *conn, const char *cond_name, const char *cond_descr)
{
pn_condition_t * cond = pn_connection_condition(conn);
(void) pn_condition_set_name( cond, cond_name);
(void) pn_condition_set_description(cond, cond_descr);
pn_connection_close(conn);
// Connection denial counts are counted and logged by python code.
}
/* close a connection when it is remote open */
static pn_event_type_t open_close_handler(test_handler_t *th, pn_event_t *e) {
switch (pn_event_type(e)) {
case PN_CONNECTION_REMOTE_OPEN:
pn_connection_close(pn_event_connection(e));
return PN_EVENT_NONE; /* common_handler will finish on TRANSPORT_CLOSED */
default:
return common_handler(th, e);
}
}
static void pn_handshaker_dispatch(pn_handler_t *handler, pn_event_t *event, pn_event_type_t type) {
switch (type) {
case PN_CONNECTION_REMOTE_OPEN:
{
pn_connection_t *conn = pn_event_connection(event);
if (pn_connection_state(conn) & PN_LOCAL_UNINIT) {
pn_connection_open(conn);
}
}
break;
case PN_SESSION_REMOTE_OPEN:
{
pn_session_t *ssn = pn_event_session(event);
if (pn_session_state(ssn) & PN_LOCAL_UNINIT) {
pn_session_open(ssn);
}
}
break;
case PN_LINK_REMOTE_OPEN:
{
pn_link_t *link = pn_event_link(event);
if (pn_link_state(link) & PN_LOCAL_UNINIT) {
pn_terminus_copy(pn_link_source(link), pn_link_remote_source(link));
pn_terminus_copy(pn_link_target(link), pn_link_remote_target(link));
pn_link_open(link);
}
}
break;
case PN_CONNECTION_REMOTE_CLOSE:
{
pn_connection_t *conn = pn_event_connection(event);
if (!(pn_connection_state(conn) & PN_LOCAL_CLOSED)) {
pn_connection_close(conn);
}
}
break;
case PN_SESSION_REMOTE_CLOSE:
{
pn_session_t *ssn = pn_event_session(event);
if (!(pn_session_state(ssn) & PN_LOCAL_CLOSED)) {
pn_session_close(ssn);
}
}
break;
case PN_LINK_REMOTE_CLOSE:
{
pn_link_t *link = pn_event_link(event);
if (!(pn_link_state(link) & PN_LOCAL_CLOSED)) {
pn_link_close(link);
}
}
break;
default:
break;
}
}
/* Common handler for simple client/server interactions, */
static pn_event_type_t common_handler(test_handler_t *th, pn_event_t *e) {
pn_connection_t *c = pn_event_connection(e);
pn_listener_t *l = pn_event_listener(e);
switch (pn_event_type(e)) {
/* Stop on these events */
case PN_TRANSPORT_CLOSED:
case PN_PROACTOR_INACTIVE:
case PN_PROACTOR_TIMEOUT:
case PN_LISTENER_OPEN:
return pn_event_type(e);
case PN_LISTENER_ACCEPT:
last_accepted = pn_connection();
pn_listener_accept2(l, last_accepted, NULL);
pn_listener_close(l); /* Only accept one connection */
return PN_EVENT_NONE;
case PN_CONNECTION_REMOTE_OPEN:
pn_connection_open(c); /* Return the open (no-op if already open) */
return PN_EVENT_NONE;
case PN_SESSION_REMOTE_OPEN:
pn_session_open(pn_event_session(e));
return PN_EVENT_NONE;
case PN_LINK_REMOTE_OPEN:
pn_link_open(pn_event_link(e));
return PN_EVENT_NONE;
case PN_CONNECTION_REMOTE_CLOSE:
pn_connection_close(c); /* Return the close */
return PN_EVENT_NONE;
/* Ignore these events */
case PN_CONNECTION_BOUND:
case PN_CONNECTION_INIT:
case PN_CONNECTION_LOCAL_CLOSE:
case PN_CONNECTION_LOCAL_OPEN:
case PN_LINK_INIT:
case PN_LINK_LOCAL_OPEN:
case PN_LISTENER_CLOSE:
case PN_SESSION_INIT:
case PN_SESSION_LOCAL_OPEN:
case PN_TRANSPORT:
case PN_TRANSPORT_ERROR:
case PN_TRANSPORT_HEAD_CLOSED:
case PN_TRANSPORT_TAIL_CLOSED:
return PN_EVENT_NONE;
default:
TEST_ERRORF(th->t, "unexpected event %s", pn_event_type_name(pn_event_type(e)));
return PN_EVENT_NONE; /* Fail the test but keep going */
}
}
void messaging_adapter::on_connection_remote_close(proton_event &pe) {
pn_event_t *cevent = pe.pn_event();
pn_connection_t *conn = pn_event_connection(cevent);
connection c(make_wrapper(conn));
if (pn_condition_is_set(pn_connection_remote_condition(conn))) {
delegate_.on_connection_error(c);
}
delegate_.on_connection_close(c);
pn_connection_close(conn);
}
/* Closing the connection during PN_TRANSPORT_ERROR should be a no-op
* Regression test for: https://issues.apache.org/jira/browse/PROTON-1586
*/
static pn_event_type_t transport_close_connection_handler(test_handler_t *th, pn_event_t *e) {
switch (pn_event_type(e)) {
case PN_TRANSPORT_ERROR:
pn_connection_close(pn_event_connection(e));
break;
default:
return open_wake_handler(th, e);
}
return PN_EVENT_NONE;
}
/* Return on connection open, close and return on wake */
static pn_event_type_t open_wake_handler(test_handler_t *th, pn_event_t *e) {
switch (pn_event_type(e)) {
case PN_CONNECTION_REMOTE_OPEN:
return pn_event_type(e);
case PN_CONNECTION_WAKE:
pn_connection_close(pn_event_connection(e));
return pn_event_type(e);
default:
return common_handler(th, e);
}
}
void global_shutdown(global_context_t *gc)
{
if (gc->shutting_down) return;
gc->shutting_down = true;
pn_acceptor_close(gc->acceptor);
size_t n = pn_list_size(gc->active_connections);
for (size_t i = 0; i < n; i++) {
pn_connection_t *conn = (pn_connection_t *) pn_list_get(gc->active_connections, i);
if (!(pn_connection_state(conn) & PN_LOCAL_CLOSED)) {
pn_connection_close(conn);
}
}
}
static pn_event_type_t ssl_client_handler(test_handler_t *h, pn_event_t *e) {
switch (pn_event_type(e)) {
case PN_CONNECTION_BOUND:
return ssl_handler(h, e);
case PN_CONNECTION_REMOTE_OPEN: {
pn_event_type_t et = ssl_handler(h, e);
pn_connection_close(pn_event_connection(e));
return et;
}
break;
default:
return common_handler(h, e);
}
}
void messaging_adapter::on_connection_remote_close(event &e) {
proton_event *pe = dynamic_cast<proton_event*>(&e);
if (pe) {
pn_event_t *cevent = pe->pn_event();
pn_connection_t *connection = pn_event_connection(cevent);
if (pn_condition_is_set(pn_connection_remote_condition(connection))) {
messaging_event mevent(messaging_event::CONNECTION_ERROR, *pe);
on_connection_error(mevent);
}
else {
messaging_event mevent(messaging_event::CONNECTION_CLOSE, *pe);
on_connection_close(mevent);
}
pn_connection_close(connection);
}
}
void pn_messenger_endpoints(pn_messenger_t *messenger, pn_connection_t *conn)
{
if (pn_connection_state(conn) | PN_LOCAL_UNINIT) {
pn_connection_open(conn);
}
pn_session_t *ssn = pn_session_head(conn, PN_LOCAL_UNINIT);
while (ssn) {
pn_session_open(ssn);
ssn = pn_session_next(ssn, PN_LOCAL_UNINIT);
}
pn_link_t *link = pn_link_head(conn, PN_LOCAL_UNINIT);
while (link) {
pn_set_source(link, pn_remote_source(link));
pn_set_target(link, pn_remote_target(link));
pn_link_open(link);
link = pn_link_next(link, PN_LOCAL_UNINIT);
}
pn_messenger_flow(messenger);
ssn = pn_session_head(conn, PN_LOCAL_ACTIVE | PN_REMOTE_CLOSED);
while (ssn) {
pn_session_close(ssn);
ssn = pn_session_next(ssn, PN_LOCAL_ACTIVE | PN_REMOTE_CLOSED);
}
link = pn_link_head(conn, PN_LOCAL_ACTIVE | PN_REMOTE_CLOSED);
while (link) {
pn_link_close(link);
link = pn_link_next(link, PN_LOCAL_ACTIVE | PN_REMOTE_CLOSED);
}
if (pn_connection_state(conn) == (PN_LOCAL_ACTIVE | PN_REMOTE_CLOSED)) {
pn_connection_close(conn);
}
}
static void deferred_close(void *context, bool discard) {
if (!discard) {
pn_connection_close((pn_connection_t*)context);
}
}
void client_callback(pn_connector_t *ctor)
{
struct client_context *ctx = pn_connector_context(ctor);
if (pn_connector_closed(ctor)) {
ctx->done = true;
}
pn_sasl_t *sasl = pn_connector_sasl(ctor);
while (pn_sasl_state(sasl) != PN_SASL_PASS) {
pn_sasl_state_t st = pn_sasl_state(sasl);
switch (st) {
case PN_SASL_IDLE:
return;
case PN_SASL_CONF:
if (ctx->mechanism && !strcmp(ctx->mechanism, "PLAIN")) {
pn_sasl_plain(sasl, ctx->username, ctx->password);
} else {
pn_sasl_mechanisms(sasl, ctx->mechanism);
pn_sasl_client(sasl);
}
break;
case PN_SASL_STEP:
if (pn_sasl_pending(sasl)) {
fprintf(stderr, "challenge failed\n");
ctx->done = true;
}
return;
case PN_SASL_FAIL:
fprintf(stderr, "authentication failed\n");
ctx->done = true;
return;
case PN_SASL_PASS:
break;
}
}
pn_connection_t *connection = pn_connector_connection(ctor);
char tagstr[1024];
char msg[ctx->size];
char data[ctx->size + 16];
for (int i = 0; i < ctx->size; i++) {
msg[i] = 'x';
}
size_t ndata = pn_message_data(data, ctx->size + 16, msg, ctx->size);
if (!ctx->init) {
ctx->init = true;
char container[1024];
if (gethostname(container, 1024)) pn_fatal("hostname lookup failed");
pn_connection_set_container(connection, container);
pn_connection_set_hostname(connection, ctx->hostname);
pn_session_t *ssn = pn_session(connection);
pn_connection_open(connection);
pn_session_open(ssn);
if (ctx->send_count) {
pn_link_t *snd = pn_sender(ssn, "sender");
pn_set_target(snd, ctx->address);
pn_link_open(snd);
char buf[16];
for (int i = 0; i < ctx->send_count; i++) {
sprintf(buf, "%x", i);
pn_delivery(snd, pn_dtag(buf, strlen(buf)));
}
}
if (ctx->recv_count) {
pn_link_t *rcv = pn_receiver(ssn, "receiver");
pn_set_source(rcv, ctx->address);
pn_link_open(rcv);
pn_flow(rcv, ctx->recv_count < ctx->high ? ctx->recv_count : ctx->high);
}
}
pn_delivery_t *delivery = pn_work_head(connection);
while (delivery)
{
pn_delivery_tag_t tag = pn_delivery_tag(delivery);
pn_quote_data(tagstr, 1024, tag.bytes, tag.size);
pn_link_t *link = pn_link(delivery);
if (pn_writable(delivery)) {
pn_send(link, data, ndata);
if (pn_advance(link)) {
if (!ctx->quiet) printf("sent delivery: %s\n", tagstr);
}
} else if (pn_readable(delivery)) {
if (!ctx->quiet) {
printf("received delivery: %s\n", tagstr);
printf(" payload = \"");
}
while (true) {
size_t n = pn_recv(link, msg, 1024);
if (n == PN_EOS) {
pn_advance(link);
pn_disposition(delivery, PN_ACCEPTED);
pn_settle(delivery);
if (!--ctx->recv_count) {
pn_link_close(link);
}
break;
} else if (!ctx->quiet) {
pn_print_data(msg, n);
}
}
if (!ctx->quiet) printf("\"\n");
if (pn_credit(link) < ctx->low && pn_credit(link) < ctx->recv_count) {
pn_flow(link, (ctx->recv_count < ctx->high ? ctx->recv_count : ctx->high) - pn_credit(link));
}
}
if (pn_updated(delivery)) {
if (!ctx->quiet) printf("disposition for %s: %u\n", tagstr, pn_remote_disposition(delivery));
pn_clear(delivery);
pn_settle(delivery);
if (!--ctx->send_count) {
pn_link_close(link);
}
}
delivery = pn_work_next(delivery);
}
if (!ctx->send_count && !ctx->recv_count) {
printf("closing\n");
// XXX: how do we close the session?
//pn_close((pn_endpoint_t *) ssn);
pn_connection_close(connection);
}
if (pn_connection_state(connection) == (PN_LOCAL_CLOSED | PN_REMOTE_CLOSED)) {
ctx->done = true;
}
}
void connection_dispatch(pn_handler_t *h, pn_event_t *event, pn_event_type_t type)
{
connection_context_t *cc = connection_context(h);
bool replying = cc->global->opts->reply;
switch (type) {
case PN_LINK_REMOTE_OPEN:
{
pn_link_t *link = pn_event_link(event);
if (pn_link_is_receiver(link)) {
check(cc->recv_link == NULL, "Multiple incomming links on one connection");
cc->recv_link = link;
pn_connection_t *conn = pn_event_connection(event);
pn_list_add(cc->global->active_connections, conn);
if (cc->global->shutting_down) {
pn_connection_close(conn);
break;
}
if (replying) {
// Set up a reply link and defer granting credit to the incoming link
pn_connection_t *conn = pn_session_connection(pn_link_session(link));
pn_session_t *ssn = pn_session(conn);
pn_session_open(ssn);
char name[100]; // prefer a multiplatform uuid generator
sprintf(name, "reply_sender_%d", cc->connection_id);
cc->reply_link = pn_sender(ssn, name);
pn_link_open(cc->reply_link);
}
else {
pn_flowcontroller_t *fc = pn_flowcontroller(1024);
pn_handler_add(h, fc);
pn_decref(fc);
}
}
}
break;
case PN_LINK_FLOW:
{
if (replying) {
pn_link_t *reply_link = pn_event_link(event);
// pn_flowcontroller handles the non-reply case
check(reply_link == cc->reply_link, "internal error");
// Grant the sender as much credit as just given to us for replies
int delta = pn_link_credit(reply_link) - pn_link_credit(cc->recv_link);
if (delta > 0)
pn_link_flow(cc->recv_link, delta);
}
}
break;
case PN_DELIVERY:
{
pn_link_t *recv_link = pn_event_link(event);
pn_delivery_t *dlv = pn_event_delivery(event);
if (pn_link_is_receiver(recv_link) && !pn_delivery_partial(dlv)) {
if (cc->global->received == 0) statistics_start(cc->global->stats);
size_t encoded_size = pn_delivery_pending(dlv);
cc->global->encoded_data = ensure_buffer(cc->global->encoded_data, encoded_size,
&cc->global->encoded_data_size);
check(cc->global->encoded_data, "decoding buffer realloc failure");
ssize_t n = pn_link_recv(recv_link, cc->global->encoded_data, encoded_size);
check(n == (ssize_t) encoded_size, "message data read fail");
pn_message_t *msg = cc->global->message;
int err = pn_message_decode(msg, cc->global->encoded_data, n);
check(err == 0, "message decode error");
cc->global->received++;
pn_delivery_settle(dlv);
statistics_msg_received(cc->global->stats, msg);
if (replying) {
const char *reply_addr = pn_message_get_reply_to(msg);
if (reply_addr) {
pn_link_t *rl = cc->reply_link;
check(pn_link_credit(rl) > 0, "message received without corresponding reply credit");
LOG("Replying to: %s\n", reply_addr );
pn_message_set_address(msg, reply_addr);
pn_message_set_creation_time(msg, msgr_now());
char tag[8];
void *ptr = &tag;
*((uint64_t *) ptr) = cc->global->sent;
pn_delivery_t *dlv = pn_delivery(rl, pn_dtag(tag, 8));
size_t size = cc->global->encoded_data_size;
int err = pn_message_encode(msg, cc->global->encoded_data, &size);
check(err == 0, "message encoding error");
pn_link_send(rl, cc->global->encoded_data, size);
pn_delivery_settle(dlv);
cc->global->sent++;
}
}
}
if (cc->global->received >= cc->global->opts->msg_count) {
global_shutdown(cc->global);
}
}
break;
case PN_CONNECTION_UNBOUND:
{
pn_connection_t *conn = pn_event_connection(event);
pn_list_remove(cc->global->active_connections, conn);
pn_connection_release(conn);
}
break;
default:
break;
}
}
void connection::close() {
pn_connection_close(pn_cast(this));
}
/* Process each event posted by the reactor.
*/
static void event_handler(pn_handler_t *handler,
pn_event_t *event,
pn_event_type_t type)
{
app_data_t *data = GET_APP_DATA(handler);
switch (type) {
case PN_CONNECTION_INIT: {
// Create and open all the endpoints needed to send a message
//
pn_connection_t *conn;
pn_session_t *ssn;
pn_link_t *sender;
conn = pn_event_connection(event);
pn_connection_open(conn);
ssn = pn_session(conn);
pn_session_open(ssn);
sender = pn_sender(ssn, "MySender");
// we do not wait for ack until the last message
pn_link_set_snd_settle_mode(sender, PN_SND_MIXED);
if (!data->anon) {
pn_terminus_set_address(pn_link_target(sender), data->target);
}
pn_link_open(sender);
} break;
case PN_LINK_FLOW: {
// the remote has given us some credit, now we can send messages
//
static long tag = 0; // a simple tag generator
pn_delivery_t *delivery;
pn_link_t *sender = pn_event_link(event);
int credit = pn_link_credit(sender);
while (credit > 0 && data->count > 0) {
--credit;
--data->count;
++tag;
delivery = pn_delivery(sender,
pn_dtag((const char *)&tag, sizeof(tag)));
pn_link_send(sender, data->msg_data, data->msg_len);
pn_link_advance(sender);
if (data->count > 0) {
// send pre-settled until the last one, then wait for an ack on
// the last sent message. This allows the sender to send
// messages as fast as possible and then exit when the consumer
// has dealt with the last one.
//
pn_delivery_settle(delivery);
}
}
} break;
case PN_DELIVERY: {
// Since the example sends all messages but the last pre-settled
// (pre-acked), only the last message's delivery will get updated with
// the remote state (acked/nacked).
//
pn_delivery_t *dlv = pn_event_delivery(event);
if (pn_delivery_updated(dlv) && pn_delivery_remote_state(dlv)) {
uint64_t rs = pn_delivery_remote_state(dlv);
int done = 1;
switch (rs) {
case PN_RECEIVED:
// This is not a terminal state - it is informational, and the
// peer is still processing the message.
done = 0;
break;
case PN_ACCEPTED:
pn_delivery_settle(dlv);
if (!quiet) fprintf(stdout, "Send complete!\n");
break;
case PN_REJECTED:
case PN_RELEASED:
case PN_MODIFIED:
pn_delivery_settle(dlv);
fprintf(stderr, "Message not accepted - code:%lu\n", (unsigned long)rs);
break;
default:
// ??? no other terminal states defined, so ignore anything else
pn_delivery_settle(dlv);
fprintf(stderr, "Unknown delivery failure - code=%lu\n", (unsigned long)rs);
break;
}
if (done) {
// initiate clean shutdown of the endpoints
pn_link_t *link = pn_delivery_link(dlv);
pn_session_t *ssn = pn_link_session(link);
pn_link_close(link);
pn_session_close(ssn);
pn_connection_close(pn_session_connection(ssn));
}
}
} break;
case PN_TRANSPORT_ERROR: {
// The connection to the peer failed.
//
pn_transport_t *tport = pn_event_transport(event);
pn_condition_t *cond = pn_transport_condition(tport);
fprintf(stderr, "Network transport failed!\n");
if (pn_condition_is_set(cond)) {
const char *name = pn_condition_get_name(cond);
const char *desc = pn_condition_get_description(cond);
fprintf(stderr, " Error: %s Description: %s\n",
(name) ? name : "<error name not provided>",
(desc) ? desc : "<no description provided>");
}
// pn_reactor_process() will exit with a false return value, stopping
// the main loop.
} break;
default:
break;
}
}
void sender_dispatch(pn_handler_t *h, pn_event_t *event, pn_event_type_t type)
{
sender_context_t *sc = sender_context(h);
switch (type) {
case PN_CONNECTION_INIT:
{
pn_connection_t *conn = pn_event_connection(event);
pn_connection_set_container(conn, pn_string_get(sc->container_id));
pn_connection_set_hostname(conn, pn_string_get(sc->hostname));
pn_connection_open(conn);
pn_session_t *ssn = pn_session(conn);
pn_session_open(ssn);
pn_link_t *snd = pn_sender(ssn, "sender");
const char *path = pn_url_get_path(sc->send_url);
if (path && strlen(path)) {
pn_terminus_set_address(pn_link_target(snd), path);
pn_terminus_set_address(pn_link_source(snd), path);
}
pn_link_open(snd);
}
break;
case PN_LINK_FLOW:
{
pn_link_t *snd = pn_event_link(event);
while (pn_link_credit(snd) > 0 && sc->sent < sc->opts->msg_count) {
if (sc->sent == 0)
statistics_start(sc->stats);
char tag[8];
void *ptr = &tag;
*((uint64_t *) ptr) = sc->sent;
pn_delivery_t *dlv = pn_delivery(snd, pn_dtag(tag, 8));
// setup the message to send
pn_message_t *msg = sc->message;
pn_message_set_address(msg, sc->opts->targets.addresses[0]);
sc->id.u.as_ulong = sc->sent;
pn_message_set_correlation_id(msg, sc->id);
pn_message_set_creation_time(msg, msgr_now());
size_t size = sc->encoded_data_size;
int err = pn_message_encode(msg, sc->encoded_data, &size);
check(err == 0, "message encoding error");
pn_link_send(snd, sc->encoded_data, size);
pn_delivery_settle(dlv);
sc->sent++;
}
if (sc->sent == sc->opts->msg_count && !sc->opts->get_replies) {
pn_link_close(snd);
pn_connection_t *conn = pn_event_connection(event);
pn_connection_close(conn);
}
}
break;
case PN_LINK_INIT:
{
pn_link_t *link = pn_event_link(event);
if (pn_link_is_receiver(link)) {
// Response messages link. Could manage credit and deliveries in this handler but
// a dedicated handler also works.
pn_handler_t *replyto = replyto_handler(sc);
pn_flowcontroller_t *fc = pn_flowcontroller(1024);
pn_handler_add(replyto, fc);
pn_decref(fc);
pn_handshaker_t *handshaker = pn_handshaker();
pn_handler_add(replyto, handshaker);
pn_decref(handshaker);
pn_record_t *record = pn_link_attachments(link);
pn_record_set_handler(record, replyto);
pn_decref(replyto);
}
}
break;
case PN_CONNECTION_LOCAL_CLOSE:
{
statistics_report(sc->stats, sc->sent, sc->received);
}
break;
default:
break;
}
}
int pn_event_handler(void *handler_context, void *conn_context, pn_event_t *event, qd_connection_t *qd_conn)
{
qd_container_t *container = (qd_container_t*) handler_context;
pn_connection_t *conn = qd_connection_pn(qd_conn);
pn_session_t *ssn;
pn_link_t *pn_link;
qd_link_t *qd_link;
pn_delivery_t *delivery;
switch (pn_event_type(event)) {
case PN_CONNECTION_REMOTE_OPEN :
qd_connection_set_user(qd_conn);
if (pn_connection_state(conn) & PN_LOCAL_UNINIT) {
// This Open is an externally initiated connection
// Let policy engine decide
qd_connection_set_event_stall(qd_conn, true);
qd_conn->open_container = (void *)container;
qd_connection_invoke_deferred(qd_conn, qd_policy_amqp_open, qd_conn);
} else {
// This Open is in response to an internally initiated connection
notify_opened(container, qd_conn, conn_context);
}
break;
case PN_CONNECTION_REMOTE_CLOSE :
if (pn_connection_state(conn) == (PN_LOCAL_ACTIVE | PN_REMOTE_CLOSED))
pn_connection_close(conn);
break;
case PN_SESSION_REMOTE_OPEN :
if (!(pn_connection_state(conn) & PN_LOCAL_CLOSED)) {
ssn = pn_event_session(event);
if (pn_session_state(ssn) & PN_LOCAL_UNINIT) {
if (qd_conn->policy_settings) {
if (!qd_policy_approve_amqp_session(ssn, qd_conn)) {
break;
}
qd_conn->n_sessions++;
}
qd_policy_apply_session_settings(ssn, qd_conn);
pn_session_open(ssn);
}
}
break;
case PN_SESSION_REMOTE_CLOSE :
if (!(pn_connection_state(conn) & PN_LOCAL_CLOSED)) {
ssn = pn_event_session(event);
if (pn_session_state(ssn) == (PN_LOCAL_ACTIVE | PN_REMOTE_CLOSED)) {
// remote has nuked our session. Check for any links that were
// left open and forcibly detach them, since no detaches will
// arrive on this session.
pn_connection_t *conn = pn_session_connection(ssn);
pn_link_t *pn_link = pn_link_head(conn, PN_LOCAL_ACTIVE | PN_REMOTE_ACTIVE);
while (pn_link) {
if (pn_link_session(pn_link) == ssn) {
qd_link_t *qd_link = (qd_link_t*) pn_link_get_context(pn_link);
if (qd_link && qd_link->node) {
if (qd_conn->policy_settings) {
if (qd_link->direction == QD_OUTGOING) {
qd_conn->n_receivers--;
assert(qd_conn->n_receivers >= 0);
} else {
qd_conn->n_senders--;
assert(qd_conn->n_senders >= 0);
}
}
qd_log(container->log_source, QD_LOG_NOTICE,
"Aborting link '%s' due to parent session end",
pn_link_name(pn_link));
qd_link->node->ntype->link_detach_handler(qd_link->node->context,
qd_link, QD_LOST);
}
}
pn_link = pn_link_next(pn_link, PN_LOCAL_ACTIVE | PN_REMOTE_ACTIVE);
}
if (qd_conn->policy_settings) {
qd_conn->n_sessions--;
}
pn_session_close(ssn);
}
}
break;
case PN_LINK_REMOTE_OPEN :
if (!(pn_connection_state(conn) & PN_LOCAL_CLOSED)) {
pn_link = pn_event_link(event);
if (pn_link_state(pn_link) & PN_LOCAL_UNINIT) {
if (pn_link_is_sender(pn_link)) {
if (qd_conn->policy_settings) {
if (!qd_policy_approve_amqp_receiver_link(pn_link, qd_conn)) {
break;
}
qd_conn->n_receivers++;
}
setup_outgoing_link(container, pn_link);
} else {
if (qd_conn->policy_settings) {
if (!qd_policy_approve_amqp_sender_link(pn_link, qd_conn)) {
break;
}
qd_conn->n_senders++;
}
setup_incoming_link(container, pn_link);
}
} else if (pn_link_state(pn_link) & PN_LOCAL_ACTIVE)
handle_link_open(container, pn_link);
}
break;
case PN_LINK_REMOTE_CLOSE :
case PN_LINK_REMOTE_DETACH :
if (!(pn_connection_state(conn) & PN_LOCAL_CLOSED)) {
pn_link = pn_event_link(event);
qd_link = (qd_link_t*) pn_link_get_context(pn_link);
if (qd_link) {
qd_node_t *node = qd_link->node;
qd_detach_type_t dt = pn_event_type(event) == PN_LINK_REMOTE_CLOSE ? QD_CLOSED : QD_DETACHED;
if (node)
node->ntype->link_detach_handler(node->context, qd_link, dt);
else if (qd_link->pn_link == pn_link) {
pn_link_close(pn_link);
}
if (qd_conn->policy_counted && qd_conn->policy_settings) {
if (pn_link_is_sender(pn_link)) {
qd_conn->n_receivers--;
qd_log(container->log_source, QD_LOG_TRACE,
"Closed receiver link %s. n_receivers: %d",
pn_link_name(pn_link), qd_conn->n_receivers);
assert (qd_conn->n_receivers >= 0);
} else {
qd_conn->n_senders--;
qd_log(container->log_source, QD_LOG_TRACE,
"Closed sender link %s. n_senders: %d",
pn_link_name(pn_link), qd_conn->n_senders);
assert (qd_conn->n_senders >= 0);
}
}
if (qd_link->close_sess_with_link && qd_link->pn_sess &&
pn_link_state(pn_link) == (PN_LOCAL_CLOSED | PN_REMOTE_CLOSED))
pn_session_close(qd_link->pn_sess);
}
}
break;
case PN_LINK_FLOW :
pn_link = pn_event_link(event);
qd_link = (qd_link_t*) pn_link_get_context(pn_link);
if (qd_link && qd_link->node && qd_link->node->ntype->link_flow_handler)
qd_link->node->ntype->link_flow_handler(qd_link->node->context, qd_link);
break;
case PN_DELIVERY :
delivery = pn_event_delivery(event);
if (pn_delivery_readable(delivery))
do_receive(delivery);
if (pn_delivery_updated(delivery)) {
do_updated(delivery);
pn_delivery_clear(delivery);
}
break;
case PN_EVENT_NONE :
case PN_REACTOR_INIT :
case PN_REACTOR_QUIESCED :
case PN_REACTOR_FINAL :
case PN_TIMER_TASK :
case PN_CONNECTION_INIT :
case PN_CONNECTION_BOUND :
case PN_CONNECTION_UNBOUND :
case PN_CONNECTION_LOCAL_OPEN :
case PN_CONNECTION_LOCAL_CLOSE :
case PN_CONNECTION_FINAL :
case PN_SESSION_INIT :
case PN_SESSION_LOCAL_OPEN :
case PN_SESSION_LOCAL_CLOSE :
case PN_SESSION_FINAL :
case PN_LINK_INIT :
case PN_LINK_LOCAL_OPEN :
case PN_LINK_LOCAL_CLOSE :
case PN_LINK_LOCAL_DETACH :
case PN_LINK_FINAL :
case PN_TRANSPORT :
case PN_TRANSPORT_ERROR :
case PN_TRANSPORT_HEAD_CLOSED :
case PN_TRANSPORT_TAIL_CLOSED :
case PN_TRANSPORT_CLOSED :
case PN_TRANSPORT_AUTHENTICATED :
case PN_SELECTABLE_INIT :
case PN_SELECTABLE_UPDATED :
case PN_SELECTABLE_READABLE :
case PN_SELECTABLE_WRITABLE :
case PN_SELECTABLE_ERROR :
case PN_SELECTABLE_EXPIRED :
case PN_SELECTABLE_FINAL :
break;
}
return 1;
}
void Connection::process()
{
QPID_LOG(trace, id << " process()");
if ((pn_connection_state(connection) & REQUIRES_OPEN) == REQUIRES_OPEN) {
QPID_LOG_CAT(debug, model, id << " connection opened");
pn_connection_set_container(connection, broker.getFederationTag().c_str());
pn_connection_open(connection);
}
for (pn_session_t* s = pn_session_head(connection, REQUIRES_OPEN); s; s = pn_session_next(s, REQUIRES_OPEN)) {
QPID_LOG_CAT(debug, model, id << " session begun");
pn_session_open(s);
boost::shared_ptr<Session> ssn(new Session(s, broker, *this, out));
sessions[s] = ssn;
}
for (pn_link_t* l = pn_link_head(connection, REQUIRES_OPEN); l; l = pn_link_next(l, REQUIRES_OPEN)) {
pn_link_open(l);
Sessions::iterator session = sessions.find(pn_link_session(l));
if (session == sessions.end()) {
QPID_LOG(error, id << " Link attached on unknown session!");
} else {
try {
session->second->attach(l);
QPID_LOG_CAT(debug, protocol, id << " link " << l << " attached on " << pn_link_session(l));
} catch (const std::exception& e) {
QPID_LOG_CAT(error, protocol, "Error on attach: " << e.what());
//TODO: set error details on detach when that is exposed via engine API
pn_link_close(l);
}
}
}
//handle deliveries
for (pn_delivery_t* delivery = pn_work_head(connection); delivery; delivery = pn_work_next(delivery)) {
pn_link_t* link = pn_delivery_link(delivery);
if (pn_link_is_receiver(link)) {
Sessions::iterator i = sessions.find(pn_link_session(link));
if (i != sessions.end()) {
i->second->readable(link, delivery);
} else {
pn_delivery_update(delivery, PN_REJECTED);
}
} else { //i.e. SENDER
Sessions::iterator i = sessions.find(pn_link_session(link));
if (i != sessions.end()) {
QPID_LOG(trace, id << " handling outgoing delivery for " << link << " on session " << pn_link_session(link));
i->second->writable(link, delivery);
} else {
QPID_LOG(error, id << " Got delivery for non-existent session: " << pn_link_session(link) << ", link: " << link);
}
}
}
for (pn_link_t* l = pn_link_head(connection, REQUIRES_CLOSE); l; l = pn_link_next(l, REQUIRES_CLOSE)) {
pn_link_close(l);
Sessions::iterator session = sessions.find(pn_link_session(l));
if (session == sessions.end()) {
QPID_LOG(error, id << " peer attempted to detach link on unknown session!");
} else {
session->second->detach(l);
QPID_LOG_CAT(debug, model, id << " link detached");
}
}
for (pn_session_t* s = pn_session_head(connection, REQUIRES_CLOSE); s; s = pn_session_next(s, REQUIRES_CLOSE)) {
pn_session_close(s);
Sessions::iterator i = sessions.find(s);
if (i != sessions.end()) {
i->second->close();
sessions.erase(i);
QPID_LOG_CAT(debug, model, id << " session ended");
} else {
QPID_LOG(error, id << " peer attempted to close unrecognised session");
}
}
if ((pn_connection_state(connection) & REQUIRES_CLOSE) == REQUIRES_CLOSE) {
QPID_LOG_CAT(debug, model, id << " connection closed");
pn_connection_close(connection);
}
}
void server_callback(pn_connector_t *ctor)
{
pn_sasl_t *sasl = pn_connector_sasl(ctor);
while (pn_sasl_state(sasl) != PN_SASL_PASS) {
switch (pn_sasl_state(sasl)) {
case PN_SASL_IDLE:
return;
case PN_SASL_CONF:
pn_sasl_mechanisms(sasl, "PLAIN ANONYMOUS");
pn_sasl_server(sasl);
break;
case PN_SASL_STEP:
{
size_t n = pn_sasl_pending(sasl);
char iresp[n];
pn_sasl_recv(sasl, iresp, n);
printf("%s", pn_sasl_remote_mechanisms(sasl));
printf(" response = ");
pn_print_data(iresp, n);
printf("\n");
pn_sasl_done(sasl, PN_SASL_OK);
pn_connector_set_connection(ctor, pn_connection());
}
break;
case PN_SASL_PASS:
break;
case PN_SASL_FAIL:
return;
}
}
pn_connection_t *conn = pn_connector_connection(ctor);
struct server_context *ctx = pn_connector_context(ctor);
char tagstr[1024];
char msg[10*1024];
char data[ctx->size + 16];
for (int i = 0; i < ctx->size; i++) {
msg[i] = 'x';
}
size_t ndata = pn_message_data(data, ctx->size + 16, msg, ctx->size);
if (pn_connection_state(conn) == (PN_LOCAL_UNINIT | PN_REMOTE_ACTIVE)) {
pn_connection_open(conn);
}
pn_session_t *ssn = pn_session_head(conn, PN_LOCAL_UNINIT | PN_REMOTE_ACTIVE);
while (ssn) {
pn_session_open(ssn);
ssn = pn_session_next(ssn, PN_LOCAL_UNINIT | PN_REMOTE_ACTIVE);
}
pn_link_t *link = pn_link_head(conn, PN_LOCAL_UNINIT | PN_REMOTE_ACTIVE);
while (link) {
printf("%s, %s\n", pn_remote_source(link), pn_remote_target(link));
pn_set_source(link, pn_remote_source(link));
pn_set_target(link, pn_remote_target(link));
pn_link_open(link);
if (pn_is_receiver(link)) {
pn_flow(link, 100);
} else {
pn_delivery(link, pn_dtag("blah", 4));
}
link = pn_link_next(link, PN_LOCAL_UNINIT | PN_REMOTE_ACTIVE);
}
pn_delivery_t *delivery = pn_work_head(conn);
while (delivery)
{
pn_delivery_tag_t tag = pn_delivery_tag(delivery);
pn_quote_data(tagstr, 1024, tag.bytes, tag.size);
pn_link_t *link = pn_link(delivery);
if (pn_readable(delivery)) {
if (!ctx->quiet) {
printf("received delivery: %s\n", tagstr);
printf(" payload = \"");
}
while (true) {
ssize_t n = pn_recv(link, msg, 1024);
if (n == PN_EOS) {
pn_advance(link);
pn_disposition(delivery, PN_ACCEPTED);
break;
} else if (!ctx->quiet) {
pn_print_data(msg, n);
}
}
if (!ctx->quiet) printf("\"\n");
if (pn_credit(link) < 50) pn_flow(link, 100);
} else if (pn_writable(delivery)) {
pn_send(link, data, ndata);
if (pn_advance(link)) {
if (!ctx->quiet) printf("sent delivery: %s\n", tagstr);
char tagbuf[16];
sprintf(tagbuf, "%i", ctx->count++);
pn_delivery(link, pn_dtag(tagbuf, strlen(tagbuf)));
}
}
if (pn_updated(delivery)) {
if (!ctx->quiet) printf("disposition for %s: %u\n", tagstr, pn_remote_disposition(delivery));
pn_settle(delivery);
}
delivery = pn_work_next(delivery);
}
if (pn_connection_state(conn) == (PN_LOCAL_ACTIVE | PN_REMOTE_CLOSED)) {
pn_connection_close(conn);
}
ssn = pn_session_head(conn, PN_LOCAL_ACTIVE | PN_REMOTE_CLOSED);
while (ssn) {
pn_session_close(ssn);
ssn = pn_session_next(ssn, PN_LOCAL_ACTIVE | PN_REMOTE_CLOSED);
}
link = pn_link_head(conn, PN_LOCAL_ACTIVE | PN_REMOTE_CLOSED);
while (link) {
pn_link_close(link);
link = pn_link_next(link, PN_LOCAL_ACTIVE | PN_REMOTE_CLOSED);
}
}
void connection::close() { pn_connection_close(pn_object()); }
int
main ( int argc, char ** argv )
{
char info[1000];
int expected = (argc > 1) ? atoi(argv[1]) : 100000;
int received = 0;
int size = 32;
int msg_size = 50;
bool done = false;
int initial_credit = 500,
new_credit = 250,
low_credit_limit = 250;
char const * host = "0.0.0.0";
char const * port = "5672";
bool sasl_done = false;
pn_driver_t * driver;
pn_listener_t * listener;
pn_connector_t * connector;
pn_connection_t * connection;
pn_session_t * session;
pn_link_t * link;
pn_delivery_t * delivery;
char * message_data = (char *) malloc ( MY_BUF_SIZE );
int message_data_capacity = MY_BUF_SIZE;
fprintf ( stderr, "drecv expecting %d messages.\n", expected );
driver = pn_driver ( );
if ( ! pn_listener(driver, host, port, 0) )
{
fprintf ( stderr, "listener creation failed.\n" );
exit ( 1 );
}
while ( ! done)
{
pn_driver_wait ( driver, -1 );
if ( (listener = pn_driver_listener(driver)) )
pn_listener_accept( listener );
if ( (connector = pn_driver_connector(driver)) )
{
pn_connector_process ( connector );
if ( ! sasl_done )
if( ! (sasl_done = get_sasl_over_with(connector) ))
continue;
connection = pn_connector_connection ( connector );
/*=========================================================
Open everything that is ready on the
other side but not here.
=========================================================*/
pn_state_t hes_ready_im_not = PN_LOCAL_UNINIT | PN_REMOTE_ACTIVE;
if (pn_connection_state(connection) == hes_ready_im_not)
pn_connection_open( connection);
for ( session = pn_session_head(connection, hes_ready_im_not);
session;
session = pn_session_next(session, hes_ready_im_not)
)
pn_session_open(session);
for ( link = pn_link_head(connection, hes_ready_im_not);
link;
link = pn_link_next(link, hes_ready_im_not)
)
{
pn_terminus_copy(pn_link_source(link), pn_link_remote_source(link));
pn_terminus_copy(pn_link_target(link), pn_link_remote_target(link));
pn_link_open ( link );
if ( pn_link_is_receiver(link) )
pn_link_flow ( link, initial_credit );
}
/*==========================================================
Get all available deliveries.
==========================================================*/
for ( delivery = pn_work_head ( connection );
delivery;
delivery = pn_work_next ( delivery )
)
{
if ( pn_delivery_readable(delivery) )
{
link = pn_delivery_link ( delivery );
while ( PN_EOS != pn_link_recv(link, message_data, MY_BUF_SIZE) )
;
pn_link_advance ( link );
pn_delivery_update ( delivery, PN_ACCEPTED );
pn_delivery_settle ( delivery );
if ( ++ received >= expected )
{
sprintf ( info, "received %d messages", received );
print_timestamp ( stderr, info );
done = true;
}
// a progress report for long tests.
if ( ! (received % 5000000) )
fprintf ( stderr, "received: %d\n", received );
if ( pn_link_credit(link) <= low_credit_limit )
pn_link_flow ( link, new_credit );
}
else
{
// TODO
// Why am I getting writables?
// And what to do with them?
}
}
/*===============================================================
Shut down everything that the other side has closed.
===============================================================*/
pn_state_t active_here_closed_there = PN_LOCAL_ACTIVE | PN_REMOTE_CLOSED;
if ( pn_connection_state(connection) == active_here_closed_there )
pn_connection_close ( connection );
for ( session = pn_session_head(connection, active_here_closed_there);
session;
session = pn_session_next(session, active_here_closed_there)
)
pn_session_close ( session );
for ( link = pn_link_head(connection, active_here_closed_there);
link;
link = pn_link_next(link, active_here_closed_there)
)
pn_link_close ( link );
if ( pn_connector_closed(connector) )
{
pn_connection_free ( pn_connector_connection(connector) );
pn_connector_free ( connector );
done = true;
}
else
pn_connector_process(connector);
}
}
pn_driver_free(driver);
return 0;
}
void
connection_dispatch ( pn_handler_t *h, pn_event_t *event, pn_event_type_t type )
{
connection_context_t *cc = connection_context(h);
switch ( type )
{
case PN_LINK_REMOTE_OPEN:
{
pn_link_t *link = pn_event_link(event);
if (pn_link_is_receiver(link)) {
check(cc->recv_link == NULL, "Multiple incomming links on one connection");
cc->recv_link = link;
pn_connection_t *conn = pn_event_connection(event);
pn_list_add(cc->global->active_connections, conn);
if (cc->global->shutting_down) {
pn_connection_close(conn);
break;
}
pn_flowcontroller_t *fc = pn_flowcontroller(1024);
pn_handler_add(h, fc);
pn_decref(fc);
}
}
break;
case PN_DELIVERY:
{
pn_link_t *recv_link = pn_event_link(event);
pn_delivery_t *dlv = pn_event_delivery(event);
if (pn_link_is_receiver(recv_link) && !pn_delivery_partial(dlv)) {
if (cc->global->received == 0) statistics_start(cc->global->stats);
size_t encoded_size = pn_delivery_pending(dlv);
cc->global->encoded_data = ensure_buffer(cc->global->encoded_data, encoded_size,
&cc->global->encoded_data_size);
check(cc->global->encoded_data, "decoding buffer realloc failure");
/*
If this was the first message received,
initialize our reporting.
*/
if ( ! cc->global->received )
rr_init ( & cc->global->resource_reporter );
ssize_t n = pn_link_recv(recv_link, cc->global->encoded_data, encoded_size);
check(n == (ssize_t) encoded_size, "message data read fail");
//fprintf ( stderr, "MDEBUG encoded_size == %d\n", encoded_size );
pn_message_t *msg = cc->global->message;
int err = pn_message_decode ( msg, cc->global->encoded_data, n );
check ( err == 0, "message decode error" );
/* MICK -- annotate! ================================ */
if ( cc->global->opts->timestamping )
{
double message_timestamp;
if ( get_message_timestamp ( msg, & message_timestamp ) )
{
double now = now_timestamp ( );
cc->global->total_latency += (now - message_timestamp);
}
else
{
fprintf ( stderr,
"receiver: no timestamp at msg count %d.\n",
cc->global->received
);
exit ( 1 );
}
}
/* MICK -- end annotate! ============================= */
cc->global->received++;
/*---------------------------------------
Do a report
---------------------------------------*/
if ( ! ( cc->global->received % cc->global->opts->report_frequency ) )
{
static bool first_time = true;
double cpu_percentage;
int rss;
double sslr = rr_seconds_since_last_report ( & cc->global->resource_reporter );
rr_report ( & cc->global->resource_reporter, & cpu_percentage, & rss );
double throughput = (double)(cc->global->opts->report_frequency) / sslr;
if ( first_time )
{
if ( cc->global->opts->timestamping )
{
if ( cc->global->opts->print_message_size )
fprintf(cc->global->report_fp, "msg_size\trecv_msgs\tcpu\trss\tthroughput\tlatency\n");
else
fprintf(cc->global->report_fp, "recv_msgs\tcpu\trss\tthroughput\tlatency\n");
}
else
{
if ( cc->global->opts->print_message_size )
fprintf(cc->global->report_fp, "msg_size\trecv_msgs\tcpu\trss\tthroughput\n");
else
fprintf(cc->global->report_fp, "recv_msgs\tcpu\trss\tthroughput\n");
}
first_time = false;
}
if ( cc->global->opts->timestamping )
{
double average_latency = cc->global->total_latency /
cc->global->opts->report_frequency;
average_latency *= 1000.0; // in msec.
cc->global->total_latency = 0;
fprintf ( cc->global->report_fp,
"%d\t%lf\t%d\t%lf\t%lf\n",
cc->global->received,
cpu_percentage,
rss,
throughput,
average_latency
);
}
else
{
// was:
// "recv_msgs: %10d cpu: %5.1lf rss: %6d throughput: %8.0lf\n"
if ( cc->global->opts->print_message_size )
{
fprintf ( cc->global->report_fp,
"%d\t%d\t%lf\t%d\t%lf\n",
cc->global->opts->message_size,
cc->global->received,
cpu_percentage,
rss,
throughput
);
}
else
{
fprintf ( cc->global->report_fp,
"%d\t%lf\t%d\t%lf\n",
cc->global->received,
cpu_percentage,
rss,
throughput
);
}
}
}
pn_delivery_settle(dlv); // move this up
statistics_msg_received(cc->global->stats, msg);
}
if (cc->global->received >= cc->global->opts->msg_count) {
global_shutdown(cc->global);
}
}
break;
case PN_CONNECTION_UNBOUND:
{
pn_connection_t *conn = pn_event_connection(event);
pn_list_remove(cc->global->active_connections, conn);
pn_connection_release(conn);
}
break;
default:
break;
}
}