public static void Main(string[] args)
{
parseCommandLine(args);
try
{
initializeMama();
buildDataDictionary();
/* Subscribe to the symbol list */
MamaSubscription symbolListSubscription = new MamaSubscription();
symbolListSubscription.setSubscriptionType(mamaSubscriptionType.MAMA_SUBSC_TYPE_SYMBOL_LIST);
symbolListSubscription.create(myDefaultQueue,
symbolListSubscriptionCallback,
mySource,
"Symbol List",
null);
Console.WriteLine("Type CTRL-C to exit.");
Mama.start(myBridge);
}
catch (Exception e)
{
Console.Error.WriteLine(e.ToString());
Environment.Exit(1);
}
}
private void createSubscriptions()
{
mamaSource = new MamaSource();
mamaSource.symbolNamespace = mamaSourceName;
mamaSource.transport = mamaTransport;
for (int i = 0; i < mamaNumSymbols; i++)
{
mamaSubscriptions[i] = new MamaSubscription();
mamaSubscriptions[i].setServiceLevel(mamaServiceLevel.MAMA_SERVICE_LEVEL_REAL_TIME);
mamaSubscriptions[i].setSubscriptionType(mamaSubscriptionType.MAMA_SUBSC_TYPE_NORMAL);
mamaSubscriptions[i].setTimeout(10);
mamaSubscriptions[i].setRetries(3);
mamaSubscriptions[i].setRequiresInitial(true);
mamaSubscriptions[i].create(
mamaQueueGroup == null ? mamaDefaultQueue : mamaQueueGroup.getNextQueue(),
this,
mamaSource,
mamaSymbols[i]);
}
}
public void onMsg(MamaSubscription subscription, MamaMsg msg)
{
MamaMsgIterator iterator = new MamaMsgIterator(mDictionary);
// Set the iterator to the beginning of the message
msg.begin(ref iterator);
Console.WriteLine("\n+------------------------+--------+--------------+-------------------");
Console.WriteLine("| FIELD NAME | FID | TYPE | VALUE (AS STRING) ");
Console.WriteLine("+------------------------+--------+--------------+-------------------");
// Keep going until there are no more fields
MamaMsgField field = iterator.getField();
while (field != null)
{
string fieldType = field.getTypeName();
string fieldName = field.getName();
int fid = field.getFid();
string fieldValueAsString = field.getAsString();
Console.WriteLine("| {0,-22} | {1,-6} | {2,-12} | {3}",
fieldName,
fid,
fieldType,
fieldValueAsString);
iterator++;
// Get the next field
field = iterator.getField();
}
}
private static MamaDictionary buildDataDictionary()
{
bool[] gotDict = new bool[] { false };
MamaDictionaryCallback dictionaryCallback = new DictionaryCallback(gotDict);
lock (dictionaryCallback)
{
MamaSubscription subscription = new MamaSubscription();
MamaDictionary dictionary = new MamaDictionary();
dictionary.create(
myDefaultQueue,
dictionaryCallback,
myDictSource,
3,
10);
Mama.start(myBridge);
if (!gotDict[0])
{
if (!Monitor.TryEnter(dictionaryCallback, 30000))
{
Console.Error.WriteLine("Timed out waiting for dictionary.");
Environment.Exit(0);
}
Monitor.Exit(dictionaryCallback);
}
return(dictionary);
}
}
private static MamaDictionary buildDataDictionary(
MamaTransport transport,
MamaQueue defaultQueue,
MamaSource dictionarySource)
{
bool[] gotDict = new bool[] { false };
MamaDictionaryCallback dictionaryCallback = new DictionaryCallback(gotDict);
lock (dictionaryCallback)
{
MamaSubscription subscription = new MamaSubscription ();
MamaDictionary dictionary = new MamaDictionary();
dictionary.create(
defaultQueue,
dictionaryCallback,
dictionarySource,
3,
10);
Mama.start(myBridge);
if (!gotDict[0])
{
if (!Monitor.TryEnter(dictionaryCallback, 30000))
{
Console.Error.WriteLine("Timed out waiting for dictionary.");
Environment.Exit(0);
}
Monitor.Exit(dictionaryCallback);
}
return dictionary;
}
}
public void onMsg(MamaSubscription subscription, MamaMsg msg)
{
if (quietness < 1)
{
Console.WriteLine("Recieved message of type " + msg.stringForType(msg.getType()) + " for " + subscription.subscSymbol);
}
}
public void onCreate(MamaSubscription subscription)
{
if (quietness < 1)
{
Console.WriteLine("Created symbol list subscription.\n");
}
}
public void onTimer(MamaTimer mamaTimer, object closure)
{
mamaTimer.destroy();
// Only continue if the application is not shutting down
bool shuttingDown = m_killEvent.WaitOne(0, false);
if (!shuttingDown)
{
int i = (int)closure;
mamaSubscriptions[i].destroy();
mamaSubscriptions[i] = new MamaSubscription();
mamaSubscriptions[i].setServiceLevel(mamaServiceLevel.MAMA_SERVICE_LEVEL_REAL_TIME);
mamaSubscriptions[i].setSubscriptionType(mamaSubscriptionType.MAMA_SUBSC_TYPE_NORMAL);
mamaSubscriptions[i].setTimeout(10);
mamaSubscriptions[i].setRetries(3);
mamaSubscriptions[i].setRequiresInitial(true);
mamaSubscriptions[i].create(
mamaQueueGroup == null ? mamaDefaultQueue : mamaQueueGroup.getNextQueue(),
this,
mamaSource,
mamaSymbols[i]);
stats.mRecreates++;
}
}
private static void subscribeToSubjects()
{
int howMany = 0;
queueGroup = new MamaQueueGroup(myBridge, numThreads);
/* Subscribe to all symbols parsed from the symbol list */
for (IEnumerator enumerator = subjectList.GetEnumerator(); enumerator.MoveNext();)
{
string symbol = (string)enumerator.Current;
MamaSubscription subscription = new MamaSubscription();
subscription.create(
queueGroup.getNextQueue(),
subscriptionCallback,
mySource,
symbol,
null);
subscriptions.Add(subscription);
if (++howMany % 1000 == 0)
{
Console.WriteLine("Subscribed to " + howMany + " symbols.");
}
}
}
/*Invoked if any errors are encountered during subscription processing*/
public void onError(MamaSubscription subscription,
MamaStatus.mamaStatus status,
string subject)
{
Console.WriteLine("Symbol=[" + subscription.subscSymbol + "] : " +
"An error occurred creating subscription: " +
MamaStatus.stringForStatus(status));
}
public void onCreate(MamaSubscription subscription)
{
// Increment the number of subscriptions
int totalSubscriptions = Interlocked.Increment(ref m_numberSubscriptions);
// Log a message if we've got them all
if (totalSubscriptions == m_totalSubscriptions)
{
Console.WriteLine("All Subscriptions created.");
}
}
/// <summary>
/// This function will create subscriptions for all the symbols in the array list.
/// </summary>
private void createSubscriptions()
{
// There must be at least 1 symbol
if (m_symbols.Count < 1)
{
throw new ApplicationException("There are no symbols to subscribe to.");
}
ListenerSubscriptionCallback subscriptionCallback = new ListenerSubscriptionCallback(m_dictionary, m_iterator, m_quietness, m_symbols.Count);
// Enumerate all the symbol names and create a subscription for each one
foreach (string symbol in m_symbols)
{
MamaSubscription subscription = new MamaSubscription();
// Set the service level depending on whether we need a snapshot subscription or not
if (m_snapshot)
{
subscription.setServiceLevel(mamaServiceLevel.MAMA_SERVICE_LEVEL_SNAPSHOT);
}
else
{
subscription.setServiceLevel(mamaServiceLevel.MAMA_SERVICE_LEVEL_REAL_TIME);
}
// Complete the remaining properties
subscription.setSubscriptionType(mamaSubscriptionType.MAMA_SUBSC_TYPE_NORMAL);
subscription.setTimeout(10);
subscription.setRetries(3);
subscription.setRequiresInitial(true);
/* Determine the queue to use, if there are multiple threads running then the next queue in the
* group will be acquired.
*/
MamaQueue queue = m_defaultQueue;
if (m_queueGroup != null)
{
queue = m_queueGroup.getNextQueue();
}
subscription.create(queue, subscriptionCallback, m_source, symbol);
// Add the subscription to the array list so that they can all be destroyed later on
m_subscriptions.Add(subscription);
}
}
public void onMsg(MamaSubscription subscription,
MamaMsg msg)
{
if (msg.getType() == mamaMsgType.MAMA_MSG_TYPE_INITIAL)
{
stats.mInitialMsgCount++;
}
else
{
stats.mOtherMsgCount++;
}
if (mamaLogLevel > MamaLogLevel.MAMA_LOG_LEVEL_NORMAL)
{
Console.WriteLine("msg.getSymbol msg.getStatus");
}
}
public void onMsg(MamaSubscription subscription, MamaMsg msg)
{
// Create a field callback class to display the field contents
ListenerFieldCallback fieldCallback = new ListenerFieldCallback(m_dictionary, m_iterator, m_quietness);
if (m_quietness < 2)
{
Console.WriteLine(subscription.subscSource + "." +
subscription.subscSymbol + " TYPE: " +
msg.getType() + " Status: " +
msg.getStatus());
}
if (m_quietness < 1)
{
if (m_iterator)
{
// Set the iterator to the beginning of the message
msg.begin(ref m_messageIterator);
// Keep going until there are no more fields
MamaMsgField field = m_messageIterator.getField();
while (field != null)
{
// Display the field
fieldCallback.displayField(field, 0);
m_messageIterator++;
// Get the next field
field = m_messageIterator.getField();
}
}
else
{
// Otherwise use the iteration function on the message itself
int indentlevel = 0;
msg.iterateFields(fieldCallback, m_dictionary, indentlevel);
}
}
}
public void onMsg(MamaSubscription subscription, MamaMsg msg)
{
switch (msg.getType())
{
case mamaMsgType.MAMA_MSG_TYPE_INITIAL:
char[] delimiter = { ',' };
string newSymbols = msg.getString(MamaReservedFields.SymbolList.getName(), (ushort)MamaReservedFields.SymbolList.getFid());
string[] parsedSymbols = newSymbols.Split(delimiter);
for (int i = 0; i < parsedSymbols.Length; i++)
{
subjectList.Add((Object)parsedSymbols[i]);
}
Console.WriteLine("Received initial for symbol list subscription. Updating list of symbols to subscribe to.\n");
break;
case mamaMsgType.MAMA_MSG_TYPE_END_OF_INITIALS:
Console.WriteLine("End of initials. Subscribing to symbols.\n");
subscribeToSubjects();
break;
default:
break;
}
}
public void onError(MamaSubscription subscription,
MamaStatus.mamaStatus status,
string subject)
{
Console.WriteLine("Subscription error:" + subject);
}
public void onError(MamaSubscription subscription, MamaStatus.mamaStatus status, string subject)
{
Console.WriteLine("An error occurred creating subscription for " + subject + ": " + status.ToString());
}
public void onQuality(MamaSubscription subscription, mamaQuality quality, string symbol)
{
// You may add your own event handling logic here
}
/*Invoked once the subscrption request has been dispatched from the
* throttle queue.*/
public void onCreate(MamaSubscription subscription)
{
}
public void onGap(MamaSubscription subscription)
{
// You may add your own event handling logic here
}
public void onRecapRequest(MamaSubscription subscription)
{
// You may add your own event handling logic here
}
/// <summary>
/// Subscription callbacks
/// </summary>
/// <param name="args"></param>
////////////////////////////////////////////////////////////////////////////////////
public void onCreate(MamaSubscription subscription)
{
stats.mCreateMsgCount++;
}
public void onError(MamaSubscription subscription,
MamaStatus.mamaStatus status,
string subject)
{
stats.mErrorCount++;
}
public void onRecapRequest(MamaSubscription subscription)
{
Console.WriteLine(subscription.subscSymbol + ": recap requested ");
}
/*Invoked if the quality status for the subscription changes*/
public void onQuality(MamaSubscription subscription, mamaQuality quality, string symbol)
{
Console.WriteLine("Symbol list subscription: quality is now " +
(int)quality);
}
public void onGap(MamaSubscription subscription)
{
Console.WriteLine(subscription.subscSymbol + ": gap detected ");
}
public void onGap(MamaSubscription subscription)
{
Console.WriteLine("Subscription gap");
}
public void onDestroy(MamaSubscription subscription)
{
}
public void onQuality(MamaSubscription subscription, mamaQuality quality, string symbol)
{
Console.WriteLine("Subscription quality:" + (int)quality);
}
public void onRecapRequest(MamaSubscription subscription)
{
Console.WriteLine("Subscription recap request");
}
static void Main(string[] args)
{
// Parse the command line options to override defaults
String middlewareName = "qpid";
String transportName = "sub";
String sourceName = "OM";
String symbolName = null;
String dictionaryFile = "/opt/openmama/data/dictionaries/data.dict";
bool requiresDictionary = true;
bool requiresInitial = true;
if (args.Length == 0)
{
usageAndExit();
}
for (int i = 0; i < args.Length; i++)
{
switch (args[i])
{
case "-B":
requiresDictionary = false;
break;
case "-d":
dictionaryFile = args[++i];
break;
case "-I":
requiresInitial = false;
break;
case "-m":
middlewareName = args[++i];
break;
case "-s":
symbolName = args[++i];
break;
case "-S":
sourceName = args[++i];
break;
case "-t":
transportName = args[++i];
break;
case "-v":
Mama.enableLogging(MamaLogLevel.MAMA_LOG_LEVEL_FINEST);
break;
default:
usageAndExit();
break;
}
}
// Symbol name is mandatory here, so error if it's null
if (symbolName == null)
{
usageAndExit();
}
// Load the requested OpenMAMA middleware bridge (and default payload too)
MamaBridge bridge = Mama.loadBridge(middlewareName);
// Time to initialize OpenMAMA's underlying bridges with an "open"
Mama.open();
// Get default event queue from the bridge for testing
MamaQueue queue = Mama.getDefaultEventQueue(bridge);
// Set up the required transport on the specified bridge
MamaTransport transport = new MamaTransport();
transport.create(transportName, bridge);
// Set up the data dictionary
MamaDictionary dictionary = null;
if (requiresDictionary)
{
dictionary = new MamaDictionary();
dictionary.create(dictionaryFile);
}
// Set up the OpenMAMA source (symbol namespace)
MamaSource source = new MamaSource();
source.symbolNamespace = sourceName;
source.transport = transport;
// Set up the event handlers for OpenMAMA
SubscriptionEventHandler eventHandler = new SubscriptionEventHandler();
eventHandler.mDictionary = dictionary;
// Set up the OpenMAMA Subscription (interest in a topic)
MamaSubscription subscription = new MamaSubscription();
subscription.setRequiresInitial(requiresInitial);
subscription.create(queue, eventHandler, source, symbolName);
// Kick off OpenMAMA now (blocking call, non-blocking call also available)
Mama.start(bridge);
// Clean up connection on termination
Mama.close();
}
