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);
}
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);
}
}
/* 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);
}
static int pn_event_inspect(pn_event_t *event, pn_string_t *dst)
{
assert(event);
assert(dst);
const char *name = pn_event_type_name(event->type);
int err;
if (name) {
err = pn_string_addf(dst, "(%s", pn_event_type_name(event->type));
} else {
err = pn_string_addf(dst, "(<%u>", (unsigned int) event->type);
}
if (err) return err;
if (event->context) {
err = pn_string_addf(dst, ", ");
if (err) return err;
err = pn_class_inspect(event->clazz, event->context, dst);
if (err) return err;
}
return pn_string_addf(dst, ")");
}
std::string proton_event::name() const { return pn_event_type_name(pn_event_type_t(type_)); }
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)));
}
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_link(ldp_connection_t *conn, pn_event_t *event) {
fprintf(stderr, "link event %s\n", pn_event_type_name(pn_event_type(event)));
}
