public void StateInfoChanged()
{
string connectionString = Configuration.ConnectionBuilders(AccountType.Gross, Configuration.ConnectionType.Feed).First().ToString();
this.dataFeed = new DataFeed(connectionString);
this.dataFeed.Logon += this.OnFeedLogon;
connectionString = Configuration.ConnectionBuilders(AccountType.Gross, Configuration.ConnectionType.Trade).First().ToString();
this.dataTrade = new DataTrade(connectionString);
this.dataTrade.Logon += this.OnTradeLogon;
StateCalculator stateCalculator = new StateCalculator(dataTrade, dataFeed);
stateCalculator.StateInfoChanged += StateCalculator_StateInfoChanged;
this.dataFeed.Start();
this.dataTrade.Start();
var status = this.feedLogonEvent.WaitOne(LogonWaitingTimeout);
Assert.IsTrue(status, "Timeout of feed logon event");
status = this.tradeLogonEvent.WaitOne(LogonWaitingTimeout);
Assert.IsTrue(status, "Timeout of trade logon event");
status = this.stateInfoEvent.WaitOne(LogonWaitingTimeout*10000);
this.dataFeed.Stop();
this.dataTrade.Stop();
this.dataFeed.Logon -= this.OnFeedLogon;
this.dataTrade.Logon -= this.OnTradeLogon;
}
public BarsTimeIntervalEnumerator(DataFeed dataFeed, IStorage storage, string symbol, PriceType priceType, BarPeriod period, DateTime startTime, DateTime endTime, int preferredBufferSize)
: base(dataFeed, storage, symbol, priceType, period, startTime, preferredBufferSize)
{
this.endTime = endTime;
this.Reset();
}
public BarsCountEnumerator(DataFeed dataFeed, IStorage storage, string symbol, PriceType priceType, BarPeriod period, DateTime startTime, int barsNumber, int preferredBufferSize)
: base(dataFeed, storage, symbol, priceType, period, startTime, preferredBufferSize)
{
this.barsNumber = barsNumber;
this.Reset();
}
public void Cleanup()
{
Cleanup(this.dataFeed);
this.dataFeed = null;
Cleanup(this.dataTrade);
this.dataTrade = null;
}
public static void RegisterToFeed(DataFeed feed, FinancialCalculator calculator)
{
feed.Tick += (object sender, TickEventArgs e) =>
{
calculator.Prices.Update(e.Tick.Symbol, e.Tick.Bid, e.Tick.Ask);
};
feed.Server.SubscribeToQuotes(Symbols.Select(symbol=>symbol.Name), 1);
}
public void StartFeed()
{
if (this.dataClient != null)
throw new InvalidOperationException("Start method can be called only once.");
var connectionString = this.Builder.ToString();
var feed = new DataFeed(connectionString);
feed.SymbolInfo += this.OnSymbolInfo;
this.dataClient = feed;
this.dataClient.Start();
}
public void Cleanup()
{
if (this.dataFeed != null)
{
if (this.dataFeed.IsStarted)
{
this.dataFeed.Stop();
}
this.dataFeed.Dispose();
this.dataFeed = null;
}
}
static DataFeed CreateDataFeed()
{
var builder = new FixConnectionStringBuilder
{
SecureConnection = true,
Port = 5003,
Address = Settings.Default.DataSources_FDK_Server,
Username = Settings.Default.DataSources_FDK_Username,
Password = Settings.Default.DataSources_FDK_Password,
};
var dataFeed = new DataFeed(builder.ToString());
return dataFeed;
}
public StorageDataSourceProvider()
{
this.dataFeed = CreateDataFeed();
this.storage = new DataFeedStorage(Settings.Default.DataSources_FDK_StorageLocation, StorageProvider.Ntfs, this.dataFeed, flushOnDispose: true);
this.dataFeed.Start();
var symbols = this.GetSymbols();
var sources = symbols.Select(o =>
{
return new []
{
new SymbolBarsDataSource(this.dataFeed, this.storage, o, PriceType.Bid),
new SymbolBarsDataSource(this.dataFeed, this.storage, o, PriceType.Ask)
};
});
this.DataSources = sources.SelectMany(o => o)
.ToArray();
}
internal Snapshot(DataTrade trade, DataFeed feed, StateCalculator calculator, object synchronizer, AutoResetEvent syncEvent)
{
this.synchronizer = synchronizer;
this.syncEvent = syncEvent;
this.calculator = calculator;
this.Quotes = new Dictionary<string, Quote>();
trade.Logon += this.OnTradeLogon;
trade.SessionInfo += this.OnTradeSession;
trade.AccountInfo += this.OnAccountInfo;
trade.Logout += this.OnTradeLogout;
feed.Logon += this.OnFeedLogon;
feed.Logout += this.OnFeedLogout;
feed.SymbolInfo += this.OnFeedSymbolInfo;
feed.SessionInfo += this.OnFeedSessionInfo;
calculator.StateInfoChanged += this.OnFinancialInfoChanged;
}
static void ValidateArguments(DataFeed datafeed, string symbol, BarPeriod period, int preferredBufferSize)
{
if (datafeed == null)
{
throw new ArgumentNullException(nameof(datafeed), "DataFeed instance can not be null.");
}
if (symbol == null)
{
throw new ArgumentNullException(nameof(symbol), "Symbol can not be null.");
}
if (period == null)
{
throw new ArgumentNullException(nameof(period), "Bar period instance can not be null.");
}
if (preferredBufferSize <= 1)
{
throw new ArgumentOutOfRangeException(nameof(preferredBufferSize), preferredBufferSize, "Preferred buffer size should be more than 1.");
}
}
void BackwardBarsEnumeration(ConnectionStringBuilder builder)
{
var connectionString = builder.ToString();
this.dataFeed = new DataFeed(connectionString);
this.dataFeed.Logon += this.OnLogon;
this.dataFeed.Start();
var status = this.logonEvent.WaitOne(LogonWaitingTimeout);
Assert.IsTrue(status, "Timeout of logon event");
var startTime = new DateTime(2015, 10, 10, 12, 0, 0, 0, DateTimeKind.Utc);
var endTime = new DateTime(2015, 10, 10, 12, 1, 0, 0, DateTimeKind.Utc);
var data = new List<Bar>();
var bars = new Bars(this.dataFeed, "EURUSD", PriceType.Bid, BarPeriod.S1, endTime, startTime);
foreach (var element in bars)
{
Assert.IsTrue(startTime <= element.From, "startTime <= element.From");
Assert.IsTrue(element.To <= endTime, "element.To <= endTime");
Assert.IsTrue(element.From < element.To, "Invalid a bar timestamp");
data.Add(element);
}
this.dataFeed.Logon -= this.OnLogon;
this.dataFeed.Stop();
for (var index = 1; index < data.Count; ++index)
{
var first = data[index];
var second = data[index - 1];
Assert.IsTrue(first.To <= second.From, "Invalid bars sequence order.");
}
}
public void Tick(ConnectionStringBuilder builder)
{
var connectionString = builder.ToString();
this.dataFeed = new DataFeed(connectionString);
this.dataFeed.Logon += this.OnLogon;
this.dataFeed.Tick += this.OnTick;
this.dataFeed.Start();
var status = this.logonEvent.WaitOne(LogonWaitingTimeout);
Assert.IsTrue(status, "Timeout of logon event");
var symbols = new[] { "EURUSD" };
this.dataFeed.Server.SubscribeToQuotes(symbols, 0);
status = this.tickEvent.WaitOne(TickWaitingTimeout);
Assert.IsTrue(status, "Timeout of tick event");
this.dataFeed.Stop();
this.dataFeed.Logon -= this.OnLogon;
this.dataFeed.Tick -= this.OnTick;
}
void IncorrectSubscribeToQuotes(ConnectionStringBuilder builder)
{
var connectionString = builder.ToString();
this.dataFeed = new DataFeed(connectionString);
this.dataFeed.Logon += this.OnLogon;
this.dataFeed.Start();
var status = this.logonEvent.WaitOne(LogonWaitingTimeout);
Assert.IsTrue(status, "Timeout of logon event");
try
{
this.dataFeed.Server.SubscribeToQuotes(null, 0);
Assert.Fail("Null parameter has been accepted");
}
catch
{
}
try
{
var symbols = new[] { "EURUSD" };
this.dataFeed.Server.SubscribeToQuotes(symbols, -1);
Assert.Fail("Negative parameter has been accepted");
}
catch
{
}
try
{
var symbols = new[] { "EURUSD" };
this.dataFeed.Server.SubscribeToQuotes(symbols, 6);
Assert.Fail("Negative parameter has been accepted");
}
catch
{
}
try
{
var symbols = new[] { "YYY/XXX" };
this.dataFeed.Server.SubscribeToQuotes(symbols, 0);
Assert.Fail("Invalid symbols have been accepted");
}
catch
{
}
this.dataFeed.Stop();
this.dataFeed.Logon -= this.OnLogon;
}
void NotValidUsernameAndPasswordLogout(ConnectionStringBuilder builder)
{
var fixBuilder = builder as FixConnectionStringBuilder;
fixBuilder.Username = "******";
fixBuilder.Password = "******";
fixBuilder.FixLogDirectory = "C:\\Temporary\\logs";
var connectionString = builder.ToString();
this.dataFeed = new DataFeed(connectionString);
this.dataFeed.Logon += OnLogon;
this.dataFeed.Logout += OnLogout;
this.dataFeed.Start();
var status = this.logonEvent.WaitOne(LogonWaitingTimeout);
Assert.IsTrue(!status, "Logon has been generated by error");
status = this.logoutEvent.WaitOne(10 * LogoutWaitingTimeout);
Assert.IsTrue(status, "Timeout of logout event");
if ("ext.0.0" == fixBuilder.ProtocolVersion)
{
Assert.IsTrue(LogoutReason.None == this.logoutReason);
}
else
{
Assert.IsTrue(LogoutReason.InvalidCredentials == this.logoutReason);
}
this.dataFeed.Stop();
this.dataFeed.Logon -= OnLogon;
this.dataFeed.Logout -= OnLogout;
}
void GetQuotes(DataFeed feed)
{
foreach (var element in this.symbols)
{
this.GetQuotes(feed, element.Name);
}
}
void CreateAndDestroy(ConnectionStringBuilder builder)
{
var connectionString = builder.ToString();
this.dataFeed = new DataFeed(connectionString);
}
public BarsTimeIntervalEnumerator(DataFeed dataFeed, string symbol, PriceType priceType, BarPeriod period, DateTime startTime, DateTime endTime, int preferredBufferSize)
: this(dataFeed, null, symbol, priceType, period, startTime, endTime, preferredBufferSize)
{
}
void Run(DataFeed feed)
{
this.CheckCancel();
this.Log("Starting data feed");
if (feed.Start(30000))
{
this.Log("Data feed is started");
this.GetSymbols(feed);
this.GetQuotes(feed);
}
else
{
this.Log("Couldn't start data feed");
}
}
void ThreadMethod(object obj)
{
try
{
var connectionString = (string)obj;
this.Log("Creating data feed");
using (var feed = new DataFeed(connectionString))
{
this.Log("Data feed is created");
this.Run(feed);
this.Log("Disposing data feed");
}
this.Log("Data feed is disposed");
}
catch(Exception ex)
{
this.Log(ex.Message);
}
this.Finish();
}
void GetQuotes(DataFeed feed, string symbol)
{
this.CheckCancel();
this.Log("Getting quotes for {0}", symbol);
var bars = new PairBars(feed, symbol, BarPeriod.S1, timeStamp, -1);
foreach (var element in bars)
{
if ((null != element.Bid) && (null != element.Ask))
{
var entry = new FullSymbolEntry(symbol)
{
Bid = element.Bid.Close,
Ask = element.Ask.Close,
};
this.quotes.Add(entry);
this.Log("Quotes for symbol {0} have been got: {1}/{2}", symbol, entry.Bid, entry.Ask);
}
else
{
this.Log("Quotes for symbol {0} are not available", symbol);
}
break;
}
}
void ForwardAndBackwardBarsEnumerationConsistency(ConnectionStringBuilder builder)
{
var connectionString = builder.ToString();
this.dataFeed = new DataFeed(connectionString);
this.dataFeed.Logon += this.OnLogon;
this.dataFeed.Start();
var status = this.logonEvent.WaitOne(LogonWaitingTimeout);
Assert.IsTrue(status, "Timeout of logon event");
var startTime = new DateTime(2011, 10, 10, 12, 0, 0, 0, DateTimeKind.Utc);
var endTime = new DateTime(2011, 10, 10, 12, 1, 0, 0, DateTimeKind.Utc);
var forwardBars = new Bars(this.dataFeed, "EURUSD", PriceType.Bid, BarPeriod.S1, startTime, endTime);
var forwardData = forwardBars.ToList();
var backwardBars = new Bars(this.dataFeed, "EURUSD", PriceType.Bid, BarPeriod.S1, endTime, startTime);
var backwardData = backwardBars.ToList();
var count = forwardData.Count;
Assert.IsTrue(forwardData.Count == backwardData.Count, "forwardData.Count == backwardData.Count");
for (var index = 0; index < count; ++index)
{
var first = forwardData[index];
var second = backwardData[count - 1 - index];
Assert.IsTrue(first.From == second.From);
Assert.IsTrue(first.To == second.To);
}
}
public BarsCountEnumerator(DataFeed dataFeed, string symbol, PriceType priceType, BarPeriod period, DateTime startTime, int barsNumber, int preferredBufferSize)
: this(dataFeed, null, symbol, priceType, period, startTime, barsNumber, preferredBufferSize)
{
}
/// <summary>
/// Creates a new Bars stream instance.
/// If startTime is less or equal than endTime then this is forward bars enumeration (from past to future), otherwise this is backward enumeration (from future to past).
/// Anyway all bars should be in the following time range: Min(startTime, endTime) <= Bar.From and Bar.To <= Max(startTime, endTime)
/// </summary>
/// <param name="datafeed">Datafeed instance; can not be null.</param>
/// <param name="symbol">A required symbol; can not be null.</param>
/// <param name="period">Bar period instance; can not be null.</param>
/// <param name="startTime">A start time of bars enumeration.</param>
/// <param name="endTime">A end time of bars enumeration.</param>
/// <param name="preferredBufferSize">Bars enumeration requests bars from server by chunks. This is preferred chunk size. It should be positive.</param>
/// <exception cref="System.ArgumentNullException">If datafeed, period or symbol is null.</exception>
/// <exception cref="System.ArgumentOutOfRangeException">If preferredBufferSize is less than 2.</exception>
public PairBars(DataFeed datafeed, string symbol, BarPeriod period, DateTime startTime, DateTime endTime, int preferredBufferSize)
{
this.bids = new Bars(datafeed, symbol, PriceType.Bid, period, startTime, endTime, preferredBufferSize);
this.asks = new Bars(datafeed, symbol, PriceType.Ask, period, startTime, endTime, preferredBufferSize);
this.positive = DateTime.Compare(startTime, endTime) >= 0;
}
public void SetupPathsAndConnect(string rootPath)
{
if (Initialized)
{
throw new InvalidOperationException("Fdk seems to be initialized for second time");
}
Initialized = true;
// create and specify log directory
string root;
if (string.IsNullOrEmpty(rootPath))
{
var assembly = Assembly.GetEntryAssembly();
root = assembly == null ? Directory.GetCurrentDirectory() : assembly.Location;
root = Path.GetDirectoryName(root);
if (root == null)
throw new InvalidDataException("FDK assembly's directory seems to be invalid");
}
else
{
root = rootPath;
}
var logsPath = Path.Combine(root, "Logs\\Fix");
Directory.CreateDirectory(logsPath);
Builder.FixLogDirectory = logsPath;
Feed = new DataFeed(Builder.ToString()) { SynchOperationTimeout = 18000 };
var storagePath = Path.Combine(root, "Storage");
Directory.CreateDirectory(storagePath);
Storage = new DataFeedStorage(storagePath, StorageProvider.Ntfs, Feed, true);
}
protected DirectionalBarsEnumerator(DataFeed dataFeed, IStorage storage, string symbol, PriceType priceType, BarPeriod period, DateTime startTime, int preferredBufferSize)
: base(dataFeed, storage, symbol, priceType, period, startTime, preferredBufferSize)
{
}
public BarsCountEnumerator(DataFeed dataFeed, string symbol, PriceType priceType, BarPeriod period, DateTime startTime, int barsNumber, int preferredBufferSize)
: this(dataFeed, null, symbol, priceType, period, startTime, barsNumber, preferredBufferSize)
{
}
/// <summary>
/// Creates a new Bars stream instance.
/// If startTime is less or equal than endTime then this is forward bars enumeration (from past to future), otherwise this is backward enumeration (from future to past).
/// Anyway all bars should be in the following time range: Min(startTime, endTime) <= Bar.From and Bar.To <= Max(startTime, endTime)
/// </summary>
/// <param name="datafeed">DataFeed instance; can not be null.</param>
/// <param name="symbol">A required symbol; can not be null.</param>
/// <param name="priceType">A required price type: Bid or Ask.</param>
/// <param name="period">Bar period instance; can not be null.</param>
/// <param name="startTime">A start time of bars enumeration.</param>
/// <param name="endTime">A end time of bars enumeration.</param>
/// <param name="preferredBufferSize">Bars enumeration requests bars from server by chunks. This is preferred chunk size. It should be positive.</param>
/// <exception cref="System.ArgumentNullException">If datafeed, period or symbol is null.</exception>
/// <exception cref="System.ArgumentOutOfRangeException">If preferredBufferSize is less than 2.</exception>
public Bars(DataFeed datafeed, string symbol, PriceType priceType, BarPeriod period, DateTime startTime, DateTime endTime, int preferredBufferSize)
{
ValidateArguments(datafeed, symbol, period, preferredBufferSize);
this.enumerator = new BarsTimeIntervalEnumerator(datafeed, symbol, priceType, period, startTime, endTime, preferredBufferSize);
}
void GetSymbols(DataFeed feed)
{
this.CheckCancel();
this.Log("Getting symbols");
this.symbols = feed.Server.GetSymbols();
this.Log("{0} symbols have been got", this.symbols.Length);
}
/// <summary>
/// Creates a new Bars stream instance.
/// If barsNumber is less than zero then this is forward bars enumeration (from past to future), otherwise this is backward enumeration (from future to past).
/// Anyway all bars should be in the following time range:
/// Bar.From >= startTime for forward enumeration
/// Bar.To <= startTime for backward enumeration
/// </summary>
/// <param name="datafeed">Datafeed instance; can not be null.</param>
/// <param name="symbol">A required symbol; can not be null.</param>
/// <param name="priceType">A required price type: Bid or Ask.</param>
/// <param name="period">Bar period instance; can not be null.</param>
/// <param name="startTime">A start time of bars enumeration.</param>
/// <param name="barsNumber">Requested bars number; positive value means forward enumeration; negative value means backward enumeration.</param>
/// <param name="preferredBufferSize">Bars enumeration requests bars from server by chunks. This is preferred chunk size. It should be positive.</param>
/// <exception cref="System.ArgumentNullException">If datafeed, period or symbol is null.</exception>
/// <exception cref="System.ArgumentOutOfRangeException">If preferredBufferSize is less than 2.</exception>
public Bars(DataFeed datafeed, string symbol, PriceType priceType, BarPeriod period, DateTime startTime, int barsNumber, int preferredBufferSize)
{
ValidateArguments(datafeed, symbol, period, preferredBufferSize);
this.enumerator = new BarsCountEnumerator(datafeed, symbol, priceType, period, startTime, barsNumber, preferredBufferSize);
}
public BarsTimeIntervalEnumerator(DataFeed dataFeed, string symbol, PriceType priceType, BarPeriod period, DateTime startTime, DateTime endTime, int preferredBufferSize)
: this(dataFeed, null, symbol, priceType, period, startTime, endTime, preferredBufferSize)
{
}
/// <summary>
/// Creates a new Bars stream instance.
/// If startTime is less or equal than endTime then this is forward bars enumeration (from past to future), otherwise this is backward enumeration (from future to past).
/// Anyway all bars should be in the following time range: Min(startTime, endTime) <= Bar.From and Bar.To <= Max(startTime, endTime)
/// </summary>
/// <param name="datafeed">DataFeed instance; can not be null.</param>
/// <param name="symbol">A required symbol; can not be null.</param>
/// <param name="priceType">A required price type: Bid or Ask.</param>
/// <param name="period">Bar period instance; can not be null.</param>
/// <param name="startTime">A start time of bars enumeration.</param>
/// <param name="endTime">A end time of bars enumeration.</param>
/// <exception cref="System.ArgumentNullException">If datafeed, period or symbol is null.</exception>
public Bars(DataFeed datafeed, string symbol, PriceType priceType, BarPeriod period, DateTime startTime, DateTime endTime)
: this(datafeed, symbol, priceType, period, startTime, endTime, DefaultBufferSize)
{
}
void Logon(ConnectionStringBuilder builder)
{
var connectionString = builder.ToString();
this.dataFeed = new DataFeed(connectionString);
this.dataFeed.Logon += this.OnLogon;
this.dataFeed.Start();
var status = this.logonEvent.WaitOne(LogonWaitingTimeout);
Assert.IsTrue(status, "Timeout of logon event");
var fixBuilder = builder as FixConnectionStringBuilder;
if (fixBuilder != null)
{
var st = this.dataFeed.UsedProtocolVersion.ToString();
Assert.IsTrue(fixBuilder.ProtocolVersion == st, "Server is not supported required protocol version");
}
this.dataFeed.Stop();
this.dataFeed.Logon -= this.OnLogon;
}
/// <summary>
/// Creates a new Bars stream instance.
/// If barsNumber is less than zero then this is forward bars enumeration (from past to future), otherwise this is backward enumeration (from future to past).
/// Anyway all bars should be in the following time range:
/// Bar.From >= startTime for forward enumeration
/// Bar.To <= startTime for backward enumeration
/// </summary>
/// <param name="datafeed">Datafeed instance; can not be null.</param>
/// <param name="symbol">A required symbol; can not be null.</param>
/// <param name="priceType">A required price type: Bid or Ask.</param>
/// <param name="period">Bar period instance; can not be null.</param>
/// <param name="startTime">A start time of bars enumeration.</param>
/// <param name="barsNumber">Requested bars number; positive value means forward enumeration; negative value means backward enumeration.</param>
/// <exception cref="System.ArgumentNullException">If datafeed, period or symbol is null.</exception>
public Bars(DataFeed datafeed, string symbol, PriceType priceType, BarPeriod period, DateTime startTime, int barsNumber)
: this(datafeed, symbol, priceType, period, startTime, barsNumber, DefaultBufferSize)
{
}
void RegularLogout(ConnectionStringBuilder builder)
{
var fixBuilder = builder as FixConnectionStringBuilder;
var connectionString = builder.ToString();
this.dataFeed = new DataFeed(connectionString);
this.dataFeed.Logon += this.OnLogon;
this.dataFeed.Logout += this.OnLogout;
this.dataFeed.Start();
var status = this.logonEvent.WaitOne(LogonWaitingTimeout);
Assert.IsTrue(status, "Timeout of logon event");
this.dataFeed.Stop();
status = this.logoutEvent.WaitOne(0);
Assert.IsTrue(status, "Timeout of logout event");
this.dataFeed.Logon -= this.OnLogon;
this.dataFeed.Logout -= this.OnLogout;
Assert.IsTrue(LogoutReason.ClientInitiated == this.logoutReason);
}
protected DirectionalBarsEnumerator(DataFeed dataFeed, IStorage storage, string symbol, PriceType priceType, BarPeriod period, DateTime startTime, int preferredBufferSize)
: base(dataFeed, storage, symbol, priceType, period, startTime, preferredBufferSize)
{
}
void ConnectionErrorLogout(ConnectionStringBuilder builder)
{
var fixBuilder = builder as FixConnectionStringBuilder;
fixBuilder.Address = "localhost";
fixBuilder.FixLogDirectory = "C:\\Temporary\\Logs";
var connectionString = builder.ToString();
this.dataFeed = new DataFeed(connectionString);
this.dataFeed.Logon += this.OnLogon;
this.dataFeed.Logout += this.OnLogout;
this.dataFeed.Start();
var status = this.logonEvent.WaitOne(LogonWaitingTimeout);
Assert.IsTrue(!status, "Logon has been generated by error");
status = this.logoutEvent.WaitOne(10 * LogoutWaitingTimeout);
Assert.IsTrue(status, "Timeout of logout event");
Assert.IsTrue(LogoutReason.NetworkError == this.logoutReason);
this.dataFeed.Stop();
this.dataFeed.Logon -= this.OnLogon;
this.dataFeed.Logout -= this.OnLogout;
}