public void testInvalidTimeZone()
{
QuickFix.Dictionary settings = new QuickFix.Dictionary();
settings.SetString(QuickFix.SessionSettings.START_TIME, "06:00:23");
settings.SetString(QuickFix.SessionSettings.END_TIME, "00:12:00");
settings.SetString(QuickFix.SessionSettings.TIME_ZONE, "Doh");
Assert.Throws(typeof (TimeZoneNotFoundException), delegate { new QuickFix.SessionSchedule(settings); });
}
private static QuickFix.Dictionary CreateConfig()
{
QuickFix.Dictionary config = new QuickFix.Dictionary();
config.SetBool(QuickFix.SessionSettings.PERSIST_MESSAGES, false);
config.SetString(QuickFix.SessionSettings.CONNECTION_TYPE, "initiator");
config.SetString(QuickFix.SessionSettings.START_TIME, "00:00:00");
config.SetString(QuickFix.SessionSettings.END_TIME, "00:00:00");
return config;
}
public void testLocalTimeTimeZoneConflict()
{
QuickFix.Dictionary settings = new QuickFix.Dictionary();
settings.SetString(QuickFix.SessionSettings.START_TIME, "06:00:23");
settings.SetString(QuickFix.SessionSettings.END_TIME, "00:12:00");
settings.SetString(QuickFix.SessionSettings.TIME_ZONE, "Doh");
settings.SetString(QuickFix.SessionSettings.USE_LOCAL_TIME, "Y");
settings.SetString(QuickFix.SessionSettings.TIME_ZONE, "Eastern Standard Time");
Assert.Throws(typeof (QuickFix.ConfigError), delegate { new QuickFix.SessionSchedule(settings); });
}
public void testOptArgs()
{
QuickFix.Dictionary settings = new QuickFix.Dictionary();
settings.SetString(QuickFix.SessionSettings.START_TIME, "00:00:00");
settings.SetString(QuickFix.SessionSettings.END_TIME, "00:00:00");
settings.SetDay(QuickFix.SessionSettings.START_DAY, System.DayOfWeek.Thursday);
Assert.Throws(typeof(QuickFix.ConfigError), delegate { new QuickFix.SessionSchedule(settings); });
settings.SetDay(QuickFix.SessionSettings.END_DAY, System.DayOfWeek.Friday);
Assert.DoesNotThrow(delegate { new QuickFix.SessionSchedule(settings); });
}
public void testThrowsIfNoConfig()
{
QuickFix.SessionID sessionID = new QuickFix.SessionID("FIX.4.2", "SENDERCOMP", "TARGETCOMP");
QuickFix.Dictionary config = new QuickFix.Dictionary();
config.SetString(QuickFix.SessionSettings.CONNECTION_TYPE, "initiator");
QuickFix.SessionSettings settings = new QuickFix.SessionSettings();
settings.Set(sessionID, config);
QuickFix.FileLogFactory factory = new QuickFix.FileLogFactory(settings);
Assert.Throws<QuickFix.ConfigError>(delegate { factory.Create(sessionID); });
}
public void testLastEndTime_takesUtcOnly()
{
QuickFix.Dictionary settings = new QuickFix.Dictionary();
settings.SetString(QuickFix.SessionSettings.START_TIME, "09:30:00");
settings.SetString(QuickFix.SessionSettings.END_TIME, "16:00:00");
QuickFix.SessionSchedule sched = new QuickFix.SessionSchedule(settings);
Assert.Throws <ArgumentException>(
delegate { sched.LastEndTime(new DateTime(2012, 10, 18, 12, 00, 00, DateTimeKind.Local)); });
Assert.Throws <ArgumentException>(
delegate { sched.LastEndTime(new DateTime(2012, 10, 18, 12, 00, 00, DateTimeKind.Unspecified)); });
}
public void Set(SessionID sessionID, QuickFix.Dictionary settings)
{
if (Has(sessionID))
{
throw new ConfigError("Duplicate Session " + sessionID.ToString());
}
settings.SetString(BEGINSTRING, sessionID.BeginString);
settings.SetString(SENDERCOMPID, sessionID.SenderCompID);
settings.SetString(TARGETCOMPID, sessionID.TargetCompID);
settings.Merge(defaults_);
Validate(settings);
settings_[sessionID] = settings;
}
public void testNextEndTime_takesUtcOnly()
{
QuickFix.Dictionary settings = new QuickFix.Dictionary();
settings.SetString(QuickFix.SessionSettings.START_TIME, "09:30:00");
settings.SetString(QuickFix.SessionSettings.END_TIME, "16:00:00");
QuickFix.SessionSchedule sched = new QuickFix.SessionSchedule(settings);
DateTime local = new DateTime(2001, 1, 1, 1, 1, 1, DateTimeKind.Local);
DateTime none = new DateTime(2001, 1, 1, 1, 1, 1, DateTimeKind.Unspecified);
Assert.Throws <ArgumentException>(delegate { sched.NextEndTime(local); });
Assert.Throws <ArgumentException>(delegate { sched.NextEndTime(none); });
}
public void testDailyIsSessionTimeAllDay()
{
QuickFix.Dictionary settings = new QuickFix.Dictionary();
settings.SetString(QuickFix.SessionSettings.START_TIME, "00:00:00");
settings.SetString(QuickFix.SessionSettings.END_TIME, "00:00:00");
QuickFix.SessionSchedule sched = new QuickFix.SessionSchedule(settings);
Assert.IsTrue(sched.IsSessionTime(new DateTime(2011,10,17,9,43,0)));
Assert.IsTrue(sched.IsSessionTime(new DateTime(2011,10,18,9,43,0)));
Assert.IsTrue(sched.IsSessionTime(new DateTime(2011, 10, 18, 0, 0, 0)));
Assert.IsTrue(sched.IsSessionTime(new DateTime(2011, 10, 18, 23, 59, 59)));
}
public void testDailyIsSessionTimeAllDay()
{
QuickFix.Dictionary settings = new QuickFix.Dictionary();
settings.SetString(QuickFix.SessionSettings.START_TIME, "00:00:00");
settings.SetString(QuickFix.SessionSettings.END_TIME, "00:00:00");
QuickFix.SessionSchedule sched = new QuickFix.SessionSchedule(settings);
Assert.IsTrue(sched.IsSessionTime(new DateTime(2011, 10, 17, 9, 43, 0)));
Assert.IsTrue(sched.IsSessionTime(new DateTime(2011, 10, 18, 9, 43, 0)));
Assert.IsTrue(sched.IsSessionTime(new DateTime(2011, 10, 18, 0, 0, 0)));
Assert.IsTrue(sched.IsSessionTime(new DateTime(2011, 10, 18, 23, 59, 59)));
}
public void setup()
{
sessionID = new QuickFix.SessionID("FIX.4.2", "SENDERCOMP", "TARGETCOMP");
QuickFix.Dictionary config = new QuickFix.Dictionary();
config.SetString(QuickFix.SessionSettings.CONNECTION_TYPE, "initiator");
config.SetString(QuickFix.SessionSettings.ODBC_STORE_CONNECTION_STRING, "DSN=FIXSIM");
settings = new QuickFix.SessionSettings();
settings.Set(sessionID, config);
factory = new QuickFix.ODBCStoreFactory(settings);
store = (QuickFix.ODBCStore)factory.Create(sessionID);
}
private void CreateSessions(SessionSettings settings, SessionFactory sessionFactory)
{
sessionFactory_ = sessionFactory;
foreach (SessionID sessionID in settings.GetSessions())
{
QuickFix.Dictionary dict = settings.Get(sessionID);
AddSession(sessionID, dict);
}
if (0 == socketDescriptorForAddress_.Count)
{
throw new ConfigError("No acceptor sessions found in SessionSettings.");
}
}
public void testTimeZone()
{
QuickFix.Dictionary settings = new QuickFix.Dictionary();
settings.SetString(QuickFix.SessionSettings.START_TIME, "09:30:00");
settings.SetString(QuickFix.SessionSettings.END_TIME, "16:00:00");
settings.SetString(QuickFix.SessionSettings.TIME_ZONE, EASTERN_STANDARD_TIME_ZONE_ID);
QuickFix.SessionSchedule sched = new QuickFix.SessionSchedule(settings);
Assert.IsFalse(sched.IsSessionTime(new DateTime(2011, 10, 17, 13, 29, 59, DateTimeKind.Utc)));
Assert.IsTrue(sched.IsSessionTime(new DateTime(2011, 10, 17, 13, 30, 0, DateTimeKind.Utc)));
Assert.IsTrue(sched.IsSessionTime(new DateTime(2011, 10, 17, 20, 0, 0, DateTimeKind.Utc)));
Assert.IsFalse(sched.IsSessionTime(new DateTime(2011, 10, 17, 20, 0, 1, DateTimeKind.Utc)));
}
/// <summary>
/// </summary>
/// <param name="settings"></param>
public SessionSchedule(QuickFix.Dictionary settings)
{
this.WeeklySession = false;
if (!settings.Has(SessionSettings.START_DAY) && settings.Has(SessionSettings.END_DAY))
{
throw new QuickFix.ConfigError("EndDay used without StartDay");
}
if (settings.Has(SessionSettings.START_DAY) && !settings.Has(SessionSettings.END_DAY))
{
throw new QuickFix.ConfigError("StartDay used without EndDay");
}
if (settings.Has(SessionSettings.START_DAY) && settings.Has(SessionSettings.END_DAY))
{
StartDay = settings.GetDay(SessionSettings.START_DAY);
EndDay = settings.GetDay(SessionSettings.END_DAY);
WeeklySession = true;
}
if (settings.Has(SessionSettings.USE_LOCAL_TIME))
{
UseLocalTime = settings.GetBool(SessionSettings.USE_LOCAL_TIME);
}
if (settings.Has(SessionSettings.TIME_ZONE))
{
if (UseLocalTime)
{
throw new ConfigError(
SessionSettings.TIME_ZONE + " conflicts with " + SessionSettings.USE_LOCAL_TIME);
}
string id = settings.GetString(SessionSettings.TIME_ZONE);
TimeZone = System.TimeZoneInfo.FindSystemTimeZoneById(id);
}
try
{
this.StartTime = System.TimeSpan.Parse(
settings.GetString(SessionSettings.START_TIME));
this.EndTime = System.TimeSpan.Parse(
settings.GetString(SessionSettings.END_TIME));
}
catch (System.FormatException e)
{
throw new ConfigError(e.Message);
}
}
public void testRequiredArgs()
{
QuickFix.Dictionary settings = new QuickFix.Dictionary();
Assert.Throws(typeof(QuickFix.ConfigError), delegate { new QuickFix.SessionSchedule(settings); });
settings.SetString(QuickFix.SessionSettings.START_TIME, "00:00:00");
Assert.Throws(typeof(QuickFix.ConfigError), delegate { new QuickFix.SessionSchedule(settings); });
settings.SetString(QuickFix.SessionSettings.END_TIME, "00:0blkajsdf");
Assert.Throws(typeof(QuickFix.ConfigError), delegate { new QuickFix.SessionSchedule(settings); });
settings.SetString(QuickFix.SessionSettings.END_TIME, "00:00:00");
Assert.DoesNotThrow(delegate { new QuickFix.SessionSchedule(settings); });
}
public void testRequiredArgs()
{
QuickFix.Dictionary settings = new QuickFix.Dictionary();
Assert.Throws(typeof(QuickFix.ConfigError), delegate { new QuickFix.SessionSchedule(settings); });
settings.SetString(QuickFix.SessionSettings.START_TIME, "00:00:00");
Assert.Throws(typeof(QuickFix.ConfigError), delegate { new QuickFix.SessionSchedule(settings); });
settings.SetString(QuickFix.SessionSettings.END_TIME, "00:0blkajsdf");
Assert.Throws(typeof(QuickFix.ConfigError), delegate { new QuickFix.SessionSchedule(settings); });
settings.SetString(QuickFix.SessionSettings.END_TIME, "00:00:00");
Assert.DoesNotThrow(delegate { new QuickFix.SessionSchedule(settings); });
}
protected void Load(TextReader conf)
{
Settings settings = new Settings(conf);
//---- load the DEFAULT section
LinkedList <QuickFix.Dictionary> section = settings.Get("DEFAULT");
QuickFix.Dictionary def = new QuickFix.Dictionary();
if (section.Count > 0)
{
def = section.First.Value;
}
Set(def);
//---- load each SESSION section
section = settings.Get("SESSION");
foreach (QuickFix.Dictionary dict in section)
{
dict.Merge(def);
string sessionQualifier = SessionID.NOT_SET;
string senderSubID = SessionID.NOT_SET;
string senderLocID = SessionID.NOT_SET;
string targetSubID = SessionID.NOT_SET;
string targetLocID = SessionID.NOT_SET;
if (dict.Has(SESSION_QUALIFIER))
{
sessionQualifier = dict.GetString(SESSION_QUALIFIER);
}
if (dict.Has(SENDERSUBID))
{
senderSubID = dict.GetString(SENDERSUBID);
}
if (dict.Has(SENDERLOCID))
{
senderLocID = dict.GetString(SENDERLOCID);
}
if (dict.Has(TARGETSUBID))
{
targetSubID = dict.GetString(TARGETSUBID);
}
if (dict.Has(TARGETLOCID))
{
targetLocID = dict.GetString(TARGETLOCID);
}
SessionID sessionID = new SessionID(dict.GetString(BEGINSTRING), dict.GetString(SENDERCOMPID), senderSubID, senderLocID, dict.GetString(TARGETCOMPID), targetSubID, targetLocID, sessionQualifier);
Set(sessionID, dict);
}
}
public void testDailyIsSessionTime()
{
QuickFix.Dictionary settings = new QuickFix.Dictionary();
settings.SetString(QuickFix.SessionSettings.START_TIME, "00:12:00");
settings.SetString(QuickFix.SessionSettings.END_TIME, "06:00:23");
QuickFix.SessionSchedule sched = new QuickFix.SessionSchedule(settings);
Assert.IsTrue(sched.IsSessionTime(new DateTime(2011, 10, 17, 0, 12, 0)));
Assert.IsTrue(sched.IsSessionTime(new DateTime(2011, 10, 17, 5, 43, 0)));
Assert.IsTrue(sched.IsSessionTime(new DateTime(2011, 10, 18, 6, 0, 23)));
Assert.IsFalse(sched.IsSessionTime(new DateTime(2011, 10, 18, 0, 11, 0)));
Assert.IsFalse(sched.IsSessionTime(new DateTime(2011, 10, 18, 6, 0, 24)));
}
public void testDailyIsSessionTimeWrapAround()
{
QuickFix.Dictionary settings = new QuickFix.Dictionary();
settings.SetString(QuickFix.SessionSettings.START_TIME, "06:00:23");
settings.SetString(QuickFix.SessionSettings.END_TIME, "00:12:00");
QuickFix.SessionSchedule sched = new QuickFix.SessionSchedule(settings);
Assert.IsTrue(sched.IsSessionTime(new DateTime(2011, 10, 17, 6, 0, 23, DateTimeKind.Utc)));
Assert.IsTrue(sched.IsSessionTime(new DateTime(2011, 10, 17, 8, 43, 0, DateTimeKind.Utc)));
Assert.IsTrue(sched.IsSessionTime(new DateTime(2011, 10, 18, 0, 12, 00, DateTimeKind.Utc)));
Assert.IsFalse(sched.IsSessionTime(new DateTime(2011, 10, 18, 0, 12, 1, DateTimeKind.Utc)));
Assert.IsFalse(sched.IsSessionTime(new DateTime(2011, 10, 18, 6, 0, 22, DateTimeKind.Utc)));
}
public void testDailyIsSessionTimeWrapAround()
{
QuickFix.Dictionary settings = new QuickFix.Dictionary();
settings.SetString(QuickFix.SessionSettings.START_TIME, "06:00:23");
settings.SetString(QuickFix.SessionSettings.END_TIME, "00:12:00");
QuickFix.SessionSchedule sched = new QuickFix.SessionSchedule(settings);
Assert.IsTrue(sched.IsSessionTime(new DateTime(2011, 10, 17, 6, 0, 23)));
Assert.IsTrue(sched.IsSessionTime(new DateTime(2011, 10, 17, 8, 43, 0)));
Assert.IsTrue(sched.IsSessionTime(new DateTime(2011, 10, 18, 0, 12, 00)));
Assert.IsFalse(sched.IsSessionTime(new DateTime(2011, 10, 18, 0, 12, 1)));
Assert.IsFalse(sched.IsSessionTime(new DateTime(2011, 10, 18, 6, 0, 22)));
}
public void setup()
{
if (System.IO.Directory.Exists("store"))
System.IO.Directory.Delete("store", true);
sessionID = new QuickFix.SessionID("FIX.4.2", "SENDERCOMP", "TARGETCOMP");
QuickFix.Dictionary config = new QuickFix.Dictionary();
config.SetString(QuickFix.SessionSettings.CONNECTION_TYPE, "initiator");
config.SetString(QuickFix.SessionSettings.FILE_STORE_PATH, "store");
settings = new QuickFix.SessionSettings();
settings.Set(sessionID, config);
factory = new QuickFix.FileStoreFactory(settings);
store = (QuickFix.FileStore)factory.Create(sessionID);
}
public void testLogRotation()
{
string logDir = "log";
if (System.IO.Directory.Exists(logDir))
System.IO.Directory.Delete(logDir, true);
QuickFix.SessionID sessionID = new QuickFix.SessionID("FIX.4.2", "SENDERCOMP", "TARGETCOMP");
QuickFix.SessionSettings settings = new QuickFix.SessionSettings();
QuickFix.Dictionary config = new QuickFix.Dictionary();
config.SetString(QuickFix.SessionSettings.CONNECTION_TYPE, "initiator");
config.SetString(QuickFix.SessionSettings.FILE_LOG_PATH, logDir);
int NumLogsToRotate = 5;
config.SetString(QuickFix.SessionSettings.FILE_LOG_ROTATE_NUM_TO_KEEP, NumLogsToRotate.ToString());
config.SetString(QuickFix.SessionSettings.FILE_LOG_ROTATE_ON_NEW_SESSION, "Y");
settings.Set(sessionID, config);
string timeStampMinute = System.DateTime.UtcNow.ToString("MMddyyyy-HHmm");
for (int i = 0; i < NumLogsToRotate; i++)
{
QuickFix.FileLogFactory factory = new QuickFix.FileLogFactory(settings);
log = (QuickFix.FileLog)factory.Create(sessionID);
log.OnEvent("some event");
log.OnIncoming("some incoming");
log.OnOutgoing("some outgoing");
Assert.That(System.IO.File.Exists(logDir+"/FIX.4.2-SENDERCOMP-TARGETCOMP.event.current.log"));
Assert.That(System.IO.File.Exists(logDir+"/FIX.4.2-SENDERCOMP-TARGETCOMP.messages.current.log"));
log.Dispose();
}
Assert.That(System.IO.Directory.GetFiles(logDir,
String.Format("FIX.4.2-SENDERCOMP-TARGETCOMP.messages.current.log.{0}*",timeStampMinute),
System.IO.SearchOption.TopDirectoryOnly)
.Count().Equals(NumLogsToRotate-1));
Assert.That(System.IO.Directory.GetFiles(logDir,
String.Format("FIX.4.2-SENDERCOMP-TARGETCOMP.event.current.log.{0}*", timeStampMinute),
System.IO.SearchOption.TopDirectoryOnly)
.Count().Equals(NumLogsToRotate-1));
}
public void testNextEndTime_Daily()
{
QuickFix.Dictionary settings = new QuickFix.Dictionary();
settings.SetString(QuickFix.SessionSettings.START_TIME, "09:30:00");
settings.SetString(QuickFix.SessionSettings.END_TIME, "16:00:00");
QuickFix.SessionSchedule sched = new QuickFix.SessionSchedule(settings);
Assert.AreEqual("20121018-16:00:00",
sched.NextEndTime(new DateTime(2012, 10, 18, 15, 59, 59, DateTimeKind.Utc)).ToString(FMT));
Assert.AreEqual("20121018-16:00:00",
sched.NextEndTime(new DateTime(2012, 10, 18, 16, 00, 00, DateTimeKind.Utc)).ToString(FMT));
Assert.AreEqual("20121019-16:00:00",
sched.NextEndTime(new DateTime(2012, 10, 18, 16, 00, 01, DateTimeKind.Utc)).ToString(FMT));
// ==========
// Settings file is specified in a zone (est, -5)
settings = new QuickFix.Dictionary();
settings.SetString(QuickFix.SessionSettings.START_TIME, "04:30:00"); // 09:30:00 utc
settings.SetString(QuickFix.SessionSettings.END_TIME, "11:00:00"); // 16:00:00 utc
settings.SetString(QuickFix.SessionSettings.TIME_ZONE, EASTERN_STANDARD_TIME_ZONE_ID); //-5
sched = new QuickFix.SessionSchedule(settings);
Assert.AreEqual("20121218-11:00:00",
sched.NextEndTime(new DateTime(2012, 12, 18, 15, 59, 59, DateTimeKind.Utc)).ToString(FMT));
Assert.AreEqual("20121218-11:00:00",
sched.NextEndTime(new DateTime(2012, 12, 18, 16, 00, 00, DateTimeKind.Utc)).ToString(FMT));
Assert.AreEqual("20121219-11:00:00",
sched.NextEndTime(new DateTime(2012, 12, 18, 16, 00, 01, DateTimeKind.Utc)).ToString(FMT));
// ==========
// Time zone during Daylight Savings
settings = new QuickFix.Dictionary();
settings.SetString(QuickFix.SessionSettings.START_TIME, "05:30:00"); // 09:30:00 utc
settings.SetString(QuickFix.SessionSettings.END_TIME, "12:00:00"); // 16:00:00 utc
settings.SetString(QuickFix.SessionSettings.TIME_ZONE, EASTERN_STANDARD_TIME_ZONE_ID); //-4 for DST
sched = new QuickFix.SessionSchedule(settings);
Assert.AreEqual("20120618-12:00:00",
sched.NextEndTime(new DateTime(2012, 06, 18, 15, 59, 59, DateTimeKind.Utc)).ToString(FMT));
Assert.AreEqual("20120618-12:00:00",
sched.NextEndTime(new DateTime(2012, 06, 18, 16, 00, 00, DateTimeKind.Utc)).ToString(FMT));
Assert.AreEqual("20120619-12:00:00",
sched.NextEndTime(new DateTime(2012, 06, 18, 16, 00, 01, DateTimeKind.Utc)).ToString(FMT));
}
public void setup()
{
if (System.IO.Directory.Exists("store"))
{
System.IO.Directory.Delete("store", true);
}
sessionID = new QuickFix.SessionID("FIX.4.2", "SENDERCOMP", "TARGETCOMP");
QuickFix.Dictionary config = new QuickFix.Dictionary();
config.SetString(QuickFix.SessionSettings.CONNECTION_TYPE, "initiator");
config.SetString(QuickFix.SessionSettings.FILE_STORE_PATH, "store");
settings = new QuickFix.SessionSettings();
settings.Set(sessionID, config);
factory = new QuickFix.FileStoreFactory(settings);
store = (QuickFix.FileStore)factory.Create(sessionID);
}
/// <summary>
/// Creates a ClientHandlerThread
/// </summary>
/// <param name="tcpClient"></param>
/// <param name="clientId"></param>
/// <param name="debugLogFilePath">path where thread log will go</param>
public ClientHandlerThread(TcpClient tcpClient, long clientId, QuickFix.Dictionary settingsDict, SocketSettings socketSettings)
{
string debugLogFilePath = "log";
if (settingsDict.Has(SessionSettings.DEBUG_FILE_LOG_PATH))
{
debugLogFilePath = settingsDict.GetString(SessionSettings.DEBUG_FILE_LOG_PATH);
}
else if (settingsDict.Has(SessionSettings.FILE_LOG_PATH))
{
debugLogFilePath = settingsDict.GetString(SessionSettings.FILE_LOG_PATH);
}
// FIXME - do something more flexible than hardcoding a filelog
log_ = new FileLog(debugLogFilePath, new SessionID("ClientHandlerThread", clientId.ToString(), "Debug"));
this.Id = clientId;
socketReader_ = new SocketReader(tcpClient, socketSettings, this);
}
private void CreateSessions(SessionSettings settings)
{
foreach (SessionID sessionID in settings.GetSessions())
{
QuickFix.Dictionary dict = settings.Get(sessionID);
string connectionType = dict.GetString(SessionSettings.CONNECTION_TYPE);
if ("acceptor".Equals(connectionType))
{
AcceptorSocketDescriptor descriptor = GetAcceptorSocketDescriptor(settings, sessionID);
Session session = sessionFactory_.Create(sessionID, dict);
descriptor.AcceptSession(session);
sessions_[sessionID] = session;
}
}
if (0 == socketDescriptorForAddress_.Count)
{
throw new ConfigError("No acceptor sessions found in SessionSettings.");
}
}
internal ClientHandlerThread(TcpClient tcpClient, long clientId, QuickFix.Dictionary settingsDict,
SocketSettings socketSettings, AcceptorSocketDescriptor acceptorDescriptor)
{
string debugLogFilePath = "";
if (settingsDict.Has(SessionSettings.DEBUG_FILE_LOG_PATH))
{
debugLogFilePath = settingsDict.GetString(SessionSettings.DEBUG_FILE_LOG_PATH);
}
//else if (settingsDict.Has(SessionSettings.FILE_LOG_PATH))
// debugLogFilePath = settingsDict.GetString(SessionSettings.FILE_LOG_PATH);
// FIXME - do something more flexible than hardcoding a filelog
if (!string.IsNullOrEmpty(debugLogFilePath))
{
log_ = new FileLog(debugLogFilePath, new SessionID(
"ClientHandlerThread", clientId.ToString(), "Debug-" + Guid.NewGuid().ToString()));
}
this.Id = clientId;
socketReader_ = new SocketReader(tcpClient, socketSettings, this, acceptorDescriptor);
}
protected void Validate(QuickFix.Dictionary dictionary)
{
string beginString = dictionary.GetString(BEGINSTRING);
if (beginString != Values.BeginString_FIX40 &&
beginString != Values.BeginString_FIX41 &&
beginString != Values.BeginString_FIX42 &&
beginString != Values.BeginString_FIX43 &&
beginString != Values.BeginString_FIX44 &&
beginString != Values.BeginString_FIXT11)
{
throw new ConfigError(BEGINSTRING + " (" + beginString + ") must be FIX.4.0 to FIX.4.4 or FIXT.1.1");
}
string connectionType = dictionary.GetString(CONNECTION_TYPE);
if (!"initiator".Equals(connectionType) && !"acceptor".Equals(connectionType))
{
throw new ConfigError(CONNECTION_TYPE + " must be 'initiator' or 'acceptor'");
}
}
public void testLastEndTime_WeeklySessions()
{
QuickFix.Dictionary settings = new QuickFix.Dictionary();
settings.SetString(QuickFix.SessionSettings.START_TIME, "09:30:00");
settings.SetString(QuickFix.SessionSettings.END_TIME, "16:00:00");
settings.SetDay(QuickFix.SessionSettings.START_DAY, System.DayOfWeek.Monday);
settings.SetDay(QuickFix.SessionSettings.END_DAY, System.DayOfWeek.Friday);
QuickFix.SessionSchedule sched = new QuickFix.SessionSchedule(settings);
DateTime thisWeekEnd = new DateTime(2013, 02, 08, 16, 00, 00, DateTimeKind.Utc);
DateTime prevWeekEnd = new DateTime(2013, 02, 01, 16, 00, 00, DateTimeKind.Utc);
// before starttime
Assert.AreEqual(prevWeekEnd, sched.LastEndTime(new DateTime(2013, 02, 04, 08, 00, 00, DateTimeKind.Utc)));
// during session
Assert.AreEqual(prevWeekEnd, sched.LastEndTime(new DateTime(2013, 02, 05, 08, 00, 00, DateTimeKind.Utc)));
// equals endtime
Assert.AreEqual(prevWeekEnd, sched.LastEndTime(thisWeekEnd));
// after endtime
Assert.AreEqual(thisWeekEnd, sched.LastEndTime(new DateTime(2013, 02, 08, 17, 00, 00, DateTimeKind.Utc)));
// ==========
// Settings file is specified in a zone (est, -5)
settings = new QuickFix.Dictionary();
settings.SetString(QuickFix.SessionSettings.START_TIME, "04:30:00"); // 09:30:00 utc
settings.SetString(QuickFix.SessionSettings.END_TIME, "11:00:00"); // 16:00:00 utc
settings.SetString(QuickFix.SessionSettings.TIME_ZONE, EASTERN_STANDARD_TIME_ZONE_ID); //-5
settings.SetDay(QuickFix.SessionSettings.START_DAY, System.DayOfWeek.Monday);
settings.SetDay(QuickFix.SessionSettings.END_DAY, System.DayOfWeek.Friday);
sched = new QuickFix.SessionSchedule(settings);
// before starttime
Assert.AreEqual(prevWeekEnd, sched.LastEndTime(new DateTime(2013, 02, 04, 08, 00, 00, DateTimeKind.Utc)));
// during session
Assert.AreEqual(prevWeekEnd, sched.LastEndTime(new DateTime(2013, 02, 05, 08, 00, 00, DateTimeKind.Utc)));
// equals endtime
Assert.AreEqual(prevWeekEnd, sched.LastEndTime(thisWeekEnd));
// after endtime
Assert.AreEqual(thisWeekEnd, sched.LastEndTime(new DateTime(2013, 02, 08, 17, 00, 00, DateTimeKind.Utc)));
}
public void testWeeklySessionMultiDayHoursOverlap()
{
QuickFix.Dictionary settings = new QuickFix.Dictionary();
settings.SetString(QuickFix.SessionSettings.START_TIME, "15:00:00");
settings.SetString(QuickFix.SessionSettings.END_TIME, "07:00:00");
//only on monday-fri
settings.SetDay(QuickFix.SessionSettings.START_DAY, System.DayOfWeek.Monday);
settings.SetDay(QuickFix.SessionSettings.END_DAY, System.DayOfWeek.Friday);
QuickFix.SessionSchedule sched = new QuickFix.SessionSchedule(settings);
//weekdays
Assert.IsTrue(sched.IsSessionTime(new DateTime(2011, 10, 17, 15, 30, 0, DateTimeKind.Utc)));
Assert.IsFalse(sched.IsSessionTime(new DateTime(2011, 10, 17, 6, 30, 0, DateTimeKind.Utc)), "foo");
Assert.IsTrue(sched.IsSessionTime(new DateTime(2011, 10, 21, 5, 30, 59, DateTimeKind.Utc)));
Assert.IsFalse(sched.IsSessionTime(new DateTime(2011, 10, 21, 15, 30, 59, DateTimeKind.Utc)));
Assert.IsFalse(sched.IsSessionTime(new DateTime(2011, 10, 22, 6, 59, 59, DateTimeKind.Utc)));
Assert.IsFalse(sched.IsSessionTime(new DateTime(2011, 10, 22, 7, 00, 1, DateTimeKind.Utc)));
Assert.IsFalse(sched.IsSessionTime(new DateTime(2011, 10, 22, 15, 30, 0, DateTimeKind.Utc)));
}
internal ClientHandlerThread(TcpClient tcpClient, long clientId, QuickFix.Dictionary settingsDict,
SocketSettings socketSettings, AcceptorSocketDescriptor acceptorDescriptor)
{
string debugLogFilePath = "log";
if (settingsDict.Has(SessionSettings.DEBUG_FILE_LOG_PATH))
{
debugLogFilePath = settingsDict.GetString(SessionSettings.DEBUG_FILE_LOG_PATH);
}
else if (settingsDict.Has(SessionSettings.FILE_LOG_PATH))
{
debugLogFilePath = settingsDict.GetString(SessionSettings.FILE_LOG_PATH);
}
// FIXME - do something more flexible than hardcoding a filelog
log_ = new FileLog(debugLogFilePath, new SessionID(
"ClientHandlerThread", clientId.ToString(), "Debug-" + Guid.NewGuid().ToString()));
this.Id = clientId;
this.SourceAddress = ((IPEndPoint)tcpClient.Client.RemoteEndPoint).Address.ToString();
socketReader_ = new SocketReader(tcpClient, socketSettings, this, acceptorDescriptor);
}
public UnitTestContext()
{
QuickFix.Dictionary config = CreateConfig();
QuickFix.SessionID sessionID = new QuickFix.SessionID("FIX.4.2", "SENDER", "TARGET");
QuickFix.SessionSettings settings = new QuickFix.SessionSettings();
settings.Set(sessionID, config);
App = new QFApp(settings);
Initiator = new MockInitiator();
App.Initiator = Initiator;
Session = new SessionThatTracksOutbound(
App,
new QuickFix.MemoryStoreFactory(),
sessionID,
new QuickFix.DataDictionaryProvider(),
new QuickFix.SessionSchedule(config),
0,
new QuickFix.ScreenLogFactory(settings),
new QuickFix.DefaultMessageFactory(),
"blah");
Session.MaxLatency = 120;
}
public void testWeeklySessionSameDayOneDay()
{
QuickFix.Dictionary settings = new QuickFix.Dictionary();
settings.SetString(QuickFix.SessionSettings.START_TIME, "00:00:00");
settings.SetString(QuickFix.SessionSettings.END_TIME, "05:00:00");
settings.SetDay(QuickFix.SessionSettings.START_DAY, System.DayOfWeek.Monday);
settings.SetDay(QuickFix.SessionSettings.END_DAY, System.DayOfWeek.Monday);
QuickFix.SessionSchedule sched = new QuickFix.SessionSchedule(settings);
//a sunday
Assert.IsFalse(sched.IsSessionTime(new DateTime(2011, 10, 16, 23, 59, 59, DateTimeKind.Utc)));
Assert.IsFalse(sched.IsSessionTime(new DateTime(2011, 10, 16, 0, 0, 0, DateTimeKind.Utc)));
//a monday
Assert.IsTrue(sched.IsSessionTime(new DateTime(2011, 10, 17, 0, 0, 1, DateTimeKind.Utc)));
Assert.IsTrue(sched.IsSessionTime(new DateTime(2011, 10, 17, 4, 0, 1, DateTimeKind.Utc)));
Assert.IsFalse(sched.IsSessionTime(new DateTime(2011, 10, 17, 6, 59, 59, DateTimeKind.Utc)));
//a tuesday
Assert.IsFalse(sched.IsSessionTime(new DateTime(2011, 10, 18, 9, 43, 0, DateTimeKind.Utc)));
Assert.IsFalse(sched.IsSessionTime(new DateTime(2011, 10, 18, 0, 0, 0, DateTimeKind.Utc)));
}
public void testLastEndTime_DailySessions()
{
QuickFix.Dictionary settings = new QuickFix.Dictionary();
settings.SetString(QuickFix.SessionSettings.START_TIME, "09:30:00");
settings.SetString(QuickFix.SessionSettings.END_TIME, "16:00:00");
QuickFix.SessionSchedule sched = new QuickFix.SessionSchedule(settings);
DateTime thisDayEnd = new DateTime(2012, 10, 18, 16, 00, 00, DateTimeKind.Utc);
DateTime prevDayEnd = new DateTime(2012, 10, 17, 16, 00, 00, DateTimeKind.Utc);
// before starttime
Assert.AreEqual(prevDayEnd, sched.LastEndTime(new DateTime(2012, 10, 18, 08, 00, 00, DateTimeKind.Utc)));
// during session
Assert.AreEqual(prevDayEnd, sched.LastEndTime(new DateTime(2012, 10, 18, 08, 00, 00, DateTimeKind.Utc)));
// equals endtime
Assert.AreEqual(thisDayEnd, sched.LastEndTime(thisDayEnd));
// after endtime
Assert.AreEqual(thisDayEnd, sched.LastEndTime(new DateTime(2012, 10, 18, 17, 00, 00, DateTimeKind.Utc)));
// ==========
// Settings file is specified in a zone (est, -5)
settings = new QuickFix.Dictionary();
settings.SetString(QuickFix.SessionSettings.START_TIME, "04:30:00"); // 09:30:00 utc
settings.SetString(QuickFix.SessionSettings.END_TIME, "11:00:00"); // 16:00:00 utc
settings.SetString(QuickFix.SessionSettings.TIME_ZONE, "Eastern Standard Time"); //-5
sched = new QuickFix.SessionSchedule(settings);
// before starttime
Assert.AreEqual(prevDayEnd, sched.LastEndTime(new DateTime(2012, 10, 18, 08, 00, 00, DateTimeKind.Utc)));
// during session
Assert.AreEqual(prevDayEnd, sched.LastEndTime(new DateTime(2012, 10, 18, 10, 00, 00, DateTimeKind.Utc)));
// equals endtime
Assert.AreEqual(thisDayEnd, sched.LastEndTime(thisDayEnd));
// after endtime
Assert.AreEqual(thisDayEnd, sched.LastEndTime(new DateTime(2012, 10, 18, 17, 00, 00, DateTimeKind.Utc)));
}
public void testWeeklySessionMultiDay()
{
QuickFix.Dictionary settings = new QuickFix.Dictionary();
settings.SetString(QuickFix.SessionSettings.START_TIME, "00:00:00");
settings.SetString(QuickFix.SessionSettings.END_TIME, "00:00:00");
//only on monday-thur (note end time)
settings.SetDay(QuickFix.SessionSettings.START_DAY, System.DayOfWeek.Monday);
settings.SetDay(QuickFix.SessionSettings.END_DAY, System.DayOfWeek.Friday);
QuickFix.SessionSchedule sched = new QuickFix.SessionSchedule(settings);
//a monday
Assert.IsTrue(sched.IsSessionTime(new DateTime(2011, 10, 17, 0, 0, 0, DateTimeKind.Utc)));
Assert.IsTrue(sched.IsSessionTime(new DateTime(2011, 10, 17, 9, 43, 0, DateTimeKind.Utc)));
// a thursday
Assert.IsTrue(sched.IsSessionTime(new DateTime(2011, 10, 20, 23, 59, 59, DateTimeKind.Utc)));
//a fri, sat, sun
Assert.IsFalse(sched.IsSessionTime(new DateTime(2011, 10, 21, 23, 59, 59, DateTimeKind.Utc)));
Assert.IsFalse(sched.IsSessionTime(new DateTime(2011, 10, 22, 0, 0, 0, DateTimeKind.Utc)));
Assert.IsFalse(sched.IsSessionTime(new DateTime(2011, 10, 16, 9, 43, 0, DateTimeKind.Utc)));
}
public Settings(System.IO.TextReader conf)
{
QuickFix.Dictionary currentSection = null;
string line = null;
while ((line = conf.ReadLine()) != null)
{
line = line.Trim();
if (IsComment(line))
{
continue;
}
else if (IsSection(line))
{
currentSection = Add(new Dictionary(SplitSection(line)));
}
else if (IsKeyValue(line) && currentSection != null)
{
string[] kv = line.Split(new char[] { '=' }, 2);
currentSection.SetString(kv[0].Trim(), kv[1].Trim());
}
}
}
public void testGeneratedFileName()
{
if (System.IO.Directory.Exists("log"))
System.IO.Directory.Delete("log", true);
QuickFix.SessionID sessionID = new QuickFix.SessionID("FIX.4.2", "SENDERCOMP", "TARGETCOMP");
QuickFix.SessionSettings settings = new QuickFix.SessionSettings();
QuickFix.Dictionary config = new QuickFix.Dictionary();
config.SetString(QuickFix.SessionSettings.CONNECTION_TYPE, "initiator");
config.SetString(QuickFix.SessionSettings.FILE_LOG_PATH, "log");
settings.Set(sessionID, config);
QuickFix.FileLogFactory factory = new QuickFix.FileLogFactory(settings);
log = (QuickFix.FileLog)factory.Create(sessionID);
log.OnEvent("some event");
log.OnIncoming("some incoming");
log.OnOutgoing("some outgoing");
Assert.That(System.IO.File.Exists("log/FIX.4.2-SENDERCOMP-TARGETCOMP.event.current.log"));
Assert.That(System.IO.File.Exists("log/FIX.4.2-SENDERCOMP-TARGETCOMP.messages.current.log"));
}
public void testDailyIsSessionTime()
{
QuickFix.Dictionary settings = new QuickFix.Dictionary();
settings.SetString(QuickFix.SessionSettings.START_TIME, "00:12:00");
settings.SetString(QuickFix.SessionSettings.END_TIME, "06:00:23");
QuickFix.SessionSchedule sched = new QuickFix.SessionSchedule(settings);
Assert.IsTrue(sched.IsSessionTime(new DateTime(2011, 10, 17, 0, 12, 0, DateTimeKind.Utc)));
Assert.IsTrue(sched.IsSessionTime(new DateTime(2011, 10, 17, 5, 43, 0, DateTimeKind.Utc)));
Assert.IsTrue(sched.IsSessionTime(new DateTime(2011, 10, 18, 6, 0, 23, DateTimeKind.Utc)));
Assert.IsFalse(sched.IsSessionTime(new DateTime(2011, 10, 18, 0, 11, 0, DateTimeKind.Utc)));
Assert.IsFalse(sched.IsSessionTime(new DateTime(2011, 10, 18, 6, 0, 24, DateTimeKind.Utc)));
}
public void testLastEndTime_WeeklySessions()
{
QuickFix.Dictionary settings = new QuickFix.Dictionary();
settings.SetString(QuickFix.SessionSettings.START_TIME, "09:30:00");
settings.SetString(QuickFix.SessionSettings.END_TIME, "16:00:00");
settings.SetDay(QuickFix.SessionSettings.START_DAY, System.DayOfWeek.Monday);
settings.SetDay(QuickFix.SessionSettings.END_DAY, System.DayOfWeek.Friday);
QuickFix.SessionSchedule sched = new QuickFix.SessionSchedule(settings);
DateTime thisWeekEnd = new DateTime(2013, 02, 08, 16, 00, 00, DateTimeKind.Utc);
DateTime prevWeekEnd = new DateTime(2013, 02, 01, 16, 00, 00, DateTimeKind.Utc);
// before starttime
Assert.AreEqual(prevWeekEnd, sched.LastEndTime(new DateTime(2013, 02, 04, 08, 00, 00, DateTimeKind.Utc)));
// during session
Assert.AreEqual(prevWeekEnd, sched.LastEndTime(new DateTime(2013, 02, 05, 08, 00, 00, DateTimeKind.Utc)));
// equals endtime
Assert.AreEqual(prevWeekEnd, sched.LastEndTime(thisWeekEnd));
// after endtime
Assert.AreEqual(thisWeekEnd, sched.LastEndTime(new DateTime(2013, 02, 08, 17, 00, 00, DateTimeKind.Utc)));
// ==========
// Settings file is specified in a zone (est, -5)
settings = new QuickFix.Dictionary();
settings.SetString(QuickFix.SessionSettings.START_TIME, "04:30:00"); // 09:30:00 utc
settings.SetString(QuickFix.SessionSettings.END_TIME, "11:00:00"); // 16:00:00 utc
settings.SetString(QuickFix.SessionSettings.TIME_ZONE, EASTERN_STANDARD_TIME_ZONE_ID); //-5
settings.SetDay(QuickFix.SessionSettings.START_DAY, System.DayOfWeek.Monday);
settings.SetDay(QuickFix.SessionSettings.END_DAY, System.DayOfWeek.Friday);
sched = new QuickFix.SessionSchedule(settings);
// before starttime
Assert.AreEqual(prevWeekEnd, sched.LastEndTime(new DateTime(2013, 02, 04, 08, 00, 00, DateTimeKind.Utc)));
// during session
Assert.AreEqual(prevWeekEnd, sched.LastEndTime(new DateTime(2013, 02, 05, 08, 00, 00, DateTimeKind.Utc)));
// equals endtime
Assert.AreEqual(prevWeekEnd, sched.LastEndTime(thisWeekEnd));
// after endtime
Assert.AreEqual(thisWeekEnd, sched.LastEndTime(new DateTime(2013, 02, 08, 17, 00, 00, DateTimeKind.Utc)));
}
public ThreadedSocketReactor(IPEndPoint serverSocketEndPoint, SocketSettings socketSettings, QuickFix.Dictionary sessionDict)
{
socketSettings_ = socketSettings;
tcpListener_ = new TcpListener(serverSocketEndPoint);
sessionDict_ = sessionDict;
}
protected DataDictionary.DataDictionary createDataDictionary(SessionID sessionID, QuickFix.Dictionary settings, string settingsKey, string beginString)
{
DataDictionary.DataDictionary dd;
string path;
if (settings.Has(settingsKey))
{
path = settings.GetString(settingsKey);
}
else
{
path = beginString.Replace(".", "") + ".xml";
}
if (!dictionariesByPath_.TryGetValue(path, out dd))
{
dd = new DataDictionary.DataDictionary(path);
dictionariesByPath_[path] = dd;
}
DataDictionary.DataDictionary ddCopy = new DataDictionary.DataDictionary(dd);
if (settings.Has(SessionSettings.VALIDATE_FIELDS_OUT_OF_ORDER))
{
ddCopy.CheckFieldsOutOfOrder = settings.GetBool(SessionSettings.VALIDATE_FIELDS_OUT_OF_ORDER);
}
if (settings.Has(SessionSettings.VALIDATE_FIELDS_HAVE_VALUES))
{
ddCopy.CheckFieldsHaveValues = settings.GetBool(SessionSettings.VALIDATE_FIELDS_HAVE_VALUES);
}
if (settings.Has(SessionSettings.VALIDATE_USER_DEFINED_FIELDS))
{
ddCopy.CheckUserDefinedFields = settings.GetBool(SessionSettings.VALIDATE_USER_DEFINED_FIELDS);
}
if (settings.Has(SessionSettings.ALLOW_UNKNOWN_MSG_FIELDS))
{
ddCopy.AllowUnknownMessageFields = settings.GetBool(SessionSettings.ALLOW_UNKNOWN_MSG_FIELDS);
}
return(ddCopy);
}
public void testAdjustDateTime()
{
QuickFix.Dictionary settings = new QuickFix.Dictionary();
settings.SetString(QuickFix.SessionSettings.START_TIME, "09:30:00");
settings.SetString(QuickFix.SessionSettings.END_TIME, "16:00:00");
QuickFix.SessionSchedule sched = new QuickFix.SessionSchedule(settings);
// 1) reject if param is not utc
Assert.Throws<ArgumentException>(
delegate { sched.AdjustUtcDateTime(new DateTime(2012, 10, 18, 12, 00, 00, DateTimeKind.Local)); });
Assert.Throws<ArgumentException>(
delegate { sched.AdjustUtcDateTime(new DateTime(2012, 10, 18, 12, 00, 00, DateTimeKind.Unspecified)); });
// 2) if settings is UTC, don't convert
DateTime d2 = new DateTime(2013, 01, 15, 12, 00, 00, DateTimeKind.Utc);
Assert.AreEqual(d2, sched.AdjustUtcDateTime(d2));
// 3) if settings has a TimeZone, convert to TimeZone
settings = new QuickFix.Dictionary();
settings.SetString(QuickFix.SessionSettings.START_TIME, "04:30:00"); // 09:30:00 utc
settings.SetString(QuickFix.SessionSettings.END_TIME, "11:00:00"); // 16:00:00 utc
settings.SetString(QuickFix.SessionSettings.TIME_ZONE, EASTERN_STANDARD_TIME_ZONE_ID); //-5
sched = new QuickFix.SessionSchedule(settings);
DateTime d3 = new DateTime(2013, 01, 15, 03, 00, 00, DateTimeKind.Utc);
DateTime d3expected = new DateTime(2013, 01, 14, 22, 00, 00, DateTimeKind.Unspecified);
DateTime d3actual = sched.AdjustUtcDateTime(d3);
Util.UtcDateTimeSerializerTests.AssertHackyDateTimeEquality(d3expected, d3actual);
// now with Pacific Standard Time
settings = new QuickFix.Dictionary();
settings.SetString(QuickFix.SessionSettings.START_TIME, "04:30:00"); // 09:30:00 utc
settings.SetString(QuickFix.SessionSettings.END_TIME, "11:00:00"); // 16:00:00 utc
settings.SetString(QuickFix.SessionSettings.TIME_ZONE, PACIFIC_STANDARD_TIME_ZONE_ID); //-5
sched = new QuickFix.SessionSchedule(settings);
d3 = new DateTime(2013, 01, 15, 03, 00, 00, DateTimeKind.Utc);
d3expected = new DateTime(2013, 01, 14, 19, 00, 00, DateTimeKind.Unspecified);
d3actual = sched.AdjustUtcDateTime(d3);
Util.UtcDateTimeSerializerTests.AssertHackyDateTimeEquality(d3expected, d3actual);
// 4) TimeZone with daylight savings
settings = new QuickFix.Dictionary();
settings.SetString(QuickFix.SessionSettings.START_TIME, "04:30:00"); // 09:30:00 utc
settings.SetString(QuickFix.SessionSettings.END_TIME, "11:00:00"); // 16:00:00 utc
settings.SetString(QuickFix.SessionSettings.TIME_ZONE, EASTERN_STANDARD_TIME_ZONE_ID); //-4 in June
sched = new QuickFix.SessionSchedule(settings);
DateTime d4 = new DateTime(2013, 06, 15, 03, 00, 00, DateTimeKind.Utc);
DateTime d4expected = new DateTime(2013, 06, 14, 23, 00, 00, DateTimeKind.Unspecified);
DateTime d4actual = sched.AdjustUtcDateTime(d4);
Util.UtcDateTimeSerializerTests.AssertHackyDateTimeEquality(d4expected, d4actual);
// 5) if settings has UseLocalTime, convert to local time
settings = new QuickFix.Dictionary();
settings.SetString(QuickFix.SessionSettings.START_TIME, "04:30:00"); // 09:30:00 utc
settings.SetString(QuickFix.SessionSettings.END_TIME, "11:00:00"); // 16:00:00 utc
settings.SetString(QuickFix.SessionSettings.USE_LOCAL_TIME, "Y");
sched = new QuickFix.SessionSchedule(settings);
DateTime d5 = new DateTime(2013, 01, 15, 16, 00, 00, DateTimeKind.Utc);
DateTime d5expected = d5.ToLocalTime();
DateTime d5actual = sched.AdjustUtcDateTime(d5);
Util.UtcDateTimeSerializerTests.AssertHackyDateTimeEquality(d5expected, d5actual);
Assert.AreEqual(DateTimeKind.Local, d5actual.Kind);
}
public void testIsNewSession_Daily()
{
QuickFix.Dictionary settings = new QuickFix.Dictionary();
settings.SetString(QuickFix.SessionSettings.START_TIME, "09:30:00");
settings.SetString(QuickFix.SessionSettings.END_TIME, "16:00:00");
QuickFix.SessionSchedule sched = new QuickFix.SessionSchedule(settings);
Assert.False(sched.IsNewSession(
new DateTime(2012, 10, 18, 15, 59, 58, DateTimeKind.Utc),
new DateTime(2012, 10, 18, 15, 59, 59, DateTimeKind.Utc)));
Assert.False(sched.IsNewSession(
new DateTime(2012, 10, 18, 15, 59, 59, DateTimeKind.Utc),
new DateTime(2012, 10, 18, 16, 00, 00, DateTimeKind.Utc)));
Assert.True(sched.IsNewSession(
new DateTime(2012, 10, 18, 16, 00, 00, DateTimeKind.Utc),
new DateTime(2012, 10, 18, 16, 00, 01, DateTimeKind.Utc)));
Assert.False(sched.IsNewSession(
new DateTime(2012, 10, 18, 16, 00, 01, DateTimeKind.Utc),
new DateTime(2012, 10, 18, 16, 00, 02, DateTimeKind.Utc)));
// ==========
// Settings file is specified in a zone (est, -5)
settings = new QuickFix.Dictionary();
settings.SetString(QuickFix.SessionSettings.START_TIME, "04:30:00"); // 09:30:00 utc
settings.SetString(QuickFix.SessionSettings.END_TIME, "11:00:00"); // 16:00:00 utc
settings.SetString(QuickFix.SessionSettings.TIME_ZONE, EASTERN_STANDARD_TIME_ZONE_ID); //-5
sched = new QuickFix.SessionSchedule(settings);
Assert.False(sched.IsNewSession(
new DateTime(2012, 12, 18, 15, 59, 58, DateTimeKind.Utc),
new DateTime(2012, 12, 18, 15, 59, 59, DateTimeKind.Utc)));
Assert.False(sched.IsNewSession(
new DateTime(2012, 12, 18, 15, 59, 59, DateTimeKind.Utc),
new DateTime(2012, 12, 18, 16, 00, 00, DateTimeKind.Utc)));
Assert.True(sched.IsNewSession(
new DateTime(2012, 12, 18, 16, 00, 00, DateTimeKind.Utc),
new DateTime(2012, 12, 18, 16, 00, 01, DateTimeKind.Utc)));
Assert.False(sched.IsNewSession(
new DateTime(2012, 12, 18, 16, 00, 01, DateTimeKind.Utc),
new DateTime(2012, 12, 18, 16, 00, 02, DateTimeKind.Utc)));
// ==========
// Time zone during Daylight savings
settings = new QuickFix.Dictionary();
settings.SetString(QuickFix.SessionSettings.START_TIME, "05:30:00"); // 09:30:00 utc
settings.SetString(QuickFix.SessionSettings.END_TIME, "12:00:00"); // 16:00:00 utc
settings.SetString(QuickFix.SessionSettings.TIME_ZONE, EASTERN_STANDARD_TIME_ZONE_ID); //-4 during dst
sched = new QuickFix.SessionSchedule(settings);
Assert.False(sched.IsNewSession(
new DateTime(2012, 06, 18, 15, 59, 58, DateTimeKind.Utc),
new DateTime(2012, 06, 18, 15, 59, 59, DateTimeKind.Utc)));
Assert.False(sched.IsNewSession(
new DateTime(2012, 06, 18, 15, 59, 59, DateTimeKind.Utc),
new DateTime(2012, 06, 18, 16, 00, 00, DateTimeKind.Utc)));
Assert.True(sched.IsNewSession(
new DateTime(2012, 06, 18, 16, 00, 00, DateTimeKind.Utc),
new DateTime(2012, 06, 18, 16, 00, 01, DateTimeKind.Utc)));
Assert.False(sched.IsNewSession(
new DateTime(2012, 06, 18, 16, 00, 01, DateTimeKind.Utc),
new DateTime(2012, 06, 18, 16, 00, 02, DateTimeKind.Utc)));
}
public void testWeeklySessionMultiDay()
{
QuickFix.Dictionary settings = new QuickFix.Dictionary();
settings.SetString(QuickFix.SessionSettings.START_TIME, "00:00:00");
settings.SetString(QuickFix.SessionSettings.END_TIME, "00:00:00");
//only on monday-thur (note end time)
settings.SetDay(QuickFix.SessionSettings.START_DAY, System.DayOfWeek.Monday);
settings.SetDay(QuickFix.SessionSettings.END_DAY, System.DayOfWeek.Friday);
QuickFix.SessionSchedule sched = new QuickFix.SessionSchedule(settings);
//a monday
Assert.IsTrue(sched.IsSessionTime(new DateTime(2011, 10, 17, 0, 0, 0)));
Assert.IsTrue(sched.IsSessionTime(new DateTime(2011, 10, 17, 9, 43, 0)));
// a thursday
Assert.IsTrue(sched.IsSessionTime(new DateTime(2011, 10, 20, 23, 59, 59)));
//a fri, sat, sun
Assert.IsFalse(sched.IsSessionTime(new DateTime(2011, 10, 21, 23, 59, 59)));
Assert.IsFalse(sched.IsSessionTime(new DateTime(2011, 10, 22, 0, 0, 0)));
Assert.IsFalse(sched.IsSessionTime(new DateTime(2011, 10, 16, 9, 43, 0)));
}
public void testNextEndTime_Weekly()
{
QuickFix.Dictionary settings = new QuickFix.Dictionary();
settings.SetString(QuickFix.SessionSettings.START_TIME, "09:30:00");
settings.SetString(QuickFix.SessionSettings.END_TIME, "16:00:00");
settings.SetDay(QuickFix.SessionSettings.START_DAY, System.DayOfWeek.Monday);
settings.SetDay(QuickFix.SessionSettings.END_DAY, System.DayOfWeek.Friday);
QuickFix.SessionSchedule sched = new QuickFix.SessionSchedule(settings);
// Oct 15 and 22 are Mondays, 19 and 26 are Fridays
Assert.AreEqual("20121019-16:00:00",
sched.NextEndTime(new DateTime(2012, 10, 19, 15, 59, 59, DateTimeKind.Utc)).ToString(FMT));
Assert.AreEqual("20121019-16:00:00",
sched.NextEndTime(new DateTime(2012, 10, 19, 16, 00, 00, DateTimeKind.Utc)).ToString(FMT));
Assert.AreEqual("20121026-16:00:00",
sched.NextEndTime(new DateTime(2012, 10, 19, 16, 00, 01, DateTimeKind.Utc)).ToString(FMT));
// ==========
// Settings file is specified in a zone (est, -5)
settings = new QuickFix.Dictionary();
settings.SetString(QuickFix.SessionSettings.START_TIME, "04:30:00"); // 09:30:00 utc
settings.SetString(QuickFix.SessionSettings.END_TIME, "11:00:00"); // 16:00:00 utc
settings.SetString(QuickFix.SessionSettings.TIME_ZONE, EASTERN_STANDARD_TIME_ZONE_ID); //-5
settings.SetDay(QuickFix.SessionSettings.START_DAY, System.DayOfWeek.Monday);
settings.SetDay(QuickFix.SessionSettings.END_DAY, System.DayOfWeek.Friday);
sched = new QuickFix.SessionSchedule(settings);
// Dec 14 and 21 are Fridays
Assert.AreEqual("20121214-11:00:00",
sched.NextEndTime(new DateTime(2012, 12, 14, 15, 59, 59, DateTimeKind.Utc)).ToString(FMT));
Assert.AreEqual("20121214-11:00:00",
sched.NextEndTime(new DateTime(2012, 12, 14, 16, 00, 00, DateTimeKind.Utc)).ToString(FMT));
Assert.AreEqual("20121221-11:00:00",
sched.NextEndTime(new DateTime(2012, 12, 14, 16, 00, 01, DateTimeKind.Utc)).ToString(FMT));
// ==========
// Time zone during Daylight Savings
settings = new QuickFix.Dictionary();
settings.SetString(QuickFix.SessionSettings.START_TIME, "05:30:00"); // 09:30:00 utc
settings.SetString(QuickFix.SessionSettings.END_TIME, "12:00:00"); // 16:00:00 utc
settings.SetString(QuickFix.SessionSettings.TIME_ZONE, EASTERN_STANDARD_TIME_ZONE_ID); //-4 for DST
settings.SetDay(QuickFix.SessionSettings.START_DAY, System.DayOfWeek.Monday);
settings.SetDay(QuickFix.SessionSettings.END_DAY, System.DayOfWeek.Friday);
sched = new QuickFix.SessionSchedule(settings);
// June 15 and 22 are Fridays
Assert.AreEqual("20120615-12:00:00",
sched.NextEndTime(new DateTime(2012, 06, 15, 15, 59, 59, DateTimeKind.Utc)).ToString(FMT));
Assert.AreEqual("20120615-12:00:00",
sched.NextEndTime(new DateTime(2012, 06, 15, 16, 00, 00, DateTimeKind.Utc)).ToString(FMT));
Assert.AreEqual("20120622-12:00:00",
sched.NextEndTime(new DateTime(2012, 06, 15, 16, 00, 01, DateTimeKind.Utc)).ToString(FMT));
}
protected void Load(TextReader conf)
{
Settings settings = new Settings(conf);
//---- load the DEFAULT section
LinkedList<QuickFix.Dictionary> section = settings.Get("DEFAULT");
QuickFix.Dictionary def = new QuickFix.Dictionary();
if (section.Count > 0)
def = section.First.Value;
Set(def);
//---- load each SESSION section
section = settings.Get("SESSION");
foreach (QuickFix.Dictionary dict in section)
{
dict.Merge(def);
string sessionQualifier = SessionID.NOT_SET;
string senderSubID = SessionID.NOT_SET;
string senderLocID = SessionID.NOT_SET;
string targetSubID = SessionID.NOT_SET;
string targetLocID = SessionID.NOT_SET;
if (dict.Has(SESSION_QUALIFIER))
sessionQualifier = dict.GetString(SESSION_QUALIFIER);
if (dict.Has(SENDERSUBID))
senderSubID = dict.GetString(SENDERSUBID);
if (dict.Has(SENDERLOCID))
senderLocID = dict.GetString(SENDERLOCID);
if (dict.Has(TARGETSUBID))
targetSubID = dict.GetString(TARGETSUBID);
if (dict.Has(TARGETLOCID))
targetLocID = dict.GetString(TARGETLOCID);
SessionID sessionID = new SessionID(dict.GetString(BEGINSTRING), dict.GetString(SENDERCOMPID), senderSubID, senderLocID, dict.GetString(TARGETCOMPID), targetSubID, targetLocID, sessionQualifier);
Set(sessionID, dict);
}
}
public void testNextEndTime_Daily()
{
QuickFix.Dictionary settings = new QuickFix.Dictionary();
settings.SetString(QuickFix.SessionSettings.START_TIME, "09:30:00");
settings.SetString(QuickFix.SessionSettings.END_TIME, "16:00:00");
QuickFix.SessionSchedule sched = new QuickFix.SessionSchedule(settings);
Assert.AreEqual("20121018-16:00:00",
sched.NextEndTime(new DateTime(2012, 10, 18, 15, 59, 59, DateTimeKind.Utc)).ToString(FMT));
Assert.AreEqual("20121018-16:00:00",
sched.NextEndTime(new DateTime(2012, 10, 18, 16, 00, 00, DateTimeKind.Utc)).ToString(FMT));
Assert.AreEqual("20121019-16:00:00",
sched.NextEndTime(new DateTime(2012, 10, 18, 16, 00, 01, DateTimeKind.Utc)).ToString(FMT));
// ==========
// Settings file is specified in a zone (est, -5)
settings = new QuickFix.Dictionary();
settings.SetString(QuickFix.SessionSettings.START_TIME, "04:30:00"); // 09:30:00 utc
settings.SetString(QuickFix.SessionSettings.END_TIME, "11:00:00"); // 16:00:00 utc
settings.SetString(QuickFix.SessionSettings.TIME_ZONE, EASTERN_STANDARD_TIME_ZONE_ID); //-5
sched = new QuickFix.SessionSchedule(settings);
Assert.AreEqual("20121218-11:00:00",
sched.NextEndTime(new DateTime(2012, 12, 18, 15, 59, 59, DateTimeKind.Utc)).ToString(FMT));
Assert.AreEqual("20121218-11:00:00",
sched.NextEndTime(new DateTime(2012, 12, 18, 16, 00, 00, DateTimeKind.Utc)).ToString(FMT));
Assert.AreEqual("20121219-11:00:00",
sched.NextEndTime(new DateTime(2012, 12, 18, 16, 00, 01, DateTimeKind.Utc)).ToString(FMT));
// ==========
// Time zone during Daylight Savings
settings = new QuickFix.Dictionary();
settings.SetString(QuickFix.SessionSettings.START_TIME, "05:30:00"); // 09:30:00 utc
settings.SetString(QuickFix.SessionSettings.END_TIME, "12:00:00"); // 16:00:00 utc
settings.SetString(QuickFix.SessionSettings.TIME_ZONE, EASTERN_STANDARD_TIME_ZONE_ID); //-4 for DST
sched = new QuickFix.SessionSchedule(settings);
Assert.AreEqual("20120618-12:00:00",
sched.NextEndTime(new DateTime(2012, 06, 18, 15, 59, 59, DateTimeKind.Utc)).ToString(FMT));
Assert.AreEqual("20120618-12:00:00",
sched.NextEndTime(new DateTime(2012, 06, 18, 16, 00, 00, DateTimeKind.Utc)).ToString(FMT));
Assert.AreEqual("20120619-12:00:00",
sched.NextEndTime(new DateTime(2012, 06, 18, 16, 00, 01, DateTimeKind.Utc)).ToString(FMT));
}
internal ThreadedSocketReactor(IPEndPoint serverSocketEndPoint, SocketSettings socketSettings, QuickFix.Dictionary sessionDict, AcceptorSocketDescriptor acceptorDescriptor)
{
socketSettings_ = socketSettings;
serverSocketEndPoint_ = serverSocketEndPoint;
tcpListener_ = new TcpListener(serverSocketEndPoint_);
sessionDict_ = sessionDict;
acceptorDescriptor_ = acceptorDescriptor;
}
public void testIsNewSession_takesUtcOnly()
{
QuickFix.Dictionary settings = new QuickFix.Dictionary();
settings.SetString(QuickFix.SessionSettings.START_TIME, "09:30:00");
settings.SetString(QuickFix.SessionSettings.END_TIME, "16:00:00");
QuickFix.SessionSchedule sched = new QuickFix.SessionSchedule(settings);
DateTime local = new DateTime(2001, 1, 1, 1, 1, 1, DateTimeKind.Local);
DateTime utc = new DateTime(2001, 1, 1, 1, 1, 1, DateTimeKind.Utc);
DateTime none = new DateTime(2001, 1, 1, 1, 1, 1, DateTimeKind.Unspecified);
Assert.Throws<ArgumentException>(delegate { sched.IsNewSession(local, utc); });
Assert.Throws<ArgumentException>(delegate { sched.IsNewSession(utc, local); });
Assert.Throws<ArgumentException>(delegate { sched.IsNewSession(none, utc); });
Assert.Throws<ArgumentException>(delegate { sched.IsNewSession(utc, none); });
}
public void testWeeklySessionMultiDayHours()
{
QuickFix.Dictionary settings = new QuickFix.Dictionary();
settings.SetString(QuickFix.SessionSettings.START_TIME, "07:00:00");
settings.SetString(QuickFix.SessionSettings.END_TIME, "15:00:00");
//only on monday-fri
settings.SetDay(QuickFix.SessionSettings.START_DAY, System.DayOfWeek.Monday);
settings.SetDay(QuickFix.SessionSettings.END_DAY, System.DayOfWeek.Friday);
QuickFix.SessionSchedule sched = new QuickFix.SessionSchedule(settings);
//Monday Scenarios
Assert.IsFalse(sched.IsSessionTime(new DateTime(2011, 10, 17, 6, 59, 0)));
Assert.IsTrue(sched.IsSessionTime(new DateTime(2011, 10, 17, 7, 30, 0)));
Assert.IsTrue(sched.IsSessionTime(new DateTime(2011, 10, 17, 15, 30, 0)));
//Midweek Scenarios
Assert.IsTrue(sched.IsSessionTime(new DateTime(2011, 10, 19, 6, 59, 0)));
Assert.IsTrue(sched.IsSessionTime(new DateTime(2011, 10, 19, 7, 30, 0)));
Assert.IsTrue(sched.IsSessionTime(new DateTime(2011, 10, 19, 15, 30, 0)));
//Friday Scenarios
Assert.IsTrue(sched.IsSessionTime(new DateTime(2011, 10, 21, 6, 59, 0)));
Assert.IsTrue(sched.IsSessionTime(new DateTime(2011, 10, 21, 7, 30, 0)));
Assert.IsFalse(sched.IsSessionTime(new DateTime(2011, 10, 21, 15, 30, 0)));
//Weekend
Assert.IsFalse(sched.IsSessionTime(new DateTime(2011, 10, 22, 6, 59, 0)));
Assert.IsFalse(sched.IsSessionTime(new DateTime(2011, 10, 22, 7, 30, 0)));
Assert.IsFalse(sched.IsSessionTime(new DateTime(2011, 10, 22, 15, 30, 0)));
}
public AcceptorSocketDescriptor(IPEndPoint socketEndPoint, SocketSettings socketSettings, QuickFix.Dictionary sessionDict)
{
socketEndPoint_ = socketEndPoint;
socketReactor_ = new ThreadedSocketReactor(socketEndPoint_, socketSettings, sessionDict);
}
public void testWeeklySessionMultiDayHoursOverlap()
{
QuickFix.Dictionary settings = new QuickFix.Dictionary();
settings.SetString(QuickFix.SessionSettings.START_TIME, "15:00:00");
settings.SetString(QuickFix.SessionSettings.END_TIME, "07:00:00");
//only on monday-fri
settings.SetDay(QuickFix.SessionSettings.START_DAY, System.DayOfWeek.Monday);
settings.SetDay(QuickFix.SessionSettings.END_DAY, System.DayOfWeek.Friday);
QuickFix.SessionSchedule sched = new QuickFix.SessionSchedule(settings);
//weekdays
Assert.IsTrue(sched.IsSessionTime(new DateTime(2011, 10, 17, 15, 30, 0)));
Assert.IsFalse(sched.IsSessionTime(new DateTime(2011, 10, 17, 6, 30, 0)),"foo");
Assert.IsTrue(sched.IsSessionTime(new DateTime(2011, 10, 21, 5, 30, 59)));
Assert.IsFalse(sched.IsSessionTime(new DateTime(2011, 10, 21, 15, 30, 59)));
Assert.IsFalse(sched.IsSessionTime(new DateTime(2011, 10, 22, 6, 59, 59)));
Assert.IsFalse(sched.IsSessionTime(new DateTime(2011, 10, 22, 7, 00, 1)));
Assert.IsFalse(sched.IsSessionTime(new DateTime(2011, 10, 22, 15, 30, 0)));
}
public ClientHandlerThread(TcpClient tcpClient, long clientId, QuickFix.Dictionary settingsDict)
: this(tcpClient, clientId, settingsDict, new SocketSettings())
{
}
public void testWeeklySessionMultiDayOverlap()
{
QuickFix.Dictionary settings = new QuickFix.Dictionary();
settings.SetString(QuickFix.SessionSettings.START_TIME, "00:00:00");
settings.SetString(QuickFix.SessionSettings.END_TIME, "00:00:00");
//only on wed-sunday night
settings.SetDay(QuickFix.SessionSettings.START_DAY, System.DayOfWeek.Wednesday);
settings.SetDay(QuickFix.SessionSettings.END_DAY, System.DayOfWeek.Monday);
QuickFix.SessionSchedule sched = new QuickFix.SessionSchedule(settings);
//wed-monday
Assert.IsTrue(sched.IsSessionTime(new DateTime(2011, 10, 19, 9, 43, 0)));
Assert.IsTrue(sched.IsSessionTime(new DateTime(2011, 10, 20, 9, 43, 0)));
Assert.IsTrue(sched.IsSessionTime(new DateTime(2011, 10, 21, 9, 43, 0)));
Assert.IsTrue(sched.IsSessionTime(new DateTime(2011, 10, 22, 9, 43, 0)));
Assert.IsTrue(sched.IsSessionTime(new DateTime(2011, 10, 16, 9, 43, 0)));
//monday
Assert.IsFalse(sched.IsSessionTime(new DateTime(2011, 10, 17, 9, 43, 0)));
//tuesday
Assert.IsFalse(sched.IsSessionTime(new DateTime(2011, 10, 18, 9, 43, 0)));
}
public void testLastEndTime_takesUtcOnly()
{
QuickFix.Dictionary settings = new QuickFix.Dictionary();
settings.SetString(QuickFix.SessionSettings.START_TIME, "09:30:00");
settings.SetString(QuickFix.SessionSettings.END_TIME, "16:00:00");
QuickFix.SessionSchedule sched = new QuickFix.SessionSchedule(settings);
Assert.Throws<ArgumentException>(
delegate { sched.LastEndTime(new DateTime(2012, 10, 18, 12, 00, 00, DateTimeKind.Local)); });
Assert.Throws<ArgumentException>(
delegate { sched.LastEndTime(new DateTime(2012, 10, 18, 12, 00, 00, DateTimeKind.Unspecified)); });
}
public void testWeeklySessionSameDayOneDay()
{
QuickFix.Dictionary settings = new QuickFix.Dictionary();
settings.SetString(QuickFix.SessionSettings.START_TIME, "00:00:00");
settings.SetString(QuickFix.SessionSettings.END_TIME, "05:00:00");
settings.SetDay(QuickFix.SessionSettings.START_DAY, System.DayOfWeek.Monday);
settings.SetDay(QuickFix.SessionSettings.END_DAY, System.DayOfWeek.Monday);
QuickFix.SessionSchedule sched = new QuickFix.SessionSchedule(settings);
//a sunday
Assert.IsFalse(sched.IsSessionTime(new DateTime(2011, 10, 16, 23, 59, 59)));
Assert.IsFalse(sched.IsSessionTime(new DateTime(2011, 10, 16, 0, 0, 0)));
//a monday
Assert.IsTrue(sched.IsSessionTime(new DateTime(2011, 10, 17, 0, 0, 1)));
Assert.IsTrue(sched.IsSessionTime(new DateTime(2011, 10, 17, 4, 0, 1)));
Assert.IsFalse(sched.IsSessionTime(new DateTime(2011, 10, 17, 6, 59, 59)));
//a tuesday
Assert.IsFalse(sched.IsSessionTime(new DateTime(2011, 10, 18, 9, 43, 0)));
Assert.IsFalse(sched.IsSessionTime(new DateTime(2011, 10, 18, 0, 0, 0)));
}
public Session Create(SessionID sessionID, QuickFix.Dictionary settings)
{
string connectionType = settings.GetString(SessionSettings.CONNECTION_TYPE);
if (!"acceptor".Equals(connectionType) && !"initiator".Equals(connectionType))
{
throw new ConfigError("Invalid ConnectionType");
}
if ("acceptor".Equals(connectionType) && settings.Has(SessionSettings.SESSION_QUALIFIER))
{
throw new ConfigError("SessionQualifier cannot be used with acceptor.");
}
bool useDataDictionary = true;
if (settings.Has(SessionSettings.USE_DATA_DICTIONARY))
{
useDataDictionary = settings.GetBool(SessionSettings.USE_DATA_DICTIONARY);
}
QuickFix.Fields.ApplVerID defaultApplVerID = null;
IMessageFactory sessionMsgFactory = messageFactory_;
if (sessionID.IsFIXT)
{
if (!settings.Has(SessionSettings.DEFAULT_APPLVERID))
{
throw new ConfigError("ApplVerID is required for FIXT transport");
}
string rawDefaultApplVerIdSetting = settings.GetString(SessionSettings.DEFAULT_APPLVERID);
defaultApplVerID = Message.GetApplVerID(rawDefaultApplVerIdSetting);
// DefaultMessageFactory as created in the SessionFactory ctor cannot
// tell the difference between FIX50 versions (same BeginString, unknown defaultApplVerId).
// But we have the real session settings here, so we can fix that.
// This is, of course, kind of a hack, and it should be reworked in V2 (TODO!).
if (messageFactory_ is DefaultMessageFactory)
{
sessionMsgFactory = new DefaultMessageFactory(
FixValues.ApplVerID.FromBeginString(rawDefaultApplVerIdSetting));
}
}
DataDictionaryProvider dd = new DataDictionaryProvider();
if (useDataDictionary)
{
if (sessionID.IsFIXT)
{
ProcessFixTDataDictionaries(sessionID, settings, dd);
}
else
{
ProcessFixDataDictionary(sessionID, settings, dd);
}
}
int heartBtInt = 0;
if (connectionType == "initiator")
{
heartBtInt = System.Convert.ToInt32(settings.GetLong(SessionSettings.HEARTBTINT));
if (heartBtInt <= 0)
{
throw new ConfigError("Heartbeat must be greater than zero");
}
}
string senderDefaultApplVerId = "";
if (defaultApplVerID != null)
{
senderDefaultApplVerId = defaultApplVerID.Obj;
}
Session session = new Session(
application_,
messageStoreFactory_,
sessionID,
dd,
new SessionSchedule(settings),
heartBtInt,
logFactory_,
sessionMsgFactory,
senderDefaultApplVerId);
if (settings.Has(SessionSettings.SEND_REDUNDANT_RESENDREQUESTS))
{
session.SendRedundantResendRequests = settings.GetBool(SessionSettings.SEND_REDUNDANT_RESENDREQUESTS);
}
if (settings.Has(SessionSettings.RESEND_SESSION_LEVEL_REJECTS))
{
session.ResendSessionLevelRejects = settings.GetBool(SessionSettings.RESEND_SESSION_LEVEL_REJECTS);
}
/* FIXME - implement optional settings
* if (settings.Has(SessionSettings.CHECK_COMPID))
* session.SetCheckCompId(settings.GetBool(SessionSettings.CHECK_COMPID));
*/
if (settings.Has(SessionSettings.CHECK_LATENCY))
{
session.CheckLatency = settings.GetBool(SessionSettings.CHECK_LATENCY);
}
if (settings.Has(SessionSettings.MAX_LATENCY))
{
session.MaxLatency = settings.GetInt(SessionSettings.MAX_LATENCY);
}
if (settings.Has(SessionSettings.LOGON_TIMEOUT))
{
session.LogonTimeout = settings.GetInt(SessionSettings.LOGON_TIMEOUT);
}
if (settings.Has(SessionSettings.LOGOUT_TIMEOUT))
{
session.LogoutTimeout = settings.GetInt(SessionSettings.LOGOUT_TIMEOUT);
}
if (settings.Has(SessionSettings.RESET_ON_LOGON))
{
session.ResetOnLogon = settings.GetBool(SessionSettings.RESET_ON_LOGON);
}
if (settings.Has(SessionSettings.RESET_ON_LOGOUT))
{
session.ResetOnLogout = settings.GetBool(SessionSettings.RESET_ON_LOGOUT);
}
if (settings.Has(SessionSettings.RESET_ON_DISCONNECT))
{
session.ResetOnDisconnect = settings.GetBool(SessionSettings.RESET_ON_DISCONNECT);
}
if (settings.Has(SessionSettings.REFRESH_ON_LOGON))
{
session.RefreshOnLogon = settings.GetBool(SessionSettings.REFRESH_ON_LOGON);
}
if (settings.Has(SessionSettings.PERSIST_MESSAGES))
{
session.PersistMessages = settings.GetBool(SessionSettings.PERSIST_MESSAGES);
}
if (settings.Has(SessionSettings.MILLISECONDS_IN_TIMESTAMP))
{
session.MillisecondsInTimeStamp = settings.GetBool(SessionSettings.MILLISECONDS_IN_TIMESTAMP);
}
if (settings.Has(SessionSettings.TIMESTAMP_PRECISION))
{
session.TimeStampPrecision = settings.GetTimeStampPrecision(SessionSettings.TIMESTAMP_PRECISION);
}
if (settings.Has(SessionSettings.ENABLE_LAST_MSG_SEQ_NUM_PROCESSED))
{
session.EnableLastMsgSeqNumProcessed = settings.GetBool(SessionSettings.ENABLE_LAST_MSG_SEQ_NUM_PROCESSED);
}
if (settings.Has(SessionSettings.MAX_MESSAGES_IN_RESEND_REQUEST))
{
session.MaxMessagesInResendRequest = settings.GetInt(SessionSettings.MAX_MESSAGES_IN_RESEND_REQUEST);
}
if (settings.Has(SessionSettings.SEND_LOGOUT_BEFORE_TIMEOUT_DISCONNECT))
{
session.SendLogoutBeforeTimeoutDisconnect = settings.GetBool(SessionSettings.SEND_LOGOUT_BEFORE_TIMEOUT_DISCONNECT);
}
if (settings.Has(SessionSettings.IGNORE_POSSDUP_RESEND_REQUESTS))
{
session.IgnorePossDupResendRequests = settings.GetBool(SessionSettings.IGNORE_POSSDUP_RESEND_REQUESTS);
}
if (settings.Has(SessionSettings.VALIDATE_LENGTH_AND_CHECKSUM))
{
session.ValidateLengthAndChecksum = settings.GetBool(SessionSettings.VALIDATE_LENGTH_AND_CHECKSUM);
}
if (settings.Has(SessionSettings.RESETSEQUENCE_MESSAGE_REQUIRES_ORIGSENDINGTIME))
{
session.RequiresOrigSendingTime = settings.GetBool(SessionSettings.RESETSEQUENCE_MESSAGE_REQUIRES_ORIGSENDINGTIME);
}
return(session);
}
public void setup()
{
responder = new MockResponder();
sessionID = new QuickFix.SessionID("FIX.4.2", "SENDER", "TARGET");
application = new MockApplication();
settings = new QuickFix.SessionSettings();
QuickFix.Dictionary config = new QuickFix.Dictionary();
config.SetBool(QuickFix.SessionSettings.PERSIST_MESSAGES, false);
config.SetString(QuickFix.SessionSettings.CONNECTION_TYPE, "initiator");
config.SetString(QuickFix.SessionSettings.START_TIME, "00:00:00");
config.SetString(QuickFix.SessionSettings.END_TIME, "00:00:00");
settings.Set(sessionID, config);
session = new QuickFix.Session(application, new QuickFix.MemoryStoreFactory(), sessionID,
new QuickFix.DataDictionaryProvider(),new QuickFix.SessionSchedule(config), 0, new QuickFix.ScreenLogFactory(settings), new QuickFix.DefaultMessageFactory(), "blah");
session.SetResponder(responder);
session.CheckLatency = false;
// must be set for an initiator
int heartBeatInterval = 10;
session2 = new QuickFix.Session(application, new QuickFix.MemoryStoreFactory(), new QuickFix.SessionID("FIX.4.2", "OTHER_SENDER", "OTHER_TARGET"),
new QuickFix.DataDictionaryProvider(), new QuickFix.SessionSchedule(config), heartBeatInterval, new QuickFix.ScreenLogFactory(settings), new QuickFix.DefaultMessageFactory(), "blah");
session2.SetResponder(responder);
session2.CheckLatency = false;
seqNum = 1;
}
public void Set(QuickFix.Dictionary defaults)
{
defaults_ = defaults;
foreach (KeyValuePair<SessionID, QuickFix.Dictionary> entry in settings_)
entry.Value.Merge(defaults_);
}
public void testTimeZone()
{
QuickFix.Dictionary settings = new QuickFix.Dictionary();
settings.SetString(QuickFix.SessionSettings.START_TIME, "09:30:00");
settings.SetString(QuickFix.SessionSettings.END_TIME, "16:00:00");
settings.SetString(QuickFix.SessionSettings.TIME_ZONE, "Eastern Standard Time");
QuickFix.SessionSchedule sched = new QuickFix.SessionSchedule(settings);
Assert.IsFalse(sched.IsSessionTime(new DateTime(2011, 10, 17, 13, 29, 59, DateTimeKind.Utc)));
Assert.IsTrue(sched.IsSessionTime(new DateTime(2011, 10, 17, 13, 30, 0, DateTimeKind.Utc)));
Assert.IsTrue(sched.IsSessionTime(new DateTime(2011, 10, 17, 20, 0, 0, DateTimeKind.Utc)));
Assert.IsFalse(sched.IsSessionTime(new DateTime(2011, 10, 17, 20, 0, 1, DateTimeKind.Utc)));
}
