qd_field_iterator_t *qdr_terminus_dnp_address(qdr_terminus_t *term)
{
pn_data_t *props = term->properties;
if (!props)
return 0;
pn_data_rewind(props);
if (pn_data_next(props) && pn_data_enter(props) && pn_data_next(props)) {
pn_bytes_t sym = pn_data_get_symbol(props);
if (sym.start && strcmp(QD_DYNAMIC_NODE_PROPERTY_ADDRESS, sym.start) == 0) {
if (pn_data_next(props)) {
pn_bytes_t val = pn_data_get_string(props);
if (val.start && *val.start != '\0')
return qd_field_iterator_binary(val.start, val.size);
}
}
}
return 0;
}
void DataReader::readOne(pn_data_t* data)
{
qpid::amqp::Descriptor descriptor(0);
bool described = pn_data_is_described(data);
if (described) {
pn_data_enter(data);
pn_data_next(data);
if (pn_data_type(data) == PN_ULONG) {
descriptor = qpid::amqp::Descriptor(pn_data_get_ulong(data));
} else if (pn_data_type(data) == PN_SYMBOL) {
descriptor = qpid::amqp::Descriptor(convert(pn_data_get_symbol(data)));
} else {
QPID_LOG(notice, "Ignoring descriptor of type " << pn_data_type(data));
}
pn_data_next(data);
}
switch (pn_data_type(data)) {
case PN_NULL:
reader.onNull(described ? &descriptor : 0);
break;
case PN_BOOL:
reader.onBoolean(pn_data_get_bool(data), described ? &descriptor : 0);
break;
case PN_UBYTE:
reader.onUByte(pn_data_get_ubyte(data), described ? &descriptor : 0);
break;
case PN_BYTE:
reader.onByte(pn_data_get_byte(data), described ? &descriptor : 0);
break;
case PN_USHORT:
reader.onUShort(pn_data_get_ushort(data), described ? &descriptor : 0);
break;
case PN_SHORT:
reader.onShort(pn_data_get_short(data), described ? &descriptor : 0);
break;
case PN_UINT:
reader.onUInt(pn_data_get_uint(data), described ? &descriptor : 0);
break;
case PN_INT:
reader.onInt(pn_data_get_int(data), described ? &descriptor : 0);
break;
case PN_CHAR:
pn_data_get_char(data);
break;
case PN_ULONG:
reader.onULong(pn_data_get_ulong(data), described ? &descriptor : 0);
break;
case PN_LONG:
reader.onLong(pn_data_get_long(data), described ? &descriptor : 0);
break;
case PN_TIMESTAMP:
reader.onTimestamp(pn_data_get_timestamp(data), described ? &descriptor : 0);
break;
case PN_FLOAT:
reader.onFloat(pn_data_get_float(data), described ? &descriptor : 0);
break;
case PN_DOUBLE:
reader.onDouble(pn_data_get_double(data), described ? &descriptor : 0);
break;
case PN_DECIMAL32:
pn_data_get_decimal32(data);
break;
case PN_DECIMAL64:
pn_data_get_decimal64(data);
break;
case PN_DECIMAL128:
pn_data_get_decimal128(data);
break;
case PN_UUID:
reader.onUuid(convert(pn_data_get_uuid(data)), described ? &descriptor : 0);
break;
case PN_BINARY:
reader.onBinary(convert(pn_data_get_binary(data)), described ? &descriptor : 0);
break;
case PN_STRING:
reader.onString(convert(pn_data_get_string(data)), described ? &descriptor : 0);
break;
case PN_SYMBOL:
reader.onSymbol(convert(pn_data_get_symbol(data)), described ? &descriptor : 0);
break;
case PN_DESCRIBED:
break;
case PN_ARRAY:
readArray(data, described ? &descriptor : 0);
break;
case PN_LIST:
readList(data, described ? &descriptor : 0);
break;
case PN_MAP:
readMap(data, described ? &descriptor : 0);
break;
}
if (described) pn_data_exit(data);
}
mama_status
qpidBridgeMsgCodec_unpack (msgBridge bridgeMessage,
mamaMsg target,
pn_message_t* protonMessage)
{
pn_data_t* properties = NULL;
pn_data_t* body = NULL;
mama_status status = MAMA_STATUS_OK;
qpidMsgType type = QPID_MSG_PUB_SUB;
pn_bytes_t prop;
pn_atom_t firstAtom;
if (NULL == bridgeMessage || NULL == protonMessage)
{
return MAMA_STATUS_NULL_ARG;
}
/* grab the body */
body = pn_message_body (protonMessage);
/* Ensure position is at the start */
pn_data_rewind (body);
/* Skip over the initial null atom */
pn_data_next (body);
/* Grab the first atom and see what it is - PN_LIST = qpid */
firstAtom = pn_data_get_atom (body);
/* If this is a proton message */
if (PN_LIST == firstAtom.type)
{
status = mamaMsgImpl_setMsgBuffer (target,
(void*) protonMessage,
sizeof (pn_message_t*),
MAMA_PAYLOAD_QPID);
}
/* If this looks like another MAMA payload type */
else if (PN_BINARY == firstAtom.type)
{
mamaPayloadType payloadType = MAMA_PAYLOAD_UNKNOWN;
if (firstAtom.u.as_bytes.size == 0)
{
mama_log (MAMA_LOG_LEVEL_ERROR,
"qpidBridgeMamaMsgImpl_unpack(): "
"Binary blob of zero length found - not processing");
return MAMA_STATUS_INVALID_ARG;
}
/* The payload type is the first character */
payloadType = (mamaPayloadType) firstAtom.u.as_bytes.start[0];
/* Use byte buffer to populate MAMA message */
status = mamaMsgImpl_setMsgBuffer (
target,
(void*) firstAtom.u.as_bytes.start,
(mama_size_t) firstAtom.u.as_bytes.size,
payloadType);
if (MAMA_STATUS_OK != status)
{
mama_log (MAMA_LOG_LEVEL_ERROR,
"qpidBridgeMamaMsgImpl_unpack(): "
"Could not set msg buffer. Cannot unpack (%s).",
mamaStatus_stringForStatus (status));
return status;
}
}
/* If this looks like something we cannot handle */
else
{
mama_log (MAMA_LOG_LEVEL_ERROR,
"qpidBridgeMamaMsgImpl_unpack(): "
"Unable to unpack data received: incompatible format %s",
pn_type_name (firstAtom.type));
}
/* Get the properties */
properties = pn_message_properties (protonMessage);
/* Ensure position is at the start */
pn_data_rewind (properties);
/* Skip over the initial null atom */
pn_data_next (properties);
/* Main container should be a list to allow expansion */
pn_data_get_list (properties);
pn_data_enter (properties);
/* Get the message type out */
pn_data_next (properties);
type = (qpidMsgType) pn_data_get_ubyte (properties);
qpidBridgeMamaMsgImpl_setMsgType (bridgeMessage, type);
switch (type)
{
case QPID_MSG_INBOX_REQUEST:
/* Move onto inbox name and extract / copy */
pn_data_next (properties);
prop = pn_data_get_string (properties);
status = qpidBridgeMamaMsgImpl_setInboxName (bridgeMessage, prop.start);
if (MAMA_STATUS_OK != status)
{
return status;
}
/* Move onto reply to url and extract / copy */
pn_data_next (properties);
prop = pn_data_get_string (properties);
status = qpidBridgeMamaMsgImpl_setReplyTo (bridgeMessage, prop.start);
if (MAMA_STATUS_OK != status)
{
return status;
}
break;
case QPID_MSG_INBOX_RESPONSE:
/* Move onto target subject and extract / copy */
pn_data_next (properties);
prop = pn_data_get_string (properties);
status = qpidBridgeMamaMsgImpl_setTargetSubject (bridgeMessage,
prop.start);
if (MAMA_STATUS_OK != status)
{
return status;
}
break;
/* The following message types require no further meta data */
case QPID_MSG_TERMINATE:
case QPID_MSG_SUB_REQUEST:
case QPID_MSG_PUB_SUB:
default:
break;
}
pn_data_exit (properties);
return status;
}
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;
}