mama_status
msgUtils_getIssueSymbol (mamaMsg msg, const char** result)
{
mama_status status = MAMA_STATUS_OK;
if(MAMA_STATUS_OK!=(status=mamaMsg_getString( msg, NULL, 305, result)))
{
mama_log (MAMA_LOG_LEVEL_FINE, "Could not get wIssueSymbol [%s]."
"Trying wIndexSymbol.", mamaMsgStatus_stringForStatus (status));
/*The symbol might be in wIndexSymbol*/
status = mamaMsg_getString (msg, NULL, 293, result);
}
return status;
}
TEST_F(MamaFieldCacheTestC, getFullMsg1)
{
mamaFieldCache fieldCache = NULL;
mama_status ret = mamaFieldCache_create(&fieldCache);
mamaFieldCacheField field = NULL;
mamaFieldCacheField_create(&field, 10, MAMA_FIELD_TYPE_BOOL, NULL);
mamaFieldCacheField_setBool(field, 1);
mamaFieldCache_applyField(fieldCache, field);
/* This field must never be published */
mamaFieldCacheField_create(&field, 25, MAMA_FIELD_TYPE_F64, NULL);
mamaFieldCacheField_setF64(field, 3.1);
mamaFieldCacheField_setPublish(field, 0);
mamaFieldCache_applyField(fieldCache, field);
mamaFieldCacheField_create(&field, 66, MAMA_FIELD_TYPE_I32, NULL);
mamaFieldCacheField_setI32(field, -100);
mamaFieldCache_applyField(fieldCache, field);
// Creating a string field without a value. Even if this field is added to the
// cache, it will not be added to the message because we cannot add a NULL
// string to a mama message
mamaFieldCacheField_create(&field, 110, MAMA_FIELD_TYPE_STRING, NULL);
mamaFieldCache_applyField(fieldCache, field);
mamaFieldCacheField_create(&field, 90, MAMA_FIELD_TYPE_STRING, NULL);
mamaFieldCacheField_setString(field, "hello world", 0);
mamaFieldCache_applyField(fieldCache, field);
mamaMsg message;
mamaMsg_create(&message);
// should use add* methods to populate the message because the message is empty
mamaFieldCache_getFullMessage(fieldCache, message);
mama_bool_t resultBool = 0;
ret = mamaMsg_getBool(message, "test_bool", 10, &resultBool);
ASSERT_EQ(MAMA_STATUS_OK, ret);
mama_f64_t resultF64;
ret = mamaMsg_getF64(message, "test_f32", 25, &resultF64);
ASSERT_EQ(MAMA_STATUS_NOT_FOUND, ret);
mama_i32_t resultI32;
ret = mamaMsg_getI32(message, "test_i32", 66, &resultI32);
ASSERT_EQ(MAMA_STATUS_OK, ret);
const char* resultString;
ret = mamaMsg_getString(message, "test_string", 90, &resultString);
ASSERT_EQ(MAMA_STATUS_OK, ret);
ASSERT_EQ(1, resultBool);
ASSERT_DOUBLE_EQ(-100, resultI32);
ASSERT_STREQ("hello world", resultString);
mamaMsg_destroy (message);
ret = mamaFieldCache_destroy(fieldCache);
}
static void MAMACALLTYPE
dqPublisherImplMsgCb (mamaSubscription subsc,
mamaMsg msg,
void* closure,
void* itemClosure)
{
mama_i32_t msgType = 0;
mama_i32_t subType = 0;
const char* symbol = NULL;
mama_status status = MAMA_STATUS_NOT_FOUND;
mamaPublishTopic* info = NULL;
mamaDQPublisherManagerImpl* impl = (mamaDQPublisherManagerImpl*) (closure);
if (mamaMsg_getI32 (msg, MamaFieldSubscriptionType.mName,
MamaFieldSubscriptionType.mFid, &subType) == MAMA_STATUS_OK)
{
if (mamaMsg_getString (msg, MamaFieldSubscSymbol.mName,
MamaFieldSubscSymbol.mFid, &symbol) != MAMA_STATUS_OK)
{
if (mamaMsg_getSendSubject (msg, &symbol) != MAMA_STATUS_OK)
{
impl->mUserCallbacks.onError ((mamaDQPublisherManager)impl,
status, "No symbol", msg);
return;
}
}
if (mamaMsg_getI32 (msg, MamaFieldSubscMsgType.mName,
MamaFieldSubscMsgType.mFid, &msgType) != MAMA_STATUS_OK)
{
impl->mUserCallbacks.onError ((mamaDQPublisherManager)impl, status,
"NO msg type", msg);
return;
}
if ((info = wtable_lookup (impl->mPublisherMap, (symbol))))
{
switch (msgType)
{
case MAMA_SUBSC_REFRESH:
if (!impl->mRefreshResponseMsg)
{
mamaMsg_create(&impl->mRefreshResponseMsg);
mamaMsg_addU8(impl->mRefreshResponseMsg, NULL,
MamaFieldMsgStatus.mFid, MAMA_MSG_STATUS_MISC);
mamaMsg_addU8(impl->mRefreshResponseMsg, NULL,
MamaFieldMsgType.mFid, MAMA_MSG_TYPE_REFRESH);
}
mamaDQPublisher_send(info->pub, impl->mRefreshResponseMsg);
impl->mUserCallbacks.onRefresh((mamaDQPublisherManager)impl,
info, subType, msgType, msg );
break;
default:
impl->mUserCallbacks.onRequest ((mamaDQPublisherManager)impl,
info, subType, msgType, msg);
break;
}
}
else
{
impl->mUserCallbacks.onNewRequest ((mamaDQPublisherManager)impl,
symbol,
subType,
msgType,
msg);
}
}
else
{
if (impl->mUserCallbacks.onMsg)
impl->mUserCallbacks.onMsg ((mamaDQPublisherManager)impl, msg);
}
}
TEST_F(MamaFieldCacheTestC, getDeltaMsgTrackingModif)
{
mama_size_t size = 0;
mama_bool_t modified = 0;
mamaFieldCache fieldCache = NULL;
mama_status ret = mamaFieldCache_create(&fieldCache);
// tracking modification state globally at cache level
mamaFieldCache_setTrackModified(fieldCache, 1);
mamaFieldCacheField field = NULL;
// This field must be always published
mamaFieldCacheField_create(&field, 66, MAMA_FIELD_TYPE_I32, NULL);
mamaFieldCacheField_setI32(field, -100);
// Enable publishing
mamaFieldCacheField_setPublish(field, 1);
// Don't check if modified before publishing -> always publish
mamaFieldCacheField_setCheckModified(field, 0);
mamaFieldCache_applyField(fieldCache, field);
mamaFieldCacheField_destroy(field);
size = 0;
mamaFieldCacheList_getSize(fieldCache->mAlwaysPublishFields, &size);
ASSERT_EQ(1, size);
size = 0;
mamaFieldCacheList_getSize(fieldCache->mModifiedFields, &size);
ASSERT_EQ(0, size);
mamaMsg message;
mamaMsg_create(&message);
// reset the modified field and remove from list for field 66
mamaFieldCache_getDeltaMessage(fieldCache, message);
mamaMsg_destroy(message);
message = NULL;
size = 0;
mamaFieldCacheList_getSize(fieldCache->mAlwaysPublishFields, &size);
ASSERT_EQ(1, size);
size = 0;
mamaFieldCacheList_getSize(fieldCache->mModifiedFields, &size);
ASSERT_EQ(0, size);
// This field will be published
mamaFieldCacheField_create(&field, 10, MAMA_FIELD_TYPE_BOOL, NULL);
mamaFieldCacheField_setBool(field, 1);
// Enable publishing
mamaFieldCacheField_setPublish(field, 1);
// Check if modified before publishing
mamaFieldCacheField_setCheckModified(field, 1);
mamaFieldCache_applyField(fieldCache, field);
mamaFieldCacheField_destroy(field);
size = 0;
mamaFieldCacheList_getSize(fieldCache->mModifiedFields, &size);
ASSERT_EQ(1, size);
// This field must never be published because publish is false
mamaFieldCacheField_create(&field, 25, MAMA_FIELD_TYPE_F64, NULL);
mamaFieldCacheField_setF64(field, 3.1);
// Disable publishing
mamaFieldCacheField_setPublish(field, 0);
// Check modified can be anything - no publishing anyway... see above
mamaFieldCacheField_setCheckModified(field, 1);
mamaFieldCache_applyField(fieldCache, field);
mamaFieldCacheField_destroy(field);
size = 0;
mamaFieldCacheList_getSize(fieldCache->mModifiedFields, &size);
ASSERT_EQ(1, size);
// This field will always be published
mamaFieldCacheField_create(&field, 90, MAMA_FIELD_TYPE_STRING, NULL);
mamaFieldCacheField_setString(field, "hello world", 0);
// Enable publishing
mamaFieldCacheField_setPublish(field, 1);
// Don't check if modified
mamaFieldCacheField_setCheckModified(field, 0);
mamaFieldCache_applyField(fieldCache, field);
mamaFieldCacheField_destroy(field);
size = 0;
mamaFieldCacheList_getSize(fieldCache->mModifiedFields, &size);
ASSERT_EQ(1, size);
// This field will always be published
mamaFieldCacheField_create(&field, 91, MAMA_FIELD_TYPE_STRING, NULL);
mamaFieldCacheField_setString(field, "hello world again", 0);
// Enable publishing
mamaFieldCacheField_setPublish(field, 1);
// Don't check if modified
mamaFieldCacheField_setCheckModified(field, 0);
mamaFieldCache_applyField(fieldCache, field);
mamaFieldCacheField_destroy(field);
size = 0;
mamaFieldCacheList_getSize(fieldCache->mModifiedFields, &size);
ASSERT_EQ(1, size);
mamaMsg_create(&message);
mamaFieldCache_getDeltaMessage(fieldCache, message);
size = 0;
mamaFieldCacheList_getSize(fieldCache->mModifiedFields, &size);
ASSERT_EQ(0, size);
ASSERT_EQ(MAMA_STATUS_OK, mamaFieldCache_find(fieldCache, 10, "", &field));
mamaFieldCacheField_isModified(field, &modified);
ASSERT_FALSE(modified);
mama_bool_t resultBool;
ret = mamaMsg_getBool(message, "test_bool", 10, &resultBool);
ASSERT_EQ(MAMA_STATUS_OK, ret);
ASSERT_EQ(1, resultBool);
mama_f64_t resultF64;
ret = mamaMsg_getF64(message, "test_f32", 25, &resultF64);
ASSERT_EQ(MAMA_STATUS_NOT_FOUND, ret);
mama_i32_t resultI32;
ret = mamaMsg_getI32(message, "test_i32", 66, &resultI32);
ASSERT_EQ(MAMA_STATUS_OK, ret);
ASSERT_EQ(-100, resultI32);
const char* resultString;
ret = mamaMsg_getString(message, "test_string", 90, &resultString);
ASSERT_EQ(MAMA_STATUS_OK, ret);
ASSERT_STREQ("hello world", resultString);
ret = mamaMsg_getString(message, "test_string", 91, &resultString);
ASSERT_EQ(MAMA_STATUS_OK, ret);
ASSERT_STREQ("hello world again", resultString);
mamaMsg_destroy (message);
ret = mamaFieldCache_destroy(fieldCache);
}
TEST_F(MamaFieldCacheTestC, getDeltaMsgNotTrackingModif)
{
mama_bool_t modified = 0;
mamaFieldCache fieldCache = NULL;
mama_status ret = mamaFieldCache_create(&fieldCache);
// setting explicitely to non-tracking mode
mamaFieldCache_setTrackModified(fieldCache, 0);
// This field will be published
mamaFieldCacheField field = NULL;
mamaFieldCacheField_create(&field, 10, MAMA_FIELD_TYPE_BOOL, NULL);
mamaFieldCacheField_setBool(field, 1);
// Enable publishing
mamaFieldCacheField_setPublish(field, 1);
// Check if modified before publishing - who cares... global check modified is disabled
mamaFieldCacheField_setCheckModified(field, 1);
mamaFieldCache_applyField(fieldCache, field);
mamaFieldCacheField_destroy(field);
// This field will not be published
mamaFieldCacheField_create(&field, 25, MAMA_FIELD_TYPE_F64, NULL);
mamaFieldCacheField_setF64(field, 3.1);
// Disable publishing
mamaFieldCacheField_setPublish(field, 0);
// Check modified can be anything - no publishing anyway... see above
mamaFieldCacheField_setCheckModified(field, 1);
mamaFieldCache_applyField(fieldCache, field);
mamaFieldCacheField_destroy(field);
// This field will be published
mamaFieldCacheField_create(&field, 66, MAMA_FIELD_TYPE_I32, NULL);
mamaFieldCacheField_setI32(field, -100);
// Enable publishing
mamaFieldCacheField_setPublish(field, 1);
// Check if modified - who cares... global check modified is disabled
mamaFieldCacheField_setCheckModified(field, 1);
mamaFieldCache_applyField(fieldCache, field);
mamaFieldCacheField_destroy(field);
// This field will be published
mamaFieldCacheField_create(&field, 90, MAMA_FIELD_TYPE_STRING, NULL);
mamaFieldCacheField_setString(field, "hello world", 0);
// Enable publishing
mamaFieldCacheField_setPublish(field, 1);
// Don't check if modified - who cares... global check modified is disabled
mamaFieldCacheField_setCheckModified(field, 0);
mamaFieldCache_applyField(fieldCache, field);
mamaFieldCacheField_destroy(field);
// This field will be published
mamaFieldCacheField_create(&field, 91, MAMA_FIELD_TYPE_STRING, NULL);
mamaFieldCacheField_setString(field, "hello world again", 0);
// Enable publishing
mamaFieldCacheField_setPublish(field, 1);
// Don't check if modified - who cares... global check modified is disabled
mamaFieldCacheField_setCheckModified(field, 1);
mamaFieldCache_applyField(fieldCache, field);
mamaFieldCacheField_destroy(field);
mamaMsg message;
mamaMsg_create(&message);
// This results in a Full message because track modified is false
mamaFieldCache_getDeltaMessage(fieldCache, message);
ASSERT_EQ(MAMA_STATUS_OK, mamaFieldCache_find(fieldCache, 10, "", &field));
mamaFieldCacheField_isModified(field, &modified);
// The modified flag is not modified if the cache is not tracking modifications
ASSERT_FALSE(modified);
mama_bool_t resultBool;
ret = mamaMsg_getBool(message, "test_bool", 10, &resultBool);
ASSERT_EQ(MAMA_STATUS_OK, ret);
ASSERT_EQ(1, resultBool);
mama_f64_t resultF64;
ret = mamaMsg_getF64(message, "test_f32", 25, &resultF64);
ASSERT_EQ(MAMA_STATUS_NOT_FOUND, ret);
mama_i32_t resultI32;
ret = mamaMsg_getI32(message, "test_i32", 66, &resultI32);
ASSERT_EQ(MAMA_STATUS_OK, ret);
ASSERT_EQ(-100, resultI32);
const char* resultString;
ret = mamaMsg_getString(message, "test_string", 90, &resultString);
ASSERT_EQ(MAMA_STATUS_OK, ret);
ASSERT_STREQ("hello world", resultString);
ret = mamaMsg_getString(message, "test_string", 91, &resultString);
ASSERT_EQ(MAMA_STATUS_OK, ret);
ASSERT_STREQ("hello world again", resultString);
mamaMsg_destroy (message);
ret = mamaFieldCache_destroy(fieldCache);
}
static void MAMACALLTYPE
wildCardMsgCb (mamaSubscription subscription,
mamaMsg msg,
const char* topic,
void * closure,
void * itemClosure)
{
static int i = 0;
if (gMuteTopic)
{
const char* topic = NULL;
mamaMsg_getString (msg, "PublisherTopic", 10002, &topic);
if (0 == strncmp (topic, gMuteTopic, strlen(topic)))
{
gMuteTopic = NULL;
printf ("Mutting %s\n", topic);
mamaSubscription_muteCurrentTopic (subscription);
return;
}
}
if (itemClosure == NULL)
{
mamaSubscription_setItemClosure (subscription, (void*)strdup(topic));
}
if (gQuietLevel < 2)
{
printf ("Received Wild Card Message with topic %s closure=%s\n",
topic,
(char*)itemClosure);
}
displayMsg (msg);
}
static void MAMACALLTYPE
dictMsgIterator (const mamaMsg msg,
const mamaMsgField field,
void* closure)
{
mamaDictionaryImpl* impl = (mamaDictionaryImpl*) closure;
const char* fieldName = NULL;
mama_fid_t fid = 0;
mamaFieldType type = 0;
const char* val = NULL;
mamaMsgField_getType(field,&type);
mamaMsgField_getFid(field,&fid);
mamaMsgField_getName(field,&fieldName);
if (MamaFieldFeedName.mFid == fid)
{
if (MAMA_STATUS_OK == mamaMsg_getString (msg, fieldName, fid, &val))
{
checkFree(&impl->mFeedName);
impl->mFeedName = copyString(val);
mama_log ( MAMA_LOG_LEVEL_FINE,
"Dictionary source feed name: %s",
val);
}
}
else if (MamaFieldFeedHost.mFid == fid)
{
if (MAMA_STATUS_OK == mamaMsg_getString (msg, fieldName, fid, &val))
{
checkFree(&impl->mFeedHost);
impl->mFeedHost = copyString(val);
mama_log ( MAMA_LOG_LEVEL_FINE,
"Dictionary source hostname: %s",
val);
}
}
mamaDictionary_createFieldDescriptor (impl,
fid,
fieldName,
type,
NULL);
}
