static void createSubscriber (void)
{
mama_status status;
memset(&gCb, 0, sizeof(gCb));
gCb.onCreate = createCb;
gCb.onError = errorCb;
gCb.onMsg = msgCb;
gCb.onQuality = NULL; /* not used by basic subscriptions */
gCb.onGap = NULL; /* not used by basic subscriptions */
gCb.onRecapRequest = NULL; /* not used by basic subscriptions */
if (MAMA_STATUS_OK!=(status=mamaSubscription_allocate (&gSubscription)))
{
printf ("Error allocating subscription: %s\n",
mamaStatus_stringForStatus (status));
exit (status);
}
mamaSubscription_setDebugLevel (gSubscription, gSubscLogLevel);
if (MAMA_STATUS_OK!=(status=mamaSubscription_createBasic (gSubscription,
gTransport,
gMamaDefaultQueue,
&gCb,
gTopic,
NULL)))
{
printf ("Error creating subscription: %s\n",
mamaStatus_stringForStatus (status));
exit (status);
}
}
static void createFtMember (void)
{
mama_status status;
if (MAMA_STATUS_OK != (status= mamaFtMember_create(&gFtMember)))
{
printf ("Error creating FT Member: %s\n",
mamaStatus_stringForStatus (status));
exit (status);
}
if (MAMA_STATUS_OK != (status = mamaFtMember_setup(gFtMember,
gFtType,
gMamaDefaultQueue,
onFtStateChangeCb,
gTransport,
gFtGroup,
gFtWeight,
1.0,
6.0,
NULL)))
{
printf ("Error setting up FT Member: %s\n",
mamaStatus_stringForStatus (status));
exit (status);
}
if (MAMA_STATUS_OK != (status= mamaFtMember_activate(gFtMember)))
{
printf ("Error activating FT Member: %s\n",
mamaStatus_stringForStatus (status));
exit (status);
}
}
static void createWildCardSubscriber (void)
{
mama_status status;
const char* source = gTport ? gTopic : NULL;
const char* symbol = gWildcard ? gTopic : NULL;
memset(&gWcCb, 0, sizeof(gWcCb));
gWcCb.onCreate = createCb;
gWcCb.onError = errorCb;
gWcCb.onMsg = wildCardMsgCb;
if (MAMA_STATUS_OK!=(status=mamaSubscription_allocate (&gSubscription)))
{
printf ("Error allocating subscription: %s\n",
mamaStatus_stringForStatus (status));
exit (status);
}
mamaSubscription_setDebugLevel (gSubscription, gSubscLogLevel);
if (MAMA_STATUS_OK!=(status=mamaSubscription_createBasicWildCard (gSubscription,
gTransport,
gMamaDefaultQueue,
&gWcCb,
source,
symbol,
NULL)))
{
printf ("Error creating subscription: %s\n",
mamaStatus_stringForStatus (status));
exit (status);
}
}
/* Send a message from the specified inbox using the throttle. */
mama_status
qpidBridgeMamaPublisher_sendFromInboxByIndex (publisherBridge publisher,
int tportIndex,
mamaInbox inbox,
mamaMsg msg)
{
qpidPublisherBridge* impl = (qpidPublisherBridge*) publisher;
const char* replyAddr = NULL;
inboxBridge inboxImpl = NULL;
mama_status status = MAMA_STATUS_OK;
if (NULL == impl || NULL == inbox || NULL == msg)
{
return MAMA_STATUS_NULL_ARG;
}
/* Get the inbox which you want the publisher to respond to */
inboxImpl = mamaInboxImpl_getInboxBridge (inbox);
replyAddr = qpidBridgeMamaInboxImpl_getReplySubject (inboxImpl);
/* Mark this as being a request from an inbox */
status = qpidBridgeMamaMsgImpl_setMsgType (impl->mMamaBridgeMsg,
QPID_MSG_INBOX_REQUEST);
if (MAMA_STATUS_OK != status)
{
mama_log (MAMA_LOG_LEVEL_ERROR,
"qpidBridgeMamaPublisher_sendFromInboxByIndex(): "
"Failed to set message type [%s]",
mamaStatus_stringForStatus (status));
return status;
}
/* Update meta data in outgoing message to reflect the inbox name */
qpidBridgeMamaMsgImpl_setInboxName (impl->mMamaBridgeMsg,
replyAddr);
if (MAMA_STATUS_OK != status)
{
mama_log (MAMA_LOG_LEVEL_ERROR,
"qpidBridgeMamaPublisher_sendFromInboxByIndex(): "
"Failed to set inbox name [%s]",
mamaStatus_stringForStatus (status));
return status;
}
/* Update meta data in outgoing message to reflect the reply URL */
qpidBridgeMamaMsgImpl_setReplyTo (impl->mMamaBridgeMsg,
impl->mTransport->mReplyAddress);
if (MAMA_STATUS_OK != status)
{
mama_log (MAMA_LOG_LEVEL_ERROR,
"qpidBridgeMamaPublisher_sendFromInboxByIndex(): "
"Failed to set reply to [%s]",
mamaStatus_stringForStatus (status));
return status;
}
return qpidBridgeMamaPublisher_send (publisher, msg);;
}
mama_status createTransport (mamaCaptureConfig subCapture,
mamaTransport* transport,
char* tportName)
{
mama_status status = MAMA_STATUS_OK;
mamaCapture* capture = (mamaCapture*)subCapture;
if (capture == NULL) return MAMA_STATUS_NULL_ARG;
status = mamaTransport_allocate (transport);
if (status != MAMA_STATUS_OK)
{
mama_log (MAMA_LOG_LEVEL_NORMAL,
"Failed to allocate transport STATUS: %d %s\n", status,
mamaStatus_stringForStatus (status));
exit(1);
}
status = mamaTransport_setTransportCallback(*transport, transportCb, NULL);
status = mamaTransport_create (*transport, tportName, capture->myBridge);
if (status != MAMA_STATUS_OK)
{
mama_log (MAMA_LOG_LEVEL_NORMAL,
"Failed to create transport STATUS: %d %s\n", status,
mamaStatus_stringForStatus (status));
exit(1);
}
/*if we still haven't create a transport for
dictionary then do so */
if (capture->myDictTransport == NULL)
{
capture->myDictTransport = *transport;
mamaSource_create (&capture->myDictSource);
mamaSource_setTransport (capture->myDictSource,
capture->myDictTransport);
mamaSource_setSymbolNamespace (capture->myDictSource,
capture->myDictSourceName);
if (status != MAMA_STATUS_OK)
{
mama_log (MAMA_LOG_LEVEL_NORMAL,
"Failed to create data dictionary transport STATUS: %d %s\n",
status, mamaStatus_stringForStatus (status));
exit(1);
}
}
return status;
}
mama_status
qpidBridgeMamaMsg_setSendSubject (msgBridge msg,
const char* symbol,
const char* subject)
{
qpidBridgeMsgImpl* impl = (qpidBridgeMsgImpl*) msg;
mama_status status = MAMA_STATUS_OK;
if (NULL == impl || NULL == symbol || (NULL == symbol && NULL == subject))
{
return MAMA_STATUS_NULL_ARG;
}
status = qpidBridgeMamaMsgImpl_setStringValue (impl->mSendSubject, symbol);
if (MAMA_STATUS_OK != status)
{
mama_log (MAMA_LOG_LEVEL_ERROR,
"qpidBridgeMamaMsg_setSendSubject(): "
"Could not set send subject: %s",
mamaStatus_stringForStatus(status));
return MAMA_STATUS_PLATFORM;
}
/* Update the MAMA message with the send subject if it has a parent */
if (NULL != impl->mParent)
{
status = mamaMsg_updateString (impl->mParent,
MamaFieldSubscSymbol.mName,
MamaFieldSubscSymbol.mFid,
symbol);
}
return status;
}
/*
* Subscribe to specified message topic
*/
void subscribeToTopic(const char * topicName)
{
global.subscription = NULL;
mama_status status;
if ((status = mamaSubscription_allocate(&global.subscription)) == MAMA_STATUS_OK)
{
// initialize functions called by MAMA on different subscription events
memset(&global.receiver, 0, sizeof(global.receiver));
global.receiver.onCreate = onCreate; // when subscription created
global.receiver.onError = onError; // when error occurs
global.receiver.onMsg = onMessage; // when a message arrives on subscribed topic
// subscribe to messages on specified topic
mamaQueue defaultQueue;
if (((status = mama_getDefaultEventQueue(global.bridge, &defaultQueue)) == MAMA_STATUS_OK) &&
((status = mamaSubscription_createBasic(global.subscription, global.transport,
defaultQueue,
&global.receiver,
topicName,
NULL)) == MAMA_STATUS_OK))
{
// normal exit
return;
}
}
// error exit
printf("Error subscribing to topic %s, error code: %s\n", topicName,
mamaStatus_stringForStatus(status));
mama_close();
exit(status);
}
/*
* Call this routine when subscription error occurs
*/
void onError(mamaSubscription subscription, mama_status status,
void * platformError, const char * subject, void * closure)
{
const char * topicName = NULL;
if (mamaSubscription_getSymbol(subscription, &topicName) == MAMA_STATUS_OK)
printf("Error occured with subscription to topic \"%s\", error code: %s\n",
topicName, mamaStatus_stringForStatus(status));
}
void initializeMama (void)
{
mama_status status;
status = mama_loadBridge (&gMamaBridge, gMiddleware);
if (status != MAMA_STATUS_OK)
{
printf ("Error loading bridge: %s\n",
mamaStatus_stringForStatus (status));
exit (status);
}
status = mama_open ();
if (status != MAMA_STATUS_OK)
{
printf ("Error initializing mama: %s\n",
mamaStatus_stringForStatus (status));
exit (status);
}
mama_getDefaultEventQueue (gMamaBridge, &gMamaDefaultQueue);
status = mamaTransport_allocate (&gTransport);
if (status != MAMA_STATUS_OK)
{
printf ("Error allocating transport: %s\n",
mamaStatus_stringForStatus (status));
exit (status);
}
status = mamaTransport_create (gTransport, gTransportName, gMamaBridge);
if (status != MAMA_STATUS_OK)
{
printf ("Error creating transport: %s\n",
mamaStatus_stringForStatus (status));
exit (status);
}
}
static void MAMACALLTYPE
errorCb (mamaSubscription subscription,
mama_status status,
void* platformError,
const char* subject,
void* closure)
{
printf ("mamasubscriberc: Error creating subscription: %s\n",
mamaStatus_stringForStatus (status));
exit (status);
}
static void MAMACALLTYPE
subscriptionHandlerOnErrorCb (mamaDQPublisherManager manager,
mama_status status,
const char* errortxt,
mamaMsg msg)
{
if (msg)
{
printf ("Unhandled Msg: %s (%s) %s\n",
mamaStatus_stringForStatus (status),
mamaMsg_toString (msg),
errortxt);
}
else
{
printf("Unhandled Msg: %s %s\n",
mamaStatus_stringForStatus (status),
errortxt);
}
}
static void createIOHandlers (void)
{
mama_status status = MAMA_STATUS_OK;
mamaQueue defaultQueue = NULL;
if (gQuietLevel < 2)
{
printf ("Creating IO Handler\n");
}
/*Get the default event queue*/
mama_getDefaultEventQueue (gMamaBridge, &defaultQueue);
status = mamaIo_create (&gReadHandler,
defaultQueue,
gFD,
ioCallback,
MAMA_IO_READ,
NULL);
if (status != MAMA_STATUS_OK)
{
printf ("Error creating mamaIoHandler for READ: %s\n",
mamaStatus_stringForStatus (status));
exit (1);
}
status = mamaIo_create (&gWriteHandler,
defaultQueue,
gFD,
ioCallback,
MAMA_IO_WRITE,
NULL);
if (status != MAMA_STATUS_OK)
{
printf ("Error creating mamaIoHandler for WRITE: %s\n",
mamaStatus_stringForStatus (status));
exit (1);
}
}
static void MAMACALLTYPE
listenerErrorCb (mamaSubscription subscription,
mama_status status,
void * platformError,
const char * subject,
void * closure)
{
mama_log (MAMA_LOG_LEVEL_NORMAL,
"An error occurred creating listener for %s: %s\n",
subject,
mamaStatus_stringForStatus (status));
}
static void MAMACALLTYPE
subscriptionOnError (mamaSubscription subscription,
mama_status status,
void* platformError,
const char* subject,
void* closure)
{
fprintf (stdout,
"An error occurred creating subscription for %s: %s\n",
subject ? subject : "(null)",
mamaStatus_stringForStatus (status));
}
void initializeMama (void)
{
mama_status status = MAMA_STATUS_OK;
if (MAMA_STATUS_OK !=
(status = mama_loadBridge (&gMamaBridge, gMiddleware)))
{
printf ("Error loading %s bridge : %s\n",
gMiddleware,
mamaStatus_stringForStatus (status));
exit (status);
}
status = mama_open ();
if (status != MAMA_STATUS_OK)
{
printf ("Error initializing mama: %s\n",
mamaStatus_stringForStatus (status));
exit (status);
}
}
/*
* Load and initialize specified middleware bridge, initialize MAMA
*/
void initializeBridge(const char * bridgeName)
{
global.bridge = NULL;
mama_status status;
if (((status = mama_loadBridge(&global.bridge, bridgeName)) == MAMA_STATUS_OK) &&
((status = mama_openWithProperties(".","mama.properties")) == MAMA_STATUS_OK))
{
// normal exit;
return;
}
// error exit
mama_close();
printf("MAMA initialization error: %s\n", mamaStatus_stringForStatus(status));
exit(status);
}
/*
* Connect to specified transport using the previously loaded bridge
*/
void connectTransport(const char * transportName)
{
global.transport = NULL;
mama_status status;
if (((status = mamaTransport_allocate(&global.transport)) == MAMA_STATUS_OK) &&
((status = mamaTransport_create(global.transport, transportName, global.bridge)) == MAMA_STATUS_OK))
{
// normal exit
return;
}
// error exit
printf("Transport %s connect error: %s\n", transportName, mamaStatus_stringForStatus(status));
mama_close();
exit(status);
}
mama_status
qpidBridge_open (mamaBridge bridgeImpl)
{
mama_status status = MAMA_STATUS_OK;
mamaBridgeImpl* bridge = (mamaBridgeImpl*) bridgeImpl;
wsocketstartup();
if (NULL == bridgeImpl)
{
return MAMA_STATUS_NULL_ARG;
}
/* Create the default event queue */
status = mamaQueue_create (&bridge->mDefaultEventQueue, bridgeImpl);
if (MAMA_STATUS_OK != status)
{
mama_log (MAMA_LOG_LEVEL_ERROR,
"qpidBridge_open(): Failed to create QPID queue (%s).",
mamaStatus_stringForStatus (status));
return status;
}
/* Set the queue name (used to identify this queue in MAMA stats) */
mamaQueue_setQueueName (bridge->mDefaultEventQueue,
QPID_DEFAULT_QUEUE_NAME);
/* Create the timer heap */
if (0 != createTimerHeap (&gQpidTimerHeap))
{
mama_log (MAMA_LOG_LEVEL_ERROR,
"qpidBridge_open(): Failed to initialize timers.");
return MAMA_STATUS_PLATFORM;
}
/* Start the dispatch timer heap which will create a new thread */
if (0 != startDispatchTimerHeap (gQpidTimerHeap))
{
mama_log (MAMA_LOG_LEVEL_ERROR,
"qpidBridge_open(): Failed to start timer thread.");
return MAMA_STATUS_PLATFORM;
}
/* Start the io thread */
qpidBridgeMamaIoImpl_start ();
return MAMA_STATUS_OK;
}
static void MAMACALLTYPE
dict_onError( mamaSubscription mamaSubsc,
mama_status status,
void *platformError,
const char *subject,
void *dictionary )
{
if( status == MAMA_STATUS_TIMEOUT )
{
self->mCallbackSet.onTimeout( self,
self->mClosure );
}
else
{
self->mCallbackSet.onError( self,
mamaStatus_stringForStatus( status ),
self->mClosure );
}
}
int main(int argc, const char** argv)
{
printf("Solace OpenMAMA tutorial.\nReceiving messages with OpenMAMA.\n");
// set Ctrl-C handler
signal(SIGINT, stopHandler);
initializeBridge("solace");
connectTransport("vmr"); // see mama.properties
subscribeToTopic("tutorial.topic");
// receive messages until Ctrl-C is pressed
mama_status status;
if ((status = mama_start(global.bridge)) != MAMA_STATUS_OK)
{
printf("OpenMAMA start error: %s\n",
mamaStatus_stringForStatus(status));
}
// normal exit after Ctrl-C was pressed
printf("Closing OpenMAMA\n");
mama_close();
exit(status);
}
static void initializeMama ()
{
mama_status status;
status = mama_loadBridge (&gPubBridge, gPubMiddleware);
status = mama_loadBridge (&gSubBridge, gSubMiddleware);
mama_open();
mama_getDefaultEventQueue (gPubBridge, &gPubDefaultQueue);
mama_getDefaultEventQueue (gSubBridge, &gSubDefaultQueue);
mamaTransport_allocate (&gSubTransport);
mamaTransport_create (gSubTransport,
gSubTransportName,
gSubBridge);
mamaTransport_allocate (&gPubTransport);
mamaTransport_create (gPubTransport,
gPubTransportName,
gPubBridge);
/*The mamaSource used for all subscription creation*/
if (MAMA_STATUS_OK!=(status=mamaSource_create (&gSubscriptionSource)))
{
fprintf (stderr,
"Failed to create subscription mamaSource STATUS: %d %s\n",
status, mamaStatus_stringForStatus (status));
exit(1);
}
mamaSource_setId (gSubscriptionSource, "Subscription_Source");
mamaSource_setTransport (gSubscriptionSource, gSubTransport);
mamaSource_setSymbolNamespace (gSubscriptionSource, gSubSource);
}
void buildDataDictionary (mamaCaptureConfig subCapture)
{
mamaCapture * capture = (mamaCapture*)subCapture;
mamaDictionaryCallbackSet dictionaryCallback;
mama_status result;
if (capture->myBuildDataDict)
{
dictionaryCallback.onComplete = completeCb;
dictionaryCallback.onTimeout = timeoutCb;
dictionaryCallback.onError = errorCb;
result = mama_createDictionary (&capture->myDictionary,
capture->myDefaultQueue,
dictionaryCallback,
capture->myDictSource,
10.0,
3,
capture);
if (result != MAMA_STATUS_OK)
{
mama_logStdout (MAMA_LOG_LEVEL_NORMAL, "Exception creating "
"dictionary: MamaStatus: %s\n",
mamaStatus_stringForStatus (result));
exit (1);
}
mama_start (capture->myBridge);
if (!capture->myDictionaryComplete)
{
mama_log(MAMA_LOG_LEVEL_NORMAL, "MamaCapture Could not create dictionary.\n" );
exit(1);
}
}
}
static void MAMACALLTYPE pubCallback (mamaTimer timer, void* closure)
{
int index =0;
char*temp=NULL;
char*source=NULL;
char* headerString = NULL;
mamaMsg newMessage;
mama_status status = MAMA_STATUS_OK;
for (index=0; index < gNumSymbols; index++)
{
if (gSubscriptionList[index].fileParser)
{
int header = 1;
while ((header = mamaPlaybackFileParser_getNextHeader (
gSubscriptionList[index].fileParser, &headerString)))
{
if (strlen (headerString) == 0) continue;
/*skip source and transport name*/
temp = strchr (headerString,DELIM);
temp++;
source = strchr (temp,DELIM);
source++; /*skip :*/
temp = strchr (source, DELIM);
if (mamaPlaybackFileParser_getNextMsg (
gSubscriptionList[index].fileParser, &newMessage))
{
int symLength = temp - source;
if (0 == strncmp (gSubscriptionList[index].symbol,
source,
symLength)
&&
symLength == (strlen (gSubscriptionList[index].symbol))
)
{
mamaMsg_applyMsg (gSubscriptionList[index].cachedMsg,
newMessage);
mama_log (MAMA_LOG_LEVEL_FINEST,
"Publishing message: %s",
mamaMsg_toString(newMessage));
mamaDQPublisher_send (gSubscriptionList[index].pub,
newMessage);
break;
}
}
}
if (gRewind && !header)
{
mama_log (MAMA_LOG_LEVEL_FINE,
"End of file reached for symbol %s - Rewinding.",
gSubscriptionList[index].symbol);
status = mamaPlaybackFileParser_rewindFile(
gSubscriptionList[index].fileParser);
if (MAMA_STATUS_OK != status)
{
mama_log(MAMA_LOG_LEVEL_FINE, "Failed to rewind file %s",
mamaStatus_stringForStatus(status));
}
} else if (!header) {
mama_log (MAMA_LOG_LEVEL_FINE,
"End of file reached for symbol %s.",
gSubscriptionList[index].symbol);
}
}
}
}
static mama_status initializeMama (mamaCaptureConfig subCapture)
{
mamaCapture * capture = (mamaCapture*)subCapture;
mama_status status = MAMA_STATUS_OK;
status = mama_loadBridge (&capture->myBridge, capture->myMiddleware);
if (MAMA_STATUS_OK!=status)
{
mama_log (MAMA_LOG_LEVEL_NORMAL,"Could not open MAMA %s bridge.",
capture->myMiddleware);
exit (1);
}
status = mama_open ();
if (status != MAMA_STATUS_OK)
{
mama_log (MAMA_LOG_LEVEL_NORMAL,
"Failed to initialize MAMA STATUS: %d (%s)\n", status,
mamaStatus_stringForStatus (status));
exit(1);
}
mama_getDefaultEventQueue (capture->myBridge, &capture->myDefaultQueue);
status = mamaCapture_allocate(&capture->myCapture);
if (status != MAMA_STATUS_OK)
{
mama_log (MAMA_LOG_LEVEL_NORMAL,
"Failed to create capture STATUS: %d %s\n", status,
mamaStatus_stringForStatus (status));
exit(1);
}
if (capture->myDictTport != NULL)
{
mama_log (MAMA_LOG_LEVEL_FINE,
"Creating data dictionary transport using name: %s\n",
capture->myDictTport);
if (strlen(capture->myDictTport)==0) capture->myDictTport = NULL;
status = mamaTransport_allocate (&capture->myDictTransport);
status = mamaTransport_create (capture->myDictTransport,
capture->myDictTport,
capture->myBridge);
mamaSource_create (&capture->myDictSource);
mamaSource_setTransport (capture->myDictSource,
capture->myDictTransport);
mamaSource_setSymbolNamespace (capture->myDictSource,
capture->myDictSourceName);
if (status != MAMA_STATUS_OK)
{
mama_log (MAMA_LOG_LEVEL_NORMAL,
"Failed to create data dictionary transport STATUS: %d %s\n",
status, mamaStatus_stringForStatus (status));
exit(1);
}
}
return MAMA_STATUS_OK;
}
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;
}
mama_status
qpidBridgeMamaPublisher_sendReplyToInboxHandle (publisherBridge publisher,
void* inbox,
mamaMsg reply)
{
qpidPublisherBridge* impl = (qpidPublisherBridge*) publisher;
const char* inboxSubject = NULL;
const char* replyTo = NULL;
mama_status status = MAMA_STATUS_OK;
if (NULL == publisher || NULL == inbox || NULL == reply)
{
return MAMA_STATUS_NULL_ARG;
}
/* Set properties for the outgoing bridge message */
qpidBridgeMamaMsgImpl_setMsgType (impl->mMamaBridgeMsg,
QPID_MSG_INBOX_RESPONSE);
/* Target is for MD subscriptions to respond to this particular topic */
qpidBridgeMamaMsgImpl_setTargetSubject (impl->mMamaBridgeMsg,
impl->mSubject);
/* Get properties from the incoming bridge message */
status = qpidBridgeMamaMsgReplyHandleImpl_getInboxName (
inbox,
(char**) &inboxSubject);
if (MAMA_STATUS_OK != status)
{
mama_log (MAMA_LOG_LEVEL_ERROR,
"qpidBridgeMamaPublisher_sendReplyToInbox(): "
"Could not get inbox name [%s]",
mamaStatus_stringForStatus (status));
return status;
}
status = qpidBridgeMamaMsgReplyHandleImpl_getReplyTo (
inbox,
(char**) &replyTo);
if (MAMA_STATUS_OK != status)
{
mama_log (MAMA_LOG_LEVEL_ERROR,
"qpidBridgeMamaPublisher_sendReplyToInbox(): "
"Could not get reply to [%s]",
mamaStatus_stringForStatus (status));
return status;
}
if (NULL == inboxSubject || NULL == replyTo)
{
mama_log (MAMA_LOG_LEVEL_ERROR,
"qpidBridgeMamaPublisher_sendReplyToInboxHandle(): "
"No reply address specified - cannot respond to inbox %s.",
inboxSubject);
return status;
}
/* Set the send subject to publish onto the inbox subject */
status = qpidBridgeMamaMsg_setSendSubject (impl->mMamaBridgeMsg,
inboxSubject,
impl->mSource);
if (MAMA_STATUS_OK != status)
{
mama_log (MAMA_LOG_LEVEL_ERROR,
"qpidBridgeMamaPublisher_sendReplyToInboxHandle(): "
"Could not set send subject '%s' [%s]",
inboxSubject,
mamaStatus_stringForStatus (status));
return status;
}
/* Set the destination to the replyTo URL */
status = qpidBridgeMamaMsgImpl_setDestination (impl->mMamaBridgeMsg,
replyTo);
if (MAMA_STATUS_OK != status)
{
mama_log (MAMA_LOG_LEVEL_ERROR,
"qpidBridgeMamaPublisher_sendReplyToInboxHandle(): "
"Could not set destination '%s' [%s]",
replyTo,
mamaStatus_stringForStatus (status));
return status;
}
/* Fire out the message to the inbox */
return qpidBridgeMamaPublisher_send (publisher, reply);
}
mama_status
qpidBridgeMamaPublisher_createByIndex (publisherBridge* result,
mamaTransport tport,
int tportIndex,
const char* topic,
const char* source,
const char* root,
mamaPublisher parent)
{
qpidPublisherBridge* impl = NULL;
qpidTransportBridge* transport = NULL;
mama_status status = MAMA_STATUS_OK;
const char* outgoingAddress = NULL;
const char* uuid = NULL;
if (NULL == result || NULL == tport || NULL == parent)
{
return MAMA_STATUS_NULL_ARG;
}
transport = qpidBridgeMamaTransportImpl_getTransportBridge (tport);
if (NULL == transport)
{
mama_log (MAMA_LOG_LEVEL_SEVERE,
"qpidBridgeMamaPublisher_createByIndex(): "
"Could not find transport.");
return MAMA_STATUS_NULL_ARG;
}
impl = (qpidPublisherBridge*) calloc (1, sizeof (qpidPublisherBridge));
if (NULL == impl)
{
mama_log (MAMA_LOG_LEVEL_ERROR,
"qpidBridgeMamaPublisher_createByIndex(): "
"Could not allocate mem publisher.");
return MAMA_STATUS_NOMEM;
}
/* Initialize the publisher members */
impl->mTransport = transport;
impl->mParent = parent;
/* Create an underlying bridge message with no parent to be used in sends */
status = qpidBridgeMamaMsgImpl_createMsgOnly (&impl->mMamaBridgeMsg);
if (MAMA_STATUS_OK != status)
{
mama_log (MAMA_LOG_LEVEL_ERROR,
"qpidBridgeMamaPublisher_createByIndex(): "
"Could not create qpid bridge message for publisher: %s.",
mamaStatus_stringForStatus (status));
free (impl);
return MAMA_STATUS_NOMEM;
}
/* Get the outgoing address format string */
outgoingAddress = qpidBridgeMamaTransportImpl_getOutgoingAddress (
(transportBridge) impl->mTransport);
/* Get the transport UUID which is unique to the transport in case we need
* it during format string expansion */
uuid = qpidBridgeMamaTransportImpl_getUuid (
(transportBridge) impl->mTransport);
/* Collapse subject key to single string based on supplied values
*
* _MD requests do not use the topic on the wire as the responder may not
* necessarily be listening for requests on that topic until the first
* request comes in. */
if (NULL != root && 0 == strcmp (root, MAMA_ROOT_MARKET_DATA))
{
qpidBridgeCommon_generateSubjectKey (root,
source,
NULL,
&impl->mSubject);
}
else
{
qpidBridgeCommon_generateSubjectKey (root,
source,
topic,
&impl->mSubject);
}
/* Parse the collapsed string to extract the standardized values */
qpidBridgeCommon_parseSubjectKey (impl->mSubject,
&impl->mRoot,
&impl->mSource,
&impl->mTopic,
(transportBridge) impl->mTransport);
if (NULL != outgoingAddress)
{
/* Generate subject URI based on standardized values */
qpidBridgeCommon_generateSubjectUri (outgoingAddress,
impl->mRoot,
impl->mSource,
impl->mTopic,
uuid,
&impl->mUri);
}
/* Create a reusable proton message */
impl->mQpidRawMsg = pn_message ();
/* Populate the publisherBridge pointer with the publisher implementation */
*result = (publisherBridge) impl;
return status;
}
