public void setup()
{
sessionID = new QuickFix.SessionID("FIX.4.2", "SENDERCOMP", "TARGETCOMP");
Wipe();
QuickFix.Dictionary config = new QuickFix.Dictionary();
config.SetString(QuickFix.SessionSettings.CONNECTION_TYPE, "initiator");
config.SetString(QuickFix.SessionSettings.DATABASE_STORE_CONNECTION_STRING, connectionString);
settings = new QuickFix.SessionSettings();
settings.Set(sessionID, config);
factory = new QuickFix.DatabaseStoreFactory(settings);
settings.Set(config);
store = (QuickFix.DatabaseStore)factory.Create(sessionID, new NullLog());
}
/// <summary>
/// Add new session, either at start-up or as an ad-hoc operation
/// </summary>
/// <param name="sessionID">ID of new session<param>
/// <param name="dict">config settings for new session</param></param>
/// <returns>true if session added successfully, false if session already exists or is not an initiator</returns>
public bool AddSession(SessionID sessionID, Dictionary dict)
{
if (dict.GetString(SessionSettings.CONNECTION_TYPE) == "initiator" && !sessionIDs_.Contains(sessionID))
{
Session session = sessionFactory_.Create(sessionID, dict);
lock (sync_)
{
if (!_settings.Has(sessionID)) // session won't be in settings if ad-hoc creation after startup
{
_settings.Set(sessionID, dict);
}
sessionIDs_.Add(sessionID);
sessions_[sessionID] = session;
SetDisconnected(sessionID);
}
return(true);
}
return(false);
}
/// <summary>
/// Add new session as an ad-hoc (dynamic) operation
/// </summary>
/// <param name="sessionID">ID of new session</param>
/// <param name="dict">config settings for new session</param>
/// <returns>true if session added successfully, false if session already exists or is not an initiator</returns>
public bool AddSession(SessionID sessionID, Dictionary dict)
{
lock (_settings)
if (!_settings.Has(sessionID)) // session won't be in settings if ad-hoc creation after startup
{
_settings.Set(sessionID, dict); // need to to this here to merge in default config settings
}
else
{
return(false);
} // session already exists
if (CreateSession(sessionID, dict))
{
return(true);
}
lock (_settings) // failed to create new session
_settings.Remove(sessionID);
return(false);
}
/// <summary>
/// Add new session as an ad-oc (dynamic) operation
/// </summary>
/// <param name="sessionID">ID of new session<param>
/// <param name="dict">config settings for new session</param></param>
/// <returns>true if session added successfully, false if session already exists or is not an acceptor</returns>
public bool AddSession(SessionID sessionID, Dictionary dict)
{
lock (GdaxPrototyping.Common.Core.Threading.TThreadingHelpers.MainLockable)
if (!settings_.Has(sessionID)) // session won't be in settings if ad-hoc creation after startup
{
settings_.Set(sessionID, dict); // need to to this here to merge in default config settings
}
else
{
return(false);
} // session already exists
if (CreateSession(sessionID, dict))
{
return(true);
}
lock (GdaxPrototyping.Common.Core.Threading.TThreadingHelpers.MainLockable) // failed to create session, so remove from settings
settings_.Remove(sessionID);
return(false);
}
public FixInitiator(MarketIncrementalProcessor mktIncProc, ChannelUMDFConfig channelUmdfConfig, string templateFile, Queue <UdpPacket> qUdpPkt, Object replayLockObject)
{
logger = LogManager.GetLogger("FixInitiator-" + channelUmdfConfig.ChannelID);
MDSUtils.AddAppender("FixInitiator-" + channelUmdfConfig.ChannelID, logger.Logger);
XMLMessageTemplateLoader loader = new XMLMessageTemplateLoader();
registry = UmdfUtils.loadTemplates(templateFile);
context = new Context();
context.TemplateRegistry = registry;
_mktIncProc = mktIncProc;
_channelUmdfConfig = channelUmdfConfig;
if (!listaChannelQueues.ContainsKey(channelUmdfConfig.ChannelID))
{
listaChannelQueues.Add(channelUmdfConfig.ChannelID, new ListChannelQueues(qUdpPkt, replayLockObject));
}
logger.Info("Start(): iniciando sessao FIX...");
try
{
// Cria sessao FIX
_session = new QuickFix.SessionID(
_channelUmdfConfig.TCPConfig.BeginString,
_channelUmdfConfig.TCPReplayConfig.SenderCompID,
_channelUmdfConfig.TCPReplayConfig.SubID,
_channelUmdfConfig.TCPReplayConfig.TargetCompID,
_channelUmdfConfig.TCPReplayConfig.SubID);
// Cria dicionario da configuracao
QuickFix.Dictionary mainDic = new QuickFix.Dictionary();
mainDic.SetLong("SocketConnectPort", _channelUmdfConfig.TCPReplayConfig.SocketConnectPort);
mainDic.SetLong("HeartBtInt", _channelUmdfConfig.TCPConfig.HeartBtInt);
mainDic.SetLong("ReconnectInterval", _channelUmdfConfig.TCPConfig.ReconnectInterval);
mainDic.SetBool("ResetOnLogon", _channelUmdfConfig.TCPConfig.ResetOnLogon);
mainDic.SetBool("ResetOnLogout", _channelUmdfConfig.TCPConfig.ResetOnLogout);
mainDic.SetBool("ResetOnDisconnect", _channelUmdfConfig.TCPConfig.ResetOnDisconnect);
mainDic.SetBool("PersistMessages", _channelUmdfConfig.TCPConfig.PersistMessages);
mainDic.SetString("ConnectionType", _channelUmdfConfig.TCPConfig.ConnectionType);
mainDic.SetString("SocketConnectHost", _channelUmdfConfig.TCPReplayConfig.SocketConnectHost);
mainDic.SetString("FileStorePath", _channelUmdfConfig.TCPConfig.FileStorePath);
mainDic.SetString("FileLogPath", _channelUmdfConfig.TCPConfig.FileLogPath);
mainDic.SetString("StartTime", _channelUmdfConfig.TCPReplayConfig.StartTime);
mainDic.SetString("EndTime", _channelUmdfConfig.TCPReplayConfig.EndTime);
QuickFix.Dictionary sessDic = new QuickFix.Dictionary();
sessDic.SetString("BeginString", _channelUmdfConfig.TCPConfig.BeginString);
sessDic.SetString("SenderCompID", _channelUmdfConfig.TCPReplayConfig.SenderCompID);
sessDic.SetString("SenderSubID", _channelUmdfConfig.TCPReplayConfig.SubID);
sessDic.SetString("TargetCompID", _channelUmdfConfig.TCPReplayConfig.TargetCompID);
sessDic.SetString("TargetSubID", _channelUmdfConfig.TCPReplayConfig.SubID);
sessDic.SetString("DataDictionary", _channelUmdfConfig.TCPConfig.DataDictionary);
sessDic.SetBool("UseDataDictionary", true);
// Configure the session settings
QuickFix.SessionSettings settings = new QuickFix.SessionSettings();
settings.Set(mainDic);
settings.Set(_session, sessDic);
MemoryStoreFactory store = new MemoryStoreFactory();
FileLogFactory log = new FileLogFactory(settings);
IMessageFactory message = new DefaultMessageFactory();
// Cria o socket
_initiator = new QuickFix.Transport.SocketInitiator(this, store, settings, log, message);
_initiator.Start();
}
catch (Exception ex)
{
logger.Error("Start():" + ex.Message, ex);
}
logger.Info("Start(): Sessao FIX iniciado!");
}
public FixServerAcceptor(
TCPReplayConfig tcpReplayConfig,
Dictionary <string, SessionID> dctSessionsFixClients,
Dictionary <string, SessionID> dctSessionsFixChannels)
{
_tcpReplayConfig = tcpReplayConfig;
_dctSessionsFixClients = dctSessionsFixClients;
_dctSessionsFixChannels = dctSessionsFixChannels;
logger = LogManager.GetLogger("FixServerAcceptor");
MDSUtils.AddAppender("FixServerAcceptor", logger.Logger);
XMLMessageTemplateLoader loader = new XMLMessageTemplateLoader();
registry = UmdfUtils.loadTemplates(tcpReplayConfig.TemplateFile);
context = new Context();
context.TemplateRegistry = registry;
try
{
// Cria dicionario da configuracao
QuickFix.Dictionary mainDic = new QuickFix.Dictionary();
mainDic.SetLong("SocketAcceptPort", tcpReplayConfig.SocketAcceptPort);
mainDic.SetBool("ResetOnLogon", tcpReplayConfig.ResetOnLogon);
mainDic.SetBool("ResetOnDisconnect", tcpReplayConfig.ResetOnDisconnect);
mainDic.SetBool("PersistMessages", tcpReplayConfig.PersistMessages);
mainDic.SetString("ConnectionType", tcpReplayConfig.ConnectionType);
mainDic.SetString("FileStorePath", tcpReplayConfig.FileStorePath);
mainDic.SetString("FileLogPath", tcpReplayConfig.FileLogPath);
mainDic.SetString("StartTime", tcpReplayConfig.StartTime);
mainDic.SetString("EndTime", tcpReplayConfig.EndTime);
QuickFix.Dictionary sessDic = new QuickFix.Dictionary();
sessDic.SetString("BeginString", tcpReplayConfig.BeginString);
sessDic.SetString("SenderCompID", tcpReplayConfig.SenderCompID);
sessDic.SetString("TargetCompID", tcpReplayConfig.TargetCompID);
sessDic.SetString("DataDictionary", tcpReplayConfig.DataDictionary);
sessDic.SetBool("UseDataDictionary", true);
// Configure the session settings
QuickFix.SessionSettings settings = new QuickFix.SessionSettings();
settings.Set(mainDic);
MemoryStoreFactory store = new MemoryStoreFactory();
FileLogFactory log = new FileLogFactory(settings);
IMessageFactory message = new DefaultMessageFactory();
IEnumerable <int> rangeSenderSubID = Enumerable.Range(
tcpReplayConfig.SubIDStartSeq,
tcpReplayConfig.SubIDEndSeq);
foreach (int item in rangeSenderSubID)
{
string subID = tcpReplayConfig.SubIDPrefix + item.ToString("D3");
// Cria sessao FIX
SessionID sessionID = new QuickFix.SessionID(
tcpReplayConfig.BeginString,
tcpReplayConfig.SenderCompID,
subID,
tcpReplayConfig.TargetCompID,
subID);
sessDic.SetString("SenderSubID", subID);
sessDic.SetString("TargetSubID", subID);
settings.Set(sessionID, sessDic);
}
logger.InfoFormat("Start(): iniciando FIX ACCEPTOR na porta {0}...", tcpReplayConfig.SocketAcceptPort);
_acceptor = new ThreadedSocketAcceptor(this, store, settings, log, message);
_acceptor.Start();
}
catch (Exception ex)
{
logger.Error("Start():" + ex.Message, ex);
}
logger.Info("Start(): Sessao FIX iniciada!");
}
public FixServerInitiator(
string channelsID,
TCPReplayConfig tcpReplayConfig,
Dictionary <string, SessionID> dctSessionsFixClients,
Dictionary <string, SessionID> dctSessionsFixChannels)
{
_tcpReplayConfig = tcpReplayConfig;
_dctSessionsFixClients = dctSessionsFixClients;
_dctSessionsFixChannels = dctSessionsFixChannels;
logger = LogManager.GetLogger("FixServerInitiator-" + tcpReplayConfig.ChannelID);
MDSUtils.AddAppender("FixServerInitiator-" + tcpReplayConfig.ChannelID, logger.Logger);
XMLMessageTemplateLoader loader = new XMLMessageTemplateLoader();
registry = UmdfUtils.loadTemplates(tcpReplayConfig.TemplateFile);
context = new Context();
context.TemplateRegistry = registry;
try
{
// Cria dicionario da configuracao
QuickFix.Dictionary mainDic = new QuickFix.Dictionary();
mainDic.SetString("SocketConnectHost", tcpReplayConfig.SocketConnectHost);
mainDic.SetLong("SocketConnectPort", tcpReplayConfig.SocketConnectPort);
if (!String.IsNullOrEmpty(tcpReplayConfig.SocketConnectHost1))
{
mainDic.SetString("SocketConnectHost1", tcpReplayConfig.SocketConnectHost1);
mainDic.SetLong("SocketConnectPort1", tcpReplayConfig.SocketConnectPort1);
}
mainDic.SetLong("HeartBtInt", tcpReplayConfig.HeartBtInt);
mainDic.SetLong("ReconnectInterval", tcpReplayConfig.ReconnectInterval);
mainDic.SetBool("ResetOnLogon", tcpReplayConfig.ResetOnLogon);
mainDic.SetBool("PersistMessages", tcpReplayConfig.PersistMessages);
mainDic.SetString("ConnectionType", tcpReplayConfig.ConnectionType);
mainDic.SetString("FileStorePath", tcpReplayConfig.FileStorePath);
mainDic.SetString("FileLogPath", tcpReplayConfig.FileLogPath);
mainDic.SetString("StartTime", tcpReplayConfig.StartTime);
mainDic.SetString("EndTime", tcpReplayConfig.EndTime);
QuickFix.Dictionary sessDic = new QuickFix.Dictionary();
sessDic.SetString("BeginString", tcpReplayConfig.BeginString);
sessDic.SetString("SenderCompID", tcpReplayConfig.SenderCompID);
sessDic.SetString("TargetCompID", tcpReplayConfig.TargetCompID);
sessDic.SetString("DataDictionary", tcpReplayConfig.DataDictionary);
sessDic.SetBool("UseDataDictionary", true);
// Configure the session settings
QuickFix.SessionSettings settings = new QuickFix.SessionSettings();
settings.Set(mainDic);
MemoryStoreFactory store = new MemoryStoreFactory();
FileLogFactory log = new FileLogFactory(settings);
IMessageFactory message = new DefaultMessageFactory();
// Cria sessao FIX
_sessionID = new QuickFix.SessionID(
tcpReplayConfig.BeginString,
tcpReplayConfig.SenderCompID,
tcpReplayConfig.TargetCompID);
settings.Set(_sessionID, sessDic);
string[] quebraChannelsID = channelsID.Split(",".ToCharArray());
foreach (string channel in quebraChannelsID)
{
dctSessionsFixChannels.Add(channel, _sessionID);
}
logger.InfoFormat("Start(): iniciando FIX com sessionID[{0}]...", _sessionID.ToString());
_initiator = new QuickFix.Transport.SocketInitiator(this, store, settings, log, message);
_initiator.Start();
}
catch (Exception ex)
{
logger.Error("Start():" + ex.Message, ex);
}
logger.Info("Start(): Sessao FIX iniciada!");
}
public void Validate()
{
SessionSettings settings = new SessionSettings();
SessionID sessionID = new SessionID("FIX.4.2", "SenderCompID", "TargetCompID");
// ConnectionType not set
QuickFix.Dictionary dictionary = new QuickFix.Dictionary();
Assert.Throws<ConfigError>(delegate { settings.Set(sessionID, dictionary); });
// ConnectionType set to invalid value
dictionary.SetString(SessionSettings.CONNECTION_TYPE, "badvalue");
Assert.Throws<ConfigError>(delegate { settings.Set(sessionID, dictionary); });
// ConnectionType set to valid value
dictionary.SetString(SessionSettings.CONNECTION_TYPE, "initiator");
Assert.DoesNotThrow(delegate { settings.Set(sessionID, dictionary); });
// Invalid BeginString
sessionID = new SessionID("FIX4.2", "SenderCompID", "TargetCompID");
Assert.Throws<ConfigError>(delegate { settings.Set(sessionID, dictionary); });
}
public void ThreadSafeSetAndGet()
{
//Set up store
if (System.IO.Directory.Exists("store")) {
System.IO.Directory.Delete("store", true);
}
SessionID sessionId = new SessionID("FIX.4.2", "SENDERCOMP", "TARGETCOMP");
Dictionary config = new Dictionary();
config.SetString(SessionSettings.CONNECTION_TYPE, "initiator");
config.SetString(SessionSettings.FILE_STORE_PATH, "store");
SessionSettings settings = new SessionSettings();
settings.Set(sessionId, config);
FileStoreFactory factory = new FileStoreFactory(settings);
FileStore store = (FileStore)factory.Create(sessionId);
NullLog log = new NullLog();
//Set up sessionstate
SessionState state = new SessionState(log, 1) {MessageStore = store};
Hashtable errorsTable = Hashtable.Synchronized(new Hashtable());//used in more than 1 thread at a time
Hashtable setTable = new Hashtable(1000);//only used in 1 thread at a time
Hashtable getTable = new Hashtable(1000);//only used in 1 thread at a time
//Synchronously populate 1000 messages
for (int i = 1; i < 1000; i++) {
string msg = "msg" + i;
state.Set(i, msg);
setTable[i] = msg;
}
//Simulate background sending of messages that populate into the store
AutoResetEvent setEvent = new AutoResetEvent(false);
ThreadPool.QueueUserWorkItem(delegate(object stateObject) {
AutoResetEvent internalSetEvent = (AutoResetEvent)((object[])stateObject)[0];
SessionState internalState = (SessionState)((object[])stateObject)[1];
for (int i = 1001; i < 2000; i++) {
try {
internalState.Set(i, "msg" + i);
}
catch (System.IO.IOException ex) {
errorsTable[ex.Message] = ex;
}
}
internalSetEvent.Set();
}
, new object[] { setEvent, state });
//Simulate background reading of messages from the store - like is done in a resend request answer
AutoResetEvent getEvent = new AutoResetEvent(false);
ThreadPool.QueueUserWorkItem(delegate(object stateObject){
AutoResetEvent internalGetEvent = (AutoResetEvent)((object[])stateObject)[0];
SessionState internalState = (SessionState)((object[])stateObject)[1];
for (int i = 1; i < 1000; i++) {
try {
List<string> lst = new List<string>(1);
internalState.Get(i, i, lst);
if (lst.Count == 0) {
getTable[i] = "nothing read";
}
else {
getTable[i] = lst[0];
}
}
catch (System.IO.IOException ex) {
errorsTable[ex.Message] = ex;
}
}
internalGetEvent.Set();
}
, new object[]{getEvent, state});
//wait till done and assert results
Assert.True(setEvent.WaitOne(10000), "Get or Set hung/timed out during concurrent usage");
Assert.True(getEvent.WaitOne(10000), "Get or Set hung/timed out during concurrent usage");
Assert.AreEqual(setTable, getTable, "Garbled data read in concurrent set and get (like between resendrequest and send)");
Assert.AreEqual(errorsTable.Count, 0, "IOException occured in concurrent set and get (like between resendrequest and send)");
//Tear down filestore
state.Dispose();
store.Dispose();
}
public ChannelTcpConflated(TCPConflatedConfig conflatedConfig)
{
logger = LogManager.GetLogger("ChannelTcpConflated-" + conflatedConfig.ChannelID);
MDSUtils.AddAppender("ChannelTcpConflated-" + conflatedConfig.ChannelID, logger.Logger);
_bKeepRunning = true;
machineGun = new MachineGunFixSplitter();
machineGun.UnderFIXMessageFire += new FIXMachineGunEventHandler(machineGun_UnderFIXMessageFire);
machineGun.Start();
thQueueProc = new Thread(new ThreadStart(queueProc));
thQueueProc.Start();
thSplitProc = new Thread(new ThreadStart(splitterThreadWork));
thSplitProc.Start();
_channelUmdfConfig = conflatedConfig;
//if (!listaChannelQueues.ContainsKey(conflatedConfig.ChannelID))
// listaChannelQueues.Add(conflatedConfig.ChannelID, new ListChannelQueues(qUdpPkt, replayLockObject));
logger.Info("Start(): iniciando sessao FIX...");
try
{
// Cria sessao FIX
_session = new QuickFix.SessionID(
conflatedConfig.BeginString,
conflatedConfig.SenderCompID,
conflatedConfig.TargetCompID);
// Cria dicionario da configuracao
QuickFix.Dictionary mainDic = new QuickFix.Dictionary();
mainDic.SetLong("SocketConnectPort", conflatedConfig.ProxyPort);
mainDic.SetLong("HeartBtInt", conflatedConfig.HeartBtInt);
mainDic.SetLong("ReconnectInterval", conflatedConfig.ReconnectInterval);
mainDic.SetBool("ResetOnLogon", conflatedConfig.ResetOnLogon);
mainDic.SetBool("ResetOnLogout", conflatedConfig.ResetOnLogout);
mainDic.SetBool("ResetOnDisconnect", conflatedConfig.ResetOnDisconnect);
mainDic.SetBool("PersistMessages", conflatedConfig.PersistMessages);
mainDic.SetString("ConnectionType", conflatedConfig.ConnectionType);
mainDic.SetString("SocketConnectHost", conflatedConfig.ProxyHost);
mainDic.SetString("FileStorePath", conflatedConfig.FileStorePath);
mainDic.SetString("FileLogPath", conflatedConfig.FileLogPath);
mainDic.SetString("StartTime", conflatedConfig.StartTime);
mainDic.SetString("EndTime", conflatedConfig.EndTime);
QuickFix.Dictionary sessDic = new QuickFix.Dictionary();
sessDic.SetString("BeginString", conflatedConfig.BeginString);
sessDic.SetString("SenderCompID", conflatedConfig.SenderCompID);
sessDic.SetString("TargetCompID", conflatedConfig.TargetCompID);
sessDic.SetString("DataDictionary", conflatedConfig.DataDictionary);
sessDic.SetBool("CheckLatency", false);
sessDic.SetBool("UseDataDictionary", true);
sessDic.SetLong("SocketReceiveBufferSize", conflatedConfig.SocketReceiveBufferSize);
// Configure the session settings
QuickFix.SessionSettings settings = new QuickFix.SessionSettings();
settings.Set(mainDic);
settings.Set(_session, sessDic);
MemoryStoreFactory store = new MemoryStoreFactory();
FileLogFactory log = new FileLogFactory(settings);
IMessageFactory message = new DefaultMessageFactory();
// Cria o socket
_initiator = new QuickFix.Transport.SocketInitiator(this, store, settings, this, message);
_initiator.Start();
QuickFix.Session mySession = QuickFix.Session.LookupSession(_session);
QuickFix.Session.LookupSession(_session).ValidateLengthAndChecksum = false;
}
catch (Exception ex)
{
logger.Error("Start():" + ex.Message, ex);
}
logger.Info("Start(): Sessao FIX iniciado!");
}
void StartEngine(bool initiator)
{
TestApplication application = new TestApplication(LogonCallback, LogoffCallback);
IMessageStoreFactory storeFactory = new MemoryStoreFactory();
ILogFactory logFactory = new ScreenLogFactory(false, false, false);
SessionSettings settings = new SessionSettings();
if (initiator)
{
Dictionary defaults = new Dictionary();
defaults.SetString(SessionSettings.RECONNECT_INTERVAL, "1");
settings.Set(defaults);
settings.Set(CreateSessionID(StaticInitiatorCompID), CreateSessionConfig(StaticInitiatorCompID, true));
_initiator = new SocketInitiator(application, storeFactory, settings, logFactory);
_initiator.Start();
}
else
{
settings.Set(CreateSessionID(StaticAcceptorCompID), CreateSessionConfig(StaticAcceptorCompID, false));
_acceptor = new ThreadedSocketAcceptor(application, storeFactory, settings, logFactory);
_acceptor.Start();
}
}
void StartEngine(bool initiator)
{
TestApplication application = new TestApplication(LogonCallback, LogoffCallback);
IMessageStoreFactory storeFactory = new MemoryStoreFactory();
SessionSettings settings = new SessionSettings();
Dictionary defaults = new Dictionary();
defaults.SetString(QuickFix.SessionSettings.FILE_LOG_PATH, LogPath);
// Put IP endpoint settings into default section to verify that that defaults get merged into
// session-specific settings not only for static sessions, but also for dynamic ones
defaults.SetString(SessionSettings.SOCKET_CONNECT_HOST, Host);
defaults.SetString(SessionSettings.SOCKET_CONNECT_PORT, ConnectPort.ToString());
defaults.SetString(SessionSettings.SOCKET_ACCEPT_HOST, Host);
defaults.SetString(SessionSettings.SOCKET_ACCEPT_PORT, AcceptPort.ToString());
settings.Set(defaults);
ILogFactory logFactory = new FileLogFactory(settings);
if (initiator)
{
defaults.SetString(SessionSettings.RECONNECT_INTERVAL, "1");
settings.Set(CreateSessionID(StaticInitiatorCompID), CreateSessionConfig(StaticInitiatorCompID, true));
_initiator = new SocketInitiator(application, storeFactory, settings, logFactory);
_initiator.Start();
}
else
{
settings.Set(CreateSessionID(StaticAcceptorCompID), CreateSessionConfig(StaticAcceptorCompID, false));
_acceptor = new ThreadedSocketAcceptor(application, storeFactory, settings, logFactory);
_acceptor.Start();
}
}
