private MamaSubscriberCS(string[] args)
{
try
{
if (parseCommandLine(args))
{
mamaBridge = Mama.loadBridge(middlewareName);
Mama.open();
mamaTransport = new MamaTransport();
mamaTransport.setTransportCallback(this);
mamaTransport.create(transportName, mamaBridge);
mamaDefaultQueue = Mama.getDefaultEventQueue(mamaBridge);
mamaSubscription = new MamaSubscription();
mamaSubscription.createBasic(
mamaTransport,
mamaDefaultQueue,
this, // callback
topicName);
Console.WriteLine("Starting mama...");
Mama.start(mamaBridge);
// Prevent over-enthusiastic GC from reclaiming transport object
GC.KeepAlive(mamaTransport);
}
}
catch (Exception e)
{
Console.WriteLine(e.Message);
}
}
public int Run()
{
ParseArgs();
if (helpNeeded)
{
DisplayUsage();
return 0;
}
Mama.logToFile(@"mama.log", MamaLogLevel.MAMA_LOG_LEVEL_FINEST);
bridge = Mama.loadBridge(middlewareName);
Mama.open();
MamaTransport transport = new MamaTransport();
MamaQueue defaultQueue = Mama.getDefaultEventQueue(bridge);
MamaTimer timer = new MamaTimer();
MamaSubscription subscription = new MamaSubscription();
MamaPublisherCS publisher = this;
transport.create(transportName, bridge);
timer.create(defaultQueue, publisher, interval, null);
subscription.createBasic(transport, defaultQueue, publisher, inboundTopic);
publisher.create(transport, outboundTopic);
msg = new MamaMsg();
Mama.start(bridge);
Mama.close();
return 0;
}
public MamaFtMemberCS()
{
myState = mamaFtState.MAMA_FT_STATE_UNKNOWN;
myTransport = null;
myWeight = 50;
myGroup = null;
}
/// <summary>
/// Create and activate a subscription.
/// Any properties for the subscription should be set prior to
/// calling this method.
/// </summary>
/// <param name="transport"></param>
/// <param name="queue"></param>
/// <param name="source"></param>
/// <param name="symbol"></param>
/// <param name="closure"></param>
public void create(
MamaTransport transport,
MamaQueue queue,
string source,
string symbol,
object closure)
{
setSource(source);
setSymbol(symbol);
setTransport(transport);
setQueue(queue);
setClosure(closure);
activate();
}
/// <summary>
/// </summary>
/// <param name="transport"></param>
/// <param name="queue"></param>
/// <param name="handler"></param>
/// <param name="source"></param>
/// <param name="symbol"></param>
/// <param name="intervalSeconds"></param>
public MamdaOrderBookChecker(
MamaTransport transport,
MamaQueue queue,
MamdaOrderBookCheckerHandler handler,
string source,
string symbol,
double intervalSeconds)
{
mSnapShotmHandler = new SnapShotChecker(this);
mRealTimeSubsc = new MamdaSubscription();
mRealTimeListener = new MamdaOrderBookListener();
mHandler = handler;
mQueue = queue;
mIntervalSecs = intervalSeconds;
mRandomTimerFired = false;
mRealTimeSubsc.setType(mamaSubscriptionType.MAMA_SUBSC_TYPE_BOOK);
mRealTimeSubsc.create(transport, queue, source, symbol, null);
mRealTimeSubsc.addMsgListener(mRealTimeListener);
init();
}
protected void setupFtType(
mamaFtType ftType,
MamaQueue queue,
MamaFtMemberCallback callback,
MamaTransport transport,
string groupName,
uint weight,
double heartbeatInterval,
double timeoutInterval,
object closure)
{
EnsurePeerCreated();
if (callback == null)
{
mCallbackForwarder = null;
mCallback = null;
}
else
{
mCallbackForwarder = new CallbackForwarder(this, callback, closure);
mCallback = new CallbackForwarder.FtMemberCallbackDelegate(mCallbackForwarder.OnFtStateChange);
}
IntPtr queueHandle = queue != null ? queue.NativeHandle : IntPtr.Zero;
IntPtr transportHandle = transport != null ? transport.NativeHandle : IntPtr.Zero;
int code = NativeMethods.mamaFtMember_setup(
nativeHandle,
mamaFtType.MAMA_FT_TYPE_MULTICAST,
queueHandle,
mCallback,
transportHandle,
groupName,
weight,
heartbeatInterval,
timeoutInterval,
null);
CheckResultCode(code);
}
public void onReconnect(MamaTransport transport)
{
Console.WriteLine("Transport Reconnected.");
}
private void createSubscriber (MamaBridge bridge)
{
MamaSubscription mamaSubscription = new MamaSubscription();
MamaTransport mamaTransport = new MamaTransport();
MamaQueue mamaDefaultQueue = Mama.getDefaultEventQueue(bridge);
Dispatcher dispatcher = new Dispatcher(bridge);
mamaTransport = new MamaTransport();
mamaTransport.setTransportCallback(this);
mamaTransport.create(transportName, bridge);
mamaSubscription = new MamaSubscription();
mamaSubscription.createBasic(
mamaTransport,
mamaDefaultQueue,
this, // callback
topicName);
Console.WriteLine("Starting mama...");
mamaSubscriptions.Add(mamaSubscription);
mamaTransports.Add(mamaTransport);
Thread startThread = new Thread (new ThreadStart(dispatcher.dispatch));
startThread.Start();
}
private void parseCommandLine(string[] args)
{
string tport = null;
uint ft_type = (uint)mamaFtType.MAMA_FT_TYPE_MULTICAST;
bool displayVersion = false;
for (int i = 0; i < args.Length; )
{
if ((args[i].CompareTo ("-h")) == 0 ||
(args[i].CompareTo ("-?")) == 0)
{
usage (0);
}
if ((args[i].CompareTo ("-g") == 0) ||
(args[i].CompareTo ("-group") == 0))
{
myGroup = args[i+1];
i += 2;
continue;
}
if ((args[i].CompareTo ("-w") == 0) ||
(args[i].CompareTo ("-weight") == 0))
{
myWeight = Convert.ToUInt32 (args[i+1]);
i += 2;
continue;
}
if (args[i].CompareTo ("-m") == 0)
{
myMiddleware = args[i+1];
i += 2;
continue;
}
if ((args[i].CompareTo ("-t") == 0) ||
(args[i].CompareTo ("-tport") == 0))
{
tport = args[i+1];
i += 2;
continue;
}
if (args[i].CompareTo ("-v") == 0)
{
if (mamaLogLevel == MamaLogLevel.MAMA_LOG_LEVEL_WARN)
{
mamaLogLevel = MamaLogLevel.MAMA_LOG_LEVEL_NORMAL;
Mama.enableLogging (mamaLogLevel);
}
else if (mamaLogLevel == MamaLogLevel.MAMA_LOG_LEVEL_NORMAL)
{
mamaLogLevel = MamaLogLevel.MAMA_LOG_LEVEL_FINE;
Mama.enableLogging (mamaLogLevel);
}
else if (mamaLogLevel == MamaLogLevel.MAMA_LOG_LEVEL_FINE)
{
mamaLogLevel = MamaLogLevel.MAMA_LOG_LEVEL_FINER;
Mama.enableLogging (mamaLogLevel);
}
else
{
mamaLogLevel = MamaLogLevel.MAMA_LOG_LEVEL_FINEST;
Mama.enableLogging (mamaLogLevel);
}
i++;
continue;
}
if (args[i].CompareTo ("-version") == 0)
{
displayVersion = true;
break;
}
if (args[i].CompareTo ("-b") == 0)
{
ft_type = (uint)mamaFtType.MAMA_FT_TYPE_BRIDGE;
i++;
continue;
}
i++;
}
myBridge = Mama.loadBridge(myMiddleware);
Mama.open();
if (displayVersion)
{
Console.WriteLine (Mama.getVersion (myBridge));
Exit (0);
}
myTimer = new MamaTimer();
myTransport = new MamaTransport();
myTransport.create(tport, myBridge);
if (myGroup == null)
{
Console.WriteLine ("No FT group name specified");
usage(1);
}
switch (ft_type)
{
case (uint)mamaFtType.MAMA_FT_TYPE_MULTICAST:
myFtMember = new MamaMulticastFtMember ();
break;
case (uint)mamaFtType.MAMA_FT_TYPE_BRIDGE:
myFtMember = new MamaBridgeFtMember ();
break;
default:
Console.WriteLine ("No FT type specified");
usage(1);
break;
}
}
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 onNamingServiceDisconnect(MamaTransport transport)
{
Console.WriteLine("Transport Naming Service Disconnected.");
}
public void onConnect(MamaTransport transport)
{
Console.WriteLine("Transport Connect");
}
private static void initializeMama()
{
Mama.enableLogging(mamaLogLevel);
try
{
myBridge = Mama.loadBridge (myMiddleware);
/* Always the first API method called. Initialized internal API
* state*/
Mama.open ();
myDefaultQueue = Mama.getDefaultEventQueue (myBridge);
}
catch (Exception e)
{
Console.WriteLine(e.ToString());
Console.WriteLine("Failed to initialize MAMA");
Environment.Exit (1);
}
transport = new MamaTransport ();
/* The name specified here is the name identifying properties in the
* mama.properties file*/
transport.create (transportName, myBridge);
if (myDictTportName != null)
{
myDictTransport = new MamaTransport ();
myDictTransport.create (myDictTportName, myBridge);
}
else
{
myDictTransport = transport;
}
/*MamaSource for all subscriptions*/
mySource = new MamaSource ();
mySource.transport = transport;
mySource.symbolNamespace = mySymbolNamespace;
/*MamaSource for dictionary subscription*/
myDictSource = new MamaSource ();
myDictSource.transport = myDictTransport;
myDictSource.symbolNamespace = dictSource;
}
private void parseCommandLine(string[] args)
{
string tport = null;
uint ft_type = (uint)mamaFtType.MAMA_FT_TYPE_MULTICAST;
bool displayVersion = false;
for (int i = 0; i < args.Length;)
{
if ((args[i].CompareTo("-h")) == 0 ||
(args[i].CompareTo("-?")) == 0)
{
usage(0);
}
if ((args[i].CompareTo("-g") == 0) ||
(args[i].CompareTo("-group") == 0))
{
myGroup = args[i + 1];
i += 2;
continue;
}
if ((args[i].CompareTo("-w") == 0) ||
(args[i].CompareTo("-weight") == 0))
{
myWeight = Convert.ToUInt32(args[i + 1]);
i += 2;
continue;
}
if (args[i].CompareTo("-m") == 0)
{
myMiddleware = args[i + 1];
i += 2;
continue;
}
if ((args[i].CompareTo("-t") == 0) ||
(args[i].CompareTo("-tport") == 0))
{
tport = args[i + 1];
i += 2;
continue;
}
if (args[i].CompareTo("-v") == 0)
{
if (mamaLogLevel == MamaLogLevel.MAMA_LOG_LEVEL_WARN)
{
mamaLogLevel = MamaLogLevel.MAMA_LOG_LEVEL_NORMAL;
Mama.enableLogging(mamaLogLevel);
}
else if (mamaLogLevel == MamaLogLevel.MAMA_LOG_LEVEL_NORMAL)
{
mamaLogLevel = MamaLogLevel.MAMA_LOG_LEVEL_FINE;
Mama.enableLogging(mamaLogLevel);
}
else if (mamaLogLevel == MamaLogLevel.MAMA_LOG_LEVEL_FINE)
{
mamaLogLevel = MamaLogLevel.MAMA_LOG_LEVEL_FINER;
Mama.enableLogging(mamaLogLevel);
}
else
{
mamaLogLevel = MamaLogLevel.MAMA_LOG_LEVEL_FINEST;
Mama.enableLogging(mamaLogLevel);
}
i++;
continue;
}
if (args[i].CompareTo("-version") == 0)
{
displayVersion = true;
break;
}
if (args[i].CompareTo("-b") == 0)
{
ft_type = (uint)mamaFtType.MAMA_FT_TYPE_BRIDGE;
i++;
continue;
}
i++;
}
myBridge = Mama.loadBridge(myMiddleware);
Mama.open();
if (displayVersion)
{
Console.WriteLine(Mama.getVersion(myBridge));
Exit(0);
}
myTimer = new MamaTimer();
myTransport = new MamaTransport();
myTransport.create(tport, myBridge);
if (myGroup == null)
{
Console.WriteLine("No FT group name specified");
usage(1);
}
switch (ft_type)
{
case (uint)mamaFtType.MAMA_FT_TYPE_MULTICAST:
myFtMember = new MamaMulticastFtMember();
break;
case (uint)mamaFtType.MAMA_FT_TYPE_BRIDGE:
myFtMember = new MamaBridgeFtMember();
break;
default:
Console.WriteLine("No FT type specified");
usage(1);
break;
}
}
public CallbackForwarderSymbolMap(MamaTransport sender, MamaSymbolMapCallback callback, object closure)
{
mCallback = callback;
mClosure = closure;
}
public CallbackForwarder(MamaTransport target, MamaTransportCallback callback)
{
this.mTarget = target;
this.mCallback = callback;
}
/// <summary>
/// This function will create the basic subscription without marketdata semantics.
/// This overload provides access to the basic subscription with the MamaSubscriptionCallback rather than the
/// MamaBasicSubscriptionCallback interface.
/// Instantiating the base class directly will provide better performance.
/// </summary>
/// <param name="transport">
/// The MamaTransport.
/// </param>
/// <param name="queue">
/// The MamaQueue.
/// </param>
/// <param name="callback">
/// Provide callback function implementations to be informed of events on the subscription.
/// </param>
/// <param name="symbol">
/// The symbol to subscribe to.
/// </param>
/// <param name="closure">
/// The closure that will be passed back with the callback functions.
/// </param>
public void createBasic(MamaTransport transport, MamaQueue queue, MamaSubscriptionCallback callback, string symbol, object closure)
{
// Call the base class using the adapter to convert between the callback types
base.createBasic(transport, queue, new MamaBasicCallbackAdapter(callback), symbol, closure);
}
/// <summary>
/// This function will create the basic subscription without marketdata semantics.
/// To pass a closure use the overload.
/// This overload provides access to the basic subscription with the MamaSubscriptionCallback rather than the
/// MamaBasicSubscriptionCallback interface.
/// Instantiating the base class directly will provide better performance.
/// </summary>
/// <param name="transport">
/// The MamaTransport.
/// </param>
/// <param name="queue">
/// The MamaQueue.
/// </param>
/// <param name="callback">
/// Provide callback function implementations to be informed of events on the subscription.
/// </param>
/// <param name="symbol">
/// The symbol to subscribe to.
/// </param>
public void createBasic(MamaTransport transport, MamaQueue queue, MamaSubscriptionCallback callback, string symbol)
{
// Call the overload
createBasic(transport, queue, callback, symbol, null);
}
public void onConnect(MamaTransport transport)
{
Console.WriteLine("Transport Connect");
}
public void setup(
MamaQueue queue,
MamaFtMemberCallback callback,
MamaTransport transport,
string groupName,
uint weight,
double heartbeatInterval,
double timeoutInterval,
object closure)
{
setupFtType (
mamaFtType.MAMA_FT_TYPE_MULTICAST,
queue,
callback,
transport,
groupName,
weight,
heartbeatInterval,
timeoutInterval,
closure);
}
public CallbackForwarderSymbolMap(MamaTransport sender, MamaSymbolMapCallback callback, object closure)
{
mCallback = callback;
mClosure = closure;
}
/// <summary>
/// This function will clean up all the objects initialised before Mama.start is called.
/// </summary>
private void uninitializeMama()
{
if (m_source != null)
{
m_source.destroy();
m_source = null;
}
if (m_dictionary != null)
{
m_dictionary.Dispose();
m_dictionary = null;
}
if (m_queueGroup != null)
{
m_queueGroup.destroyWait();
m_queueGroup = null;
}
if (m_transport != null)
{
m_transport.destroy();
m_transport = null;
}
Mama.close();
}
public TopicCallbackForwarder(MamaTransport target, MamaTransportTopicCallback callback)
{
this.mTarget = target;
this.mCallback = callback;
}
/// <summary>
/// Set the MAMA transport. Do this before calling activate().
/// </summary>
/// <param name="transport"></param>
public void setTransport(MamaTransport transport)
{
mTransport = transport;
}
private void InitializeMama()
{
try
{
Mama.logToFile(@"mama.log", MamaLogLevel.MAMA_LOG_LEVEL_FINEST);
bridge = new MamaBridge(middlewareName);
Mama.open();
transport = new MamaTransport();
transport.create(transportName, bridge);
defaultQueue = Mama.getDefaultEventQueue(bridge);
}
catch (MamaException e)
{
Console.WriteLine("Error initializing mama or creating transport: {0}", e.ToString());
Exit(1);
}
}
public static void Main(string[] args)
{
MamaTransport transport = null;
MamaQueue defaultQueue = null;
MamaDictionary dictionary = null;
CommandLineProcessor options = new CommandLineProcessor(args);
double throttleRate = options.getThrottleRate();
if (options.hasLogLevel())
{
logLevel_ = options.getLogLevel();
Mama.enableLogging(logLevel_);
}
if ((throttleRate > 100.0) || (throttleRate <= 0.0))
{
throttleRate = 100.0;
}
try
{
// Initialize MAMDA
myBridge = new MamaBridge(options.getMiddleware());
Mama.open();
transport = new MamaTransport();
transport.create(options.getTransport(), myBridge);
defaultQueue = Mama.getDefaultEventQueue(myBridge);
//Get the Data dictionary.....
MamaSource dictionarySource = new MamaSource();
dictionarySource.symbolNamespace = options.getDictSource();
dictionarySource.transport = transport;
dictionary = buildDataDictionary(transport, defaultQueue, dictionarySource);
//Initialise the dictionary and fields
MamdaCommonFields.setDictionary(dictionary, null);
MamdaQuoteFields.setDictionary(dictionary, null);
MamdaTradeFields.setDictionary(dictionary, null);
foreach (string symbol in options.getSymbolList())
{
MamdaSubscription aSubscription = new MamdaSubscription();
aSubscription.setType(mamaSubscriptionType.MAMA_SUBSC_TYPE_GROUP);
aSubscription.create(
transport,
defaultQueue,
options.getSource(),
symbol,
null);
/* For each subscription a MamdaMultiParticipantManager is
* added as the message listener. The callbacks on the
* MamdaMultiPartHandler will be invokes as new group members
* become available.*/
MamdaMultiParticipantManager multiPartManager =
new MamdaMultiParticipantManager(symbol);
multiPartManager.addHandler(new MultiPartHandler());
aSubscription.addMsgListener(multiPartManager);
aSubscription.activate();
mamdaSubscriptions.Add(aSubscription);
}
Mama.start(myBridge);
GC.KeepAlive(dictionary);
Console.WriteLine("Press ENTER or Ctrl-C to quit...");
Console.ReadLine();
}
catch (Exception e)
{
Console.WriteLine(e.ToString());
Environment.Exit(1);
}
}
/// <summary>
/// Create a mama publisher for the corresponding transport. If the transport
/// is a marketdata transport, as opposed to a "basic" transport, the topic
/// corresponds to the symbol. For a basic transport, the source and root get
/// ignored.
/// </summary>
/// <param name="transport">The transport.</param>
/// <param name="topic">Symbol on which to publish.</param>
/// <param name="source">The source for market data publishers. (e.g. source.symbol)</param>
/// <param name="root">The root for market data publishers. Used internally.</param>
public void create(
MamaTransport transport,
string topic,
string source,
string root)
{
#if MAMA_WRAPPERS_CHECK_ARGUMENTS
if (transport == null)
{
throw new ArgumentNullException("transport");
}
if (topic == null)
{
throw new ArgumentNullException("topic");
}
if (nativeHandle != IntPtr.Zero)
{
throw new InvalidOperationException("MamaPublisher already created");
}
#endif // MAMA_WRAPPERS_CHECK_ARGUMENTS
int code = NativeMethods.mamaPublisher_create(ref nativeHandle, transport.NativeHandle, topic, source, root);
CheckResultCode(code);
GC.KeepAlive(transport);
}
/// <summary>
/// Create a mama publisher for the corresponding transport. If the transport
/// is a marketdata transport, as opposed to a "basic" transport, the topic
/// corresponds to the symbol. For a basic transport, the source and root get
/// ignored.
/// </summary>
/// <param name="transport">The transport.</param>
/// <param name="topic">Symbol on which to publish.</param>
public void create(
MamaTransport transport,
string topic)
{
create(transport, topic, null, null);
}
public int Run()
{
ParseArgs();
if (helpNeeded)
{
DisplayUsage();
return 0;
}
Mama.logToFile(@"mama.log", MamaLogLevel.MAMA_LOG_LEVEL_NORMAL);
bridge = Mama.loadBridge(middlewareName);
Mama.open();
MamaQueue defaultQueue = Mama.getDefaultEventQueue(bridge);
msg = new MamaMsg();
MamaTimer timer = new MamaTimer();
timer.create(defaultQueue, this, interval, null);
queueGroup = new MamaQueueGroup(bridge, 1);
MamaTransport transport = new MamaTransport();
transport.create(transportName, bridge);
MamaSubscription subscription = null;
if (nosub == false)
{
subscription = new MamaSubscription();
subscription.createBasic(transport, defaultQueue, this, inboundTopic);
}
publisher = new MamaPublisher();
if (pubCb)
{
publisher.createWithCallbacks(transport, queueGroup.getNextQueue(), this, null, outboundTopic, null, null);
}
else
{
publisher.create(transport, outboundTopic);
}
Mama.start(bridge);
Mama.close();
return 0;
}
/// <summary>
/// Create a mama publisher for the corresponding transport. If the transport
/// is a marketdata transport, as opposed to a "basic" transport, the topic
/// corresponds to the symbol. For a basic transport, the source and root get
/// ignored.
/// </summary>
/// <param name="transport">The transport.</param>
/// <param name="topic">Symbol on which to publish.</param>
/// <param name="source">The source for market data publishers. (e.g. source.symbol)</param>
public void create(
MamaTransport transport,
string topic,
string source)
{
create(transport, topic, source, null);
}
/// <summary>
/// Set the MAMA transport. Do this before calling activate().
/// </summary>
/// <param name="transport"></param>
public void setTransport(MamaTransport transport)
{
mTransport = transport;
}
/// <summary>
/// Create a mama publisher for the corresponding transport. If the transport
/// is a marketdata transport, as opposed to a "basic" transport, the topic
/// corresponds to the symbol. For a basic transport, the source and root get
/// ignored.
/// </summary>
/// <param name="transport">The transport.</param>
/// <param name="topic">Symbol on which to publish.</param>
public void create(
MamaTransport transport,
string topic)
{
create(transport, topic, null, null);
}
/// <summary>
/// Creates an inbox and stores at the address specified by the calling client.
/// </summary>
/// <param name="transport">
/// The mamaTransport being used.
/// </param>
/// <param name="queue">
/// Optional mamaQueue. Will use default queue if null.
/// </param>
/// <param name="callback">
/// A callback interface invoked in response to a p2p message being received or when an error is
/// encountered during p2p messaging.
/// </param>
public void create(MamaTransport transport, MamaQueue queue, MamaInboxCallback callback)
{
create(transport, queue, callback, null);
}
private void initializeMama()
{
mamaBridge = Mama.loadBridge(mamaMiddlewareName);
Console.WriteLine(Mama.getVersion(mamaBridge));
Mama.open();
if (mamaHighWaterMark > 0 || mamaLowWaterMark > 0)
{
if (mamaHighWaterMark > 0)
{
Mama.setDefaultQueueHighWatermark(mamaHighWaterMark);
}
if (mamaLowWaterMark > 0)
{
try
{
Mama.setDefaultQueueLowWatermark(mamaLowWaterMark);
}
catch (Exception e)
{
Console.WriteLine("Could not set default queue low water mark MamaStatus: " + e);
}
}
}
// create the transport
mamaTransport = new MamaTransport();
mamaTransport.setTransportCallback(this);
// the default throttle rate is 500 msg/sec
if (mamaThrottle != -1)
{
mamaTransport.setOutboundThrottle(MamaTransport.MamaThrottleInstance.MAMA_THROTTLE_DEFAULT, mamaThrottle);
}
// the default recap throttle rate is 250 msg/sec
if (mamaRecapThrottle != -1)
{
mamaTransport.setOutboundThrottle(MamaTransport.MamaThrottleInstance.MAMA_THROTTLE_RECAP, mamaRecapThrottle);
}
mamaTransport.create(mamaTransportName, mamaBridge);
// create default queue and, if required, queue group
createQueues();
mamaDictionarySource = new MamaSource();
mamaDictionarySource.symbolNamespace = mamaDictionarySourceName;
mamaDictionarySource.transport = mamaTransport;
// download dictionary
mamaDictionary = new MamaDictionary();
mamaDictionary.create(
mamaDefaultQueue,
this,
mamaDictionarySource,
3,
10.0f);
loadSymbolMap();
Mama.start(mamaBridge);
if (!dictionaryComplete)
{
throw new Exception("Can't create dictionary.");
}
}
/// <summary>
/// Creates an inbox and stores at the address specified by the calling client.
/// Uses a default queue.
/// This functionality is no longer supported.
/// </summary>
/// <param name="transport">
/// The mamaTransport being used.
/// </param>
/// <param name="callback">
/// A callback interface invoked in response to a p2p message being received or hen an error is
/// encountered during p2p messaging.
/// </param>
/// <param name="closure">
/// User supplied data.
/// </param>
public void create(MamaTransport transport, MamaInboxCallback callback, object closure)
{
throw new NotSupportedException("This function is no longer supported, use an overload that takes a MamaQueue object.");
}
public void onQuality(MamaTransport transport)
{
Console.WriteLine("Transport Quality.");
}
public void onPublisherDisconnect(MamaTransport transport)
{
Console.WriteLine("Transport Publisher disconnected.");
}
public void onAcceptReconnect(MamaTransport transport)
{
Console.WriteLine("Transport Accept Reconnect.");
}
public void onReconnect(MamaTransport transport)
{
Console.WriteLine("Transport Reconnected.");
}
public void onNamingServiceDisconnect(MamaTransport transport)
{
Console.WriteLine("Transport Naming Service Disconnected.");
}
/// <summary>
/// Create a mama publisher for the corresponding transport. If the transport
/// is a marketdata transport, as opposed to a "basic" transport, the topic
/// corresponds to the symbol. For a basic transport, the source and root get
/// ignored.
/// </summary>
/// <param name="transport">The transport.</param>
/// <param name="topic">Symbol on which to publish.</param>
/// <param name="source">The source for market data publishers. (e.g. source.symbol)</param>
/// <param name="root">The root for market data publishers. Used internally.</param>
public void createWithCallbacks(
MamaTransport transport,
MamaQueue queue,
MamaPublisherCallback callback,
Object closure,
string topic,
string source,
string root)
{
#if MAMA_WRAPPERS_CHECK_ARGUMENTS
if (transport == null)
{
throw new ArgumentNullException("transport");
}
if (topic == null)
{
throw new ArgumentNullException("topic");
}
if (queue == null)
{
throw new ArgumentNullException("queue");
}
if (callback == null)
{
throw new ArgumentNullException("callback");
}
if (nativeHandle != IntPtr.Zero)
{
throw new InvalidOperationException("MamaPublisher already created");
}
#endif // MAMA_WRAPPERS_CHECK_ARGUMENTS
mCallback = callback;
GCHandle handle = GCHandle.Alloc(this);
int code = NativeMethods.mamaPublisher_createWithCallbacks(
ref nativeHandle,
transport.NativeHandle,
queue.NativeHandle,
topic, source, root,
ref mCallbackDelegates,
(IntPtr)handle);
CheckResultCode(code);
GC.KeepAlive(transport);
GC.KeepAlive(queue);
GC.KeepAlive(callback);
}
public void onQuality(MamaTransport transport)
{
Console.WriteLine("Transport Quality.");
}
/// <summary>
/// Get the MamaTransport.
/// The result contains the reusable MamaTransport object of the
/// nativeHandle object. Applications calling this method will receive the same
/// reusable object for repeated calls on same nativeHandle object.
/// </summary>
public MamaTransport getTransport()
{
EnsurePeerCreated();
IntPtr transport = IntPtr.Zero;
int code = NativeMethods.mamaPublisher_getTransport(nativeHandle, ref transport);
CheckResultCode(code);
if (mReusableTransport == null)
{
mReusableTransport = new MamaTransport (transport);
}
else
{
mReusableTransport.setNativeHandle(transport);
}
return mReusableTransport;
}
public void onAcceptReconnect(MamaTransport transport)
{
Console.WriteLine("Transport Accept Reconnect.");
}
public void onPublisherDisconnect(MamaTransport transport)
{
Console.WriteLine("Transport Publisher disconnected.");
}
