public override async Task RunAsync(string[] args)
{
await using Ice.Communicator communicator = Initialize(ref args);
if (args.Length < 1)
{
throw new ArgumentException("Usage: server testdir");
}
communicator.SetProperty("TestAdapter.Endpoints", GetTestEndpoint(0, "tcp"));
communicator.SetProperty("TestAdapter.AcceptNonSecure", "True");
Ice.ObjectAdapter adapter = communicator.CreateObjectAdapter("TestAdapter");
adapter.Add("factory", new ServerFactory(args[0] + "/../certs"));
await adapter.ActivateAsync();
await communicator.WaitForShutdownAsync();
}
public static Test.ITestIntfPrx allTests(global::Test.TestHelper helper)
{
Ice.Communicator communicator = helper.communicator();
var output = helper.getWriter();
output.Write("testing stringToProxy... ");
output.Flush();
string @ref = "test:" + helper.getTestEndpoint(0);
Ice.IObjectPrx @base = IObjectPrx.Parse(@ref, communicator);
test(@base != null);
output.WriteLine("ok");
output.Write("testing checked cast... ");
output.Flush();
var obj = Test.ITestIntfPrx.CheckedCast(@base);
test(obj != null);
test(obj.Equals(@base));
output.WriteLine("ok");
{
output.Write("creating/destroying/recreating object adapter... ");
output.Flush();
ObjectAdapter adapter =
communicator.createObjectAdapterWithEndpoints("TransientTestAdapter", "default");
try
{
communicator.createObjectAdapterWithEndpoints("TransientTestAdapter", "default");
test(false);
}
catch (ArgumentException)
{
}
adapter.Destroy();
//
// Use a different port than the first adapter to avoid an "address already in use" error.
//
adapter = communicator.createObjectAdapterWithEndpoints("TransientTestAdapter", "default");
adapter.Destroy();
output.WriteLine("ok");
}
output.Write("creating/activating/deactivating object adapter in one operation... ");
output.Flush();
obj.transient();
obj.transientAsync().Wait();
output.WriteLine("ok");
{
output.Write("testing connection closure... ");
output.Flush();
for (int i = 0; i < 10; ++i)
{
var comm = new Communicator(communicator.GetProperties());
IObjectPrx.Parse($"test:{helper.getTestEndpoint(0)}", communicator).IcePingAsync();
comm.destroy();
}
output.WriteLine("ok");
}
output.Write("testing object adapter published endpoints... ");
output.Flush();
{
communicator.SetProperty("PAdapter.PublishedEndpoints", "tcp -h localhost -p 12345 -t 30000");
var adapter = communicator.createObjectAdapter("PAdapter");
test(adapter.GetPublishedEndpoints().Length == 1);
var endpt = adapter.GetPublishedEndpoints()[0];
test(endpt.ToString().Equals("tcp -h localhost -p 12345 -t 30000"));
var prx = IObjectPrx.Parse("dummy:tcp -h localhost -p 12346 -t 20000:tcp -h localhost -p 12347 -t 10000", communicator);
adapter.SetPublishedEndpoints(prx.Endpoints);
test(adapter.GetPublishedEndpoints().Length == 2);
test(Collections.Equals(adapter.CreateProxy(new Identity("dummy", "")).Endpoints, prx.Endpoints));
test(Collections.Equals(adapter.GetPublishedEndpoints(), prx.Endpoints));
adapter.RefreshPublishedEndpoints();
test(adapter.GetPublishedEndpoints().Length == 1);
test(adapter.GetPublishedEndpoints()[0].Equals(endpt));
communicator.SetProperty("PAdapter.PublishedEndpoints", "tcp -h localhost -p 12345 -t 20000");
adapter.RefreshPublishedEndpoints();
test(adapter.GetPublishedEndpoints().Length == 1);
test(adapter.GetPublishedEndpoints()[0].ToString().Equals("tcp -h localhost -p 12345 -t 20000"));
adapter.Destroy();
test(adapter.GetPublishedEndpoints().Length == 0);
}
output.WriteLine("ok");
if (obj.GetConnection() != null)
{
output.Write("testing object adapter with bi-dir connection... ");
output.Flush();
var adapter = communicator.createObjectAdapter("");
obj.GetConnection().setAdapter(adapter);
obj.GetConnection().setAdapter(null);
adapter.Deactivate();
try
{
obj.GetConnection().setAdapter(adapter);
test(false);
}
catch (ObjectAdapterDeactivatedException)
{
}
output.WriteLine("ok");
}
output.Write("testing object adapter with router... ");
output.Flush();
{
var routerId = new Identity();
routerId.name = "router";
var router = IRouterPrx.UncheckedCast(@base.Clone(routerId, connectionId: "rc"));
var adapter = communicator.createObjectAdapterWithRouter("", router);
test(adapter.GetPublishedEndpoints().Length == 1);
test(adapter.GetPublishedEndpoints()[0].ToString().Equals("tcp -h localhost -p 23456 -t 30000"));
adapter.RefreshPublishedEndpoints();
test(adapter.GetPublishedEndpoints().Length == 1);
test(adapter.GetPublishedEndpoints()[0].ToString().Equals("tcp -h localhost -p 23457 -t 30000"));
try
{
adapter.SetPublishedEndpoints(router.Endpoints);
test(false);
}
catch (ArgumentException)
{
// Expected.
}
adapter.Destroy();
try
{
routerId.name = "test";
router = IRouterPrx.UncheckedCast(@base.Clone(routerId));
communicator.createObjectAdapterWithRouter("", router);
test(false);
}
catch (OperationNotExistException)
{
// Expected: the "test" object doesn't implement Ice::Router!
}
try
{
router = IRouterPrx.Parse($"test:{helper.getTestEndpoint(1)}", communicator);
communicator.createObjectAdapterWithRouter("", router);
test(false);
}
catch (ConnectFailedException)
{
}
}
output.WriteLine("ok");
output.Write("testing object adapter creation with port in use... ");
output.Flush();
{
var adapter1 = communicator.createObjectAdapterWithEndpoints("Adpt1", helper.getTestEndpoint(10));
try
{
communicator.createObjectAdapterWithEndpoints("Adpt2", helper.getTestEndpoint(10));
test(false);
}
catch (LocalException)
{
// Expected can't re-use the same endpoint.
}
adapter1.Destroy();
}
output.WriteLine("ok");
output.Write("deactivating object adapter in the server... ");
output.Flush();
obj.deactivate();
output.WriteLine("ok");
output.Write("testing whether server is gone... ");
output.Flush();
try
{
obj.Clone(connectionTimeout: 100).IcePing(); // Use timeout to speed up testing on Windows
test(false);
}
catch (LocalException)
{
output.WriteLine("ok");
}
return(obj);
}
public static void allTests(global::Test.TestHelper helper)
{
Ice.Communicator communicator = helper.communicator();
var output = helper.getWriter();
output.Write("testing proxy endpoint information... ");
output.Flush();
{
var p1 = IObjectPrx.Parse(
"test -t:default -h tcphost -p 10000 -t 1200 -z --sourceAddress 10.10.10.10:" +
"udp -h udphost -p 10001 --interface eth0 --ttl 5 --sourceAddress 10.10.10.10:" +
"opaque -e 1.8 -t 100 -v ABCD", communicator);
Ice.Endpoint[] endps = p1.Endpoints;
Ice.EndpointInfo info = endps[0].getInfo();
Ice.TCPEndpointInfo tcpEndpoint = getTCPEndpointInfo(info);
test(tcpEndpoint.host.Equals("tcphost"));
test(tcpEndpoint.port == 10000);
test(tcpEndpoint.sourceAddress.Equals("10.10.10.10"));
test(tcpEndpoint.timeout == 1200);
test(tcpEndpoint.compress);
test(!tcpEndpoint.datagram());
test(tcpEndpoint.type() == Ice.TCPEndpointType.value && !tcpEndpoint.secure() ||
tcpEndpoint.type() == Ice.SSLEndpointType.value && tcpEndpoint.secure() ||
tcpEndpoint.type() == Ice.WSEndpointType.value && !tcpEndpoint.secure() ||
tcpEndpoint.type() == Ice.WSSEndpointType.value && tcpEndpoint.secure());
test(tcpEndpoint.type() == Ice.TCPEndpointType.value && info is Ice.TCPEndpointInfo ||
tcpEndpoint.type() == Ice.SSLEndpointType.value && info is IceSSL.EndpointInfo ||
tcpEndpoint.type() == Ice.WSEndpointType.value && info is Ice.WSEndpointInfo ||
tcpEndpoint.type() == Ice.WSSEndpointType.value && info is Ice.WSEndpointInfo);
Ice.UDPEndpointInfo udpEndpoint = (Ice.UDPEndpointInfo)endps[1].getInfo();
test(udpEndpoint.host.Equals("udphost"));
test(udpEndpoint.port == 10001);
test(udpEndpoint.mcastInterface.Equals("eth0"));
test(udpEndpoint.mcastTtl == 5);
test(udpEndpoint.sourceAddress.Equals("10.10.10.10"));
test(udpEndpoint.timeout == -1);
test(!udpEndpoint.compress);
test(!udpEndpoint.secure());
test(udpEndpoint.datagram());
test(udpEndpoint.type() == 3);
Ice.OpaqueEndpointInfo opaqueEndpoint = (Ice.OpaqueEndpointInfo)endps[2].getInfo();
test(opaqueEndpoint.rawBytes.Length > 0);
test(opaqueEndpoint.rawEncoding.Equals(new Ice.EncodingVersion(1, 8)));
}
output.WriteLine("ok");
Ice.ObjectAdapter adapter;
output.Write("test object adapter endpoint information... ");
output.Flush();
{
string host = communicator.GetPropertyAsInt("Ice.IPv6") != 0 ? "::1" : "127.0.0.1";
communicator.SetProperty("TestAdapter.Endpoints", "tcp -h \"" + host +
"\" -t 15000:udp -h \"" + host + "\"");
adapter = communicator.createObjectAdapter("TestAdapter");
Ice.Endpoint[] endpoints = adapter.GetEndpoints();
test(endpoints.Length == 2);
Ice.Endpoint[] publishedEndpoints = adapter.GetPublishedEndpoints();
test(Collections.Equals(endpoints, publishedEndpoints));
Ice.TCPEndpointInfo tcpEndpoint = getTCPEndpointInfo(endpoints[0].getInfo());
test(tcpEndpoint.type() == Ice.TCPEndpointType.value ||
tcpEndpoint.type() == Ice.SSLEndpointType.value ||
tcpEndpoint.type() == Ice.WSEndpointType.value ||
tcpEndpoint.type() == Ice.WSSEndpointType.value);
test(tcpEndpoint.host.Equals(host));
test(tcpEndpoint.port > 0);
test(tcpEndpoint.timeout == 15000);
Ice.UDPEndpointInfo udpEndpoint = (Ice.UDPEndpointInfo)endpoints[1].getInfo();
test(udpEndpoint.host.Equals(host));
test(udpEndpoint.datagram());
test(udpEndpoint.port > 0);
endpoints = new Ice.Endpoint[] { endpoints[0] };
test(endpoints.Length == 1);
adapter.SetPublishedEndpoints(endpoints);
publishedEndpoints = adapter.GetPublishedEndpoints();
test(Collections.Equals(endpoints, publishedEndpoints));
adapter.Destroy();
int port = helper.getTestPort(1);
communicator.SetProperty("TestAdapter.Endpoints", $"default -h * -p {port}");
communicator.SetProperty("TestAdapter.PublishedEndpoints", helper.getTestEndpoint(1));
adapter = communicator.createObjectAdapter("TestAdapter");
endpoints = adapter.GetEndpoints();
test(endpoints.Length >= 1);
publishedEndpoints = adapter.GetPublishedEndpoints();
test(publishedEndpoints.Length == 1);
foreach (Endpoint endpoint in endpoints)
{
tcpEndpoint = getTCPEndpointInfo(endpoint.getInfo());
test(tcpEndpoint.port == port);
}
tcpEndpoint = getTCPEndpointInfo(publishedEndpoints[0].getInfo());
test(tcpEndpoint.host == "127.0.0.1");
test(tcpEndpoint.port == port);
adapter.Destroy();
}
output.WriteLine("ok");
int endpointPort = helper.getTestPort(0);
var @base = IObjectPrx.Parse("test:" +
helper.getTestEndpoint(0) + ":" +
helper.getTestEndpoint(0, "udp"), communicator);
var testIntf = Test.TestIntfPrx.CheckedCast(@base);
string defaultHost = communicator.GetProperty("Ice.Default.Host") ?? "";
output.Write("test connection endpoint information... ");
output.Flush();
{
Ice.EndpointInfo info = @base.GetConnection().getEndpoint().getInfo();
Ice.TCPEndpointInfo tcpinfo = getTCPEndpointInfo(info);
test(tcpinfo.port == endpointPort);
test(!tcpinfo.compress);
test(tcpinfo.host.Equals(defaultHost));
Dictionary <string, string> ctx = testIntf.getEndpointInfoAsContext();
test(ctx["host"].Equals(tcpinfo.host));
test(ctx["compress"].Equals("false"));
int port = int.Parse(ctx["port"]);
test(port > 0);
info = @base.Clone(invocationMode: InvocationMode.Datagram).GetConnection().getEndpoint().getInfo();
Ice.UDPEndpointInfo udp = (Ice.UDPEndpointInfo)info;
test(udp.port == endpointPort);
test(udp.host.Equals(defaultHost));
}
output.WriteLine("ok");
output.Write("testing connection information... ");
output.Flush();
{
Ice.Connection connection = @base.GetConnection();
connection.setBufferSize(1024, 2048);
Ice.ConnectionInfo info = connection.getInfo();
Ice.TCPConnectionInfo ipInfo = getTCPConnectionInfo(info);
test(!info.incoming);
test(info.adapterName.Length == 0);
test(ipInfo.remotePort == endpointPort);
test(ipInfo.localPort > 0);
if (defaultHost.Equals("127.0.0.1"))
{
test(ipInfo.localAddress.Equals(defaultHost));
test(ipInfo.remoteAddress.Equals(defaultHost));
}
test(ipInfo.rcvSize >= 1024);
test(ipInfo.sndSize >= 2048);
Dictionary <string, string> ctx = testIntf.getConnectionInfoAsContext();
test(ctx["incoming"].Equals("true"));
test(ctx["adapterName"].Equals("TestAdapter"));
test(ctx["remoteAddress"].Equals(ipInfo.localAddress));
test(ctx["localAddress"].Equals(ipInfo.remoteAddress));
test(ctx["remotePort"].Equals(ipInfo.localPort.ToString()));
test(ctx["localPort"].Equals(ipInfo.remotePort.ToString()));
if (@base.GetConnection().type().Equals("ws") || @base.GetConnection().type().Equals("wss"))
{
Dictionary <string, string> headers = ((Ice.WSConnectionInfo)info).headers;
test(headers["Upgrade"].Equals("websocket"));
test(headers["Connection"].Equals("Upgrade"));
test(headers["Sec-WebSocket-Protocol"].Equals("ice.zeroc.com"));
test(headers["Sec-WebSocket-Accept"] != null);
test(ctx["ws.Upgrade"].Equals("websocket"));
test(ctx["ws.Connection"].Equals("Upgrade"));
test(ctx["ws.Sec-WebSocket-Protocol"].Equals("ice.zeroc.com"));
test(ctx["ws.Sec-WebSocket-Version"].Equals("13"));
test(ctx["ws.Sec-WebSocket-Key"] != null);
}
connection = @base.Clone(invocationMode: InvocationMode.Datagram).GetConnection();
connection.setBufferSize(2048, 1024);
Ice.UDPConnectionInfo udpInfo = (Ice.UDPConnectionInfo)connection.getInfo();
test(!udpInfo.incoming);
test(udpInfo.adapterName.Length == 0);
test(udpInfo.localPort > 0);
test(udpInfo.remotePort == endpointPort);
if (defaultHost.Equals("127.0.0.1"))
{
test(udpInfo.remoteAddress.Equals(defaultHost));
test(udpInfo.localAddress.Equals(defaultHost));
}
test(udpInfo.rcvSize >= 2048);
test(udpInfo.sndSize >= 1024);
}
output.WriteLine("ok");
testIntf.shutdown();
communicator.shutdown();
communicator.waitForShutdown();
}
