// log a protocol error received from the message bus
static void _log_error(const char *message, pn_condition_t *cond)
{
const char *name = pn_condition_get_name(cond);
const char *desc = pn_condition_get_description(cond);
dbgprintf("omamqp1: %s %s:%s\n",
message,
(name) ? name : "<no name>",
(desc) ? desc : "<no description>");
}
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 "";
}
/* 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);
}
std::string condition::str() const {
if (!*this) {
return "No error condition";
} else {
const char* n = pn_condition_get_name(condition_);
const char* d = pn_condition_get_description(condition_);
std::string s;
if (n) s += n;
if (d) {
if (n) s += ": ";
s += d;
}
return s;
}
}
qdr_error_t *qdr_error_from_pn(pn_condition_t *pn)
{
if (!pn)
return 0;
qdr_error_t *error = new_qdr_error_t();
ZERO(error);
const char *name = pn_condition_get_name(pn);
if (name && *name)
error->name = qdr_field(name);
const char *desc = pn_condition_get_description(pn);
if (desc && *desc)
error->description = qdr_field(desc);
error->info = pn_data(0);
return error;
}
std::string condition::description() const {
const char* d = pn_condition_get_description(condition_);
return d ? d : "";
}
/* 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;
}
}
