private static void TryCreateDirectory(DiskSdkClient client, string path)
{
var sync = new SyncObject();
var items = Enumerable.Empty <DiskItemInfo>();
Exception error = null;
EventHandler <GenericSdkEventArgs <IEnumerable <DiskItemInfo> > > listHandler = (s, e) =>
{
if (e.Error != null)
{
error = e.Error;
}
else
{
items = e.Result;
}
sync.Pulse();
};
client.GetListCompleted += listHandler;
client.GetListAsync();
sync.Wait();
client.GetListCompleted -= listHandler;
if (error != null)
{
throw error;
}
if (items.Any(i => i.IsDirectory && i.OriginalFullPath.TrimEnd("/") == path))
{
return;
}
EventHandler <SdkEventArgs> createHandler = (s, e) =>
{
error = e.Error;
sync.Pulse();
};
client.MakeFolderCompleted += createHandler;
client.MakeDirectoryAsync(path);
sync.Wait();
client.MakeFolderCompleted -= createHandler;
if (error != null)
{
throw error;
}
}
/// <summary>
/// Метод обработки исходящих сообщений.
/// </summary>
/// <param name="message">Сообщение.</param>
/// <param name="adapter">Адаптер.</param>
protected override void OnOutMessageProcessor(Message message, IMessageAdapter adapter)
{
base.OnOutMessageProcessor(message, adapter);
lock (_syncRoot)
{
if (_running && OutMessageProcessor.MessageCount < MaxMessageCount)
{
_syncRoot.Pulse();
}
}
}
private static string Publish(DiskSdkClient client, string remotePath)
{
var sync = new SyncObject();
Exception error = null;
string result = null;
EventHandler <GenericSdkEventArgs <string> > handler = (s, e) =>
{
if (e.Error == null)
{
result = e.Result;
}
else
{
error = e.Error;
}
sync.Pulse();
};
client.PublishCompleted += handler;
client.PublishAsync(remotePath);
sync.Wait();
client.PublishCompleted -= handler;
if (error != null)
{
error.Throw();
}
return(result);
}
/// <summary>
/// Остановить накопление маркет-данных.
/// </summary>
public void Stop()
{
Connector = null;
LastError = null;
_criteria = null;
//_isRefreshed = false;
_wasConnected = false;
_exportStarted = false;
lock (_refreshSync)
{
_isRefreshed = true;
_refreshSync.Pulse();
}
}
/// <summary>
/// Остановить.
/// </summary>
public void Stop()
{
lock (_syncObject)
{
State = TaskStates.Stopping;
_syncObject.Pulse();
}
}
/// <summary>
/// Остановить загрузку данных.
/// </summary>
protected override void OnStopped()
{
Connector.Disconnect();
_criteria = null;
//_isRefreshed = false;
_wasConnected = false;
_exportStarted = false;
lock (_refreshSync)
{
_isRefreshed = true;
_refreshSync.Pulse();
}
// обрабатка данных, которые могли успеть прийти в момент остановки подключения
ProcessNewData();
base.OnStopped();
}
/// <summary>
/// Opens a channel, this will create a new channel where data will be tunneled through
/// </summary>
/// <param name="channel">The channel you want to open</param>
/// <param name="Tag">The object want the channel to carry</param>
/// <returns>Was opening a channel successful</returns>
public ChannelError OpenChannel(Channel channel)
{
try
{
lock (channels)
{
//first set the default info
channel.Connection = Connection;
channel.Client = this;
channel.State = ConnectionState.Open;
OpenChannelResponse ChannelResponse = null;
SyncObject syncObject = new SyncObject(Connection);
SharedChannel.OpenChannel((OpenChannelResponse response) =>
{
ChannelResponse = response;
syncObject.Pulse();
});
syncObject.Wait <object>(null, 30000);
if (ChannelResponse == null)
{
return(ChannelError.Timeout);
}
if (!ChannelResponse.success)
{
return(ChannelError.Timeout);
}
channel.ConnectionId = ChannelResponse.ConnectionId;
channels.Add(channel.ConnectionId, channel);
try
{
channel.onChannelOpen();
} catch (Exception ex)
{
onException(ex, ErrorType.UserLand);
}
return(ChannelError.Success);
}
}
catch (Exception ex)
{
onException(ex, ErrorType.Core);
}
return(ChannelError.InitializeError);
}
public void HandleResponse(SSPClient Client, object ResponseObj)
{
if (isResponse)
{
lock (Client.Connection.Requests)
{
SyncObject syncObj = null;
if (Client.Connection.Requests.TryGetValue(RequestId, out syncObj))
{
syncObj.Value = ResponseObj;
syncObj.Pulse();
Client.Connection.Requests.Remove(RequestId);
}
}
}
}
private static void UploadFile(DiskSdkClient client, string remotePath, string localPath)
{
var sync = new SyncObject();
Exception error = null;
client.UploadFileAsync(remotePath, File.OpenRead(localPath),
new AsyncProgress((c, t) => { }),
(us, ua) =>
{
error = ua.Error;
sync.Pulse();
});
sync.Wait();
if (error != null)
{
error.Throw();
}
}
void IDisposable.Dispose()
{
_isDisposed = true;
_drawTimer.Flush();
_syncObject.Pulse();
}
/// <summary>
/// Сэмулировать заявки на истории.
/// </summary>
/// <param name="orders">Заявки, которые необходимо сэмулировать на истории.</param>
/// <param name="storageRegistry">Внешнеее хранилище для доступа к исторических данным.</param>
/// <param name="openedPositions">Сделки, описывающие начальные открытые позиции.</param>
/// <returns>Виртуальная стратегии, содержащая в себе ход эмуляционных торгов.</returns>
public static Strategy EmulateOrders(this IEnumerable <Order> orders, IStorageRegistry storageRegistry, IDictionary <Security, decimal> openedPositions)
{
if (openedPositions == null)
{
throw new ArgumentNullException("openedPositions");
}
if (storageRegistry == null)
{
throw new ArgumentNullException("storageRegistry");
}
if (orders == null)
{
throw new ArgumentNullException("orders");
}
if (orders.IsEmpty())
{
throw new ArgumentOutOfRangeException("orders");
}
using (var connector = new RealTimeEmulationTrader <HistoryEmulationConnector>(new HistoryEmulationConnector(orders.Select(o => o.Security).Distinct(), orders.Select(o => o.Portfolio).Distinct())
{
StorageRegistry = storageRegistry
}))
{
var from = orders.Min(o => o.Time).Date;
var to = from.EndOfDay();
var strategy = new EquityStrategy(orders, openedPositions)
{
Connector = connector
};
var waitHandle = new SyncObject();
connector.UnderlyingConnector.StateChanged += () =>
{
if (connector.UnderlyingConnector.State == EmulationStates.Started)
{
strategy.Start();
}
if (connector.UnderlyingConnector.State == EmulationStates.Stopped)
{
strategy.Stop();
waitHandle.Pulse();
}
};
connector.Connect();
connector.StartExport();
connector.UnderlyingConnector.Start(from, to);
lock (waitHandle)
{
if (connector.UnderlyingConnector.State != EmulationStates.Stopped)
{
waitHandle.Wait();
}
}
return(strategy);
}
}
private static string Publish(DiskSdkClient client, string remotePath)
{
var sync = new SyncObject();
Exception error = null;
String result = null;
EventHandler<GenericSdkEventArgs<string>> handler = (s, e) =>
{
if (e.Error == null)
result = e.Result;
else
error = e.Error;
sync.Pulse();
};
client.PublishCompleted += handler;
client.PublishAsync(remotePath);
sync.Wait();
client.PublishCompleted -= handler;
if (error != null)
throw error;
return result;
}
private static void UploadFile(DiskSdkClient client, string remotePath, string localPath)
{
var sync = new SyncObject();
Exception error = null;
client.UploadFileAsync(remotePath, File.OpenRead(localPath),
new AsyncProgress((c, t) => { }),
(us, ua) =>
{
error = ua.Error;
sync.Pulse();
});
sync.Wait();
if (error != null)
throw error;
}
private static void TryCreateDirectory(DiskSdkClient client, string path)
{
var sync = new SyncObject();
var items = Enumerable.Empty<DiskItemInfo>();
Exception error = null;
EventHandler<GenericSdkEventArgs<IEnumerable<DiskItemInfo>>> listHandler = (s, e) =>
{
if (e.Error != null)
error = e.Error;
else
items = e.Result;
sync.Pulse();
};
client.GetListCompleted += listHandler;
client.GetListAsync();
sync.Wait();
client.GetListCompleted -= listHandler;
if (error != null)
throw error;
if (items.Any(i => i.IsDirectory && i.OriginalFullPath.TrimEnd("/") == path))
return;
EventHandler<SdkEventArgs> createHandler = (s, e) =>
{
error = e.Error;
sync.Pulse();
};
client.MakeFolderCompleted += createHandler;
client.MakeDirectoryAsync(path);
sync.Wait();
client.MakeFolderCompleted -= createHandler;
if (error != null)
throw error;
}
internal unsafe void AsyncSocketCallback(object o, SocketAsyncEventArgs e)
{
if (e.LastOperation == SocketAsyncOperation.ReceiveFrom)
{
try
{
if (e.BytesTransferred >= 21)
{
if (!Connected)
{
return; //TCP Client is disconnected so don't process UDP packets
}
//before we process the packet, does the IP/LocalPort match ?
if (UdpHandshaked && BitConverter.ToUInt32(this.UdpEndPoint.Address.GetAddressBytes(), 0) !=
BitConverter.ToUInt32(((IPEndPoint)e.RemoteEndPoint).Address.GetAddressBytes(), 0))
{
//simply skip and don't disconnect TCP
//I'll add later a option to the server to disconnect or not just for safety reasons ;)
return;
}
//decrypt traffic here
PayloadReader pr = new PayloadReader(e.Buffer);
decimal clientId = pr.ReadDecimal();
//extra check
if (this.ClientId != clientId)
{
return;
}
UdpPAcketId packetId = (UdpPAcketId)pr.ReadByte();
uint MessageId = pr.ReadUInteger();
IMessage message = null;
try
{
message = Connection.messageHandler.HandleUdpMessage(pr, MessageId);
if (message != null)
{
message.RawSize = e.BytesTransferred;
}
}
catch (Exception ex)
{
return;
}
//process packet
if (UdpHandshaked)
{
switch (packetId)
{
case UdpPAcketId.Payload:
{
//onReceiveUdpMessage(message);
break;
}
}
}
else
{
MsgUdpHandshake HandshakeMsg = message as MsgUdpHandshake;
if (HandshakeMsg != null)
{
fixed(byte *ptr = HandshakeMsg.HandshakeCode, ptr2 = this.UdpHandshakeCode)
{
if (NativeMethods.memcmp(ptr, ptr2, (uint)this.UdpHandshakeCode.Length) == 0)
{
this.UdpEndPoint = e.RemoteEndPoint as IPEndPoint;
Connection.SendPayload(new MsgUdpValidation(new byte[] { 0x8F, 0xFF, 0x46, 0x4F, 0x37 }), PacketId.Unknown);
UdpHandshaked = true;
UdpSyncObject.Value = true;
UdpSyncObject.Pulse();
}
}
}
}
}
}
catch (Exception ex)
{
onException(ex, ErrorType.Core);
}
if (PeerSide == SecureSocketProtocol2.PeerSide.Client)
{
if (!UdpHandle.ReceiveFromAsync(UdpAsyncReceiveEvent))
{
AsyncSocketCallback(null, UdpAsyncReceiveEvent);
}
}
}
else
{
}
}
