public async Task TestConnect2SameDestination()
{
const string address = "127.0.0.1";
const int port = 7656;
var samHelperSend = await SamHelper.CreateInstance(
new SamHelperSettings()
{
SamServerAddress = address,
SamServerPort = port
},
CancellationToken.None
).ConfigureAwait(false);
try
{
var samHelperSend2 = await SamHelper.CreateInstance(
new SamHelperSettings()
{
SamServerAddress = address,
SamServerPort = port,
SessionPrivateKeys = samHelperSend.Session.PrivateKey
},
CancellationToken.None
).ConfigureAwait(false);
throw new Exception();
}
catch (EnumException <SamHelper.ECreateInstanceErrCodes> enumExc)
{
Assert.Equal(
SamHelper.ECreateInstanceErrCodes.CreateSessionError,
enumExc.ExceptionCode
);
var innerExc = (EnumException <SamHelper.ECreateSessionErrorCodes>)enumExc.InnerException;
Assert.NotNull(innerExc);
Assert.Equal(
SamHelper.ECreateSessionErrorCodes.DuplicatedDest,
innerExc.ExceptionCode
);
}
finally
{
await samHelperSend.MyDisposeAsync().ConfigureAwait(false);
}
}
private async Task testSendReceiveFunc(
ReliableSamHelper reliableHelperRecv,
ReconnectingSamHelper reconnectingSamHelperSend,
ReliableSamHelper reliableHelperSend,
byte[] data,
SamHelper samHelperReceive
)
{
var waitRecvMessage = reliableHelperRecv.ReliableMessageReceived
.Where(x => x.Destination == reconnectingSamHelperSend.Session.Destination)
.FirstAsync()
.ToTask();
try
{
var messageId = await reliableHelperSend.SendReliableMessage(
samHelperReceive.Session.Destination,
data
).ConfigureAwait(false);
_logger.Trace("Message sent id {0}", messageId);
}
catch (EnumException <ReliableSamHelper.SendReliableMessageExcs> exc)
{
_logger.Trace("Send error {0}", exc.ExceptionCode);
throw;
}
try
{
var receivedMessage = await waitRecvMessage.ConfigureAwait(false);
_logger.Trace("Message received {0} bytes", receivedMessage.Data.Length);
Assert.Equal(data, receivedMessage.Data);
}
catch (OperationCanceledException exc)
{
_logger.Trace("Recv timeout {0}", exc);
throw;
}
catch (Exception exc)
{
_logger.Trace("Recv error {0}", exc);
throw;
}
}
private async Task testSendReceiveFunc(
ReliableSamHelper reliableHelperRecv,
ReconnectingSamHelper reconnectingSamHelperSend,
ReliableSamHelper reliableHelperSend,
byte[] data,
SamHelper samHelperReceive
)
{
var waitRecvMessage = reliableHelperRecv.ReliableMessageReceived
.Where(x => x.Destination == reconnectingSamHelperSend.Session.Destination)
.FirstAsync()
.ToTask();
try
{
var messageId = await reliableHelperSend.SendReliableMessage(
samHelperReceive.Session.Destination,
data
).ConfigureAwait(false);
_logger.Trace("Message sent id {0}", messageId);
}
catch (EnumException<ReliableSamHelper.SendReliableMessageExcs> exc)
{
_logger.Trace("Send error {0}", exc.ExceptionCode);
throw;
}
try
{
var receivedMessage = await waitRecvMessage.ConfigureAwait(false);
_logger.Trace("Message received {0} bytes", receivedMessage.Data.Length);
Assert.Equal(data, receivedMessage.Data);
}
catch (OperationCanceledException exc)
{
_logger.Trace("Recv timeout {0}", exc);
throw;
}
catch (Exception exc)
{
_logger.Trace("Recv error {0}", exc);
throw;
}
}
public async Task TestConnectDisconnectNTimes()
{
const string address = "127.0.0.1";
const int port = 7656;
int n = 20;
string privateKeys = null;
for (int i = 0; i < n; i++)
{
var samHelperSend = await SamHelper.CreateInstance(
new SamHelperSettings()
{
SamServerAddress = address,
SamServerPort = port,
SessionPrivateKeys = privateKeys
},
CancellationToken.None
).ConfigureAwait(false);
privateKeys = samHelperSend.Session.PrivateKey;
_output.WriteLine("{0}", i);
await samHelperSend.MyDisposeAsync().ConfigureAwait(false);
}
}
public async Task TestGenNKeys()
{
const string address = "127.0.0.1";
const int port = 7656;
int n = 5;
for (int i = 0; i < n; i++)
{
var samHelperSend = await SamHelper.CreateInstance(
new SamHelperSettings()
{
SamServerAddress = address,
SamServerPort = port,
SessionPrivateKeys = null
},
CancellationToken.None
).ConfigureAwait(false);
_output.WriteLine("{0}", i);
_output.WriteLine("Dest: {0}", samHelperSend.Session.Destination);
_output.WriteLine("Key: {0}", samHelperSend.Session.PrivateKey);
await samHelperSend.MyDisposeAsync().ConfigureAwait(false);
}
}
public async Task TestReconnectingReliable()
{
const string addressSend = "127.0.0.1";
const int portSend = 7656;
/**/
var proxyHostname = "127.0.0.1";
var proxyPort = 17000;
var proxyServer = await MyTcpProxyServer.CreateInstance(
new MyTcpProxyServerSettings()
{
DestinationHostname = addressSend,
DestinationPort = portSend,
ServerHostname = proxyHostname,
ServerPort = proxyPort
}
).ConfigureAwait(false);
/**/
const string addressRecv = addressSend;
const int portRecv = portSend;
string sendPrivKeys;
/**/
{
var samHelperSend = await SamHelper.CreateInstance(
new SamHelperSettings()
{
SamServerAddress = addressSend,
SamServerPort = portSend
}, CancellationToken.None
).ConfigureAwait(false);
sendPrivKeys = samHelperSend.Session.PrivateKey;
await samHelperSend.MyDisposeAsync().ConfigureAwait(false);
}
/**/
var reconnectingSamHelperSend = await ReconnectingSamHelper.CreateInstance(
new ReconnectingSamHelperSettings()
{
ImplementationHelperSettings =
new SamHelperSettings()
{
SamServerAddress = proxyHostname,
SamServerPort = proxyPort,
SessionPrivateKeys = sendPrivKeys
}
}, CancellationToken.None
).ConfigureAwait(false);
var samHelperReceive = await SamHelper.CreateInstance(
new SamHelperSettings()
{
SamServerAddress = addressRecv,
SamServerPort = portRecv
}, CancellationToken.None
).ConfigureAwait(false);
var reliableHelperSend = new ReliableSamHelper(
reconnectingSamHelperSend,
new ReliableSamHelperSettings()
);
var reliableHelperRecv = new ReliableSamHelper(
samHelperReceive,
new ReliableSamHelperSettings()
);
var data = new byte[200000];
MiscFuncs.GetRandomBytes(data);
/**/
await testSendReceiveFunc(
reliableHelperRecv,
reconnectingSamHelperSend,
reliableHelperSend,
data,
samHelperReceive
).ConfigureAwait(false);
await proxyServer.MyDisposeAsync().ConfigureAwait(false);
_logger.Trace("###################################");
await Assert.ThrowsAsync <TimeoutException>(
async() => await testSendReceiveFunc(
reliableHelperRecv,
reconnectingSamHelperSend,
reliableHelperSend,
data,
samHelperReceive
).ConfigureAwait(false)
).ConfigureAwait(false);
/**/
_logger.Trace("###################################");
proxyServer = await MyTcpProxyServer.CreateInstance(
new MyTcpProxyServerSettings()
{
DestinationHostname = addressSend,
DestinationPort = portSend,
ServerHostname = proxyHostname,
ServerPort = proxyPort
}
).ConfigureAwait(false);
reconnectingSamHelperSend.TryToReconnect(DateTime.UtcNow);
await Task.Delay(TimeSpan.FromSeconds(15.0d)).ConfigureAwait(false);
/**/
await testSendReceiveFunc(
reliableHelperRecv,
reconnectingSamHelperSend,
reliableHelperSend,
data,
samHelperReceive
).ConfigureAwait(false);
/**/
await reliableHelperSend.MyDisposeAsync().ConfigureAwait(false);
_logger.Trace("reliableHelperSend disposed");
await reliableHelperRecv.MyDisposeAsync().ConfigureAwait(false);
_logger.Trace("reliableHelperRecv disposed");
await reconnectingSamHelperSend.MyDisposeAsync().ConfigureAwait(false);
_logger.Trace("samHelperSend disposed");
await samHelperReceive.MyDisposeAsync().ConfigureAwait(false);
_logger.Trace("samHelperReceive disposed");
await proxyServer.MyDisposeAsync().ConfigureAwait(false);
_logger.Trace("{0} disposed", MyNameof.GetLocalVarName(() => proxyServer));
}
public async Task TestConnectDisconnectImpl()
{
Thread.CurrentThread.CurrentCulture = new CultureInfo("en-US");
Thread.CurrentThread.CurrentUICulture = new CultureInfo("en-US");
const string address = "127.0.0.1";
const int port = 7656;
var samHelperSend = await SamHelper.CreateInstance(
new SamHelperSettings()
{
SamServerAddress = address,
SamServerPort = port
},
new CancellationToken()
).ConfigureAwait(false);
var samHelperReceive = await SamHelper.CreateInstance(
new SamHelperSettings()
{
SamServerAddress = address,
SamServerPort = port
},
new CancellationToken()
).ConfigureAwait(false);
var sendDestination = samHelperSend.Session.Destination;
_output.WriteLine("Send session created " + sendDestination.Substring(0, 20));
var recvDestination = samHelperReceive.Session.Destination;
_output.WriteLine("Recv session created " + recvDestination.Substring(0, 20));
await Task.Delay(2000).ConfigureAwait(false);
_output.WriteLine("delay");
var datagramRecvTimeout
= new CancellationTokenSource(
TimeSpan.FromSeconds(15)
);
samHelperReceive.DatagramDataReceived
.ObserveOn(TaskPoolScheduler.Default)
.Subscribe(
x => { _output.WriteLine("{0}", x.Data.Length); }
);
var datagramReceivedTask =
samHelperReceive
.DatagramDataReceived
.FirstAsync()
.ToTask(datagramRecvTimeout.Token);
for (int i = 0; i < 10; i++)
{
try
{
await samHelperSend.SendDatagram(
recvDestination,
Enumerable
.Repeat((byte)100, 200)
.ToArray()
).ConfigureAwait(false);
}
catch (Exception exc)
{
_output.WriteLine("Send datagram error '{0}' '{1}'", exc.ToString(), i);
throw;
}
}
try
{
var recvDatagram = await datagramReceivedTask.ConfigureAwait(false);
_output.WriteLine(
"Datagram received message: "
+ Encoding.ASCII.GetString(
recvDatagram.Data
)
);
}
catch (OperationCanceledException)
{
_output.WriteLine("Datagram receive timeout");
throw;
}
catch (Exception exc)
{
_output.WriteLine("Datagram receive error '{0}'", exc.ToString());
throw;
}
/**************************/
await Task.Delay(500).ConfigureAwait(false);
await samHelperSend.MyDisposeAsync().ConfigureAwait(false);
}
public async Task TestMemoryOverhead()
{
const string addressSend = "127.0.0.1";
const int portSend = 7656;
const string addressRecv = addressSend;
const int portRecv = 7656;
const string i2cpOptions = "";
var samHelperSend = await SamHelper.CreateInstance(
new SamHelperSettings()
{
SamServerAddress = addressSend,
SamServerPort = portSend
}, CancellationToken.None
).ConfigureAwait(false);
var samHelperReceive = await SamHelper.CreateInstance(
new SamHelperSettings()
{
SamServerAddress = addressRecv,
SamServerPort = portRecv
}, CancellationToken.None
).ConfigureAwait(false);
var reliableHelperSend = new ReliableSamHelper(
samHelperSend,
new ReliableSamHelperSettings()
);
var reliableHelperRecv = new ReliableSamHelper(
samHelperReceive,
new ReliableSamHelperSettings()
);
/**/
var data = new byte[400000];
MiscFuncs.GetRandomBytes(data);
_logger.Trace("Begin Total memory - {0} bytes", GC.GetTotalMemory(true));
for (int i = 0; i < 10; i++)
{
var waitRecvMessage = reliableHelperRecv.ReliableMessageReceived
.Where(x => x.Destination == samHelperSend.Session.Destination)
.FirstAsync()
.ToTask();
try
{
var messageId = await reliableHelperSend.SendReliableMessage(
samHelperReceive.Session.Destination,
data
).ConfigureAwait(false);
_logger.Trace("Message sent id {0}", messageId);
}
catch (EnumException <ReliableSamHelper.SendReliableMessageExcs> exc)
{
_logger.Trace("Send error {0}", exc.ExceptionCode);
throw;
}
try
{
var receivedMessage = await waitRecvMessage.ConfigureAwait(false);
_logger.Trace(
"Message received {0} bytes",
receivedMessage.Data.Length
);
Assert.Equal(data, receivedMessage.Data);
}
catch (OperationCanceledException exc)
{
_logger.Trace("Recv timeout {0}", exc);
throw;
}
catch (Exception exc)
{
_logger.Trace("Recv error {0}", exc);
throw;
}
}
/**/
long memory = GC.GetTotalMemory(true);
_logger.Trace("End Total memory - {0} bytes", memory);
await reliableHelperSend.MyDisposeAsync().ConfigureAwait(false);
_logger.Trace("reliableHelperSend disposed");
await reliableHelperRecv.MyDisposeAsync().ConfigureAwait(false);
_logger.Trace("reliableHelperRecv disposed");
await samHelperSend.MyDisposeAsync().ConfigureAwait(false);
_logger.Trace("samHelperSend disposed");
await samHelperReceive.MyDisposeAsync().ConfigureAwait(false);
_logger.Trace("samHelperReceive disposed");
}
public async Task TestSendReceiveOneMessageImpl()
{
const string addressSend = "192.168.56.102"; //"192.168.1.132";
const int portSend = 7656;
const string addressRecv = addressSend; //"127.0.0.1";
const int portRecv = 7656;
var samHelperSend = await SamHelper.CreateInstance(
new SamHelperSettings()
{
SamServerAddress = addressSend,
SamServerPort = portSend
}, CancellationToken.None
).ConfigureAwait(false);
var samHelperReceive = await SamHelper.CreateInstance(
new SamHelperSettings()
{
SamServerAddress = addressRecv,
SamServerPort = portRecv
}, CancellationToken.None
).ConfigureAwait(false);
var reliableHelperSend = new ReliableSamHelper(
samHelperSend,
new ReliableSamHelperSettings()
);
var reliableHelperRecv = new ReliableSamHelper(
samHelperReceive,
new ReliableSamHelperSettings()
);
var data = new byte[1];
MiscFuncs.GetRandomBytes(data);
var waitRecvMessage = reliableHelperRecv.ReliableMessageReceived
.Where(x => x.Destination == samHelperSend.Session.Destination)
.FirstAsync()
.ToTask();
var sendProgress = new Progress <OutMessageProgressInfo>(
x => _logger.Trace(x.ToString())
);
try
{
var messageId = await reliableHelperSend.SendReliableMessage(
samHelperReceive.Session.Destination,
data,
sendProgress
).ConfigureAwait(false);
_logger.Trace("Message sent id {0}", messageId);
}
catch (EnumException <ReliableSamHelper.SendReliableMessageExcs> exc)
{
_logger.Trace("Send error {0}", exc.ExceptionCode);
throw;
}
try
{
var receivedMessage = await waitRecvMessage.ConfigureAwait(false);
_logger.Trace("Message received {0} bytes", receivedMessage.Data.Length);
Assert.Equal(data, receivedMessage.Data);
}
catch (OperationCanceledException exc)
{
_logger.Trace("Recv timeout {0}", exc);
throw;
}
catch (Exception exc)
{
_logger.Trace("Recv error {0}", exc);
throw;
}
_logger.Trace("End Total memory - {0} bytes", GC.GetTotalMemory(true));
await reliableHelperSend.MyDisposeAsync().ConfigureAwait(false);
_logger.Trace("reliableHelperSend disposed");
await reliableHelperRecv.MyDisposeAsync().ConfigureAwait(false);
_logger.Trace("reliableHelperRecv disposed");
await samHelperSend.MyDisposeAsync().ConfigureAwait(false);
_logger.Trace("samHelperSend disposed");
await samHelperReceive.MyDisposeAsync().ConfigureAwait(false);
_logger.Trace("samHelperReceive disposed");
}
