public void RequestRealTimeData(RealTimeDataRequest request)
{
int id = _requestCounter++;
_requestIdMap.Add(request.AssignedID, id);
if (request.Frequency == BarSize.Tick)
{
string symbol = GetSymbol(request).ToLower();
string url = $"wss://stream.binance.com:9443/ws/{symbol}@aggTrade";
var tickSocket = new WebSocket(url);
tickSocket.MessageReceived += (s, e) => RealTimeTick(request.Instrument.ID.Value, request.AssignedID, e);
_sockets.Add(id, tickSocket);
tickSocket.Open();
}
else
{
string symbol = GetSymbol(request).ToLower();
string interval = BarSizetoInterval(request.Frequency);
string url = $"wss://stream.binance.com:9443/ws/{symbol}@kline_{interval}";
var barSocket = new WebSocket(url);
barSocket.MessageReceived += (s, e) => RealTimeBar(request.Instrument.ID.Value, request.AssignedID, e);
_sockets.Add(id, barSocket);
barSocket.Open();
}
}
private static void Main()
{
//create the client, assuming the default port settings
using (var client = new QDMSClient.QDMSClient("SampleClient", "127.0.0.1", 5556, 5557, 5558, 5555)) {
//hook up the events needed to receive data & error messages
client.HistoricalDataReceived += client_HistoricalDataReceived;
client.RealTimeDataReceived += client_RealTimeDataReceived;
client.LocallyAvailableDataInfoReceived += client_LocallyAvailableDataInfoReceived;
client.Error += client_Error;
//connect to the server
client.Connect();
//make sure the connection was succesful before we continue
if (!client.Connected)
{
Console.WriteLine("Could not connect.");
Console.WriteLine("Press enter to exit.");
Console.ReadLine();
return;
}
//request the list of available instruments
var instruments = client.FindInstruments();
foreach (var i in instruments)
{
Console.WriteLine($"Instrument ID {i.ID}: {i.Symbol} ({i.Type}), Datasource: {i.Datasource.Name}");
}
Thread.Sleep(3000);
//then we grab some historical data from Yahoo
//start by finding the SPY instrument
var spy = instruments.FirstOrDefault(x => x.Symbol == "SPY" && x.Datasource.Name == "Yahoo");
if (spy != null)
{
var req = new HistoricalDataRequest(
spy,
BarSize.OneDay,
new DateTime(2013, 1, 1),
new DateTime(2013, 1, 15));
client.RequestHistoricalData(req);
Thread.Sleep(3000);
//now that we downloaded the data, let's make a request to see what is stored locally
client.GetLocallyAvailableDataInfo(spy);
Thread.Sleep(3000);
//finally send a real time data request (from the simulated data datasource)
spy.Datasource.Name = "SIM";
var rtReq = new RealTimeDataRequest(spy, BarSize.OneSecond);
client.RequestRealTimeData(rtReq);
Thread.Sleep(3000);
//And then cancel the real time data stream
client.CancelRealTimeData(spy);
}
Console.WriteLine("Press enter to exit.");
Console.ReadLine();
}
}
private void SendIntradayBarRequest(Session session, RealTimeDataRequest req)
{
session.OpenService("//blp/refdata");
Service refDataService = session.GetService("//blp/refdata");
Request request = refDataService.CreateRequest("IntradayBarRequest");
// only one security/eventType per request
request.Set("security", req.Instrument.DatasourceSymbol);
request.Set("eventType", "TRADE");
request.Set("interval", req.Frequency.ToTimeSpan().TotalSeconds);
DateTime prevTradedDate = DateTime.Now.AddDays(-1); //todo fix
var startDateTime = string.Format("{0}-{1}-{2}T13:30:00", prevTradedDate.Year, prevTradedDate.Month, prevTradedDate.Day);
prevTradedDate = prevTradedDate.AddDays(1); // next day for end date
var endDateTime = string.Format("{0}-{1}-{2}T13:30:00", prevTradedDate.Year, prevTradedDate.Month, prevTradedDate.Day);
request.Set("startDateTime", startDateTime);
request.Set("endDateTime", endDateTime);
request.Set("gapFillInitialBar", true);
session.SendRequest(request, null);
}
public void RequestsFrontContractFromCFBrokerForContinuousFuturesRequests()
{
var cf = new ContinuousFuture()
{
ID = 1,
InstrumentID = 1,
Month = 1,
UnderlyingSymbol = new UnderlyingSymbol
{
ID = 1,
Symbol = "VIX",
Rule = new ExpirationRule()
}
};
var inst = new Instrument
{
ID = 1,
Symbol = "VIXCONTFUT",
IsContinuousFuture = true,
ContinuousFuture = cf,
Datasource = new Datasource {
ID = 999, Name = "MockSource"
}
};
var req = new RealTimeDataRequest(inst, BarSize.FiveSeconds);
_cfBrokerMock.Setup(x => x.RequestFrontContract(It.IsAny <Instrument>(), It.IsAny <DateTime?>())).Returns(0);
_broker.RequestRealTimeData(req);
_cfBrokerMock.Verify(x => x.RequestFrontContract(It.IsAny <Instrument>(), It.IsAny <DateTime?>()));
}
public void RealTimeDataIsSavedToLocalStorageIfFlagIsSet()
{
var inst = new Instrument
{
ID = 1,
Symbol = "SPY",
Datasource = new Datasource {
ID = 999, Name = "MockSource"
}
};
var req = new RealTimeDataRequest(inst, BarSize.FiveSeconds, savetoLocalStorage: true);
int assignedID = 0;
_dataSourceMock.Setup(x => x.RequestRealTimeData(It.IsAny <RealTimeDataRequest>())).Callback <RealTimeDataRequest>(r => assignedID = r.AssignedID);
_broker.RequestRealTimeData(req);
Thread.Sleep(100);
_dataSourceMock.Raise(x => x.DataReceived += null, new RealTimeDataEventArgs(1, 1389906576, 100, 100, 100, 100, 1000, 100, 5, assignedID));
_localStorageMock.Verify(x => x.AddDataAsync(
It.Is <OHLCBar>(y => y.Open == 100 && y.Volume == 1000),
It.Is <Instrument>(y => y.ID == 1 && y.Symbol == "SPY"),
It.Is <BarSize>(y => y == BarSize.FiveSeconds),
It.Is <bool>(y => y == false)));
}
public void ServerForwardsErrorToClientIfExceptionIsThrownInRequestRealTimeData()
{
var ds = new Datasource()
{
ID = 1, Name = "TestDS"
};
var inst = new Instrument()
{
ID = 1, Datasource = ds, DatasourceID = 1, Symbol = "SPY", Type = InstrumentType.Stock
};
var req = new RealTimeDataRequest(inst, BarSize.FiveSeconds, rthOnly: false, savetoLocalStorage: false);
string error = null;
int? requestID = -1;
_client.Error += (s, e) =>
{
error = e.ErrorMessage;
requestID = e.RequestID;
};
_brokerMock.Setup(x => x.RequestRealTimeData(It.IsAny <RealTimeDataRequest>())).Throws(new Exception("testerror"));
_client.RequestRealTimeData(req);
Thread.Sleep(100);
Assert.AreEqual("Real time data request error: testerror", error);
}
public void ServerReturnsErrorToClientIfNoInstrumentIdIsSet()
{
var ds = new Datasource()
{
ID = 1, Name = "TestDS"
};
var inst = new Instrument()
{
ID = null, Datasource = ds, DatasourceID = 1, Symbol = "SPY", Type = InstrumentType.Stock
};
var req = new RealTimeDataRequest(inst, BarSize.FiveSeconds, rthOnly: false, savetoLocalStorage: false);
string error = null;
int? requestID = -1;
_client.Error += (s, e) =>
{
error = e.ErrorMessage;
requestID = e.RequestID;
};
_client.RequestRealTimeData(req);
Thread.Sleep(100);
Assert.AreEqual("Real time data request error: Instrument had no ID set.", error);
}
public void ArrivedRealTimeDataCorrentlyRaisesEvent()
{
var exchange = new Exchange {
ID = 1, Name = "Ex", Timezone = "Pacific Standard Time"
};
var req = new RealTimeDataRequest
{
Instrument = new Instrument {
ID = 1, Symbol = "SPY", UnderlyingSymbol = "SPY", Exchange = exchange, Currency = "USD", Type = InstrumentType.Stock
},
Frequency = QDMS.BarSize.FiveSeconds,
RTHOnly = true
};
int requestID = -1;
_ibClientMock
.Setup(x => x.RequestRealTimeBars(
It.IsAny <int>(),
It.IsAny <Contract>(),
It.IsAny <string>(),
It.IsAny <bool>(),
It.IsAny <List <TagValue> >()))
.Callback <int, Contract, string, Boolean, List <TagValue> >((y, a, b, c, d) => requestID = y);
_ibDatasource.RequestRealTimeData(req);
bool received = false;
_ibDatasource.DataReceived += (sender, e) => received = true;
_ibClientMock.Raise(x => x.RealTimeBar += null, new RealTimeBarEventArgs(requestID, 10000000, 1, 2, 3, 4, 5, 3, 5));
Assert.IsTrue(received);
}
public void ServerForwardsErrorToClientIfExceptionIsThrownInRequestRealTimeData()
{
var ds = new Datasource {
ID = 1, Name = "TestDS"
};
var inst = new Instrument {
ID = 1, Datasource = ds, DatasourceID = 1, Symbol = "SPY", Type = InstrumentType.Stock
};
var req = new RealTimeDataRequest(inst, BarSize.FiveSeconds, false);
string error = null;
int? requestId = null;
_client.Error += (s, e) =>
{
error = e.ErrorMessage;
requestId = e.RequestID;
};
_brokerMock.Setup(x => x.RequestRealTimeData(It.IsAny <RealTimeDataRequest>())).Throws(new Exception("testerror"));
_client.RequestRealTimeData(req);
Thread.Sleep(DefaultDelayInMilliseconds);
Assert.IsTrue(!string.IsNullOrEmpty(error));
Assert.IsTrue(requestId.HasValue);
}
/// <summary>
/// Request a new real time data stream. Data will be delivered through the RealTimeDataReceived event.
/// </summary>
/// <returns>An ID uniquely identifying this real time data request. -1 if there was an error.</returns>
public int RequestRealTimeData(RealTimeDataRequest request)
{
if (!Connected)
{
RaiseEvent(Error, this, new ErrorArgs(-1, "Could not request real time data - not connected."));
return(-1);
}
if (request.Instrument == null)
{
RaiseEvent(Error, this, new ErrorArgs(-1, "Real Time Data Request Failed: null Instrument."));
return(-1);
}
request.RequestID = _requestCount++;
lock (_reqSocketLock)
{
//two part message:
//1: "RTD"
//2: serialized RealTimeDataRequest
var ms = new MemoryStream();
_reqSocket.SendMore("");
_reqSocket.SendMore("RTD");
_reqSocket.Send(MyUtils.ProtoBufSerialize(request, ms));
}
return(request.RequestID);
}
public void ServerReturnsErrorToClientIfNoInstrumentIdIsSet()
{
var ds = new Datasource {
ID = 1, Name = "TestDS"
};
var inst = new Instrument {
ID = null, Datasource = ds, DatasourceID = 1, Symbol = "SPY", Type = InstrumentType.Stock
};
var req = new RealTimeDataRequest(inst, BarSize.FiveSeconds, false);
string error = null;
int? requestId = null;
_client.Error += (s, e) =>
{
error = e.ErrorMessage;
requestId = e.RequestID;
};
_client.RequestRealTimeData(req);
Thread.Sleep(DefaultDelayInMilliseconds);
Assert.IsTrue(!string.IsNullOrEmpty(error));
Assert.IsTrue(requestId.HasValue);
}
/// <summary>
/// real time data request
/// </summary>
public int RequestRealTimeData(RealTimeDataRequest request)
{
lock (_requestIDMapLock)
{
_requestCounter++;
_realTimeDataRequests.Add(_requestCounter, request);
_requestIDMap.Add(_requestCounter, request.AssignedID);
}
try
{
Contract contract = TWSUtils.InstrumentToContract(request.Instrument);
_client.RequestRealTimeBars(
_requestCounter,
contract,
(int)TWSUtils.BarSizeConverter(request.Frequency),
RealTimeBarType.Trades, request.RTHOnly);
}
catch (Exception ex)
{
Log(LogLevel.Error, "IB: Could not send real time data request: " + ex.Message);
RaiseEvent(Error, this, new ErrorArgs(-1, "Could not send real time data request: " + ex.Message));
}
return(_requestCounter);
}
public void RequestRealTimeData(RealTimeDataRequest request)
{
if (!request.Instrument.ID.HasValue)
{
throw new Exception("ID doesn't have value.");
}
bool success = _requestedInstrumentIDs.TryAdd(_requestIDs, request.Instrument.ID.Value);
_reqIdMap.Add(request.AssignedID, _requestIDs);
_requests.Add(request.AssignedID, request);
int number;
if (request.Frequency == BarSize.Tick)
{
number = 1;
}
else
{
number = (int)(request.Frequency.ToTimeSpan().TotalMilliseconds);
}
_loopsPassed.TryAdd(request.Instrument.ID.Value, number);
_loopLimit.TryAdd(request.Instrument.ID.Value, number);
_idMap.TryAdd(request.Instrument.ID.Value, request.AssignedID);
_requestIDs++;
}
public void HistoricalDataUpdateCorrectlyRaisesRealTimeDataEvent()
{
//need to set it up from the start w/ the right setting
_ibClientMock = new Mock <IIBClient>();
_ibClientMock.Setup(x => x.Connect(It.IsAny <string>(), It.IsAny <int>(), It.IsAny <int>())).Callback(() => _clientIsConnected = true);
_ibClientMock.Setup(x => x.Connected).Returns(() => _clientIsConnected);
var settings = new Mock <ISettings>();
settings.Setup(x => x.ibClientHost).Returns(Host);
settings.Setup(x => x.ibUseNewRealTimeDataSystem).Returns(true);
_ibDatasource = new IB(settings.Object, client: _ibClientMock.Object);
_ibDatasource.Connect();
var exchange = new Exchange {
ID = 1, Name = "Ex", Timezone = "Pacific Standard Time"
};
var req = new RealTimeDataRequest
{
Instrument = new Instrument {
ID = 1, Symbol = "SPY", UnderlyingSymbol = "SPY", Exchange = exchange, Currency = "USD", Type = InstrumentType.Stock
},
Frequency = QDMS.BarSize.FiveSeconds,
RTHOnly = true
};
int requestID = -1;
_ibClientMock
.Setup(x => x.RequestHistoricalData(
It.IsAny <int>(),
It.IsAny <Contract>(),
It.IsAny <string>(),
It.IsAny <string>(),
It.IsAny <QDMSIBClient.BarSize>(),
It.IsAny <HistoricalDataType>(),
It.IsAny <bool>(),
It.IsAny <bool>(),
It.IsAny <List <TagValue> >()))
.Callback <int, Contract, string, string, BarSize, HistoricalDataType, bool, bool, List <TagValue> >((y, a, b, c, d, e, f, g, h) => requestID = y);
_ibDatasource.RequestRealTimeData(req);
bool received = false;
_ibDatasource.DataReceived += (sender, e) => received = true;
_ibClientMock.Raise(x => x.HistoricalDataUpdate += null, new HistoricalDataEventArgs(requestID, new Bar(new DateTime(2014, 1, 15),
1,
2,
3,
4,
5,
5,
3)));
Assert.IsTrue(received);
}
public void RaisesDataEventWithTheContinuousFuturesAlias()
{
var cf = new ContinuousFuture()
{
ID = 1,
InstrumentID = 1,
Month = 1,
UnderlyingSymbol = new UnderlyingSymbol
{
ID = 1,
Symbol = "VIX",
Rule = new ExpirationRule()
}
};
var inst = new Instrument
{
ID = 1,
Symbol = "VIXCONTFUT",
IsContinuousFuture = true,
ContinuousFuture = cf,
Datasource = new Datasource {
ID = 999, Name = "MockSource"
}
};
var req = new RealTimeDataRequest(inst, BarSize.FiveSeconds);
_cfBrokerMock.Setup(x => x.RequestFrontContract(It.IsAny <Instrument>(), It.IsAny <DateTime?>())).Returns(0);
int assignedID = 0;
_dataSourceMock.Setup(x => x.RequestRealTimeData(It.IsAny <RealTimeDataRequest>())).Callback <RealTimeDataRequest>(r => assignedID = r.AssignedID);
bool raisedCorrectSymbol = false;
_broker.RealTimeDataArrived += (sender, e) =>
raisedCorrectSymbol = raisedCorrectSymbol ? raisedCorrectSymbol : e.InstrumentID == 1;
_broker.RequestRealTimeData(req);
var frontFutureInstrument = new Instrument
{
Symbol = "VXF4",
ID = 2,
Datasource = new Datasource {
ID = 999, Name = "MockSource"
}
};
_cfBrokerMock.Raise(x => x.FoundFrontContract += null, new FoundFrontContractEventArgs(0, frontFutureInstrument, DateTime.Now));
_dataSourceMock.Raise(x => x.DataReceived += null,
new RealTimeDataEventArgs(2, MyUtils.ConvertToTimestamp(DateTime.Now), 100, 100, 100, 100, 50, 100, 2, assignedID));
Thread.Sleep(50);
Assert.IsTrue(raisedCorrectSymbol);
}
public int RequestRealTimeData(RealTimeDataRequest request)
{
if (!request.Instrument.ID.HasValue)
{
throw new Exception("ID doesn't have value.");
}
_requestIDs++;
var requestGrouping = new RequestGrouping
{
Instrument = request.Instrument,
Frequency = request.Frequency
};
var requestList = _connectedRequests.GetOrAdd(requestGrouping,
new ConcurrentDictionary <int, RealTimeDataRequest>());
bool success = requestList.TryAdd(_requestIDs, request);
lock (_historicalDataRequestLock)
{
int historicalRequestId;
if (!_historicalRequests.TryGetValue(requestGrouping, out historicalRequestId))
{
var asyncCall = new RequestHistoricalDataCaller(RequestHistoricalData);
asyncCall.BeginInvoke(requestGrouping, null, null);
}
}
Timer timer;
bool result = _timers.TryGetValue(request.Frequency, out timer);
if (result)
{
// start timer if not is already started:
if (!timer.Enabled)
{
timer.Start();
}
}
ShortTimerController controller;
result = _shortTimers.TryGetValue(request.Frequency, out controller);
if (result)
{
if (!controller.Active)
{
controller.Active = true;
// start simulatetimer
controller.AsyncResult = controller.Caller.BeginInvoke(controller, request.Frequency, null, null);
}
}
return(_requestIDs);
}
/// <summary>
/// Request real time data.
/// </summary>
/// <param name="request"></param>
/// <returns>The ID associated with this real time data request.</returns>
public int RequestRealTimeData(RealTimeDataRequest request)
{
//var contract = new OEC.API.Contract();
//_client.Subscribe()
//So here's what's going on: it won't let us create a contract.
//We have to request it, then when it arrives we request the data stream.
//Depending on the BarSize we have to request either ticks or bars
return(0); //fix
//TODO write
}
public int RequestRealTimeData(RealTimeDataRequest request)
{
if (!Connected)
{
throw new Exception("The datasource is not connected. A request is not possible.");
}
if (!request.Instrument.ID.HasValue)
{
throw new Exception("ID doesn't have value.");
}
if (!_intervalCache.ContainsKey(request.Frequency) || request.Frequency > BarSize.OneDay)
{
throw new Exception("Bar size is not supported");
}
string symbol = request.Instrument.DatasourceSymbol;
if (string.IsNullOrEmpty(symbol))
{
symbol = request.Instrument.Symbol;
}
var availableSymbols = GetAvailableSymbols();
if (!availableSymbols.Contains(symbol))
{
throw new Exception("Symbol is not available");
}
_requestIDs++;
var requestList = _connectedRequests.GetOrAdd(request.Frequency, new ConcurrentDictionary <int, RealTimeDataRequest>());
bool success = requestList.TryAdd(_requestIDs, request);
FeedTimer timer;
bool result = _timers.TryGetValue(request.Frequency, out timer);
if (!result)
{
throw new NotSupportedException($"Timer not found for freq. {request.Frequency}");
}
// start timer if not is already started:
if (!timer.Active)
{
timer.Start();
}
return(_requestIDs);
}
public void RequestRealTimelDataRaisesErrorEventAndReturnsMinusOneWhenInstrumentIsNull()
{
var req = new RealTimeDataRequest
{
Instrument = null
};
bool errorTriggered = false;
_client.Error += (sender, e) => errorTriggered = true;
Assert.AreEqual(-1, _client.RequestRealTimeData(req));
Assert.IsTrue(errorTriggered);
}
public void CancelRealTimeData(int requestID)
{
RealTimeDataRequest request = null;
foreach (var key1Request in _connectedRequests)
{
if (key1Request.Value.TryGetValue(requestID, out request))
{
break;
}
}
if (request == null)
{
// kein Request gefunden ...
return;
}
var requestGrouping = new RequestGrouping
{
Instrument = request.Instrument,
Frequency = request.Frequency
};
RealTimeDataRequest dummy;
Timer timer;
ConcurrentDictionary <int, RealTimeDataRequest> dummy2;
if (_connectedRequests[requestGrouping].TryRemove(requestID, out dummy))
{
if (_connectedRequests[requestGrouping].Count == 0)
{
if (_connectedRequests.TryRemove(requestGrouping, out dummy2))
{
if (_connectedRequests.Count == 0)
{
if (_timers.TryGetValue(request.Frequency, out timer))
{
if (timer.Enabled)
{
timer.Stop();
}
}
}
}
}
}
}
public void RequestsCorrectFuturesContractForContinuousFutures()
{
var cf = new ContinuousFuture()
{
ID = 1,
InstrumentID = 1,
Month = 1,
UnderlyingSymbol = new UnderlyingSymbol
{
ID = 1,
Symbol = "VIX",
Rule = new ExpirationRule()
}
};
var inst = new Instrument
{
ID = 1,
Symbol = "VIXCONTFUT",
IsContinuousFuture = true,
ContinuousFuture = cf,
Datasource = new Datasource {
ID = 999, Name = "MockSource"
}
};
var req = new RealTimeDataRequest(inst, BarSize.FiveSeconds);
_cfBrokerMock.Setup(x => x.RequestFrontContract(It.IsAny <Instrument>(), It.IsAny <DateTime?>())).Returns(0);
_broker.RequestRealTimeData(req);
var frontFutureInstrument = new Instrument
{
Symbol = "VXF4",
ID = 2,
Datasource = new Datasource {
ID = 999, Name = "MockSource"
}
};
_cfBrokerMock.Raise(x => x.FoundFrontContract += null, new FoundFrontContractEventArgs(0, frontFutureInstrument, DateTime.Now));
_dataSourceMock.Verify(x => x.RequestRealTimeData(
It.Is <RealTimeDataRequest>(y =>
y.Instrument.ID == 2)), Times.Once);
}
public void RequestRealTimelDataRaisesErrorEventAndReturnsMinusOneWhenNotConnected()
{
var req = new RealTimeDataRequest
{
Instrument = new Instrument {
ID = 1, Symbol = "SPY"
}
};
bool errorTriggered = false;
_client.Error += (sender, e) => errorTriggered = true;
Assert.AreEqual(-1, _client.RequestRealTimeData(req));
Assert.IsTrue(errorTriggered);
}
/// <summary>
/// real time data request
/// </summary>
public void RequestRealTimeData(RealTimeDataRequest request)
{
var id = _requestCounter++;
lock (_requestIDMapLock)
{
_realTimeDataRequests.Add(id, request);
_requestIDMap.Add(id, request.AssignedID);
if (_reverseRequestIDMap.ContainsKey(request.AssignedID))
{
_reverseRequestIDMap[request.AssignedID] = id;
}
else
{
_reverseRequestIDMap.Add(request.AssignedID, id);
}
}
try
{
Contract contract = TWSUtils.InstrumentToContract(request.Instrument);
if (_ibUseNewRealTimeDataSystem)
{
//the new system uses the historical data update endpoint instead of realtime data
_client.RequestHistoricalData(id, contract, "",
"60 S", QDMSIBClient.BarSize.FiveSeconds, HistoricalDataType.Trades, request.RTHOnly, true);
//todo: write test
}
else
{
_client.RequestRealTimeBars(
id,
contract,
"TRADES",
request.RTHOnly);
}
}
catch (Exception ex)
{
Log(LogLevel.Error, "IB: Could not send real time data request: " + ex.Message);
RaiseEvent(Error, this, new ErrorArgs(-1, "Could not send real time data request: " + ex.Message));
}
}
/// <summary>
/// Request a new real time data stream. Data will be delivered through the RealTimeDataReceived event.
/// </summary>
/// <returns>An ID uniquely identifying this real time data request. -1 if there was an error.</returns>
public int RequestRealTimeData(RealTimeDataRequest request)
{
if (request == null)
{
RaiseEvent(Error, this, new ErrorArgs(-1, "Real Time Data Request Failed: Request cannot be null."));
return(-1);
}
if (request.Instrument == null)
{
RaiseEvent(Error, this, new ErrorArgs(-1, "Real Time Data Request Failed: null Instrument."));
return(-1);
}
if (!Connected)
{
RaiseEvent(Error, this, new ErrorArgs(-1, "Could not request real time data - not connected."));
return(-1);
}
request.RequestID = Interlocked.Increment(ref _requestCount);
lock (_realTimeRequestSocketLock)
{
if (_realTimeRequestSocket != null)
{
// Two part message:
// 1: "RTD"
// 2: serialized RealTimeDataRequest
_realTimeRequestSocket.SendMoreFrame(string.Empty);
_realTimeRequestSocket.SendMoreFrame(MessageType.RTDRequest);
using (var ms = new MemoryStream())
{
_realTimeRequestSocket.SendFrame(MyUtils.ProtoBufSerialize(request, ms));
}
}
}
return(request.RequestID);
}
/// <summary>
/// Request to initiate a real time data stream.
/// </summary>
/// <param name="request">The request</param>
/// <returns>True is the request was successful, false otherwise.</returns>
public bool RequestRealTimeData(RealTimeDataRequest request)
{
request.AssignedID = GetUniqueRequestID();
lock (requestsLock)
{
requests.Add(request.AssignedID, request);
}
//if there is already an active stream of this instrument
bool streamExists;
lock (activeStreamsLock)
{
streamExists = ActiveStreams.Collection.Any(x => x.Instrument.ID == request.Instrument.ID);
}
if (streamExists)
{
IncrementSubscriberCount(request.Instrument);
//log the request
Log(LogLevel.Info,
$"RTD Request for existing stream: {request.Instrument.Symbol} from {request.Instrument.Datasource.Name} @ {Enum.GetName(typeof(BarSize), request.Frequency)}");
return(true);
}
if (DataSources.ContainsKey(request.Instrument.Datasource.Name) &&
//make sure the datasource is present & connected
DataSources[request.Instrument.Datasource.Name].Connected)
{
ForwardRtdRequest(request);
return(true);
}
if (!DataSources.ContainsKey(request.Instrument.Datasource.Name))
{
throw new Exception("No such datasource.");
}
if (!DataSources[request.Instrument.Datasource.Name].Connected)
{
throw new Exception("Datasource not connected.");
}
return(false);
}
public void RealTimeRequestsAreReSentAfterARealTimeDataPacingViolation()
{
var exchange = new Exchange {
ID = 1, Name = "Ex", Timezone = "Pacific Standard Time"
};
var req = new RealTimeDataRequest
{
Instrument = new Instrument {
ID = 1, Symbol = "SPY", Exchange = exchange
},
Frequency = QDMS.BarSize.FiveSeconds,
RTHOnly = true
};
int requestID = 0;
_ibClientMock
.Setup(x => x.RequestRealTimeBars(
It.IsAny <int>(),
It.IsAny <Contract>(),
It.IsAny <int>(),
It.IsAny <RealTimeBarType>(),
It.IsAny <bool>(),
It.IsAny <List <TagValue> >()))
.Callback <int, Contract, int, RealTimeBarType, bool, List <TagValue> >((y, a, b, c, d, e) => requestID = y);
_ibDatasource.RequestRealTimeData(req);
_ibClientMock.Raise(x => x.Error += null, new ErrorEventArgs(requestID, (ErrorMessage)420, ""));
Thread.Sleep(25000);
_ibClientMock.Verify(x => x.RequestRealTimeBars(
It.IsAny <int>(),
It.IsAny <Contract>(),
It.IsAny <int>(),
It.IsAny <RealTimeBarType>(),
It.IsAny <bool>(),
It.IsAny <List <TagValue> >()),
Times.Exactly(2));
}
public void CancelRealTimeData(int requestID)
{
RealTimeDataRequest request = null;
foreach (var key1Request in _connectedRequests)
{
if (key1Request.Value.TryGetValue(requestID, out request))
{
break;
}
}
if (request == null)
{
// kein Request gefunden ...
return;
}
RealTimeDataRequest dummy;
FeedTimer timer;
ConcurrentDictionary <int, RealTimeDataRequest> dummy2;
if (_connectedRequests[request.Frequency].TryRemove(requestID, out dummy))
{
if (_connectedRequests[request.Frequency].Count == 0)
{
if (_connectedRequests.TryRemove(request.Frequency, out dummy2))
{
if (_connectedRequests.Count == 0)
{
if (_timers.TryGetValue(request.Frequency, out timer))
{
if (timer.Active)
{
timer.Stop();
}
}
}
}
}
}
}
/// <summary>
/// Sends a real time data request to the correct data source, logs it, and updates subscriber counts
/// </summary>
/// <param name="request"></param>
private void ForwardRTDRequest(RealTimeDataRequest request)
{
//send the request to the correct data source
int reqID;
try
{
reqID = DataSources[request.Instrument.Datasource.Name].RequestRealTimeData(request);
}
catch (Exception ex)
{
Log(LogLevel.Error, "Error requesting real time data: " + ex.Message);
return;
}
//log the request
Log(LogLevel.Info,
string.Format("RTD Request: {0} from {1} @ {2} ID:{3}",
request.Instrument.Symbol,
request.Instrument.Datasource.Name,
Enum.GetName(typeof(BarSize), request.Frequency),
reqID));
//add the request to the active streams, though it's not necessarily active yet
var streamInfo = new RealTimeStreamInfo(
request.Instrument,
reqID,
request.Instrument.Datasource.Name,
request.Frequency,
request.RTHOnly);
lock (_activeStreamsLock)
{
ActiveStreams.TryAdd(streamInfo);
}
lock (_subscriberCountLock)
{
StreamSubscribersCount.Add(streamInfo, 1);
}
}
public void DoesNotRepeatRequestToSourceWhenARealTimeStreamAlreadyExists()
{
var inst = new Instrument
{
ID = 1,
Symbol = "SPY",
Datasource = new Datasource {
ID = 999, Name = "MockSource"
}
};
var req = new RealTimeDataRequest(inst, BarSize.FiveSeconds);
_broker.RequestRealTimeData(req);
Thread.Sleep(100);
_broker.RequestRealTimeData(req);
_dataSourceMock.Verify(x => x.RequestRealTimeData(
It.IsAny <RealTimeDataRequest>()),
Times.Once);
}
public void DoesNotRepeatRequestToSourceWhenARealTimeContinuousFuturesStreamAlreadyExists()
{
var inst = new Instrument
{
ID = 1,
Symbol = "ContinuousVIXFutures",
IsContinuousFuture = true,
Type = InstrumentType.Future,
Datasource = new Datasource {
ID = 999, Name = "MockSource"
}
};
var frontContract = new Instrument
{
ID = 2,
Symbol = "VXF3",
Type = InstrumentType.Future,
Datasource = new Datasource {
ID = 999, Name = "MockSource"
}
};
var req = new RealTimeDataRequest(inst, BarSize.FiveSeconds);
_cfBrokerMock.Setup(x => x.RequestFrontContract(It.IsAny <Instrument>(), It.IsAny <DateTime?>())).Returns(1);
_broker.RequestRealTimeData(req);
_cfBrokerMock.Raise(x => x.FoundFrontContract += null, new FoundFrontContractEventArgs(1, frontContract, DateTime.Now));
_broker.RequestRealTimeData(req);
_dataSourceMock.Verify(x => x.RequestRealTimeData(
It.IsAny <RealTimeDataRequest>()),
Times.Once);
_cfBrokerMock.Verify(x => x.RequestFrontContract(
It.IsAny <Instrument>(),
It.IsAny <DateTime?>()),
Times.Once);
}
