void process_connection(ldp_connection_t *conn, pn_event_t *event) {
fprintf(stderr, "connection event %s\n", pn_event_type_name(pn_event_type(event)));
if (pn_event_type(event) == PN_CONNECTION_REMOTE_STATE) {
pn_session_t *session = pn_session(pn_event_connection(event));
pn_session_open(session);
}
}
/* 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 process_session(ldp_connection_t *conn, pn_event_t *event) {
fprintf(stderr, "session event %s\n", pn_event_type_name(pn_event_type(event)));
if (pn_event_type(event) == PN_SESSION_REMOTE_STATE) {
pn_session_t *session = pn_event_session(event);
pn_link_t *sender = pn_sender(session, "sender-xxx");
pn_terminus_set_address(pn_link_source(sender), "hello-world");
pn_link_open(sender);
}
}
/* 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 connection_engine::dispatch() {
proton_handler& h = *ctx_->engine_handler->messaging_adapter_;
pn_collector_t* c = ctx_->collector;
for (pn_event_t *e = pn_collector_peek(c); e; e = pn_collector_peek(c)) {
if (pn_event_type(e) == PN_CONNECTION_INIT) {
// Make the messaging_adapter issue a START event.
proton_event(e, PN_REACTOR_INIT, 0).dispatch(h);
}
proton_event(e, pn_event_type(e), 0).dispatch(h);
pn_collector_pop(c);
}
}
void events(ldp_connection_t *conn, pn_collector_t *coll) {
pn_event_t *event;
while((event = pn_collector_peek(coll))) {
switch (pn_event_type(event)) {
case PN_EVENT_NONE:
break;
case PN_CONNECTION_REMOTE_STATE:
case PN_CONNECTION_LOCAL_STATE:
process_connection(conn, event);
break;
case PN_SESSION_REMOTE_STATE:
case PN_SESSION_LOCAL_STATE:
process_session(conn, event);
break;
case PN_LINK_REMOTE_STATE:
case PN_LINK_LOCAL_STATE:
process_link(conn, event);
break;
case PN_LINK_FLOW:
process_flow(conn, event);
break;
case PN_DELIVERY:
process_delivery(conn, event);
break;
case PN_TRANSPORT:
process_transport(conn, event);
break;
}
pn_collector_pop(coll);
}
}
void process_flow(ldp_connection_t *conn, pn_event_t *event) {
fprintf(stderr, "flow event %s\n", pn_event_type_name(pn_event_type(event)));
pn_link_t *sender = pn_event_link(event);
pn_message_t *message = pn_message();
pn_message_set_address(message, "amqp://foo/bar");
pn_data_t *body = pn_message_body(message);
char *msgtext = "hello world!";
pn_data_put_string(body, pn_bytes(strlen(msgtext), msgtext));
pn_buffer_t *buffer = pn_buffer(1000);
char *encoded = pn_buffer_bytes(buffer).start;
size_t size = pn_buffer_capacity(buffer);
int err = pn_message_encode(message, encoded, &size);
if (err) {
fprintf(stderr, "trouble encoding message\n");
} else {
char tag[8];
static uint64_t next_tag;
*((uint64_t*)tag) = ++next_tag;
pn_delivery_t *d = pn_delivery(sender, pn_dtag(tag, 8));
pn_link_send(sender, encoded, size);
pn_link_advance(sender);
}
pn_buffer_free(buffer);
pn_message_free(message);
}
/* 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);
}
}
/* 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;
}
static pn_event_type_t message_stream_handler(test_handler_t *th, pn_event_t *e) {
struct message_stream_context *ctx = (struct message_stream_context*)th->context;
switch (pn_event_type(e)) {
case PN_CONNECTION_BOUND:
pn_transport_set_max_frame(pn_event_transport(e), FRAME);
return PN_EVENT_NONE;
case PN_SESSION_INIT:
pn_session_set_incoming_capacity(pn_event_session(e), FRAME); /* Single frame incoming */
pn_session_set_outgoing_window(pn_event_session(e), 1); /* Single frame outgoing */
return PN_EVENT_NONE;
case PN_LINK_REMOTE_OPEN:
common_handler(th, e);
if (pn_link_is_receiver(pn_event_link(e))) {
pn_link_flow(pn_event_link(e), 1);
} else {
ctx->sender = pn_event_link(e);
}
return PN_EVENT_NONE;
case PN_LINK_FLOW: /* Start a delivery */
if (pn_link_is_sender(pn_event_link(e)) && !ctx->dlv) {
ctx->dlv = pn_delivery(pn_event_link(e), pn_dtag("x", 1));
}
return PN_LINK_FLOW;
case PN_CONNECTION_WAKE: { /* Send a chunk */
ssize_t remains = ctx->size - ctx->sent;
ssize_t n = (CHUNK < remains) ? CHUNK : remains;
TEST_CHECK(th->t, n == pn_link_send(ctx->sender, ctx->send_buf.start + ctx->sent, n));
ctx->sent += n;
if (ctx->sent == ctx->size) {
TEST_CHECK(th->t, pn_link_advance(ctx->sender));
}
return PN_CONNECTION_WAKE;
}
case PN_DELIVERY: { /* Receive a delivery - smaller than a chunk? */
pn_delivery_t *dlv = pn_event_delivery(e);
if (pn_delivery_readable(dlv)) {
ssize_t n = pn_delivery_pending(dlv);
rwbytes_ensure(&ctx->recv_buf, ctx->received + n);
TEST_ASSERT(n == pn_link_recv(pn_event_link(e), ctx->recv_buf.start + ctx->received, n));
ctx->received += n;
}
ctx->complete = !pn_delivery_partial(dlv);
return PN_DELIVERY;
}
default:
return common_handler(th, e);
}
}
static pn_event_type_t ssl_server_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_open(pn_event_connection(e));
return et;
}
default:
return listen_handler(h, e);
}
}
/* Close the transport to abort a connection, i.e. close the socket without an AMQP close */
static pn_event_type_t listen_abort_handler(test_handler_t *th, pn_event_t *e) {
switch (pn_event_type(e)) {
case PN_CONNECTION_REMOTE_OPEN:
/* Close the transport - abruptly closes the socket */
pn_transport_close_tail(pn_connection_transport(pn_event_connection(e)));
pn_transport_close_head(pn_connection_transport(pn_event_connection(e)));
return PN_EVENT_NONE;
default:
/* Don't auto-close the listener to keep the event sequences simple */
return listen_handler(th, e);
}
}
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);
}
}
/* Like common_handler but does not auto-close the listener after one accept,
and returns on LISTENER_CLOSE
*/
static pn_event_type_t listen_handler(test_handler_t *th, pn_event_t *e) {
switch (pn_event_type(e)) {
case PN_LISTENER_ACCEPT:
/* No automatic listener close/free for tests that accept multiple connections */
last_accepted = pn_connection();
pn_listener_accept2(pn_event_listener(e), last_accepted, NULL);
/* No automatic close */
return PN_EVENT_NONE;
case PN_LISTENER_CLOSE:
return PN_LISTENER_CLOSE;
default:
return common_handler(th, e);
}
}
static pn_event_type_t ssl_handler(test_handler_t *h, pn_event_t *e) {
switch (pn_event_type(e)) {
case PN_CONNECTION_BOUND:
TEST_CHECK(h->t, 0 == pn_ssl_init(pn_ssl(pn_event_transport(e)), h->ssl_domain, NULL));
return PN_EVENT_NONE;
case PN_CONNECTION_REMOTE_OPEN: {
pn_ssl_t *ssl = pn_ssl(pn_event_transport(e));
TEST_CHECK(h->t, ssl);
char protocol[256];
TEST_CHECK(h->t, pn_ssl_get_protocol_name(ssl, protocol, sizeof(protocol)));
TEST_STR_IN(h->t, "TLS", protocol);
return PN_CONNECTION_REMOTE_OPEN;
}
default:
return PN_EVENT_NONE;
}
}
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 process_link(ldp_connection_t *conn, pn_event_t *event) {
fprintf(stderr, "link event %s\n", pn_event_type_name(pn_event_type(event)));
}
void process_delivery(ldp_connection_t *conn, pn_event_t *event) {
fprintf(stderr, "delivery event %s\n", pn_event_type_name(pn_event_type(event)));
}
void process_transport(ldp_connection_t *conn, pn_event_t *event) {
fprintf(stderr, "transport event %s\n", pn_event_type_name(pn_event_type(event)));
}
/* Wait for the next single event, return its type */
static pn_event_type_t wait_next(pn_proactor_t *proactor) {
pn_event_batch_t *events = pn_proactor_wait(proactor);
pn_event_type_t etype = pn_event_type(pn_event_batch_next(events));
pn_proactor_done(proactor, events);
return etype;
}
