private void RaiseMarketDataUnSubscriptionFailed(MarketDataMessage origin, SubscriptionResponseMessage reply, Subscription subscription)
{
if (origin == null)
{
throw new ArgumentNullException(nameof(origin));
}
if (reply == null)
{
throw new ArgumentNullException(nameof(reply));
}
if (subscription == null)
{
throw new ArgumentNullException(nameof(subscription));
}
var securityId = subscription.SecurityId;
var error = reply.Error ?? new NotSupportedException();
this.AddErrorLog(LocalizedStrings.UnSubscribedError, securityId, origin.DataType2, error.Message);
var security = TryGetSecurity(securityId);
MarketDataUnSubscriptionFailed?.Invoke(security, origin, error);
MarketDataUnSubscriptionFailed2?.Invoke(security, origin, reply);
RaiseSubscriptionFailed(subscription, error, false);
}
private void RaiseMarketDataSubscriptionFailed(MarketDataMessage origin, SubscriptionResponseMessage reply, Subscription subscription)
{
if (origin == null)
{
throw new ArgumentNullException(nameof(origin));
}
if (reply == null)
{
throw new ArgumentNullException(nameof(reply));
}
if (subscription == null)
{
throw new ArgumentNullException(nameof(subscription));
}
var securityId = subscription.SecurityId;
var error = reply.Error ?? new NotSupportedException(LocalizedStrings.SubscriptionNotSupported.Put(origin));
if (reply.IsNotSupported())
{
this.AddWarningLog(LocalizedStrings.SubscriptionNotSupported, origin);
}
else
{
this.AddErrorLog(LocalizedStrings.SubscribedError, securityId, origin.DataType2, error.Message);
}
var security = TryGetSecurity(securityId);
MarketDataSubscriptionFailed?.Invoke(security, origin, error);
MarketDataSubscriptionFailed2?.Invoke(security, origin, reply);
RaiseSubscriptionFailed(subscription, error, true);
if (subscription.CandleSeries != null)
{
RaiseCandleSeriesError(subscription.CandleSeries, reply);
}
}
public Subscription ProcessResponse(SubscriptionResponseMessage response, out ISubscriptionMessage originalMsg, out bool unexpectedCancelled)
{
originalMsg = null;
try
{
lock (_syncObject)
{
unexpectedCancelled = false;
if (!_requests.TryGetValue(response.OriginalTransactionId, out var tuple))
{
originalMsg = null;
return(null);
}
// do not remove cause subscription can be interrupted after successful response
//_requests.Remove(response.OriginalTransactionId);
originalMsg = tuple.Item1;
var info = originalMsg.IsSubscribe
? TryGetInfo(originalMsg.TransactionId, false, false, null, false)
: TryGetInfo(originalMsg.OriginalTransactionId, false, true, null, false);
if (info == null)
{
originalMsg = null;
return(null);
}
var subscription = info.Subscription;
if (originalMsg.IsSubscribe)
{
if (response.IsOk())
{
ChangeState(subscription, SubscriptionStates.Active);
}
else
{
ChangeState(subscription, SubscriptionStates.Error);
Remove(subscription.TransactionId);
unexpectedCancelled = subscription.State.IsActive();
_requests.Remove(response.OriginalTransactionId);
}
}
else
{
ChangeState(subscription, SubscriptionStates.Stopped);
Remove(subscription.TransactionId);
// remove subscribe and unsubscribe requests
_requests.Remove(subscription.TransactionId);
_requests.Remove(response.OriginalTransactionId);
}
return(subscription);
}
}
finally
{
if (originalMsg == null)
{
TryWriteLog(response.OriginalTransactionId);
}
}
}
/// <inheritdoc />
protected override bool OnSendInMessage(Message message)
{
switch (message.Type)
{
case MessageTypes.Reset:
{
lock (_syncObject)
_infos.Clear();
break;
}
case MessageTypes.MarketData:
{
var mdMsg = (MarketDataMessage)message;
if (mdMsg.DataType != MarketDataTypes.MarketDepth)
{
break;
}
var isFilteredMsg = mdMsg is FilteredMarketDepthMessage;
var transId = mdMsg.TransactionId;
if (mdMsg.IsSubscribe)
{
if (!isFilteredMsg)
{
break;
}
var data = (Tuple <QuoteChangeMessage, ExecutionMessage[]>)mdMsg.Arg;
QuoteChangeMessage filtered = null;
lock (_syncObject)
{
var info = _infos.SafeAdd(mdMsg.SecurityId, key => new FilteredMarketDepthInfo(transId, data.Item2));
info.Subscriptions.Add(transId);
if (info.Subscriptions.Count == 1)
{
var clone = new MarketDataMessage();
mdMsg.CopyTo(clone);
message = clone;
filtered = info.Process(data.Item1);
}
}
if (filtered == null)
{
RaiseNewOutMessage(new SubscriptionResponseMessage {
OriginalTransactionId = transId
});
return(true);
}
else
{
RaiseNewOutMessage(filtered);
}
}
else
{
SubscriptionResponseMessage reply;
lock (_syncObject)
{
var info = _infos.FirstOrDefault(p => p.Value.Subscriptions.Contains(mdMsg.OriginalTransactionId)).Value;
if (info != null)
{
info.Subscriptions.Remove(mdMsg.OriginalTransactionId);
if (info.Subscriptions.Count > 0)
{
reply = new SubscriptionResponseMessage
{
OriginalTransactionId = transId,
};
}
else
{
message = new MarketDataMessage
{
IsSubscribe = false,
TransactionId = transId,
OriginalTransactionId = info.TransactionId,
};
break;
}
}
else
{
if (!isFilteredMsg)
{
break;
}
reply = transId.CreateSubscriptionResponse(new InvalidOperationException(LocalizedStrings.SubscriptionNonExist.Put(mdMsg.OriginalTransactionId)));
}
}
RaiseNewOutMessage(reply);
return(true);
}
break;
}
}
return(base.OnSendInMessage(message));
}
/// <inheritdoc />
protected override bool OnSendInMessage(Message message)
{
Message outMsg = null;
switch (message.Type)
{
case MessageTypes.Reset:
case MessageTypes.Disconnect:
{
lock (_syncObject)
{
_partialRequests.Clear();
_original.Clear();
_liveRequests.Clear();
}
break;
}
case MessageTypes.OrderStatus:
case MessageTypes.PortfolioLookup:
{
var subscriptionMsg = (ISubscriptionMessage)message;
if (subscriptionMsg.IsSubscribe)
{
if (subscriptionMsg is OrderStatusMessage statusMsg && statusMsg.HasOrderId())
{
break;
}
var from = subscriptionMsg.From;
var to = subscriptionMsg.To;
if (from != null || to != null)
{
var step = InnerAdapter.GetHistoryStepSize(DataType.Transactions, out _);
// adapter do not provide historical request
if (step == TimeSpan.Zero)
{
if (to != null)
{
// finishing current history request
outMsg = subscriptionMsg.CreateResult();
message = null;
}
else
{
// or sending further only live subscription
subscriptionMsg.From = null;
subscriptionMsg.To = null;
lock (_syncObject)
_liveRequests.Add(subscriptionMsg.TransactionId, false);
}
}
}
else
{
lock (_syncObject)
_liveRequests.Add(subscriptionMsg.TransactionId, false);
}
}
break;
}
case MessageTypes.MarketData:
{
var mdMsg = (MarketDataMessage)message;
var transId = mdMsg.TransactionId;
if (mdMsg.IsSubscribe)
{
var from = mdMsg.From;
var to = mdMsg.To;
if (from != null || to != null)
{
var step = InnerAdapter.GetHistoryStepSize(mdMsg.ToDataType(), out var iterationInterval);
// adapter do not provide historical request
if (step == TimeSpan.Zero)
{
if (to != null)
{
// finishing current history request
outMsg = new SubscriptionFinishedMessage {
OriginalTransactionId = transId
};
message = null;
break;
}
else
{
// or sending further only live subscription
mdMsg.From = null;
mdMsg.To = null;
lock (_syncObject)
_liveRequests.Add(transId, false);
break;
}
}
var info = new DownloadInfo(this, (MarketDataMessage)mdMsg.Clone(), step, iterationInterval);
message = info.InitNext();
lock (_syncObject)
{
_original.Add(info.Origin.TransactionId, info);
_partialRequests.Add(info.CurrTransId, info);
}
}
else
{
lock (_syncObject)
_liveRequests.Add(transId, false);
}
}
else
{
lock (_syncObject)
{
if (!_original.TryGetValue(mdMsg.OriginalTransactionId, out var info))
{
break;
}
info.UnsubscribingId = transId;
message = null;
}
}
break;
}
case ExtendedMessageTypes.PartialDownload:
{
var partialMsg = (PartialDownloadMessage)message;
lock (_syncObject)
{
if (!_original.TryGetValue(partialMsg.OriginalTransactionId, out var info))
{
return(false);
}
if (info.UnsubscribingId != null)
{
outMsg = new SubscriptionResponseMessage {
OriginalTransactionId = info.UnsubscribingId.Value
};
message = null;
break;
}
var mdMsg = info.InitNext();
if (mdMsg.To == null)
{
_liveRequests.Add(mdMsg.TransactionId, true);
_original.Remove(partialMsg.OriginalTransactionId);
_partialRequests.RemoveWhere(p => p.Value == info);
}
else
{
_partialRequests.Add(info.CurrTransId, info);
}
message = mdMsg;
}
break;
}
}
var result = true;
if (message != null)
{
result = base.OnSendInMessage(message);
}
if (outMsg != null)
{
RaiseNewOutMessage(outMsg);
}
return(result);
}
private void RaiseCandleSeriesError(CandleSeries series, SubscriptionResponseMessage reply)
{
CandleSeriesError?.Invoke(series, reply);
}
