public ClientAndServer CreateClientAndServer(IClientAndServerParameters parameters)
{
if (parameters == null)
{
parameters = new ClientAndServerParameters(null, null);
}
return(new ClientAndServer(ServerFactory.CreateServer(parameters), ClientFactory.CreateClient(parameters), parameters));
}
async Task Run(ClientAndServerParameters parameters)
{
if (Configuration.EnableDebugging)
{
parameters.EnableDebugging = true;
}
var connection = await Factory.Start(parameters);
connection.Dispose();
}
async Task RunWithLocalServer(ClientAndServerFactory factory, ClientAndServerParameters parameters)
{
try {
var connection = (IClientAndServer)await factory.Start(parameters);
var handler = ClientAndServerHandlerFactory.WaitForOkAndDone.Create(connection.Server, connection.Client);
await handler.Run();
connection.Dispose();
} catch (Exception ex) {
PrintError(ex);
}
}
public async Task TestConnection(TestContext ctx,
[ConnectionParameter] ClientAndServerParameters parameters,
[ServerTestHost] IServer server, [ClientTestHost] IClient client)
{
ctx.LogMessage("TEST CONNECTION: {0} {1} {2}", parameters, server, client);
var handler = ClientAndServerHandlerFactory.HandshakeAndDone.Create(server, client);
await handler.WaitForConnection();
await handler.Run();
ctx.LogMessage("TEST CONNECTION DONE");
}
void Connection(params string[] args)
{
int repeat = 0;
var clientFactory = Factory.OpenSslClient;
var serverFactory = Factory.OpenSslServer;
var parameters = new ClientAndServerParameters();
parameters.VerifyPeerCertificate = false;
parameters.TrustedCA = ResourceManager.LocalCACertificate;
var p = new OptionSet {
{ "verbose", v => parameters.EnableDebugging = true },
{ "repeat=", (int v) => repeat = v },
{ "client=", v => clientFactory = ConnectionFactoryProvider.GetClientFactory(v) },
{ "server=", v => serverFactory = ConnectionFactoryProvider.GetServerFactory(v) },
{ "verify", v => parameters.VerifyPeerCertificate = true },
{ "ask-for-cert", v => parameters.AskForClientCertificate = true },
{ "require-cert", v => parameters.RequireClientCertificate = true }
};
var extra = p.Parse(args);
if (extra.Count != 0)
{
throw new InvalidOperationException();
}
if (repeat < 0)
{
repeat = int.MaxValue;
}
else if (repeat == 0)
{
repeat = 1;
}
var factory = new ClientAndServerFactory(serverFactory, clientFactory);
for (int i = 0; i < repeat; i++)
{
RunWithLocalServer(factory, parameters).Wait();
}
}
async Task Run(ClientAndServerParameters parameters, Action <ClientAndServer> action = null)
{
try {
if (Configuration.EnableDebugging)
{
parameters.EnableDebugging = true;
}
using (var connection = (ClientAndServer)await Factory.Start(parameters)) {
if (action != null)
{
action(connection);
}
var handler = ConnectionHandlerFactory.HandshakeAndDone.Create(connection);
await handler.Run();
}
} catch (Exception ex) {
DebugHelper.WriteLine("ERROR: {0} {1}", ex.GetType(), ex);
throw;
}
}
async Task ExpectAlert(ClientAndServerParameters parameters, AlertDescription alert)
{
if (Configuration.EnableDebugging)
{
parameters.EnableDebugging = true;
}
using (var connection = (ClientAndServer)Factory.Create(parameters)) {
await connection.Server.Start();
await connection.Client.Start();
var serverTask = connection.Server.WaitForConnection();
var clientTask = connection.Client.WaitForConnection();
var t1 = clientTask.ContinueWith(t => ExpectAlert(t, alert, "client"));
var t2 = serverTask.ContinueWith(t => ExpectAlert(t, alert, "server"));
await Task.WhenAll(t1, t2);
}
}
async Task Run(MyFlags flags, Type expectedException = null, ClientAndServerParameters parameters = null, Action <ClientAndServer> action = null)
{
if (parameters == null)
{
parameters = GetDefaultParameters();
}
try {
if (Configuration.EnableDebugging)
{
parameters.EnableDebugging = true;
}
using (var connection = (ClientAndServer)await Factory.Start(parameters)) {
if (action != null)
{
action(connection);
}
var handler = new MyConnectionHandler(connection, flags);
await handler.Run();
}
if (expectedException != null)
{
Assert.Fail("Expected an exception of type {0}", expectedException);
}
} catch (Exception ex) {
if (expectedException != null)
{
Assert.That(ex, Is.InstanceOf(expectedException));
}
else
{
DebugHelper.WriteLine("ERROR: {0} {1}", ex.GetType(), ex);
throw;
}
}
}
async Task Run (MyFlags flags, Type expectedException = null, ClientAndServerParameters parameters = null, Action<ClientAndServer> action = null)
{
if (parameters == null)
parameters = GetDefaultParameters ();
try {
if (Configuration.EnableDebugging)
parameters.EnableDebugging = true;
using (var connection = (ClientAndServer)await Factory.Start (parameters)) {
if (action != null)
action (connection);
var handler = new MyConnectionHandler (connection, flags);
await handler.Run ();
}
if (expectedException != null)
Assert.Fail ("Expected an exception of type {0}", expectedException);
} catch (Exception ex) {
if (expectedException != null) {
Assert.That (ex, Is.InstanceOf (expectedException));
} else {
DebugHelper.WriteLine ("ERROR: {0} {1}", ex.GetType (), ex);
throw;
}
}
}
async Task Run (ClientAndServerParameters parameters)
{
if (Configuration.EnableDebugging)
parameters.EnableDebugging = true;
var connection = await Factory.Start (parameters);
connection.Dispose ();
}
