private void OnLoad()
{
try
{
var loadDate = StartDate;
var messageTypes = new[] { MessageTypes.Time, ExtendedMessageTypes.Clearing };
while (loadDate.Date <= StopDate.Date && !_disconnecting)
{
if (Boards.Any(b => b.IsTradeDate(loadDate, true)))
{
this.AddInfoLog("Loading {0} Events: {1}", loadDate.Date, LoadedMessageCount);
var enumerator = BasketStorage.Load(loadDate.Date);
// хранилище за указанную дату содержит только время и клиринг
var noData = !enumerator.DataTypes.Except(messageTypes).Any();
if (noData)
{
SendOutMessages(loadDate, GetSimpleTimeLine(loadDate).GetEnumerator());
}
else
{
SendOutMessages(loadDate, enumerator);
}
}
loadDate = loadDate.Date.AddDays(1);
}
SendOutMessage(new LastMessage {
LocalTime = StopDate.LocalDateTime
});
}
catch (Exception ex)
{
SendOutError(ex);
SendOutMessage(new LastMessage {
IsError = true
});
}
if (_disconnecting)
{
SendOutMessage(new DisconnectMessage());
}
_disconnecting = false;
if (_loadingThread == null)
{
SendOutMessage(new ResetMessage());
}
_loadingThread = null;
}
/// <summary>
/// Send next outgoing message.
/// </summary>
/// <returns><see langword="true" />, if message was sent, otherwise, <see langword="false" />.</returns>
public bool SendOutMessage()
{
if (!_isStarted || _isSuspended)
{
return(false);
}
if (!BasketStorage.MoveNext())
{
return(false);
}
var msg = BasketStorage.Current;
SendOutMessage(msg);
return(true);
}
private void OnLoad()
{
try
{
var loadDate = StartDate;
var messageTypes = new[] { MessageTypes.Time, ExtendedMessageTypes.Clearing };
BasketStorage.InnerStorages.Add(new InMemoryMarketDataStorage <TimeMessage>(null, null, GetTimeLine));
while (loadDate.Date <= StopDate.Date && !_disconnecting)
{
if (Boards.Any(b => b.IsTradeDate(loadDate, true)))
{
this.AddInfoLog("Loading {0} Events: {1}", loadDate.Date, LoadedMessageCount);
using (var enumerator = BasketStorage.Load(loadDate.UtcDateTime.Date))
{
// storage for the specified date contains only time messages and clearing events
var noData = !enumerator.DataTypes.Except(messageTypes).Any();
if (noData)
{
SendOutMessages(loadDate, GetSimpleTimeLine(loadDate).GetEnumerator());
}
else
{
SendOutMessages(loadDate, enumerator);
}
}
}
loadDate = loadDate.Date.AddDays(1).ApplyTimeZone(loadDate.Offset);
}
SendOutMessage(new LastMessage {
LocalTime = StopDate.LocalDateTime
});
}
catch (Exception ex)
{
SendOutError(ex);
SendOutMessage(new LastMessage {
IsError = true
});
}
if (_disconnecting)
{
SendOutMessage(new DisconnectMessage());
}
_disconnecting = false;
if (_loadingThread == null)
{
SendOutMessage(new ResetMessage());
}
_loadingThread = null;
BasketStorage.InnerStorages.Clear();
}
/// <summary>
/// Release resources.
/// </summary>
protected override void DisposeManaged()
{
BasketStorage.Dispose();
base.DisposeManaged();
}
private void ProcessMarketDataMessage(MarketDataMessage message)
{
var securityId = message.SecurityId;
var security = SecurityProvider.LookupById(securityId.ToStringId());
if (security == null)
{
RaiseMarketDataMessage(message, new InvalidOperationException(LocalizedStrings.Str704Params.Put(securityId)));
return;
}
if (StorageRegistry == null)
{
RaiseMarketDataMessage(message, new InvalidOperationException(LocalizedStrings.Str1117Params.Put(message.DataType, securityId)));
return;
}
var history = message as HistorySourceMessage;
Exception error = null;
switch (message.DataType)
{
case MarketDataTypes.Level1:
{
if (message.IsSubscribe)
{
if (history == null)
{
BasketStorage.AddStorage(StorageRegistry.GetLevel1MessageStorage(security, Drive, StorageFormat));
BasketStorage.AddStorage(new InMemoryMarketDataStorage <ClearingMessage>(security, null, date => new[]
{
new ClearingMessage
{
LocalTime = date.Date + security.Board.ExpiryTime,
SecurityId = securityId,
ClearMarketDepth = true
}
}));
}
else
{
BasketStorage.AddStorage(new InMemoryMarketDataStorage <Level1ChangeMessage>(security, null, history.GetMessages));
}
}
else
{
BasketStorage.RemoveStorage <IMarketDataStorage <Level1ChangeMessage> >(security, MessageTypes.Level1Change, null);
BasketStorage.RemoveStorage <InMemoryMarketDataStorage <ClearingMessage> >(security, ExtendedMessageTypes.Clearing, null);
}
break;
}
case MarketDataTypes.MarketDepth:
{
if (message.IsSubscribe)
{
BasketStorage.AddStorage(history == null
? StorageRegistry.GetQuoteMessageStorage(security, Drive, StorageFormat)
: new InMemoryMarketDataStorage <QuoteChangeMessage>(security, null, history.GetMessages));
}
else
{
BasketStorage.RemoveStorage <IMarketDataStorage <QuoteChangeMessage> >(security, MessageTypes.QuoteChange, null);
}
break;
}
case MarketDataTypes.Trades:
{
if (message.IsSubscribe)
{
BasketStorage.AddStorage(history == null
? StorageRegistry.GetTickMessageStorage(security, Drive, StorageFormat)
: new InMemoryMarketDataStorage <ExecutionMessage>(security, null, history.GetMessages));
}
else
{
BasketStorage.RemoveStorage <IMarketDataStorage <ExecutionMessage> >(security, MessageTypes.Execution, ExecutionTypes.Tick);
}
break;
}
case MarketDataTypes.OrderLog:
{
if (message.IsSubscribe)
{
BasketStorage.AddStorage(history == null
? StorageRegistry.GetOrderLogMessageStorage(security, Drive, StorageFormat)
: new InMemoryMarketDataStorage <ExecutionMessage>(security, null, history.GetMessages));
}
else
{
BasketStorage.RemoveStorage <IMarketDataStorage <ExecutionMessage> >(security, MessageTypes.Execution, ExecutionTypes.OrderLog);
}
break;
}
case MarketDataTypes.CandleTimeFrame:
case MarketDataTypes.CandleTick:
case MarketDataTypes.CandleVolume:
case MarketDataTypes.CandleRange:
case MarketDataTypes.CandlePnF:
case MarketDataTypes.CandleRenko:
{
var msgType = message.DataType.ToCandleMessageType();
if (message.IsSubscribe)
{
var candleType = message.DataType.ToCandleMessage();
BasketStorage.AddStorage(history == null
? StorageRegistry.GetCandleMessageStorage(candleType, security, message.Arg, Drive, StorageFormat)
: new InMemoryMarketDataStorage <CandleMessage>(security, message.Arg, history.GetMessages, candleType));
}
else
{
BasketStorage.RemoveStorage <IMarketDataStorage <CandleMessage> >(security, msgType, message.Arg);
}
break;
}
default:
error = new InvalidOperationException(LocalizedStrings.Str1118Params.Put(message.DataType));
break;
}
RaiseMarketDataMessage(message, error);
}
/// <summary>
/// Send message.
/// </summary>
/// <param name="message">Message.</param>
protected override void OnSendInMessage(Message message)
{
switch (message.Type)
{
case MessageTypes.Reset:
{
_isSuspended = false;
_currentTime = default(DateTimeOffset);
BasketStorage.Reset();
LoadedMessageCount = 0;
if (!_isStarted)
{
SendOutMessage(new ResetMessage());
}
break;
}
case MessageTypes.Connect:
{
if (_isStarted)
{
throw new InvalidOperationException(LocalizedStrings.Str1116);
}
SendOutMessage(new ConnectMessage {
LocalTime = StartDate
});
return;
}
case MessageTypes.Disconnect:
{
_isSuspended = false;
if (_isStarted)
{
SendOutMessage(new LastMessage {
LocalTime = StopDate
});
}
SendOutMessage(new DisconnectMessage {
LocalTime = StopDate
});
//SendOutMessage(new ResetMessage());
BasketStorage.Reset();
_isStarted = false;
return;
}
case MessageTypes.SecurityLookup:
{
var lookupMsg = (SecurityLookupMessage)message;
var securities = lookupMsg.SecurityId.IsDefault()
? SecurityProvider.LookupAll()
: SecurityProvider.Lookup(lookupMsg.ToSecurity());
securities.ForEach(security =>
{
SendOutMessage(security.Board.ToMessage());
var secMsg = security.ToMessage();
secMsg.OriginalTransactionId = lookupMsg.TransactionId;
SendOutMessage(secMsg);
//SendOutMessage(new Level1ChangeMessage { SecurityId = security.ToSecurityId() }
// .Add(Level1Fields.StepPrice, security.StepPrice)
// .Add(Level1Fields.MinPrice, security.MinPrice)
// .Add(Level1Fields.MaxPrice, security.MaxPrice)
// .Add(Level1Fields.MarginBuy, security.MarginBuy)
// .Add(Level1Fields.MarginSell, security.MarginSell));
});
SendOutMessage(new SecurityLookupResultMessage {
OriginalTransactionId = lookupMsg.TransactionId
});
return;
}
case MessageTypes.MarketData:
case ExtendedMessageTypes.HistorySource:
ProcessMarketDataMessage((MarketDataMessage)message);
return;
case ExtendedMessageTypes.EmulationState:
var stateMsg = (EmulationStateMessage)message;
var isSuspended = false;
switch (stateMsg.State)
{
case EmulationStates.Starting:
{
if (_isStarted)
{
_isSuspended = false;
}
else
{
_isStarted = true;
}
break;
}
case EmulationStates.Suspending:
{
_isSuspended = true;
isSuspended = true;
break;
}
case EmulationStates.Stopping:
{
_isSuspended = false;
break;
}
}
SendOutMessage(message);
if (isSuspended)
{
SendOutMessage(new EmulationStateMessage {
State = EmulationStates.Suspended
});
}
return;
}
//SendOutMessage(message);
}
