message::~message() {
if (pn_msg_) {
impl().~impl(); // destroy in-place
pn_message_free(pn_msg_);
}
}
void sender_cleanup(pn_handler_t *h)
{
sender_context_t *sc = sender_context(h);
pn_message_free(sc->message);
pn_message_free(sc->reply_message);
pn_url_free(sc->send_url);
pn_free(sc->hostname);
pn_free(sc->container_id);
free(sc->encoded_data);
}
void listener_cleanup(pn_handler_t *h)
{
global_context_t *gc = global_context(h);
pn_message_free(gc->message);
free(gc->encoded_data);
pn_free(gc->active_connections);
}
static char* test_receive_from_messenger(void *context)
{
nx_allocator_initialize(nx_allocator_default_config());
pn_message_t *pn_msg = pn_message();
pn_message_set_address(pn_msg, "test_addr_1");
nx_buffer_t *buf = nx_allocate_buffer();
size_t size = nx_buffer_capacity(buf);
int result = pn_message_encode(pn_msg, (char*) nx_buffer_cursor(buf), &size);
if (result != 0) return "Error in pn_message_encode";
nx_buffer_insert(buf, size);
nx_message_t *msg = nx_allocate_message();
DEQ_INSERT_TAIL(msg->buffers, buf);
int valid = nx_message_check(msg, NX_DEPTH_ALL);
if (!valid) return "nx_message_check returns 'invalid'";
nx_field_iterator_t *iter = nx_message_field_to(msg);
if (iter == 0) return "Expected an iterator for the 'to' field";
if (!nx_field_iterator_equal(iter, (unsigned char*) "test_addr_1"))
return "Mismatched 'to' field contents";
pn_message_free(pn_msg);
nx_free_message(msg);
nx_allocator_finalize();
return 0;
}
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);
}
mama_status
qpidBridgeMamaPublisher_destroy (publisherBridge publisher)
{
qpidPublisherBridge* impl = (qpidPublisherBridge*) publisher;
/* Take a copy of the callbacks - we'll need those */
mamaPublisherCallbacks callbacks;
mamaPublisher parent = NULL;
void* closure = NULL;
if (NULL == impl)
{
return MAMA_STATUS_NULL_ARG;
}
/* Take a copy of the callbacks - we'll need those */
callbacks = impl->mCallbacks;
parent = impl->mParent;
closure = impl->mCallbackClosure;
if (NULL != impl->mQpidRawMsg)
{
pn_message_free (impl->mQpidRawMsg);
}
if (NULL != impl->mSubject)
{
free ((void*) impl->mSubject);
}
if (NULL != impl->mUri)
{
free ((void*) impl->mUri);
}
if (NULL != impl->mRoot)
{
free ((void*) impl->mRoot);
}
if (NULL != impl->mSource)
{
free ((void*) impl->mSource);
}
if (NULL != impl->mTopic)
{
free ((void*) impl->mTopic);
}
if (NULL != impl->mMamaBridgeMsg)
{
qpidBridgeMamaMsg_destroy (impl->mMamaBridgeMsg, 0);
}
if (NULL != callbacks.onDestroy)
{
(*callbacks.onDestroy)(parent, closure);
}
free (impl);
return MAMA_STATUS_OK;
}
mama_status
qpidBridgeMamaSubscription_destroy (subscriptionBridge subscriber)
{
qpidSubscription* impl = NULL;
qpidTransportBridge* transportBridge = NULL;
mamaSubscription parent = NULL;
void* closure = NULL;
wombat_subscriptionDestroyCB destroyCb = NULL;
if (NULL == subscriber)
{
return MAMA_STATUS_NULL_ARG;
}
impl = (qpidSubscription*) subscriber;
parent = impl->mMamaSubscription;
closure = impl->mClosure;
destroyCb = impl->mMamaCallback.onDestroy;
transportBridge = (qpidTransportBridge*) impl->mTransport;
/* Remove the subscription from the transport's subscription pool. */
if (NULL != transportBridge && NULL != transportBridge->mSubEndpoints
&& NULL != impl->mSubjectKey)
{
endpointPool_unregister (transportBridge->mSubEndpoints,
impl->mSubjectKey,
impl->mEndpointIdentifier);
}
if (NULL != impl->mMsg)
{
pn_message_free (impl->mMsg);
}
if (NULL != impl->mSubjectKey)
{
free (impl->mSubjectKey);
}
if (NULL != impl->mEndpointIdentifier)
{
free ((void*)impl->mEndpointIdentifier);
}
free (impl);
/*
* Invoke the subscription callback to inform that the bridge has been
* destroyed.
*/
if (NULL != destroyCb)
(*(wombat_subscriptionDestroyCB)destroyCb)(parent, closure);
return MAMA_STATUS_OK;
}
static void test_overflow_error(void)
{
pn_message_t *message = pn_message();
char buf[6];
size_t size = 6;
int err = pn_message_encode(message, buf, &size);
assert(err == PN_OVERFLOW);
assert(pn_message_errno(message) == 0);
pn_message_free(message);
}
/* Test sending/receiving a message in chunks */
static void test_message_stream(test_t *t) {
test_proactor_t tps[] ={
test_proactor(t, message_stream_handler),
test_proactor(t, message_stream_handler)
};
pn_proactor_t *client = tps[0].proactor;
pn_listener_t *l = test_listen(&tps[1], "");
struct message_stream_context ctx = { 0 };
tps[0].handler.context = &ctx;
tps[1].handler.context = &ctx;
/* Encode a large (not very) message to send in chunks */
char *body = (char*)malloc(BODY);
memset(body, 'x', BODY);
pn_message_t *m = pn_message();
pn_data_put_binary(pn_message_body(m), pn_bytes(BODY, body));
free(body);
ctx.size = message_encode(m, &ctx.send_buf);
pn_message_free(m);
pn_connection_t *c = pn_connection();
pn_proactor_connect2(client, c, NULL, listener_info(l).connect);
pn_session_t *ssn = pn_session(c);
pn_session_open(ssn);
pn_link_t *snd = pn_sender(ssn, "x");
pn_link_open(snd);
TEST_PROACTORS_RUN_UNTIL(tps, PN_LINK_FLOW);
/* Send and receive the message in chunks */
do {
pn_connection_wake(c); /* Initiate send/receive of one chunk */
do { /* May be multiple receives for one send */
TEST_PROACTORS_RUN_UNTIL(tps, PN_DELIVERY);
} while (ctx.received < ctx.sent);
} while (!ctx.complete);
TEST_CHECK(t, ctx.received == ctx.size);
TEST_CHECK(t, ctx.sent == ctx.size);
TEST_CHECK(t, !memcmp(ctx.send_buf.start, ctx.recv_buf.start, ctx.size));
free(ctx.send_buf.start);
free(ctx.recv_buf.start);
TEST_PROACTORS_DESTROY(tps);
}
mama_status
qpidBridgeMamaPublisher_destroy (publisherBridge publisher)
{
qpidPublisherBridge* impl = (qpidPublisherBridge*) publisher;
if (NULL == impl)
{
return MAMA_STATUS_NULL_ARG;
}
if (NULL != impl->mQpidRawMsg)
{
pn_message_free (impl->mQpidRawMsg);
}
if (NULL != impl->mSubject)
{
free ((void*) impl->mSubject);
}
if (NULL != impl->mUri)
{
free ((void*) impl->mUri);
}
if (NULL != impl->mRoot)
{
free ((void*) impl->mRoot);
}
if (NULL != impl->mSource)
{
free ((void*) impl->mSource);
}
if (NULL != impl->mTopic)
{
free ((void*) impl->mTopic);
}
if (NULL != impl->mMamaBridgeMsg)
{
qpidBridgeMamaMsg_destroy (impl->mMamaBridgeMsg, 0);
}
free (impl);
return MAMA_STATUS_OK;
}
static char* test_send_to_messenger(void *context)
{
nx_allocator_initialize(nx_allocator_default_config());
nx_message_t *msg = nx_allocate_message();
nx_message_compose_1(msg, "test_addr_0", 0);
nx_buffer_t *buf = DEQ_HEAD(msg->buffers);
if (buf == 0) return "Expected a buffer in the test message";
pn_message_t *pn_msg = pn_message();
int result = pn_message_decode(pn_msg, (const char*) nx_buffer_base(buf), nx_buffer_size(buf));
if (result != 0) return "Error in pn_message_decode";
if (strcmp(pn_message_get_address(pn_msg), "test_addr_0") != 0)
return "Address mismatch in received message";
pn_message_free(pn_msg);
nx_free_message(msg);
nx_allocator_finalize();
return 0;
}
void amqp::Sender::send(IMessage const &message, Address const &address)
{
pn_data_t *pnmessage_body = NULL;
pn_message_t *pnmessage = pn_message();
if (pnmessage == NULL) {
throw std::exception("ERROR: Message could not be created.");
}
pn_message_set_address(pnmessage, address.toString().c_str());
_addMetaToMessage(pnmessage, message);
pnmessage_body = pn_message_body(pnmessage);
pn_data_put_binary(pnmessage_body, pn_bytes(message.getSize(), message.getBytes()));
pn_messenger_put(m_messenger, pnmessage);
if (isError()) {
_throwError();
}
// To avoid traffic flud and speed up the solution better to use blocking scokets in tracking mode
if (isTraking()) {
Log("Sending messages to %s\n", address.toString().c_str());
m_tracker = pn_messenger_outgoing_tracker(m_messenger);
pn_messenger_send(m_messenger, -1); // sync
}
else {
pn_messenger_send(m_messenger, 1); // async
}
if (isError()) {
_throwError();
}
_checkTracking();
pn_message_free(pnmessage);
}
int sendMessage(pn_messenger_t * messenger) {
//char * address = (char *) "amqps://{SAS Key Name}:{SAS key}@{namespace name}.servicebus.windows.net/{event hub name}";
char * address = (char *) "amqps://*****:*****@kelvin-flight.servicebus.windows.net/example";
char * msgtext = (char *) "Hello from C!";
pn_message_t * message;
pn_data_t * body;
message = pn_message();
pn_message_set_address(message, address);
pn_message_set_content_type(message, (char*) "application/octect-stream");
pn_message_set_inferred(message, true);
body = pn_message_body(message);
pn_data_put_binary(body, pn_bytes(strlen(msgtext), msgtext));
pn_messenger_put(messenger, message);
check(messenger);
pn_messenger_send(messenger, 1);
check(messenger);
pn_message_free(message);
}
int main(int argc, char** argv)
{
Options_t opts;
Statistics_t stats;
uint64_t sent = 0;
uint64_t received = 0;
int forwarding_index = 0;
int rc;
pn_message_t *message;
pn_messenger_t *messenger;
parse_options( argc, argv, &opts );
const int forward = opts.forwarding_targets.count != 0;
message = pn_message();
messenger = pn_messenger( opts.name );
/* load the various command line options if they're set */
if (opts.certificate) {
rc = pn_messenger_set_certificate(messenger, opts.certificate);
check_messenger(messenger);
check( rc == 0, "Failed to set certificate" );
}
if (opts.privatekey) {
rc = pn_messenger_set_private_key(messenger, opts.privatekey);
check_messenger(messenger);
check( rc == 0, "Failed to set private key" );
}
if (opts.password) {
rc = pn_messenger_set_password(messenger, opts.password);
check_messenger(messenger);
check( rc == 0, "Failed to set password" );
}
if (opts.ca_db) {
rc = pn_messenger_set_trusted_certificates(messenger, opts.ca_db);
check_messenger(messenger);
check( rc == 0, "Failed to set trusted CA database" );
}
if (opts.incoming_window) {
// RAFI: seems to cause receiver to hang:
pn_messenger_set_incoming_window( messenger, opts.incoming_window );
}
pn_messenger_set_timeout( messenger, opts.timeout );
pn_messenger_start(messenger);
check_messenger(messenger);
int i;
for (i = 0; i < opts.subscriptions.count; i++) {
pn_messenger_subscribe(messenger, opts.subscriptions.addresses[i]);
check_messenger(messenger);
LOG("Subscribing to '%s'\n", opts.subscriptions.addresses[i]);
}
// hack to let test scripts know when the receivers are ready (so
// that the senders may be started)
if (opts.ready_text) {
fprintf(stdout, "%s\n", opts.ready_text);
fflush(stdout);
}
while (!opts.msg_count || received < opts.msg_count) {
LOG("Calling pn_messenger_recv(%d)\n", opts.recv_count);
rc = pn_messenger_recv(messenger, opts.recv_count);
check_messenger(messenger);
check(rc == 0 || (opts.timeout == 0 && rc == PN_TIMEOUT), "pn_messenger_recv() failed");
// start the timer only after receiving the first msg
if (received == 0) statistics_start( &stats );
LOG("Messages on incoming queue: %d\n", pn_messenger_incoming(messenger));
while (pn_messenger_incoming(messenger)) {
pn_messenger_get(messenger, message);
check_messenger(messenger);
received++;
// TODO: header decoding?
// uint64_t id = pn_message_get_correlation_id( message ).u.as_ulong;
statistics_msg_received( &stats, message );
if (opts.reply) {
const char *reply_addr = pn_message_get_reply_to( message );
if (reply_addr) {
LOG("Replying to: %s\n", reply_addr );
pn_message_set_address( message, reply_addr );
pn_message_set_creation_time( message, msgr_now() );
pn_messenger_put(messenger, message);
sent++;
}
}
if (forward) {
const char *forward_addr = opts.forwarding_targets.addresses[forwarding_index];
forwarding_index = NEXT_ADDRESS(opts.forwarding_targets, forwarding_index);
LOG("Forwarding to: %s\n", forward_addr );
pn_message_set_address( message, forward_addr );
pn_message_set_reply_to( message, NULL ); // else points to origin sender
pn_message_set_creation_time( message, msgr_now() );
pn_messenger_put(messenger, message);
sent++;
}
}
LOG("Messages received=%llu sent=%llu\n", received, sent);
}
// this will flush any pending sends
if (pn_messenger_outgoing(messenger) > 0) {
LOG("Calling pn_messenger_send()\n");
rc = pn_messenger_send(messenger, -1);
check_messenger(messenger);
check(rc == 0, "pn_messenger_send() failed");
}
rc = pn_messenger_stop(messenger);
check(rc == 0, "pn_messenger_stop() failed");
check_messenger(messenger);
statistics_report( &stats, sent, received );
pn_messenger_free(messenger);
pn_message_free(message);
addresses_free( &opts.subscriptions );
addresses_free( &opts.forwarding_targets );
return 0;
}
int main(int argc, char** argv)
{
Options_t opts;
Statistics_t stats;
uint64_t sent = 0;
uint64_t received = 0;
int target_index = 0;
int rc;
pn_message_t *message = 0;
pn_message_t *reply_message = 0;
pn_messenger_t *messenger = 0;
parse_options( argc, argv, &opts );
messenger = pn_messenger( opts.name );
if (opts.certificate) {
rc = pn_messenger_set_certificate(messenger, opts.certificate);
check( rc == 0, "Failed to set certificate" );
}
if (opts.privatekey) {
rc = pn_messenger_set_private_key(messenger, opts.privatekey);
check( rc == 0, "Failed to set private key" );
}
if (opts.password) {
rc = pn_messenger_set_password(messenger, opts.password);
free(opts.password);
check( rc == 0, "Failed to set password" );
}
if (opts.ca_db) {
rc = pn_messenger_set_trusted_certificates(messenger, opts.ca_db);
check( rc == 0, "Failed to set trusted CA database" );
}
if (opts.outgoing_window) {
pn_messenger_set_outgoing_window( messenger, opts.outgoing_window );
}
pn_messenger_set_timeout( messenger, opts.timeout );
pn_messenger_start(messenger);
message = pn_message();
check(message, "failed to allocate a message");
pn_message_set_reply_to(message, "~");
pn_data_t *body = pn_message_body(message);
char *data = (char *)calloc(1, opts.msg_size);
pn_data_put_binary(body, pn_bytes(opts.msg_size, data));
free(data);
pn_atom_t id;
id.type = PN_ULONG;
#if 0
// TODO: how do we effectively benchmark header processing overhead???
pn_data_t *props = pn_message_properties(message);
pn_data_put_map(props);
pn_data_enter(props);
//
//pn_data_put_string(props, pn_bytes(6, "string"));
//pn_data_put_string(props, pn_bytes(10, "this is awkward"));
//
//pn_data_put_string(props, pn_bytes(4, "long"));
pn_data_put_long(props, 12345);
//
//pn_data_put_string(props, pn_bytes(9, "timestamp"));
pn_data_put_timestamp(props, (pn_timestamp_t) 54321);
pn_data_exit(props);
#endif
const int get_replies = opts.get_replies;
if (get_replies) {
// disable the timeout so that pn_messenger_recv() won't block
reply_message = pn_message();
check(reply_message, "failed to allocate a message");
}
statistics_start( &stats );
while (!opts.msg_count || (sent < opts.msg_count)) {
// setup the message to send
pn_message_set_address(message, opts.targets.addresses[target_index]);
target_index = NEXT_ADDRESS(opts.targets, target_index);
id.u.as_ulong = sent;
pn_message_set_correlation_id( message, id );
pn_message_set_creation_time( message, msgr_now() );
pn_messenger_put(messenger, message);
sent++;
if (opts.send_batch && (pn_messenger_outgoing(messenger) >= (int)opts.send_batch)) {
if (get_replies) {
while (received < sent) {
// this will also transmit any pending sent messages
received += process_replies( messenger, reply_message,
&stats, opts.recv_count );
}
} else {
LOG("Calling pn_messenger_send()\n");
rc = pn_messenger_send(messenger, -1);
check((rc == 0 || rc == PN_TIMEOUT), "pn_messenger_send() failed");
}
}
check_messenger(messenger);
}
LOG("Messages received=%llu sent=%llu\n", received, sent);
if (get_replies) {
// wait for the last of the replies
while (received < sent) {
int count = process_replies( messenger, reply_message,
&stats, opts.recv_count );
check( count > 0 || (opts.timeout == 0),
"Error: timed out waiting for reply messages\n");
received += count;
LOG("Messages received=%llu sent=%llu\n", received, sent);
}
} else if (pn_messenger_outgoing(messenger) > 0) {
LOG("Calling pn_messenger_send()\n");
rc = pn_messenger_send(messenger, -1);
check(rc == 0, "pn_messenger_send() failed");
}
rc = pn_messenger_stop(messenger);
check(rc == 0, "pn_messenger_stop() failed");
check_messenger(messenger);
statistics_report( &stats, sent, received );
pn_messenger_free(messenger);
pn_message_free(message);
if (reply_message) pn_message_free( reply_message );
addresses_free( &opts.targets );
return 0;
}
int main(int argc, char** argv)
{
Options_t opts;
int rc;
pn_message_t *response_msg = pn_message();
check( response_msg, "Failed to allocate a Message");
pn_message_t *request_msg = pn_message();
check( request_msg, "Failed to allocate a Message");
pn_messenger_t *messenger = pn_messenger( 0 );
check( messenger, "Failed to allocate a Messenger");
parse_options( argc, argv, &opts );
// no need to track outstanding messages
pn_messenger_set_outgoing_window( messenger, 0 );
pn_messenger_set_incoming_window( messenger, 0 );
pn_messenger_set_timeout( messenger, opts.timeout );
if (opts.gateway_addr) {
LOG( "routing all messages via %s\n", opts.gateway_addr );
rc = pn_messenger_route( messenger,
"*", opts.gateway_addr );
check( rc == 0, "pn_messenger_route() failed" );
}
pn_messenger_start(messenger);
char *reply_to = NULL;
if (opts.reply_to) {
LOG("subscribing to %s for replies\n", opts.reply_to);
pn_messenger_subscribe(messenger, opts.reply_to);
reply_to = _strdup(opts.reply_to);
check( reply_to, "Out of memory" );
#if 1
// need to 'fix' the reply-to for use in the message itself:
// no '~' is allowed in that case
char *tilde = strstr( reply_to, "://~" );
if (tilde) {
tilde += 3; // overwrite '~'
memmove( tilde, tilde + 1, strlen( tilde + 1 ) + 1 );
}
#endif
}
// Create a request message
//
const char *command = opts.new_fortune ? "set" : "get";
build_request_message( request_msg,
opts.send_bad_msg ? "bad-command" : command,
opts.address, reply_to,
opts.new_fortune, opts.ttl );
// set a unique identifier for this message, so remote can
// de-duplicate when we re-transmit
uuid_t uuid;
uuid_generate(uuid);
char uuid_str[37];
uuid_unparse_upper(uuid, uuid_str);
pn_data_put_string( pn_message_id( request_msg ),
pn_bytes( sizeof(uuid_str), uuid_str ));
// set the correlation id so we can ensure the response matches
// our request. (re-use uuid just 'cause it's easy!)
pn_data_put_string( pn_message_correlation_id( request_msg ),
pn_bytes( sizeof(uuid_str), uuid_str ));
int send_count = 0;
bool done = false;
// keep re-transmitting until something arrives
do {
LOG("sending request message...\n");
rc = pn_messenger_put( messenger, request_msg );
check(rc == 0, "pn_messenger_put() failed");
send_count++;
if (opts.retry) opts.retry--;
LOG("waiting for response...\n");
rc = pn_messenger_recv( messenger, -1 );
if (rc == PN_TIMEOUT) {
LOG( "Timed-out waiting for a response, retransmitting...\n" );
pn_message_set_delivery_count( request_msg, send_count );
} else {
check(rc == 0, "pn_messenger_recv() failed\n");
while (pn_messenger_incoming( messenger ) > 0) {
rc = pn_messenger_get( messenger, response_msg );
check(rc == 0, "pn_messenger_get() failed");
LOG("response received!\n");
// validate the correlation id
pn_bytes_t cid = pn_data_get_string( pn_message_correlation_id( response_msg ) );
if (cid.size == 0 || strncmp( uuid_str, cid.start, cid.size )) {
LOG( "Correlation Id mismatch! Ignoring this response!\n" );
} else {
process_reply( messenger, response_msg );
done = true;
}
}
}
} while (!done && opts.retry);
if (!done) {
fprintf( stderr, "Retries exhausted, no response received from server!\n" );
}
rc = pn_messenger_stop(messenger);
check(rc == 0, "pn_messenger_stop() failed");
pn_messenger_free(messenger);
pn_message_free( response_msg );
pn_message_free( request_msg );
if (reply_to) free(reply_to);
return 0;
}
