public DataHistoryUpdate GetDataHistoryUpdate(DataSessionInfo session, DataHistoryRequest request)
{
if (request.Period != Period)
{
SystemMonitor.OperationWarning("Source queried for historic information of wrong period.");
return null;
}
List<DataBar> bars = GetSymbolData(session.Symbol);
if (bars != null)
{
return new DataHistoryUpdate(Period, bars);
}
return null;
}
public DataHistoryUpdate GetDataHistoryUpdate(DataSessionInfo session, DataHistoryRequest request)
{
if (request.IsTickBased)
{
SystemMonitor.NotImplementedWarning();
return new DataHistoryUpdate(request.Period, new DataTick[] { });
}
if (request.Period != _period)
{
return new DataHistoryUpdate(request.Period, new DataBar[] { });
}
lock (this)
{
return new DataHistoryUpdate(request.Period, _history.ToArray());
}
}
/// <summary>
///
/// </summary>
public bool RequestDataHistoryUpdate(DataSessionInfo sessionInfo, DataHistoryRequest request, bool waitResult)
{
if (_sourceDataBarProvider == null)
{
ConstructSourceDataBarProvider(request.Period);
//SystemMonitor.Warning("Source data bar provider not created yet.");
return true;
}
if (request.StartIndex.HasValue == false)
{
request.StartIndex = -1;
}
if (request.MaxValuesRetrieved.HasValue == false)
{
request.MaxValuesRetrieved = int.MaxValue;
}
if (request.Period != _sourceDataBarProvider.Period)
{
SystemMonitor.NotImplementedCritical("Mode not supported.");
return false;
}
if (request.IsTickBased)
{
SystemMonitor.NotImplementedCritical("Mode not supported.");
return false;
}
List<DataBar> bars = new List<DataBar>();
if (request.StartIndex < 0)
{
for (int i = Math.Max(0, _sourceDataBarProvider.BarCount - request.MaxValuesRetrieved.Value);
i < _sourceDataBarProvider.BarCount; i++)
{
lock (_sourceDataBarProvider)
{
bars.Add(_sourceDataBarProvider.BarsUnsafe[i]);
}
}
}
else
{
for (int i = request.StartIndex.Value;
i < request.MaxValuesRetrieved && i < _sourceDataBarProvider.BarCount; i++)
{
lock (_sourceDataBarProvider)
{
bars.Add(_sourceDataBarProvider.BarsUnsafe[i]);
}
}
}
if (this.DataHistoryUpdateEvent != null)
{
this.DataHistoryUpdateEvent(this, sessionInfo, new DataHistoryUpdate(request.Period, bars));
}
return true;
}
void SendDataHistoryUpdate(TransportInfo[] receivers, DataSessionInfo session, DataHistoryRequest request)
{
DataSourceStub.IImplementation implementation = Implementation;
if (implementation == null)
{
return;
}
DataHistoryUpdate response = implementation.GetDataHistoryUpdate(session, request);
SendRespondingToMany(receivers, new DataHistoryUpdateMessage(session, response, response != null));
}
/// <summary>
///
/// </summary>
/// <param name="expertID"></param>
public RequestDataHistoryMessage(DataSessionInfo sessionInfo, DataHistoryRequest request)
: base(sessionInfo)
{
_request = request;
}
public DataHistoryUpdate GetDataHistoryUpdate(DataSessionInfo session, DataHistoryRequest request)
{
MBTradingConnectionManager manager = _manager;
if (manager != null)
{
DataHistoryOperation operation = new DataHistoryOperation(session.Symbol.Name, request);
if (manager.History.Place(operation) == false)
{
SystemMonitor.OperationError("Failed to place data history operation.");
return null;
}
if (operation.CompletionEvent.WaitOne(TimeSpan.FromSeconds(120)) == false)
{
SystemMonitor.OperationError("Data history operation timed out.");
return null;
}
return operation.Response;
}
return null;
}
public bool RequestDataHistoryUpdate(DataSessionInfo sessionInfo, DataHistoryRequest request, bool waitResult)
{
if (OperationalState != OperationalStateEnum.Operational)
{
return false;
}
RequestDataHistoryMessage requestMessage = new RequestDataHistoryMessage(sessionInfo, request) { RequestResponce = false };
requestMessage.RequestResponce = waitResult;
if (waitResult)
{
ResponceMessage responce = SendAndReceiveResponding<ResponceMessage>(SourceTransportInfo, requestMessage, this.DefaultTimeOut);
return responce != null && responce.OperationResult;
}
else
{
SendResponding(SourceTransportInfo, requestMessage);
return true;
}
}
/// <summary>
///
/// </summary>
public DataHistoryOperation(string symbol, DataHistoryRequest request)
{
_symbol = symbol;
_request = request;
}
/// <summary>
/// Request bar dataDelivery from entry.
/// </summary>
public bool RequestDataHistoryUpdate(DataSessionInfo sessionInfo, DataHistoryRequest request, bool waitResult)
{
DataStoreEntry entry = DataStore.Instance.GetEntryBySessionInfo(sessionInfo);
if (this.OperationalState != OperationalStateEnum.Operational
|| entry == null)
{
SystemMonitor.OperationError("Data history request received while not operational, or invalid session requrested.");
return false;
}
if (entry.Period != request.Period)
{
SystemMonitor.OperationError("Data history request received but period not recognized.");
return false;
}
if (request.MaxValuesRetrieved.HasValue == false)
{
request.MaxValuesRetrieved = int.MaxValue;
}
if (request.StartIndex.HasValue == false)
{
request.StartIndex = -1;
}
GeneralHelper.GenericReturnDelegate<bool> operationDelegate = delegate()
{
if (request.IsTickBased)
{
DataReaderWriter<DataTick> readerWriter = entry.GetDataTickReaderWriter();
List<DataTick> dataTicks;
DataHistoryUpdate update = new DataHistoryUpdate(request.Period, new DataTick[] { });
if (readerWriter.Read(request.StartIndex.Value, request.MaxValuesRetrieved.Value, out dataTicks))
{
update.DataTicksUnsafe.AddRange(dataTicks);
if (DataHistoryUpdateEvent != null)
{
DataHistoryUpdateEvent(this, sessionInfo, update);
}
return true;
}
}
else
{
DataReaderWriter<DataBar> readerWriter = entry.GetDataBarReaderWriter();
if (readerWriter == null)
{
SystemMonitor.OperationError("Failed to establish file reader writer for entry.");
return false;
}
List<DataBar> dataBars;
DataHistoryUpdate update = new DataHistoryUpdate(request.Period, new DataBar[] { });
bool readResult = false;
if (request.StartIndex.Value < 0)
{// Instruction is to read the last count items.
readResult = readerWriter.ReadLast(
request.MaxValuesRetrieved.Value, out dataBars);
}
else
{
readResult = readerWriter.Read(request.StartIndex.Value,
request.MaxValuesRetrieved.Value, out dataBars);
}
if (readResult)
{
update.DataBarsUnsafe.AddRange(dataBars);
if (DataHistoryUpdateEvent != null)
{
DataHistoryUpdateEvent(this, sessionInfo, update);
}
return true;
}
}
return false;
};
if (waitResult)
{
return operationDelegate();
}
else
{
GeneralHelper.FireAndForget(operationDelegate);
return true;
}
}