public void Setup()
{
_list = new ConcurrentNotifierBlockingList <int>();
for (int i = 0; i < 5; i++)
{
_list.TryAdd(i);
}
}
public void Setup()
{
_list = new ConcurrentNotifierBlockingList<int>();
for (int i = 0; i < 5; i++)
{
_list.TryAdd(i);
}
}
private Timer connectionTimer; //tries to reconnect every once in a while
/// <summary>
/// Constructor
/// </summary>
/// <param name="localStorage"></param>
/// <param name="additionalDataSources">Optional. Pass any additional data sources (for testing purposes).</param>
public RealTimeDataBroker(IDataStorage localStorage,
IEnumerable <IRealTimeDataSource> additionalDataSources = null)
{
connectionTimer = new Timer(10000);
connectionTimer.Elapsed += ConnectionTimerElapsed;
connectionTimer.Start();
DataSources = new ObservableDictionary <string, IRealTimeDataSource>();
if (additionalDataSources != null)
{
foreach (var ds in additionalDataSources)
{
ds.DataReceived += RealTimeData;
ds.Disconnected += SourceDisconnects;
ds.Error += s_Error;
DataSources.Add(ds.Name, ds);
}
}
//we need to set the appropriate event methods for every data source
//foreach (var s in DataSources.Values)
//{
// s.DataReceived += RealTimeData;
// s.Disconnected += SourceDisconnects;
// s.Error += s_Error;
//}
ActiveStreams = new ConcurrentNotifierBlockingList <RealTimeStreamInfo>();
arrivedBars = new BlockingCollection <RealTimeDataEventArgs>();
StreamSubscribersCount = new Dictionary <RealTimeStreamInfo, int>();
requests = new Dictionary <int, RealTimeDataRequest>();
usedIDs = new List <int>();
//connect to our data sources
TryConnect();
//local storage
this.localStorage = localStorage;
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="pubPort">The port to use for the publishing server.</param>
/// <param name="reqPort">The port to use for the request server.</param>
public RealTimeDataBroker(int pubPort, int reqPort)
{
if (pubPort == reqPort) throw new Exception("Publish and request ports must be different");
PublisherPort = pubPort;
RequestPort = reqPort;
_connectionTimer = new Timer(10000);
_connectionTimer.Elapsed += ConnectionTimerElapsed;
_connectionTimer.Start();
DataSources = new Dictionary<string, IRealTimeDataSource>
{
{"SIM", new RealTimeSim()},
{"Interactive Brokers", new IB()}
};
//we need to set the appropriate event methods for every data source
foreach (IRealTimeDataSource s in DataSources.Values)
{
s.DataReceived += RealTimeData;
s.Disconnected += SourceDisconnects;
s.Error += s_Error;
}
ActiveStreams = new ConcurrentNotifierBlockingList<RealTimeStreamInfo>();
_arrivedBars = new BlockingCollection<RealTimeDataEventArgs>();
_streamSubscribersCount = new Dictionary<RealTimeStreamInfo, int>();
_ms = new MemoryStream();
//connect to our data sources
TryConnect();
//finally start listening and stuff
StartServer();
}
public MainWindow()
{
Common.Logging.LogManager.Adapter = new NLogLoggerFactoryAdapter(new Common.Logging.Configuration.NameValueCollection());
//make sure we can connect to the database
CheckDBConnection();
//set the log directory
SetLogDirectory();
//set the connection string
DBUtils.SetConnectionString();
//set EF configuration, necessary for MySql to work
DBUtils.SetDbConfiguration();
InitializeComponent();
DataContext = this;
//load datagrid layout
string layoutFile = AppDomain.CurrentDomain.BaseDirectory + "GridLayout.xml";
if (File.Exists(layoutFile))
{
try
{
InstrumentsGrid.DeserializeLayout(File.ReadAllText(layoutFile));
}
catch
{
}
}
LogMessages = new ConcurrentNotifierBlockingList<LogEventInfo>();
//target is where the log managers send their logs, here we grab the memory target which has a Subject to observe
var target = LogManager.Configuration.AllTargets.Single(x => x.Name == "myTarget") as MemoryTarget;
//Log unhandled exceptions
AppDomain.CurrentDomain.UnhandledException += AppDomain_CurrentDomain_UnhandledException;
//we subscribe to the messages and send them all to the LogMessages collection
if (target != null)
target.Messages.Subscribe(msg => LogMessages.TryAdd(msg));
//build the instruments grid context menu
//we want a button for each BarSize enum value in the UpdateFreqSubMenu menu
foreach (int value in Enum.GetValues(typeof(BarSize)))
{
var button = new MenuItem
{
Header = Regex.Replace(((BarSize)value).ToString(), "([A-Z])", " $1").Trim(),
Tag = (BarSize)value
};
button.Click += UpdateHistoricalDataBtn_ItemClick;
((MenuItem)Resources["UpdateFreqSubMenu"]).Items.Add(button);
}
//create metadata db if it doesn't exist
var entityContext = new MyDBContext();
entityContext.Database.Initialize(false);
//seed the datasources no matter what, because these are added frequently
Seed.SeedDatasources(entityContext);
//check for any exchanges, seed the db with initial values if nothing is found
if (!entityContext.Exchanges.Any())
{
Seed.DoSeed();
}
//create data db if it doesn't exist
var dataContext = new DataDBContext();
dataContext.Database.Initialize(false);
dataContext.Dispose();
//create quartz db if it doesn't exist
QuartzUtils.InitializeDatabase(Settings.Default.databaseType);
//build the tags menu
var allTags = entityContext.Tags.ToList();
BuildTagContextMenu(allTags);
//build session templates menu
BuildSetSessionTemplateMenu();
Instruments = new ObservableCollection<Instrument>();
var mgr = new InstrumentManager();
var instrumentList = mgr.FindInstruments(entityContext);
foreach (Instrument i in instrumentList)
{
Instruments.Add(i);
}
//create brokers
var cfRealtimeBroker = new ContinuousFuturesBroker(new QDMSClient.QDMSClient(
"RTDBCFClient",
"127.0.0.1",
Properties.Settings.Default.rtDBReqPort,
Properties.Settings.Default.rtDBPubPort,
Properties.Settings.Default.instrumentServerPort,
Properties.Settings.Default.hDBPort), new InstrumentManager(), connectImmediately: false);
var cfHistoricalBroker = new ContinuousFuturesBroker(new QDMSClient.QDMSClient(
"HDBCFClient",
"127.0.0.1",
Properties.Settings.Default.rtDBReqPort,
Properties.Settings.Default.rtDBPubPort,
Properties.Settings.Default.instrumentServerPort,
Properties.Settings.Default.hDBPort), new InstrumentManager(), connectImmediately: false);
var localStorage = DataStorageFactory.Get();
RealTimeBroker = new RealTimeDataBroker(cfRealtimeBroker, localStorage,
new IRealTimeDataSource[] {
//new Xignite(Properties.Settings.Default.xigniteApiToken),
//new Oanda(Properties.Settings.Default.oandaAccountId, Properties.Settings.Default.oandaAccessToken),
new IB(Properties.Settings.Default.ibClientHost, Properties.Settings.Default.ibClientPort, Properties.Settings.Default.rtdClientIBID),
//new ForexFeed(Properties.Settings.Default.forexFeedAccessKey, ForexFeed.PriceType.Mid)
});
HistoricalBroker = new HistoricalDataBroker(cfHistoricalBroker, localStorage,
new IHistoricalDataSource[] {
new Yahoo(),
new FRED(),
//new Forexite(),
new IB(Properties.Settings.Default.ibClientHost, Properties.Settings.Default.ibClientPort, Properties.Settings.Default.histClientIBID),
new Quandl(Properties.Settings.Default.quandlAuthCode),
new BarChart(Properties.Settings.Default.barChartApiKey)
});
var countryCodeHelper = new CountryCodeHelper(entityContext.Countries.ToList());
EconomicReleaseBroker = new EconomicReleaseBroker("FXStreet",
new[] { new fx.FXStreet(countryCodeHelper) });
//create the various servers
_realTimeServer = new RealTimeDataServer(Properties.Settings.Default.rtDBPubPort, Properties.Settings.Default.rtDBReqPort, RealTimeBroker);
_instrumentsServer = new InstrumentsServer(Properties.Settings.Default.instrumentServerPort, mgr);
_historicalDataServer = new HistoricalDataServer(Properties.Settings.Default.hDBPort, HistoricalBroker);
//and start them
_realTimeServer.StartServer();
_instrumentsServer.StartServer();
_historicalDataServer.StartServer();
//we also need a client to make historical data requests with
_client = new QDMSClient.QDMSClient(
"SERVERCLIENT",
"localhost",
Properties.Settings.Default.rtDBReqPort,
Properties.Settings.Default.rtDBPubPort,
Properties.Settings.Default.instrumentServerPort,
Properties.Settings.Default.hDBPort);
_client.Connect();
_client.HistoricalDataReceived += _client_HistoricalDataReceived;
ActiveStreamGrid.ItemsSource = RealTimeBroker.ActiveStreams;
//create the scheduler
var quartzSettings = QuartzUtils.GetQuartzSettings(Settings.Default.databaseType);
ISchedulerFactory schedulerFactory = new StdSchedulerFactory(quartzSettings);
_scheduler = schedulerFactory.GetScheduler();
_scheduler.JobFactory = new JobFactory(HistoricalBroker,
Properties.Settings.Default.updateJobEmailHost,
Properties.Settings.Default.updateJobEmailPort,
Properties.Settings.Default.updateJobEmailUsername,
Properties.Settings.Default.updateJobEmailPassword,
Properties.Settings.Default.updateJobEmailSender,
Properties.Settings.Default.updateJobEmail,
new UpdateJobSettings(
noDataReceived: Properties.Settings.Default.updateJobReportNoData,
errors: Properties.Settings.Default.updateJobReportErrors,
outliers: Properties.Settings.Default.updateJobReportOutliers,
requestTimeouts: Properties.Settings.Default.updateJobTimeouts,
timeout: Properties.Settings.Default.updateJobTimeout,
toEmail: Properties.Settings.Default.updateJobEmail,
fromEmail: Properties.Settings.Default.updateJobEmailSender),
localStorage, new InstrumentManager(),
EconomicReleaseBroker
);
_scheduler.Start();
//Take jobs stored in the qmds db and move them to the quartz db - this can be removed in the next version
MigrateJobs(entityContext, _scheduler);
entityContext.Dispose();
ShowChangelog();
}