void messaging_adapter::on_connection_remote_open(proton_event &pe) {
pn_connection_t *conn = pn_event_connection(pe.pn_event());
connection c(make_wrapper(conn));
transport t(make_wrapper(pn_event_transport(pe.pn_event())));
delegate_.on_transport_open(t);
delegate_.on_connection_open(c);
if (!is_local_open(pn_connection_state(conn)) && is_local_unititialised(pn_connection_state(conn))) {
pn_connection_open(conn);
}
}
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;
}
}
void pni_handle_transport(pn_reactor_t *reactor, pn_event_t *event) {
assert(reactor);
pn_transport_t *transport = pn_event_transport(event);
pn_record_t *record = pn_transport_attachments(transport);
pn_selectable_t *sel = (pn_selectable_t *) pn_record_get(record, PN_TRANCTX);
if (sel && !pn_selectable_is_terminal(sel)) {
pni_connection_update(sel);
pn_reactor_update(reactor, sel);
}
}
void messaging_adapter::on_transport_tail_closed(proton_event &pe) {
pn_connection_t *conn = pn_event_connection(pe.pn_event());
if (conn && is_local_open(pn_connection_state(conn))) {
pn_transport_t *tspt = pn_event_transport(pe.pn_event());
transport t(make_wrapper(tspt));
if (pn_condition_is_set(pn_transport_condition(tspt))) {
delegate_.on_transport_error(t);
}
delegate_.on_transport_close(t);
}
}
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);
}
}
transport proton_event::transport() const {
pn_transport_t *t = pn_event_transport(pn_event());
if (!t)
throw error(MSG("No transport context for this event"));
return t;
}
/* Process each event emitted by the protocol engine */
static void dispatcher(pn_handler_t *handler, pn_event_t *event, pn_event_type_t type)
{
protocolState_t *ps = PROTOCOL_STATE(handler);
const configSettings_t *cfg = ps->config;
//DBGPRINTF("omamqp1: Event received: %s\n", pn_event_type_name(type));
switch (type) {
case PN_LINK_REMOTE_OPEN:
DBGPRINTF("omamqp1: Message bus opened link.\n");
break;
case PN_DELIVERY:
// has the message been delivered to the message bus?
if (ps->delivery) {
assert(ps->delivery == pn_event_delivery(event));
if (pn_delivery_updated(ps->delivery)) {
rsRetVal result = RS_RET_IDLE;
uint64_t rs = pn_delivery_remote_state(ps->delivery);
switch (rs) {
case PN_ACCEPTED:
DBGPRINTF("omamqp1: Message ACCEPTED by message bus\n");
result = RS_RET_OK;
break;
case PN_REJECTED:
dbgprintf("omamqp1: message bus rejected log message: invalid message - dropping\n");
// message bus considers this a 'bad message'. Cannot be redelivered.
// Likely a configuration error. Drop the message by returning OK
result = RS_RET_OK;
break;
case PN_RELEASED:
case PN_MODIFIED:
// the message bus cannot accept the message. This may be temporary - retry
// up to maxRetries before dropping
if (++ps->retries >= cfg->maxRetries) {
dbgprintf("omamqp1: message bus failed to accept message - dropping\n");
result = RS_RET_OK;
} else {
dbgprintf("omamqp1: message bus cannot accept message, retrying\n");
result = RS_RET_SUSPENDED;
}
break;
case PN_RECEIVED:
// not finished yet, wait for next delivery update
break;
default:
// no other terminal states defined, so ignore anything else
dbgprintf("omamqp1: unknown delivery state=0x%lX, assuming message accepted\n",
(unsigned long) pn_delivery_remote_state(ps->delivery));
result = RS_RET_OK;
break;
}
if (result != RS_RET_IDLE) {
// the command is complete
threadIPC_t *ipc = ps->ipc;
pthread_mutex_lock(&ipc->lock);
assert(ipc->command == COMMAND_SEND);
ipc->result = result;
ipc->command = COMMAND_DONE;
pthread_cond_signal(&ipc->condition);
pthread_mutex_unlock(&ipc->lock);
pn_delivery_settle(ps->delivery);
ps->delivery = NULL;
if (result == RS_RET_OK) {
ps->retries = 0;
}
}
}
}
break;
case PN_CONNECTION_BOUND:
if (!cfg->bDisableSASL) {
// force use of SASL, even allowing PLAIN authentication
pn_sasl_t *sasl = pn_sasl(pn_event_transport(event));
#if PN_VERSION_MAJOR == 0 && PN_VERSION_MINOR >= 10
pn_sasl_set_allow_insecure_mechs(sasl, true);
#else
// proton version <= 0.9 only supports PLAIN authentication
const char *user = cfg->username
? (char *)cfg->username
: pn_url_get_username(cfg->url);
if (user) {
pn_sasl_plain(sasl, user, (cfg->password
? (char *) cfg->password
: pn_url_get_password(cfg->url)));
}
#endif
}
if (cfg->idleTimeout) {
// configured as seconds, set as milliseconds
pn_transport_set_idle_timeout(pn_event_transport(event),
cfg->idleTimeout * 1000);
}
break;
case PN_CONNECTION_UNBOUND:
DBGPRINTF("omamqp1: cleaning up connection resources\n");
pn_connection_release(pn_event_connection(event));
ps->conn = NULL;
ps->sender = NULL;
ps->delivery = NULL;
break;
case PN_TRANSPORT_ERROR:
{
// TODO: if auth failure, does it make sense to retry???
pn_transport_t *tport = pn_event_transport(event);
pn_condition_t *cond = pn_transport_condition(tport);
if (pn_condition_is_set(cond)) {
_log_error("transport failure", cond);
}
dbgprintf("omamqp1: network transport failed, reconnecting...\n");
// the protocol thread will attempt to reconnect if it is not
// being shut down
}
break;
default:
break;
}
}
void pni_handle_bound(pn_reactor_t *reactor, pn_event_t *event) {
assert(reactor);
assert(event);
pn_connection_t *conn = pn_event_connection(event);
pn_transport_t *transport = pn_event_transport(event);
pn_record_t *record = pn_connection_attachments(conn);
pn_url_t *url = (pn_url_t *)pn_record_get(record, PNI_CONN_PEER_ADDRESS);
const char *host = NULL;
const char *port = "5672";
pn_string_t *str = NULL;
// link the new transport to its reactor:
pni_record_init_reactor(pn_transport_attachments(transport), reactor);
if (pn_connection_acceptor(conn) != NULL) {
// this connection was created by the acceptor. There is already a
// socket assigned to this connection. Nothing needs to be done.
return;
}
if (url) {
host = pn_url_get_host(url);
const char *uport = pn_url_get_port(url);
if (uport) {
port = uport;
} else {
const char *scheme = pn_url_get_scheme(url);
if (scheme && strcmp(scheme, "amqps") == 0) {
port = "5671";
}
}
if (!pn_connection_get_user(conn)) {
// user did not manually set auth info
const char *user = pn_url_get_username(url);
if (user) pn_connection_set_user(conn, user);
const char *passwd = pn_url_get_password(url);
if (passwd) pn_connection_set_password(conn, passwd);
}
} else {
// for backward compatibility, see if the connection's hostname can be
// used for the remote address. See JIRA PROTON-1133
const char *hostname = pn_connection_get_hostname(conn);
if (hostname) {
str = pn_string(hostname);
char *h = pn_string_buffer(str);
// see if a port has been included in the hostname. This is not
// allowed by the spec, but the old reactor interface allowed it.
char *colon = strrchr(h, ':');
if (colon) {
*colon = '\0';
port = colon + 1;
}
host = h;
}
}
if (!host) {
// error: no address configured
pn_condition_t *cond = pn_transport_condition(transport);
pn_condition_set_name(cond, "proton:io");
pn_condition_set_description(cond, "Connection failed: no address configured");
pn_transport_close_tail(transport);
pn_transport_close_head(transport);
} else {
pn_socket_t sock = pn_connect(pni_reactor_io(reactor), host, port);
// invalid sockets are ignored by poll, so we need to do this manually
if (sock == PN_INVALID_SOCKET) {
pn_condition_t *cond = pn_transport_condition(transport);
pn_condition_set_name(cond, "proton:io");
pn_condition_set_description(cond, pn_error_text(pn_reactor_error(reactor)));
pn_transport_close_tail(transport);
pn_transport_close_head(transport);
} else {
pn_reactor_selectable_transport(reactor, sock, transport);
}
}
pn_free(str);
}
/* 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;
}
}
