public List <EquityOnTime> GetAccountProfit1000(int accountId)
{
// данные не готовы к работе
if (!cacheUpdated)
{
return(new List <EquityOnTime>());
}
List <EquityOnTime> lstEqOnTime;
try
{
var pfs = dicPerformers.ReceiveValue(accountId);
if (pfs == null)
{
return(new List <EquityOnTime>());
}
lstEqOnTime = pfs.listProfit1000.ToList();
}
catch (Exception ex)
{
Logger.Error("Ошибка в GetAccountProfit1000", ex);
return(new List <EquityOnTime>());
}
return(lstEqOnTime.ToList());
}
public List <Message> GetMessages(string room)
{
if (!postedMessages.ContainsKey(room))
{
return(new List <Message>());
}
return(postedMessages.ReceiveValue(room).Select(m => new Message(m)).ToList());
}
public string GetRoomPassword(string room)
{
if (roomPasswords.ContainsKey(room))
{
return(roomPasswords.ReceiveValue(room));
}
return("");
}
/// <summary>
/// получить собственно XML торгового сигнала (объекты графика)
/// </summary>
public string GetTradeSignalXml(SignalStorageKey key)
{
// проверить наличие файла
var filePath = MakeFilePath(key);
try
{
if (!File.Exists(filePath))
{
return(string.Empty);
}
}
catch (Exception ex)
{
Logger.ErrorFormat("SignalStorage.GetTradeSignalXml({0}) error: {1}", filePath, ex);
return(string.Empty);
}
// получить доступ к файлу
var locker = fileLockers.ReceiveValue(key);
if (locker == null)
{
locker = new ReaderWriterLock();
fileLockers.UpdateValues(key, locker);
}
try
{
locker.AcquireReaderLock(LockTimeout);
}
catch (ApplicationException)
{
Logger.Error("SignalStorage.GetTradeSignalXml - read lock timeout");
return(string.Empty);
}
try
{
// прочитать файл
using (var sw = new StreamReader(filePath, TradeSignalXml.DefaultEncoding))
{
return(sw.ReadToEnd());
}
}
catch (Exception ex)
{
Logger.ErrorFormat("SignalStorage.GetTradeSignalXml - error reading file ({0}): {1}", filePath, ex);
return(string.Empty);
}
finally
{
locker.ReleaseReaderLock();
}
// загрузить XML из файла
}
/// <summary>
/// вернуть время обновления торг. сигнала (из файла, если есть таковой) или null
/// </summary>
public TradeSignalUpdate FindTradeSignal(int category, string ticker, string timeframeStr)
{
var fileName = MakeFileName(category, ticker, timeframeStr);
if (!File.Exists(fileName))
{
return(null);
}
var locker = fileLocker.ReceiveValue(fileName);
if (locker == null)
{
locker = new ReaderWriterLock();
fileLocker.UpdateValues(fileName, locker);
}
try
{
locker.AcquireReaderLock(LockTimeout);
}
catch (ApplicationException)
{
Logger.Error("TradeSignalFileStorage.FindTradeSignal() read lock timeout");
return(null);
}
try
{
// получить из документа время обновления
DateTime timeUpdated;
int objectsCount;
if (!TradeSignalXml.GetSignalUpdateParamsFromFile(fileName, TradeSignalXml.DefaultEncoding,
out timeUpdated, out objectsCount))
{
return(null);
}
return(new TradeSignalUpdate(category, ticker)
{
TimeUpdated = timeUpdated,
ObjectCount = objectsCount
});
}
catch (Exception ex)
{
Logger.Error("TradeSignalFileStorage.FindTradeSignal() error", ex);
return(null);
}
finally
{
locker.ReleaseLock();
}
}
// for internal use
public List <Message> GetMessagesInternal(DateTime timeStamp)
{
var result = new List <Message>();
var messageRooms = messages.GetKeys();
foreach (var room in messageRooms)
{
var messagesInRoom = messages.ReceiveValue(room).ToList();
for (var messageIndex = messagesInRoom.Count - 1; messageIndex >= 0; messageIndex--)
{
var message = messagesInRoom[messageIndex];
if (message.TimeStamp <= timeStamp) // using message ordering in 'messages'
{
break;
}
result.Insert(0, new Message(message));
}
}
return(result);
}
// doWorkEventArgs.Argument = operations count
private void ThreadSafeStorageGetAndUpdate(object sender, DoWorkEventArgs doWorkEventArgs)
{
var count = (int)doWorkEventArgs.Argument;
var beginTime = DateTime.Now;
var generator = new Random();
while (count > 0)
{
var key = generator.Next(1000);
var data = threadSafeStorage.ReceiveValue(key);
threadSafeStorage.UpdateValues(key, generator.Next());
count--;
}
doWorkEventArgs.Result = (int)DateTime.Now.Subtract(beginTime).TotalMilliseconds;
}
private void OnRequestStatusReceive(int requestId, ChatResultCode status)
{
ChatRequest request = null;
/*if (!pendingRequestsLock.TryEnterReadLock(lockTimeout))
* {
* Console.WriteLine("ChatSender.OnRequestStatusReceive: pendingRequestsReadLock timeout");
* return;
* }*/
try
{
if (!pendingRequests.ContainsKey(requestId))
{
forwardAnswers.UpdateValues(requestId, status);
return;
}
request = pendingRequests.ReceiveValue(requestId);
//request = pendingRequests[requestId];
request.Status = status;
}
catch (Exception ex)
{
Logger.Info("ChatSender.OnRequestStatusReceive while reading", ex);
}
/*finally
* {
* pendingRequestsLock.ExitReadLock();
* }*/
try
{
/*if (!pendingRequestsLock.TryEnterWriteLock(lockTimeout))
* {
* Console.WriteLine("ChatSender.OnRequestStatusReceive: pendingRequestsWriteLock timeout");
* return;
* }*/
pendingRequests.Remove(requestId);
//pendingRequestsLock.ExitWriteLock();
}
catch (Exception ex)
{
Logger.Info("ChatSender.OnRequestStatusReceive while removing", ex);
}
if (RequestProcessed != null && request != null)
{
RequestProcessed(request);
}
}
public void PutMessage(MessageCategory cat, string msg)
{
var upTime = messagePublished.ReceiveValue(cat);
if (upTime.HasValue)
{
var deltaSec = (DateTime.Now - upTime.Value).TotalSeconds;
if (deltaSec < minSecondsBetweenSameMessages)
{
return;
}
}
messages.Add(new Cortege2 <MessageCategory, string>(cat, msg), 1000);
messagePublished.UpdateValues(cat, DateTime.Now);
}
public void PushEvents(List <UserEvent> events)
{
try
{
if (events.Count == 0)
{
return;
}
var eventsSorted = events.GroupBy(x => x.User).ToDictionary(gdc => gdc.Key, gdc => gdc.ToList());
foreach (var pair in eventsSorted)
{
var oldEvents = userEvent.ReceiveValue(pair.Key);
oldEvents = oldEvents != null?oldEvents.ToList() : new List <UserEvent>();
oldEvents.AddRange(pair.Value);
userEvent.UpdateValues(pair.Key, oldEvents);
}
}
catch (Exception ex)
{
Logger.Error("Error in UserEventStorage.PushEvents()", ex);
}
}
public List <Cortege2 <DateTime, float> > GetQuotes(string ticker)
{
return(quotes.ReceiveValue(ticker) ?? new List <Cortege2 <DateTime, float> >());
}
public QuoteData FindQuote(string name)
{
return(lastQuotes.ReceiveValue(name));
}
/// <summary>
/// отдельный класс читает очередь сообщений от провайдеров
/// каждый FIX-дилер получает сообщения своей группы
/// </summary>
public void ProcessExecutionReport(BrokerResponse response, BrokerOrder request)
{
Logger.InfoFormat("Запрос ({0}), ответ ({1})", request, response);
requestWatchdog.OnRequestProcessed(response.RequestId);
// сообщить клиенту об отказе обработать ордер
// вынимаем ордер из базы
MarketOrder order;
int orderId;
if (request.ClosingPositionID != null && request.ClosingPositionID > 0)
{
orderId = (int)request.ClosingPositionID;
}
else
{
orderId = request.RequestId;
Logger.InfoFormat("Запрос GetMarketOrder orderId={0} requestId={1}", orderId, request.RequestId);
}
Logger.InfoFormat("Запрос GetMarketOrder accountId={0}, orderId={1}", request.AccountID, orderId);
var res = ServerInterface.GetMarketOrder(orderId, out order);
if (res == false)
{
errorStorage.AddMessage(new ErrorMessage(DateTime.Now, ErrorMessageType.ОтказСервера,
string.Format("Дилер {0}: не найдена позиция ID={0} для обработка запроса [{1}]-[счет {2}, пара {3}]",
request.RequestId, request.Id, request.AccountID, request.Instrument), null));
ServerInterface.NotifyClientOnOrderRejected(order, "не найден ордер");
return;
}
if (response.Status == OrderStatus.Отклонен)
{
var rejectReasonStr = string.IsNullOrEmpty(response.RejectReasonString)
? (response.RejectReason ?? OrderRejectReason.None).ToString()
: response.RejectReasonString;
ServerInterface.NotifyClientOnOrderRejected(order, rejectReasonStr);
errorStorage.AddMessage(new ErrorMessage(DateTime.Now, ErrorMessageType.ОтказСервера,
string.Format("Дилер {0}: отказ сервера [{1}] на запрос [{2}]-[счет {3}, пара {4}]",
DealerCode, rejectReasonStr, request.Id, request.AccountID, request.Instrument), null));
return;
}
if (!response.Price.HasValue)
{
errorStorage.AddMessage(new ErrorMessage(DateTime.Now, ErrorMessageType.ОтказСервера,
string.Format("Дилер {0}: отказ сервера [нет цены] на запрос [{1}]-[счет {2}, пара {3}]",
DealerCode, request.Id, request.AccountID, request.Instrument), null));
ServerInterface.NotifyClientOnOrderRejected(order, "Нет цены");
return;
}
var deltaMarkup = request.MarkupAbs * order.Side;
// закрытие позиции - ордер обработан
if (request.ClosingPositionID.HasValue)
{
var reason = exitReasonByOrderId.ReceiveValue(order.ID);
// закрыть ордер немедленно
ServerInterface.CloseOrder(order.ID, response.Price.Value - (decimal)deltaMarkup, reason);
return;
}
// открытие позы - обработано
order.TimeEnter = response.ValueDate;
order.PriceEnter = (float)response.Price.Value + deltaMarkup;
order.State = PositionState.Opened;
ServerInterface.ModifyMarketOrder(order);
}
private void DoSend()
{
Chat = new ChatClientStable(chatCallback, TerminalBindings.Chat);
Chat.Connected += () => { if (Connected != null)
{
Connected();
}
};
Chat.Disconnected += () => { if (Disconnected != null)
{
Disconnected();
}
};
UserInfoSource = new UserInfoExCache(TradeSharpAccountStatistics.Instance.proxy);
while (!isStopping)
{
bool timeoutFlag;
var allRequests = requests.ExtractAll(lockTimeout, out timeoutFlag);
if (timeoutFlag)
{
continue;
}
// флаг повтора запроса;
// перезапросы возникают из-за ошибок сети;
// в этом случае ожидание между запросами увеличено, чтобы не загружать проц без пользы
var repeatRequest = false;
foreach (var request in allRequests)
{
try
{
switch (request.Code)
{
case RequestCode.GetAllUsers:
request.Id = Chat.GetAllUsers((string)request.Arguments[0]);
break;
case RequestCode.Enter:
request.Id = Chat.Enter((User)request.Arguments[0]);
break;
case RequestCode.Exit:
request.Id = Chat.Exit();
break;
case RequestCode.GetRooms:
request.Id = Chat.GetRooms();
break;
case RequestCode.EnterRoom:
request.Id = Chat.EnterRoom((string)request.Arguments[0], (string)request.Arguments[1]);
break;
case RequestCode.MoveToRoom:
request.Id = Chat.MoveToRoom((int)request.Arguments[0], (string)request.Arguments[1],
(string)request.Arguments[2]);
break;
case RequestCode.LeaveRoom:
request.Id = Chat.LeaveRoom((string)request.Arguments[0]);
break;
case RequestCode.CreateRoom:
request.Id = Chat.CreateRoom((Room)request.Arguments[0]);
break;
case RequestCode.DestroyRoom:
request.Id = Chat.DestroyRoom((string)request.Arguments[0]);
break;
case RequestCode.SendPrivateMessage:
request.Id = Chat.SendPrivateMessage((int)request.Arguments[0],
(string)request.Arguments[1]);
break;
case RequestCode.SendMessage:
request.Id = Chat.SendMessage((string)request.Arguments[0],
(string)request.Arguments[1]);
break;
case RequestCode.GetPendingMessages:
request.Id = Chat.GetPendingMessages((DateTime)request.Arguments[0],
(string)request.Arguments[1]);
break;
case RequestCode.GetPendingPrivateMessages:
request.Id = Chat.GetPendingPrivateMessages((DateTime)request.Arguments[0],
(int)request.Arguments[1]);
break;
case RequestCode.Ping:
Chat.Ping();
break;
case RequestCode.GetUserInfoEx:
var userinfo = UserInfoSource.GetUserInfo((int)request.Arguments[0]);
if (UserInfoExReceived != null)
{
UserInfoExReceived(userinfo ?? new UserInfoEx {
Id = (int)request.Arguments[0]
});
}
break;
case RequestCode.SetUserInfoEx:
UserInfoSource.SetUserInfo((UserInfoEx)request.Arguments[0]);
break;
}
if (request.Id == 0)
{
QueueRequest(request); // if server refused request - try again
repeatRequest = true;
}
else if (request.Id != -1) // skip Ping, GetUserInfoEx, SetUserInfoEx
{
request.Status = ChatResultCode.InProgress;
pendingRequests.UpdateValues(request.Id, request);
/*if (pendingRequestsLock.TryEnterWriteLock(lockTimeout))
* {
* pendingRequests.Add(request.Id, request);
* pendingRequestsLock.ExitWriteLock();
* }
* else
* Console.WriteLine("ChatSender.DoSend: pendingRequestsWriteLock timeout");*/
var requestCopy = new ChatRequest(request);
if (RequestQueuedOnServer != null)
{
RequestQueuedOnServer(requestCopy);
}
if (forwardAnswers.ContainsKey(request.Id))
{
pendingRequests.Remove(request.Id);
requestCopy.Status = forwardAnswers.ReceiveValue(request.Id);
if (RequestProcessed != null)
{
RequestProcessed(requestCopy);
}
forwardAnswers.Remove(request.Id);
}
}
}
catch (Exception ex) // probably communication error
{
Logger.ErrorFormat("DoSend exception: {0}", ex);
if (request.Code != RequestCode.Ping)
{
QueueRequest(request);
}
repeatRequest = true;
}
}
//проверка соединения - ping
if (allRequests.Count == 0)
{
if (DateTime.Now.Subtract(lastConnectionCheck.GetLastHit()).TotalSeconds > 15)
{
var request = new ChatRequest(RequestCode.Ping, new List <object>(), -1);
QueueRequest(request);
lastConnectionCheck.Touch();
}
}
Thread.Sleep(repeatRequest ? 1000 : 100);
}
}
