std::string connection_engine::error_str() const { pn_condition_t *c = pn_connection_remote_condition(connection_.pn_object()); if (!c || !pn_condition_is_set(c)) c = pn_transport_condition(ctx_->transport); if (c && pn_condition_is_set(c)) { std::ostringstream os; os << pn_condition_get_name(c) << ": " << pn_condition_get_description(c); return os.str(); } return ""; }
static void pni_connection_writable(pn_selectable_t *sel) { pn_reactor_t *reactor = (pn_reactor_t *) pni_selectable_get_context(sel); pn_transport_t *transport = pni_transport(sel); ssize_t pending = pn_transport_pending(transport); if (pending > 0) { ssize_t n = pn_send(pni_reactor_io(reactor), pn_selectable_get_fd(sel), pn_transport_head(transport), pending); if (n < 0) { if (!pn_wouldblock(pni_reactor_io(reactor))) { pn_condition_t *cond = pn_transport_condition(transport); if (!pn_condition_is_set(cond)) { pn_condition_set_name(cond, "proton:io"); pn_condition_set_description(cond, pn_error_text(pn_reactor_error(reactor))); } pn_transport_close_head(transport); } } else { pn_transport_pop(transport, n); } } ssize_t newpending = pn_transport_pending(transport); if (newpending != pending) { pni_connection_update(sel); pn_reactor_update(reactor, sel); } }
void messaging_adapter::on_link_remote_close(proton_event &pe) { pn_event_t *cevent = pe.pn_event(); pn_link_t *lnk = pn_event_link(cevent); if (pn_link_is_receiver(lnk)) { receiver r(make_wrapper<receiver>(lnk)); if (pn_condition_is_set(pn_link_remote_condition(lnk))) { delegate_.on_receiver_error(r); } delegate_.on_receiver_close(r); } else { sender s(make_wrapper<sender>(lnk)); if (pn_condition_is_set(pn_link_remote_condition(lnk))) { delegate_.on_sender_error(s); } delegate_.on_sender_close(s); } pn_link_close(lnk); }
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); }
void messaging_adapter::on_session_remote_close(proton_event &pe) { pn_event_t *cevent = pe.pn_event(); pn_session_t *session = pn_event_session(cevent); class session s(make_wrapper(session)); if (pn_condition_is_set(pn_session_remote_condition(session))) { delegate_.on_session_error(s); } delegate_.on_session_close(s); pn_session_close(session); }
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); } }
/* Test that we can control listen/select on ipv6/v4 and listen on both by default */ static void test_ipv4_ipv6(test_t *t) { test_proactor_t tps[] ={ test_proactor(t, open_close_handler), test_proactor(t, listen_handler) }; pn_proactor_t *client = tps[0].proactor, *server = tps[1].proactor; /* Listen on all interfaces for IPv4 only. */ pn_listener_t *l4 = test_listen(&tps[1], "0.0.0.0"); TEST_PROACTORS_DRAIN(tps); /* Empty address listens on both IPv4 and IPv6 on all interfaces */ pn_listener_t *l = test_listen(&tps[1], ""); TEST_PROACTORS_DRAIN(tps); #define EXPECT_CONNECT(LISTENER, HOST) do { \ char addr[1024]; \ pn_proactor_addr(addr, sizeof(addr), HOST, listener_info(LISTENER).port); \ pn_proactor_connect2(client, NULL, NULL, addr); \ TEST_ETYPE_EQUAL(t, PN_TRANSPORT_CLOSED, TEST_PROACTORS_RUN(tps)); \ TEST_COND_EMPTY(t, last_condition); \ TEST_PROACTORS_DRAIN(tps); \ } while(0) EXPECT_CONNECT(l4, "127.0.0.1"); /* v4->v4 */ EXPECT_CONNECT(l4, ""); /* local->v4*/ EXPECT_CONNECT(l, "127.0.0.1"); /* v4->all */ EXPECT_CONNECT(l, ""); /* local->all */ /* Listen on ipv6 loopback, if it fails skip ipv6 tests. NOTE: Don't use the unspecified address "::" here - ipv6-disabled platforms may allow listening on "::" without complaining. However they won't have a local ipv6 loopback configured, so "::1" will force an error. */ TEST_PROACTORS_DRAIN(tps); pn_listener_t *l6 = pn_listener(); pn_proactor_listen(server, l6, "::1:0", 4); pn_event_type_t e = TEST_PROACTORS_RUN(tps); if (e == PN_LISTENER_OPEN && !pn_condition_is_set(last_condition)) { TEST_PROACTORS_DRAIN(tps); EXPECT_CONNECT(l6, "::1"); /* v6->v6 */ EXPECT_CONNECT(l6, ""); /* local->v6 */ EXPECT_CONNECT(l, "::1"); /* v6->all */ pn_listener_close(l6); } else { const char *d = pn_condition_get_description(last_condition); TEST_LOGF(t, "skip IPv6 tests: %s %s", pn_event_type_name(e), d ? d : "no condition"); } pn_listener_close(l); pn_listener_close(l4); TEST_PROACTORS_DESTROY(tps); }
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 messaging_adapter::on_link_remote_close(event &e) { proton_event *pe = dynamic_cast<proton_event*>(&e); if (pe) { pn_event_t *cevent = pe->pn_event(); pn_link_t *lnk = pn_event_link(cevent); if (pn_condition_is_set(pn_link_remote_condition(lnk))) { messaging_event mevent(messaging_event::LINK_ERROR, *pe); on_link_error(mevent); } else { messaging_event mevent(messaging_event::LINK_CLOSE, *pe); on_link_close(mevent); } pn_link_close(lnk); } }
void messaging_adapter::on_session_remote_close(event &e) { proton_event *pe = dynamic_cast<proton_event*>(&e); if (pe) { pn_event_t *cevent = pe->pn_event(); pn_session_t *session = pn_event_session(cevent); pn_state_t state = pn_session_state(session); if (pn_condition_is_set(pn_session_remote_condition(session))) { messaging_event mevent(messaging_event::SESSION_ERROR, *pe); on_session_error(mevent); } else if (is_local_closed(state)) { messaging_event mevent(messaging_event::SESSION_CLOSED, *pe); on_session_closed(mevent); } else { messaging_event mevent(messaging_event::SESSION_CLOSING, *pe); on_session_closing(mevent); } pn_session_close(session); } }
/* 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; } }
bool condition::empty() const { return !pn_condition_is_set(condition_); }
bool condition::operator!() const { return !pn_condition_is_set(condition_); }
/* 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; } }