IServer IIpcProvider.GetServer(string connectionString, IServerConfig config)
{
return(new NonMultiplexingServer <Socket>(
"TcpIpServer",
config,
new TcpIpConnectivity(TcpIpConnectivity.ParsePortNumber(connectionString))));
}
public async Task TestIcpIpConectToServerWhenNoServerIsRunningAsync()
{
using var tcpIp = new TcpIpConnectivity(port: 12345);
var ex = await Assert.ThrowsAnyAsync <SocketException>(async() => await tcpIp.ConnectToServerAsync(numTimesToRetry: 2, delayMillis: 50));
XAssert.IsNotNull(ex);
}
private async Task WithClient(TcpIpConnectivity tcpIpProvider, Func <NetworkStream, Task> action)
{
using (var tcpClient = await tcpIpProvider.ConnectToServerAsync())
using (var stream = tcpClient.GetStream())
{
await action(stream);
}
}
private async Task AssertPingServerFromNewClient(TcpIpConnectivity tcpIpProvider)
{
using (var tcpClient = await tcpIpProvider.ConnectToServerAsync())
using (var stream = tcpClient.GetStream())
{
await AssertPingServer(stream);
}
}
IServer IIpcProvider.GetServer(string connectionString, IServerConfig config)
{
var port = TcpIpConnectivity.ParsePortNumber(connectionString);
return(new MultiplexingServer <Socket>(
"TcpIp-" + port,
config.Logger,
connectivityProvider: new TcpIpConnectivity(port),
maxConcurrentClients: config.MaxConcurrentClients,
maxConcurrentRequestsPerClient: config.MaxConcurrentRequestsPerClient));
}
private async Task WithSetup(string testName, Func <MultiplexingClient, Socket, Task> testAction)
{
using (var tcpConnectivity = new TcpIpConnectivity(Utils.GetUnusedPortNumber()))
{
var serverSocketTask = Task.Run(() => tcpConnectivity.AcceptClientAsync(CancellationToken.None));
using (var tcpClient = await tcpConnectivity.ConnectToServerAsync())
using (var serverSocket = await serverSocketTask)
{
var client = new MultiplexingClient(ClientConfigWithLogger(testName), tcpClient.GetStream());
await testAction(client, serverSocket);
}
}
}
private PluginCreationArgument GetPluginArgument(string pluginPath, bool runInSeparateProcess)
{
var pluginId = PluginFactory.Instance.CreatePluginId();
return(new PluginCreationArgument()
{
PluginPath = pluginPath,
RunInSeparateProcess = runInSeparateProcess,
PluginId = pluginId,
ConnectionOption = new PluginConnectionOption()
{
IpcMoniker = IpcFactory.GetProvider().LoadAndRenderMoniker(IpcFactory.GetProvider().CreateNewMoniker().Id),
LogDir = m_logDirectory,
Logger = PluginLogUtils.CreateLoggerForPluginClients(m_loggingContext, pluginId)
},
CreatePluginClientFunc = options =>
{
int port = TcpIpConnectivity.ParsePortNumber(options.IpcMoniker);
return new PluginClient(IPAddress.Loopback.ToString(), port, options.Logger);
}
});
}
private TcpIpConnectivity CreateAndStartTcpIpProvider(ILogger logger, int numTimesToRetry = 3, int delayMillis = 250)
{
try
{
var port = Utils.GetUnusedPortNumber();
var tcpIpProvider = new TcpIpConnectivity(port);
tcpIpProvider.StartListening();
return(tcpIpProvider);
}
catch (SocketException e)
{
if (numTimesToRetry > 0)
{
logger.Verbose($"Could not connect; error: '{e.GetLogEventMessage()}'. Waiting {delayMillis}ms then retrying {numTimesToRetry} more times");
Thread.Sleep(millisecondsTimeout: delayMillis);
return(CreateAndStartTcpIpProvider(logger, numTimesToRetry - 1, delayMillis * 2));
}
else
{
logger.Verbose($"Could not connect; error: '{e.GetLogEventMessage()}'. Not retrying any more.");
throw;
}
}
}
IClient IIpcProvider.GetClient(string connectionString, IClientConfig config)
{
return(new Client(config, TcpIpConnectivity.ParsePortNumber(connectionString)));
}
public void TestParseInvalidPortNumber(string port)
{
var ex = Assert.Throws <IpcException>(() => TcpIpConnectivity.ParsePortNumber(port));
XAssert.AreEqual(IpcException.IpcExceptionKind.InvalidMoniker, ex.Kind);
}
