public void Client()
{
using (var server = new TcpRpcServer())
using (var client = new TcpRpcClient())
{
Assert.IsFalse(client.IsComputing);
Assert.IsFalse(client.IsWaitingForData);
Assert.AreEqual(0L, client.SendCount);
Assert.AreEqual(0L, client.RecvCount);
Assert.ThrowsException <InvalidOperationException>(() => client.GetMain <ITestInterface>());
Assert.ThrowsException <ArgumentNullException>(() => client.AttachTracer(null));
Assert.ThrowsException <ArgumentNullException>(() => client.InjectMidlayer(null));
(var addr, int port) = TcpManager.Instance.GetLocalAddressAndPort();
server.StartAccepting(addr, port);
client.Connect(addr.ToString(), port);
Assert.ThrowsException <InvalidOperationException>(() => client.Connect(addr.ToString(), port));
Assert.IsTrue(client.WhenConnected.Wait(MediumNonDbgTimeout));
Assert.ThrowsException <InvalidOperationException>(() => client.AttachTracer(new FrameTracing.RpcFrameTracer(Console.Out, false)));
Assert.ThrowsException <InvalidOperationException>(() => client.InjectMidlayer(_ => _));
Assert.AreEqual(port, client.RemotePort);
Assert.IsTrue(client.LocalPort != 0);
Assert.AreEqual(0L, client.SendCount);
Assert.AreEqual(0L, client.RecvCount);
Assert.IsTrue(SpinWait.SpinUntil(() => client.IsWaitingForData, MediumNonDbgTimeout));
((IConnection)client).Close();
Assert.IsTrue(SpinWait.SpinUntil(() => client.State == ConnectionState.Down, MediumNonDbgTimeout));
}
}
public void BasicClient()
{
LaunchCompatTestProcess("server:Interface", stdout =>
{
using (var client = new TcpRpcClient("localhost", TcpPort))
{
client.WhenConnected.Wait();
using (var main = client.GetMain <ITestInterface>())
{
var request1 = main.Foo(123, true, default);
var request3 = Assert.ThrowsExceptionAsync <RpcException>(() => main.Bar(default));
var s = new TestAllTypes();
Common.InitTestMessage(s);
var request2 = main.Baz(s, default);
AssertOutput(stdout, "foo 123 1");
Assert.IsTrue(request1.Wait(MediumNonDbgTimeout));
Assert.AreEqual("foo", request1.Result);
Assert.IsTrue(request2.Wait(MediumNonDbgTimeout));
AssertOutput(stdout, "baz");
AssertOutput(stdout, "baz fin");
Assert.IsTrue(request3.Wait(MediumNonDbgTimeout));
}
public async Task <List <Common.IdInformation> > GetAvailableServicesAsync()
{
//access climate services
using (TcpRpcClient regClient = new TcpRpcClient("login01.cluster.zalf.de", 10001))
{
await Task.WhenAll(regClient.WhenConnected);
var climateServices = new List <Common.IdInformation>();
using var registry = regClient.GetMain <Mas.Rpc.Service.IRegistry>();
var services = await registry.GetAvailableServices(
new Service.Registry.Query()
{
which = Service.Registry.Query.WHICH.Type,
Type = Service.ServiceType.climate
}
);
foreach (var entry in services)
{
using var climateService = ((Mas.Rpc.Common.Identifiable_Proxy)entry.Service).Cast <Mas.Rpc.Climate.IService>(true);
var serviceInfo = await climateService.Info();
climateServices.Add(serviceInfo);
}
return(climateServices);
}
}
static async Task Main(string[] args)
{
if (args.Length > 0)
{
var pair = new EnginePair();
pair.Engine1.Main = new CapnpEchoService();
var echoer = (CapabilityReflection.CreateProxy <IEchoer>(pair.Endpoint2.QueryMain()) as IEchoer);
await Run(echoer);
}
else
{
using var server = new TcpRpcServer();
server.Main = new CapnpEchoService();
server.AddBuffering();
server.StartAccepting(IPAddress.Any, 5002);
using var client = new TcpRpcClient();
client.AddBuffering();
client.Connect("localhost", 5002);
await client.WhenConnected;
using var echoer = client.GetMain <IEchoer>();
await Run(echoer);
}
}
public void ConnectNoServer()
{
(var addr, int port) = TcpManager.Instance.GetLocalAddressAndPort();
using (var client = new TcpRpcClient(addr.ToString(), port))
{
Assert.IsTrue(Assert.ThrowsExceptionAsync <RpcException>(() => client.WhenConnected).Wait(10000));
}
}
protected TcpRpcClient SetupClient()
{
var client = new TcpRpcClient();
client.AddBuffering();
client.Connect("localhost", TcpPort);
return(client);
}
/// <summary>
/// Somewhat ugly helper method which ensures that both Tcp client and server
/// are waiting for data reception from each other. This is a "balanced" state, meaning
/// that nothing will ever happen in the RcpEngines without some other thread requesting
/// anything.
/// </summary>
protected void WaitClientServerIdle(TcpRpcServer server, TcpRpcClient client)
{
var conn = server.Connections[0];
SpinWait.SpinUntil(() => conn.IsWaitingForData && client.IsWaitingForData &&
conn.RecvCount == client.SendCount &&
conn.SendCount == client.RecvCount,
MediumNonDbgTimeout);
}
public void Setup()
{
_client = new TcpRpcClient("localhost", 5002);
if (BufferSize > 0)
{
_client.AddBuffering(BufferSize);
}
_client.WhenConnected.Wait();
_echoer = _client.GetMain <IEchoer>();
_payload = new byte[PayloadBytes];
new Random().NextBytes(_payload);
}
public async Task <List <string> > GetMetaPlusDataAsync(string serviceId)
{
using (TcpRpcClient regClient = new TcpRpcClient("login01.cluster.zalf.de", 10001))
{
await Task.WhenAll(regClient.WhenConnected);
var climateServices = new List <Common.IdInformation>();
using var registry = regClient.GetMain <Mas.Rpc.Service.IRegistry>();
var services = await registry.GetAvailableServices(
new Service.Registry.Query()
{
which = Service.Registry.Query.WHICH.Type,
Type = Service.ServiceType.climate
}
);
var metaPlusData = new List <string>();
foreach (var entry in services)
{
using var climateService = ((Mas.Rpc.Common.Identifiable_Proxy)entry.Service).Cast <Mas.Rpc.Climate.IService>(true);
var serviceInfo = await climateService.Info();
if (serviceInfo.Id == serviceId)
{
var datasets = await climateService.GetAvailableDatasets();
//var datasets = await climateService.GetDatasetsFor()
foreach (var metaPlus in datasets)
{
using var info = metaPlus.Meta.Info;
var allMetaInfos = await info.ForAll();
var metaStr = allMetaInfos.
Select(x => "[" + x.Snd.Id + "|" + x.Snd.Name + "|" + x.Snd.Description + "]").
Aggregate((acc, str) => acc + ", " + str);
metaPlusData.Add(metaStr);
}
}
}
return(metaPlusData);
}
}
public void ScatteredTransfer()
{
using (var server = new TcpRpcServer(IPAddress.Any, TcpPort))
using (var client = new TcpRpcClient())
{
server.InjectMidlayer(s => new ScatteringStream(s, 7));
client.InjectMidlayer(s => new ScatteringStream(s, 10));
client.Connect("localhost", TcpPort);
client.WhenConnected.Wait();
var counters = new Counters();
server.Main = new TestInterfaceImpl(counters);
using (var main = client.GetMain <ITestInterface>())
{
for (int i = 0; i < 100; i++)
{
var request1 = main.Foo(123, true, default);
var request3 = Assert.ThrowsExceptionAsync <RpcException>(() => main.Bar(default));
public void Server3()
{
using (var server = new TcpRpcServer())
{
server.Main = new TestInterfaceImpl2();
var tracer = new FrameTracing.RpcFrameTracer(Console.Out);
server.OnConnectionChanged += (s, a) =>
{
a.Connection.Close();
};
(var addr, int port) = TcpManager.Instance.GetLocalAddressAndPort();
server.StartAccepting(addr, port);
var client1 = new TcpRpcClient(addr.ToString(), port);
Assert.IsTrue(client1.WhenConnected.Wait(MediumNonDbgTimeout));
Assert.IsTrue(SpinWait.SpinUntil(() => client1.State == ConnectionState.Down, MediumNonDbgTimeout));
}
}
protected static TcpRpcClient SetupClient(IPAddress addr, int port, TcpRpcTestOptions options = TcpRpcTestOptions.None)
{
var client = new TcpRpcClient();
client.AddBuffering();
if (options.HasFlag(TcpRpcTestOptions.ClientTracer))
{
client.AttachTracer(new FrameTracing.RpcFrameTracer(Console.Out, false));
}
if (options.HasFlag(TcpRpcTestOptions.ClientFluctStream))
{
client.InjectMidlayer(s => new FluctStream(s));
}
if (!options.HasFlag(TcpRpcTestOptions.ClientNoConnect))
{
client.Connect(addr.ToString(), port);
}
return(client);
}
public void ScatteredTransfer()
{
(var addr, int port) = TcpManager.Instance.GetLocalAddressAndPort();
using (var server = new TcpRpcServer(addr, port))
using (var client = new TcpRpcClient())
{
server.InjectMidlayer(s => new ScatteringStream(s, 7));
client.InjectMidlayer(s => new ScatteringStream(s, 10));
client.Connect(addr.ToString(), port);
//client.WhenConnected.Wait();
var counters = new Counters();
server.Main = new TestInterfaceImpl(counters);
using (var main = client.GetMain <ITestInterface>())
{
for (int i = 0; i < 100; i++)
{
var request1 = main.Foo(123, true, default);
var request3 = Assert.ThrowsExceptionAsync <RpcException>(() => main.Bar(default));
static async Task Main(string[] args)
{
using var server = new TcpRpcServer();
server.Main = new CapnpEchoService();
server.AddBuffering();
server.StartAccepting(IPAddress.Any, 5002);
using var client = new TcpRpcClient("localhost", 5002);
await client.WhenConnected;
using var echoer = client.GetMain <IEchoer>();
var payload = new byte[20];
new Random().NextBytes(payload);
while (true)
{
var result = await echoer.Echo(payload);
if (result.Count != payload.Length)
{
throw new InvalidOperationException("Echo server malfunction");
}
}
}
static async Task Main(string[] args)
{
using (var conMan = new Mas.Infrastructure.Common.ConnectionManager())
{
if (args.Length > 0 && args[0] == "client")
{
//*
using (var monicaClient = new TcpRpcClient("localhost", 6666))
using (var csvTimeSeriesClient = new TcpRpcClient("localhost", 11002))
{
await Task.WhenAll(csvTimeSeriesClient.WhenConnected, monicaClient.WhenConnected);
using var timeSeries = csvTimeSeriesClient.GetMain <Mas.Rpc.Climate.ITimeSeries>();
var y = await timeSeries.Data();
string envJson = System.IO.File.ReadAllText(@"data\monica\env.json");
using var monica = monicaClient.GetMain <Mas.Rpc.Model.IEnvInstance <Mas.Rpc.Common.StructuredText, Mas.Rpc.Common.StructuredText> >();
//var minfo = await monica.Info();
//Console.WriteLine("id: " + minfo.Id + " name: " + minfo.Name);
var res = await monica.Run(
new Mas.Rpc.Model.Env <Mas.Rpc.Common.StructuredText>()
{
Rest = new Mas.Rpc.Common.StructuredText()
{
Structure = new Mas.Rpc.Common.StructuredText.structure()
{
which = Mas.Rpc.Common.StructuredText.structure.WHICH.Json
},
Value = envJson
},
TimeSeries = Proxy.Share(timeSeries)
}
);
var data = await timeSeries.Data();
int x = 0;
foreach (var d in data)
{
x += d.Count;
}
Console.WriteLine("data.Count=" + data.Count + " should be: " + data.Count * 7 + " is: " + x);
Console.WriteLine("\n");
}
return;
//*/
/*
* var admin = (await conMan.Connect("capnp://insecure@nb-berg-9550:10001/5ea7896b-e2ea-4f63-8ad0-03ecafc35082")).Cast<Mas.Rpc.Registry.IAdmin>(true);
* var registry = await admin.Registry();
* var addSucc = await admin.AddCategory(new Mas.Rpc.Common.IdInformation() { Id = "test1", Name = "Test1 Name", Description = "Test1 Description" }, false);
* var cats = await registry.SupportedCategories();
* foreach(var cat in cats)
* Console.WriteLine(cat.Name);
* //*/
/*
* //access climate services
* using (TcpRpcClient regClient = new TcpRpcClient("login01.cluster.zalf.de", 10001))
* //using (TcpRpcClient client = new TcpRpcClient("192.168.111.202", 11111))
* {
* await Task.WhenAll(regClient.WhenConnected);
*
* using var registry = regClient.GetMain<Mas.Rpc.Service.IRegistry>();
* var services = await registry.GetAvailableServices(
* new Service.Registry.Query() {
* which = Service.Registry.Query.WHICH.Type,
* Type = Service.ServiceType.climate
* }
* );
* foreach (var entry in services)
* {
* using var climateService = ((Mas.Rpc.Common.Identifiable_Proxy)entry.Service).Cast<Mas.Rpc.Climate.IService>(true);
* var serviceInfo = await climateService.Info();
* Console.WriteLine("Service id:" + serviceInfo.Id + " name:" + serviceInfo.Name);
* var datasets = await climateService.GetAvailableDatasets();
* foreach (var metaPlusData in datasets)
* {
* using var info = metaPlusData.Meta.Info;
* var allMetaInfos = await info.ForAll();
* var metaStr = allMetaInfos.
* Select(x => "[" + x.Snd.Id + "|" + x.Snd.Name + "|" + x.Snd.Description + "]").
* Aggregate((acc, str) => acc + ", " + str);
* Console.WriteLine(metaStr);
* using var dataset = metaPlusData.Data;
* using var timeSeries = await dataset.ClosestTimeSeriesAt(
* new Geo.Coord()
* {
* Latlon = new Geo.LatLonCoord() { Lat = 53.0, Lon = 12.5 }
* }
* );
* var (start, end) = await timeSeries.Range();
* var startDate = new DateTime(start.Year, start.Month, start.Day);
* var header = await timeSeries.Header();
* var headerLine = header.Select(elem => elem.ToString()).Aggregate((acc, str) => acc + ", " + str);
* Console.WriteLine(headerLine);
* var data = await timeSeries.Data();
* foreach (var (day, index) in data.Take(10).Select((Value, Index) => ValueTuple.Create(Value, Index)))
* {
* var currentDate = startDate.AddDays(index);
* var dataLine = day.Select(elem => elem.ToString()).Aggregate((acc, str) => acc + ", " + str);
* Console.WriteLine(currentDate.ToShortDateString() + ", " + dataLine);
* }
* }
* }
*
* //return;
* }
* //*/
/*
* using (TcpRpcClient client = new TcpRpcClient("localhost", 11111))
* //using (TcpRpcClient client = new TcpRpcClient("192.168.111.202", 11111))
* {
* await Task.WhenAll(client.WhenConnected);
*
* var service = client.GetMain<Mas.Rpc.IA>();
*
* var res = await service.Method("_________________method_PARAM_____________________");
*
* Console.WriteLine(res);
*
* return;
* }
* //*/
/*
* //using (var csvTimeSeriesClient = new TcpRpcClient("login01.cluster.zalf.de", 11002))
* //using (var monicaClient = new TcpRpcClient("login01.cluster.zalf.de", 10002))
* using (var monicaClient = new TcpRpcClient("localhost", 6666))
* //using (var monicaClient = new TcpRpcClient("login01.cluster.zalf.de", 10003))
* //using (var regClient = new TcpRpcClient("login01.cluster.zalf.de", 10001))
* using (var csvTimeSeriesClient = new TcpRpcClient("localhost", 11002))
* {
* await Task.WhenAll(regClient.WhenConnected, monicaClient.WhenConnected);
* using var registry = regClient.GetMain<Mas.Rpc.Service.IRegistry>();
* var services = await registry.availableServices(
* new Service.Registry.Query()
* {
* which = Service.Registry.Query.WHICH.Type,
* Type = Service.ServiceType.climate
* }
* );
* if (services.Count() > 0)
* {
* var entry = services[0];
* using var climateService = ((Mas.Rpc.Common.Identifiable_Proxy)entry.Service).Cast<Mas.Rpc.Climate.IService>(true);
* var serviceInfo = await climateService.Info();
* Console.WriteLine("Service id:" + serviceInfo.Id + " name:" + serviceInfo.Name);
* var datasets = await climateService.GetAvailableDatasets();
* if (datasets.Count() > 0)
* {
* var metaPlusData = datasets[0];
* using var info = metaPlusData.Meta.Info;
* var allMetaInfos = await info.ForAll();
* var metaStr = allMetaInfos.
* Select(x => "[" + x.Snd.Id + "|" + x.Snd.Name + "|" + x.Snd.Description + "]").
* Aggregate((acc, str) => acc + ", " + str);
* Console.WriteLine(metaStr);
* using var dataset = metaPlusData.Data;
* using var timeSeries = await dataset.ClosestTimeSeriesAt(
* new Geo.Coord()
* {
* Latlon = new Geo.LatLonCoord() { Lat = 53.0, Lon = 12.5 }
* }
* );
*
* string envJson = System.IO.File.ReadAllText(@"data\monica\env.json");
*
* using var monica = monicaClient.GetMain<Model.IEnvInstance<Common.StructuredText, Common.StructuredText>>();
* //var minfo = await monica.Info();
* //Console.WriteLine("id: " + minfo.Id + " name: " + minfo.Name);
*
* var res = await monica.Run(
* new Model.Env<Common.StructuredText>()
* {
* Rest = new Common.StructuredText()
* {
* Structure = new Common.StructuredText.structure() { which = Common.StructuredText.structure.WHICH.Json },
* Value = envJson
* },
* TimeSeries = Proxy.Share(timeSeries)
* }
* );
*
* var data = await timeSeries.Data();
* int x = 0;
* foreach (var d in data)
* {
* x += d.Count;
* }
* Console.WriteLine("data.Count=" + data.Count + " should be: " + data.Count * 7 + " is: " + x);
* Console.WriteLine("\n");
*
* }
* }
* }
* return;
* //*/
/*
* //using (TcpRpcClient client = new TcpRpcClient("localhost", 10001))
* using (TcpRpcClient client = new TcpRpcClient("login01.cluster.zalf.de", 10001))
* {
* await Task.WhenAll(client.WhenConnected);
*
* using var registry = client.GetMain<Mas.Rpc.Service.IRegistry>();
*
* var services = await registry.GetAvailableServices(
* new Service.Registry.Query()
* {
* which = Service.Registry.Query.WHICH.Type,
* Type = Service.ServiceType.soil
* }
* );
*
* foreach (var entry in services)
* {
* using var soilService = ((Mas.Rpc.Common.Identifiable_Proxy)entry.Service).Cast<Mas.Rpc.Soil.IService>(true);
* var serviceInfo = await soilService.Info();
* Console.WriteLine("Service id:" + serviceInfo.Id + " name:" + serviceInfo.Name);
* var allParams = await soilService.GetAllAvailableParameters(true);
* Console.WriteLine("soilService.getAllAvailableParameters(true) -> ");
* Console.WriteLine("mandatory:");
* foreach (var m in allParams.Item1)
* {
* Console.WriteLine("\t" + m);
* }
* Console.WriteLine("optional:");
* foreach (var o in allParams.Item2)
* {
* Console.WriteLine("\t" + o);
* }
* Console.WriteLine("---------------------------------");
*
* var profiles = await soilService.ProfilesAt(
* new Geo.LatLonCoord() { Lat = 53.0, Lon = 12.5 },
* new Soil.Query()
* {
* Mandatory = new Soil.PropertyName[]
* {
* Soil.PropertyName.sand, Soil.PropertyName.clay, Soil.PropertyName.bulkDensity, Soil.PropertyName.organicCarbon
* },
* Optional = new Soil.PropertyName[] { Soil.PropertyName.pH },
* OnlyRawData = false
* }
* );
* Console.WriteLine("soilService.profileAt(...) -> ");
* Console.WriteLine("profiles[0]:");
* foreach (var profile in profiles)
* {
* Console.WriteLine("percentageOfArea: " + profile.PercentageOfArea);
* foreach (var it in profile.Layers.Select((Value, Index) => new { Value, Index }))
* {
* Console.WriteLine("Layer " + it.Index + ":");
* foreach (var prop in it.Value.Properties)
* {
* Func<Soil.Layer.Property, String> show = x =>
* {
* switch (x.which)
* {
* case Soil.Layer.Property.WHICH.F32Value: return x.F32Value.ToString();
* case Soil.Layer.Property.WHICH.BValue: return x.BValue.ToString();
* case Soil.Layer.Property.WHICH.Type: return x.Type.ToString();
* default: return "unknown";
* }
* };
* Console.WriteLine("\t" + prop.Name + " = " + show(prop));
* }
* }
* }
* Console.WriteLine("---------------------------------");
*
* }
* //var res = await service.Method("_________________method_PARAM_____________________");
*
* //Console.WriteLine(res);
*
* return;
* }
* //*/
/*
* using (TcpRpcClient soilServiceClient = new TcpRpcClient("localhost", 6003))
* //using (TcpRpcClient soilServiceClient = new TcpRpcClient("127.0.0.1", 6003))
* //using (TcpRpcClient soilServiceClient = new TcpRpcClient("login01.cluster.zalf.de", 6003))
* {
* await Task.WhenAll(soilServiceClient.WhenConnected);
*
* var service = soilServiceClient.GetMain<Mas.Rpc.Soil.IService>();
*
* var allParams = await service.GetAllAvailableParameters(true);
* Console.WriteLine("soilService.getAllAvailableParameters(true) -> ");
* Console.WriteLine("mandatory:");
* foreach (var m in allParams.Item1)
* {
* Console.WriteLine(m);
* }
* Console.WriteLine("optional:");
* foreach (var o in allParams.Item2)
* {
* Console.WriteLine(o);
* }
* Console.WriteLine("---------------------------------");
*
* var profiles = await service.ProfilesAt(
* new Geo.LatLonCoord() { Lat = 53.0, Lon = 12.5 },
* new Soil.Query()
* {
* Mandatory = new Soil.PropertyName[]
* {
* Soil.PropertyName.sand, Soil.PropertyName.clay, Soil.PropertyName.bulkDensity, Soil.PropertyName.organicCarbon
* },
* Optional = new Soil.PropertyName[] { Soil.PropertyName.pH },
* OnlyRawData = false
* }
* );
* Console.WriteLine("soilService.profileAt(...) -> ");
* Console.WriteLine("profiles[0]:");
* foreach (var profile in profiles)
* {
* Console.WriteLine("percentageOfArea: " + profile.PercentageOfArea);
* foreach (var it in profile.Layers.Select((Value, Index) => new {Value, Index}))
* {
* Console.WriteLine("Layer " + it.Index + ":");
* foreach (var prop in it.Value.Properties)
* {
* Func<Soil.Layer.Property, String> show = x =>
* {
* switch (x.which)
* {
* case Soil.Layer.Property.WHICH.F32Value: return x.F32Value.ToString();
* case Soil.Layer.Property.WHICH.BValue: return x.BValue.ToString();
* case Soil.Layer.Property.WHICH.Type: return x.Type.ToString();
* default: return "unknown";
* }
* };
* Console.WriteLine("\t" + prop.Name + " = " + show(prop));
* }
* }
* }
* Console.WriteLine("---------------------------------");
* return;
*
* var query = new Soil.Query()
* {
* Mandatory = new Soil.PropertyName[]
* {
* Soil.PropertyName.sand, Soil.PropertyName.clay, Soil.PropertyName.bulkDensity, Soil.PropertyName.organicCarbon
* },
* Optional = new Soil.PropertyName[] { Soil.PropertyName.pH },
* OnlyRawData = false
* };
* var locs = await service.AllLocations(query);
* var latlonAndCap = locs[0];
* var capList = latlonAndCap.Snd;
* var p = await capList[0].Cap();
*
* //var data = await ts.Data();
* //int x = 0;
* //foreach (var d in data)
* //{
* //x += d.Count;
* //}
* //Console.WriteLine("data.Count=" + data.Count + " should be: " + data.Count * 7 + " is: " + x);
* Console.WriteLine("\n");
* }
* //*/
/*
* using (TcpRpcClient csvTimeSeriesClient = new TcpRpcClient("login01.cluster.zalf.de", 11002))
* //using (TcpRpcClient csvTimeSeriesClient = new TcpRpcClient("localhost", 11002))
* //using (TcpRpcClient csvTimeSeriesClient = new TcpRpcClient("10.10.24.206", 11002))
* {
* await Task.WhenAll(csvTimeSeriesClient.WhenConnected);
*
* var ts = csvTimeSeriesClient.GetMain<Mas.Rpc.ClimateData.IListTests>();
*
* var testLI32_2 = await ts.TestLI32();
* var testLI32_2_Count = testLI32_2.Count;
* var testLI32_2_Sum = testLI32_2.Sum();
*
*
* var receivedBytes = 0;
* for (var i = 1; i < 10000; i++)
* {
* var testLI32 = await ts.TestLI32();
* var testLI32_Count = testLI32.Count;
* receivedBytes += testLI32_Count * 4;
* var testLI32_Sum_Soll = testLI32_Count * 1;
* var testLI32_Sum = testLI32.Sum();
* Console.WriteLine("Count: " + testLI32_Count
+ " ok?: " + (testLI32_Sum == testLI32_Sum_Soll)
+ " received bytes so far: " + receivedBytes);
+ }
+ //var testLI32_2 = await ts.TestLI32();
+ //var testLI32_2_Count = testLI32_2.Count;
+ //var testLI32_2_Sum = testLI32_2.Sum();
+ var testLI32_3 = await ts.TestLI32();
+ var testLI32_3_Count = testLI32_3.Count;
+ var testLI32_3_Sum = testLI32_3.Sum();
+ //var testLLI32 = await ts.TestLLI32();
+ //int testLLI32_Count = 0;
+ //int testLLI32_Soll = testLLI32.Count * 7;
+ //foreach (var d in testLLI32)
+ //{
+ // testLLI32_Count += d.Count;
+ //}
+
+ var testLF32 = await ts.TestLF32();
+ var testLF32_Count = testLF32.Count;
+ var testLLF32 = await ts.TestLLF32();
+ int testLLF32_Count = 0;
+ int testLLF32_Soll = testLLF32.Count * 7;
+ foreach (var d in testLLF32)
+ {
+ testLLF32_Count += d.Count;
+ }
+
+ //var testLI32_2 = await ts.TestLI32();
+ //var testLI32_Count_2 = testLI32_2.Count;
+
+ //Console.WriteLine("data.Count=" + data.Count + " should be: " + data.Count * 7 + " is: " + x);
+ Console.WriteLine("\n");
+ }
+ //*/
/*
* using (TcpRpcClient csvTimeSeriesClient = new TcpRpcClient("login01.cluster.zalf.de", 11000))
* //using (TcpRpcClient csvTimeSeriesClient = new TcpRpcClient("localhost", 11002))
* {
* await Task.WhenAll(csvTimeSeriesClient.WhenConnected);
*
* var ts = csvTimeSeriesClient.GetMain<Mas.Rpc.ClimateData.ITimeSeries>();
* var data = await ts.Data();
* int x = 0;
* foreach(var d in data)
* {
* x += d.Count;
* }
* Console.WriteLine("data.Count=" + data.Count + " should be: " + data.Count*7 + " is: " + x);
* Console.WriteLine("\n");
* }
* //*/
/*
* using (TcpRpcClient climateDataServiceClient = new TcpRpcClient("login01.cluster.zalf.de", 11001))
* {
* await Task.WhenAll(climateDataServiceClient.WhenConnected);
*
* var service = climateDataServiceClient.GetMain<Mas.Rpc.ClimateData.IService>();
* var sims = await service.GetAvailableSimulations();
* var sim = sims[0];
* var scens = await sim.Scenarios();
* var scen = scens[0];
* var reals = await scen.Realizations();
* var real = reals[0];
* var coord = new Geo.Coord();
* coord.Latlon = new Geo.LatLonCoord();
* coord.Latlon.Lat = 46.51412;
* coord.Latlon.Lon = 12.81895;
* var tss = await real.ClosestTimeSeriesAt(coord);
* var ts = tss[0];
* var data = await ts.Data();
* Console.WriteLine(data.Count);
* }
* //*/
/*
* using (TcpRpcClient csvTimeSeriesClient = new TcpRpcClient("localhost", 11000),
* adminMasterClient = new TcpRpcClient("10.10.24.186", 8000))
* {
* await Task.WhenAll(csvTimeSeriesClient.WhenConnected, adminMasterClient.WhenConnected);
*
* //csv_time_series = capnp.TwoPartyClient("localhost:11000").bootstrap().cast_as(
* //climate_data_capnp.TimeSeries)
* var adminMaster = adminMasterClient.GetMain<Cluster.IAdminMaster>();
* var factories = await adminMaster.AvailableModels();
* if (factories.Count > 0)
* {
* var factory = factories[0];
* var instanceCapHolder = factory.NewInstance().Eager<Mas.Rpc.Common.ICapHolder<object>>();
* var envInstance = ((BareProxy)(await instanceCapHolder.Cap())).Cast<Mas.Rpc.Model.IEnvInstance>(true);
* //var envInstance = ((BareProxy)(await instanceCapHolder.Cap())).Cast<Mas.Rpc.Model.IEnvInstance>(true);
* var infos = await envInstance.Info();
* Console.WriteLine(infos.ToString());
* //modelRes.PseudoEager<Mas.Rpc.Model.IEnvInstance>();
* //var x = modelRes.PseudoEager();
*
* Console.WriteLine("Hello World!");
*
* auto monica = modelRes.getCap().getAs<rpc::Model::EnvInstance>();
* //auto monica = cap.getAs<rpc::Model::EnvInstance>();
* //auto monica = capHolder.capRequest().send().wait(waitScope).getCap(); //<rpc::Model::EnvInstance>().;
* //auto monicaId = monica.infoRequest().send().wait(waitScope).getInfo().getId();
* monica.infoRequest().send().then([](auto && res) {
* cout << "monicaId: " << res.getInfo().getId().cStr() << endl;
* }).wait(waitScope);
* //auto monicaId = monicaRes.getInfo().getId().cStr();
* //cout << "monicaId: " << monicaId << endl;
* //auto sturdyRef = capHolder.saveRequest().send().wait(waitScope).getSturdyRef();
* instanceCapHolder.saveRequest().send().then([](auto && res) {
* cout << "sturdyRef: " << res.getSturdyRef().cStr() << endl;
* }).wait(waitScope);
* //auto sturdyRefP = instanceCapHolder.saveRequest().send().wait(waitScope);// .getSturdyRef();
*
* }
*
* var csvTimeSeries = csvTimeSeriesClient.GetMain<Climate.ITimeSeries>();
* var header = csvTimeSeries.Header();
* header.Wait();
* var elems = header.Result;
* foreach(var elem in elems)
* {
* Console.WriteLine(elem);
* }
* //csvTimeSeries.WhenResolved.Wait(3000);
*
* //SpinWait.SpinUntil(() => server.ConnectionCount > 0, MediumTimeout);
* //Assert.AreEqual(1, server.ConnectionCount);
*
* //server.Main = new ProvidedCapabilityMock();
* //var main = client.GetMain<BareProxy>();
* //var resolving = main as IResolvingCapability;
* //Assert.IsTrue(resolving.WhenResolved.Wait(MediumTimeout));
* }
* //*/
}
else if (args.Length > 0 && args[0] == "server")
{
/*
* using (TcpRpcClient runtimeClient = new TcpRpcClient("10.10.24.186", 9000),
* adminMasterClient = new TcpRpcClient("10.10.24.186", 8000))
*
* //using (client)
* {
* await Task.WhenAll(csvTimeSeriesClient.WhenConnected, adminMasterClient.WhenConnected);
*
* //csv_time_series = capnp.TwoPartyClient("localhost:11000").bootstrap().cast_as(
* //climate_data_capnp.TimeSeries)
* var adminMaster = adminMasterClient.GetMain<Cluster.IAdminMaster>();
* var factories = await adminMaster.AvailableModels();
* if (factories.Count > 0)
*
*
* }
* using (var server = new TcpRpcServer(IPAddress.Any, TcpPort))
* {
* Console.WriteLine($"starting server at localhost:{TcpPort}");
* server.Main = new Mas.Rpc.Monica.SlurmMonicaInstanceFactory("MONICA v3", "C:\\Users}\berg.ZALF-AD\\GitHub\\monica\\_cmake_vs2019_win64\\Debug\\monica-capnp-server.exe", "localhost", 10000);
* Console.WriteLine($"after");
* }
*/
}
Console.WriteLine("Hello World!");
}
}
public async Task <List <Climate.IService> > test(string serviceId)
{
using (TcpRpcClient client = new TcpRpcClient("login01.cluster.zalf.de", 10001))
{
await Task.WhenAll(client.WhenConnected);
using var registry = client.GetMain <Mas.Rpc.Service.IRegistry>();
var services = await registry.GetAvailableServices(
new Service.Registry.Query()
{
which = Service.Registry.Query.WHICH.Type,
Type = Service.ServiceType.soil
}
);
foreach (var entry in services)
{
using var soilService = ((Mas.Rpc.Common.Identifiable_Proxy)entry.Service).Cast <Mas.Rpc.Soil.IService>(true);
var serviceInfo = await soilService.Info();
Console.WriteLine("Service id:" + serviceInfo.Id + " name:" + serviceInfo.Name);
var allParams = await soilService.GetAllAvailableParameters(true);
Console.WriteLine("soilService.getAllAvailableParameters(true) -> ");
Console.WriteLine("mandatory:");
foreach (var m in allParams.Item1)
{
Console.WriteLine("\t" + m);
}
Console.WriteLine("optional:");
foreach (var o in allParams.Item2)
{
Console.WriteLine("\t" + o);
}
Console.WriteLine("---------------------------------");
var profiles = await soilService.ProfilesAt(
new Geo.LatLonCoord()
{
Lat = 53.0, Lon = 12.5
},
new Soil.Query()
{
Mandatory = new Soil.PropertyName[]
{
Soil.PropertyName.sand, Soil.PropertyName.clay, Soil.PropertyName.bulkDensity, Soil.PropertyName.organicCarbon
},
Optional = new Soil.PropertyName[] { Soil.PropertyName.pH },
OnlyRawData = false
}
);
Console.WriteLine("soilService.profileAt(...) -> ");
Console.WriteLine("profiles[0]:");
foreach (var profile in profiles)
{
Console.WriteLine("percentageOfArea: " + profile.PercentageOfArea);
foreach (var it in profile.Layers.Select((Value, Index) => new { Value, Index }))
{
Console.WriteLine("Layer " + it.Index + ":");
foreach (var prop in it.Value.Properties)
{
Func <Soil.Layer.Property, String> show = x =>
{
switch (x.which)
{
case Soil.Layer.Property.WHICH.F32Value: return(x.F32Value.ToString());
case Soil.Layer.Property.WHICH.BValue: return(x.BValue.ToString());
case Soil.Layer.Property.WHICH.Type: return(x.Type.ToString());
default: return("unknown");
}
};
Console.WriteLine("\t" + prop.Name + " = " + show(prop));
}
}
}
Console.WriteLine("---------------------------------");
}
//var res = await service.Method("_________________method_PARAM_____________________");
//Console.WriteLine(res);
//return "ignored";
}
//*/
/*
* using (TcpRpcClient soilServiceClient = new TcpRpcClient("localhost", 6003))
* //using (TcpRpcClient soilServiceClient = new TcpRpcClient("127.0.0.1", 6003))
* //using (TcpRpcClient soilServiceClient = new TcpRpcClient("login01.cluster.zalf.de", 6003))
* {
* await Task.WhenAll(soilServiceClient.WhenConnected);
*
* var service = soilServiceClient.GetMain<Mas.Rpc.Soil.IService>();
*
* var allParams = await service.GetAllAvailableParameters(true);
* Console.WriteLine("soilService.getAllAvailableParameters(true) -> ");
* Console.WriteLine("mandatory:");
* foreach (var m in allParams.Item1)
* {
* Console.WriteLine(m);
* }
* Console.WriteLine("optional:");
* foreach (var o in allParams.Item2)
* {
* Console.WriteLine(o);
* }
* Console.WriteLine("---------------------------------");
*
* var profiles = await service.ProfilesAt(
* new Geo.LatLonCoord() { Lat = 53.0, Lon = 12.5 },
* new Soil.Query()
* {
* Mandatory = new Soil.PropertyName[]
* {
* Soil.PropertyName.sand, Soil.PropertyName.clay, Soil.PropertyName.bulkDensity, Soil.PropertyName.organicCarbon
* },
* Optional = new Soil.PropertyName[] { Soil.PropertyName.pH },
* OnlyRawData = false
* }
* );
* Console.WriteLine("soilService.profileAt(...) -> ");
* Console.WriteLine("profiles[0]:");
* foreach (var profile in profiles)
* {
* Console.WriteLine("percentageOfArea: " + profile.PercentageOfArea);
* foreach (var it in profile.Layers.Select((Value, Index) => new {Value, Index}))
* {
* Console.WriteLine("Layer " + it.Index + ":");
* foreach (var prop in it.Value.Properties)
* {
* Func<Soil.Layer.Property, String> show = x =>
* {
* switch (x.which)
* {
* case Soil.Layer.Property.WHICH.F32Value: return x.F32Value.ToString();
* case Soil.Layer.Property.WHICH.BValue: return x.BValue.ToString();
* case Soil.Layer.Property.WHICH.Type: return x.Type.ToString();
* default: return "unknown";
* }
* };
* Console.WriteLine("\t" + prop.Name + " = " + show(prop));
* }
* }
* }
* Console.WriteLine("---------------------------------");
* return;
*
* var query = new Soil.Query()
* {
* Mandatory = new Soil.PropertyName[]
* {
* Soil.PropertyName.sand, Soil.PropertyName.clay, Soil.PropertyName.bulkDensity, Soil.PropertyName.organicCarbon
* },
* Optional = new Soil.PropertyName[] { Soil.PropertyName.pH },
* OnlyRawData = false
* };
* var locs = await service.AllLocations(query);
* var latlonAndCap = locs[0];
* var capList = latlonAndCap.Snd;
* var p = await capList[0].Cap();
*
* //var data = await ts.Data();
* //int x = 0;
* //foreach (var d in data)
* //{
* //x += d.Count;
* //}
* //Console.WriteLine("data.Count=" + data.Count + " should be: " + data.Count * 7 + " is: " + x);
* Console.WriteLine("\n");
* }
* //*/
/*
* using (TcpRpcClient csvTimeSeriesClient = new TcpRpcClient("login01.cluster.zalf.de", 11002))
* //using (TcpRpcClient csvTimeSeriesClient = new TcpRpcClient("localhost", 11002))
* //using (TcpRpcClient csvTimeSeriesClient = new TcpRpcClient("10.10.24.206", 11002))
* {
* await Task.WhenAll(csvTimeSeriesClient.WhenConnected);
*
* var ts = csvTimeSeriesClient.GetMain<Mas.Rpc.ClimateData.IListTests>();
*
* var testLI32_2 = await ts.TestLI32();
* var testLI32_2_Count = testLI32_2.Count;
* var testLI32_2_Sum = testLI32_2.Sum();
*
*
* var receivedBytes = 0;
* for (var i = 1; i < 10000; i++)
* {
* var testLI32 = await ts.TestLI32();
* var testLI32_Count = testLI32.Count;
* receivedBytes += testLI32_Count * 4;
* var testLI32_Sum_Soll = testLI32_Count * 1;
* var testLI32_Sum = testLI32.Sum();
* Console.WriteLine("Count: " + testLI32_Count
+ " ok?: " + (testLI32_Sum == testLI32_Sum_Soll)
+ " received bytes so far: " + receivedBytes);
+ }
+ //var testLI32_2 = await ts.TestLI32();
+ //var testLI32_2_Count = testLI32_2.Count;
+ //var testLI32_2_Sum = testLI32_2.Sum();
+ var testLI32_3 = await ts.TestLI32();
+ var testLI32_3_Count = testLI32_3.Count;
+ var testLI32_3_Sum = testLI32_3.Sum();
+ //var testLLI32 = await ts.TestLLI32();
+ //int testLLI32_Count = 0;
+ //int testLLI32_Soll = testLLI32.Count * 7;
+ //foreach (var d in testLLI32)
+ //{
+ // testLLI32_Count += d.Count;
+ //}
+
+ var testLF32 = await ts.TestLF32();
+ var testLF32_Count = testLF32.Count;
+ var testLLF32 = await ts.TestLLF32();
+ int testLLF32_Count = 0;
+ int testLLF32_Soll = testLLF32.Count * 7;
+ foreach (var d in testLLF32)
+ {
+ testLLF32_Count += d.Count;
+ }
+
+ //var testLI32_2 = await ts.TestLI32();
+ //var testLI32_Count_2 = testLI32_2.Count;
+
+ //Console.WriteLine("data.Count=" + data.Count + " should be: " + data.Count * 7 + " is: " + x);
+ Console.WriteLine("\n");
+ }
+ //*/
/*
* using (TcpRpcClient csvTimeSeriesClient = new TcpRpcClient("login01.cluster.zalf.de", 11000))
* //using (TcpRpcClient csvTimeSeriesClient = new TcpRpcClient("localhost", 11002))
* {
* await Task.WhenAll(csvTimeSeriesClient.WhenConnected);
*
* var ts = csvTimeSeriesClient.GetMain<Mas.Rpc.ClimateData.ITimeSeries>();
* var data = await ts.Data();
* int x = 0;
* foreach(var d in data)
* {
* x += d.Count;
* }
* Console.WriteLine("data.Count=" + data.Count + " should be: " + data.Count*7 + " is: " + x);
* Console.WriteLine("\n");
* }
* //*/
/*
* using (TcpRpcClient climateDataServiceClient = new TcpRpcClient("login01.cluster.zalf.de", 11001))
* {
* await Task.WhenAll(climateDataServiceClient.WhenConnected);
*
* var service = climateDataServiceClient.GetMain<Mas.Rpc.ClimateData.IService>();
* var sims = await service.GetAvailableSimulations();
* var sim = sims[0];
* var scens = await sim.Scenarios();
* var scen = scens[0];
* var reals = await scen.Realizations();
* var real = reals[0];
* var coord = new Geo.Coord();
* coord.Latlon = new Geo.LatLonCoord();
* coord.Latlon.Lat = 46.51412;
* coord.Latlon.Lon = 12.81895;
* var tss = await real.ClosestTimeSeriesAt(coord);
* var ts = tss[0];
* var data = await ts.Data();
* Console.WriteLine(data.Count);
* }
* //*/
/*
* using (TcpRpcClient csvTimeSeriesClient = new TcpRpcClient("localhost", 11000),
* adminMasterClient = new TcpRpcClient("10.10.24.186", 8000))
* {
* await Task.WhenAll(csvTimeSeriesClient.WhenConnected, adminMasterClient.WhenConnected);
*
* //csv_time_series = capnp.TwoPartyClient("localhost:11000").bootstrap().cast_as(
* //climate_data_capnp.Climate.TimeSeries)
* var adminMaster = adminMasterClient.GetMain<Cluster.IAdminMaster>();
* var factories = await adminMaster.AvailableModels();
* if (factories.Count > 0)
* {
* var factory = factories[0];
* var instanceCapHolder = factory.NewInstance().Eager<Mas.Rpc.Common.ICapHolder<object>>();
* var envInstance = ((BareProxy)(await instanceCapHolder.Cap())).Cast<Mas.Rpc.Model.IEnvInstance>(true);
* //var envInstance = ((BareProxy)(await instanceCapHolder.Cap())).Cast<Mas.Rpc.Model.IEnvInstance>(true);
* var infos = await envInstance.Info();
* Console.WriteLine(infos.ToString());
* //modelRes.PseudoEager<Mas.Rpc.Model.IEnvInstance>();
* //var x = modelRes.PseudoEager();
*
* Console.WriteLine("Hello World!");
*
* auto monica = modelRes.getCap().getAs<rpc::Model::EnvInstance>();
* //auto monica = cap.getAs<rpc::Model::EnvInstance>();
* //auto monica = capHolder.capRequest().send().wait(waitScope).getCap(); //<rpc::Model::EnvInstance>().;
* //auto monicaId = monica.infoRequest().send().wait(waitScope).getInfo().getId();
* monica.infoRequest().send().then([](auto && res) {
* cout << "monicaId: " << res.getInfo().getId().cStr() << endl;
* }).wait(waitScope);
* //auto monicaId = monicaRes.getInfo().getId().cStr();
* //cout << "monicaId: " << monicaId << endl;
* //auto sturdyRef = capHolder.saveRequest().send().wait(waitScope).getSturdyRef();
* instanceCapHolder.saveRequest().send().then([](auto && res) {
* cout << "sturdyRef: " << res.getSturdyRef().cStr() << endl;
* }).wait(waitScope);
* //auto sturdyRefP = instanceCapHolder.saveRequest().send().wait(waitScope);// .getSturdyRef();
*
* }
*
* var csvTimeSeries = csvTimeSeriesClient.GetMain<Climate.ITimeSeries>();
* var header = csvTimeSeries.Header();
* header.Wait();
* var elems = header.Result;
* foreach(var elem in elems)
* {
* Console.WriteLine(elem);
* }
* //csvTimeSeries.WhenResolved.Wait(3000);
*
* //SpinWait.SpinUntil(() => server.ConnectionCount > 0, MediumTimeout);
* //Assert.AreEqual(1, server.ConnectionCount);
*
* //server.Main = new ProvidedCapabilityMock();
* //var main = client.GetMain<BareProxy>();
* //var resolving = main as IResolvingCapability;
* //Assert.IsTrue(resolving.WhenResolved.Wait(MediumTimeout));
* }
* //*/
//}
//else if (args.Length > 0 && args[0] == "server")
//else // just pass...
//{
/*
* using (TcpRpcClient runtimeClient = new TcpRpcClient("10.10.24.186", 9000),
* adminMasterClient = new TcpRpcClient("10.10.24.186", 8000))
*
* //using (client)
* {
* await Task.WhenAll(csvTimeSeriesClient.WhenConnected, adminMasterClient.WhenConnected);
*
* //csv_time_series = capnp.TwoPartyClient("localhost:11000").bootstrap().cast_as(
* //climate_data_capnp.Climate.TimeSeries)
* var adminMaster = adminMasterClient.GetMain<Cluster.IAdminMaster>();
* var factories = await adminMaster.AvailableModels();
* if (factories.Count > 0)
*
*
* }
* using (var server = new TcpRpcServer(IPAddress.Any, TcpPort))
* {
* Console.WriteLine($"starting server at localhost:{TcpPort}");
* server.Main = new Mas.Rpc.Monica.SlurmMonicaInstanceFactory("MONICA v3", "C:\\Users}\berg.ZALF-AD\\GitHub\\monica\\_cmake_vs2019_win64\\Debug\\monica-capnp-server.exe", "localhost", 10000);
* Console.WriteLine($"after");
* }
*/
return(null);
}
public void Server1()
{
var cbb = new BufferBlock <IConnection>();
var server = new TcpRpcServer();
server.Main = new TestInterfaceImpl2();
bool init = true;
var tracer = new FrameTracing.RpcFrameTracer(Console.Out);
(var addr, int port) = TcpManager.Instance.GetLocalAddressAndPort();
server.OnConnectionChanged += (s, a) =>
{
var c = a.Connection;
if (init)
{
Assert.ThrowsException <ArgumentNullException>(() => c.AttachTracer(null));
c.AttachTracer(tracer);
Assert.ThrowsException <ArgumentNullException>(() => c.InjectMidlayer(null));
c.InjectMidlayer(_ => _);
Assert.IsFalse(c.IsComputing);
Assert.IsFalse(c.IsWaitingForData);
Assert.AreEqual(ConnectionState.Initializing, c.State);
Assert.IsNotNull(c.RemotePort);
Assert.AreEqual(port, c.LocalPort);
Assert.AreEqual(0L, c.RecvCount);
Assert.AreEqual(0L, c.SendCount);
}
else
{
Assert.ThrowsException <InvalidOperationException>(() => c.AttachTracer(tracer));
Assert.ThrowsException <InvalidOperationException>(() => c.InjectMidlayer(_ => _));
Assert.AreEqual(ConnectionState.Down, c.State);
}
cbb.Post(c);
};
Assert.ThrowsException <InvalidOperationException>(() => server.StopListening());
server.StartAccepting(addr, port);
Assert.IsTrue(server.IsAlive);
Assert.ThrowsException <InvalidOperationException>(() => server.StartAccepting(addr, port));
var server2 = new TcpRpcServer();
Assert.ThrowsException <SocketException>(() => server2.StartAccepting(addr, port));
var client1 = new TcpRpcClient(addr.ToString(), port);
var c1 = cbb.Receive(TimeSpan.FromMilliseconds(MediumNonDbgTimeout));
Assert.IsNotNull(c1);
Assert.AreEqual(1, server.ConnectionCount);
Assert.AreEqual(c1, server.Connections[0]);
Assert.AreEqual(ConnectionState.Active, c1.State);
var proxy = client1.GetMain <ITestInterface>();
Assert.IsTrue(proxy is IResolvingCapability r && r.WhenResolved.WrappedTask.Wait(MediumNonDbgTimeout));
Assert.IsTrue(c1.RecvCount > 0);
Assert.IsTrue(c1.SendCount > 0);
var client2 = new TcpRpcClient(addr.ToString(), port);
var c2 = cbb.Receive(TimeSpan.FromMilliseconds(MediumNonDbgTimeout));
Assert.IsNotNull(c2);
Assert.AreEqual(2, server.ConnectionCount);
Assert.AreEqual(c2, server.Connections[1]);
init = false;
client1.Dispose();
var c1d = cbb.Receive(TimeSpan.FromMilliseconds(MediumNonDbgTimeout));
Assert.IsNotNull(c1d);
Assert.AreEqual(1, server.ConnectionCount);
Assert.AreEqual(c2, server.Connections[0]);
Assert.IsTrue(SpinWait.SpinUntil(() => c1d.State == ConnectionState.Down, MediumNonDbgTimeout));
client2.Dispose();
var c2d = cbb.Receive(TimeSpan.FromMilliseconds(MediumNonDbgTimeout));
Assert.IsNotNull(c2d);
Assert.AreEqual(0, server.ConnectionCount);
Assert.IsTrue(SpinWait.SpinUntil(() => c2d.State == ConnectionState.Down, MediumNonDbgTimeout));
server.StopListening();
Assert.IsFalse(server.IsAlive);
Assert.ThrowsException <InvalidOperationException>(() => server.StopListening());
for (int i = 0; i < 100; i++)
{
server.StartAccepting(addr, port);
Assert.IsTrue(server.IsAlive);
server.StopListening();
Assert.IsFalse(server.IsAlive);
}
server.Dispose();
}
