public static void allTests(global::Test.TestHelper helper)
{
var controller = IControllerPrx.Parse($"controller:{helper.getTestEndpoint(1)}", helper.communicator());
try
{
allTestsWithController(helper, controller);
}
catch (Exception)
{
// Ensure the adapter is not in the holding state when an unexpected exception occurs to prevent
// the test from hanging on exit in case a connection which disables timeouts is still opened.
controller.resumeAdapter();
throw;
}
}
public static async Task RunAsync(TestHelper helper)
{
Communicator communicator = helper.Communicator;
var controller = IControllerPrx.Parse(helper.GetTestProxy("controller", 1), communicator);
try
{
await RunWithControllerAsync(helper, controller);
}
catch
{
// Ensure the adapter is not in the holding state when an unexpected exception occurs to prevent
// the test from hanging on exit in case a connection which disables timeouts is still opened.
controller.ResumeAdapter();
throw;
}
}
allTests(Test.TestHelper helper, int num)
{
var output = helper.getWriter();
Ice.Communicator communicator = helper.communicator();
List <IControllerPrx> proxies = new List <IControllerPrx>();
List <IControllerPrx> indirectProxies = new List <IControllerPrx>();
for (int i = 0; i < num; ++i)
{
string id = "controller" + i;
proxies.Add(IControllerPrx.Parse(id, communicator));
indirectProxies.Add(IControllerPrx.Parse($"{id}@control{i}", communicator));
}
output.Write("testing indirect proxies... ");
output.Flush();
{
foreach (IControllerPrx prx in indirectProxies)
{
prx.IcePing();
}
}
output.WriteLine("ok");
output.Write("testing well-known proxies... ");
output.Flush();
{
foreach (IControllerPrx prx in proxies)
{
prx.IcePing();
}
}
output.WriteLine("ok");
output.Write("testing object adapter registration... ");
output.Flush();
{
try
{
IObjectPrx.Parse("object @ oa1", communicator).IcePing();
test(false);
}
catch (NoEndpointException)
{
}
proxies[0].activateObjectAdapter("oa", "oa1", "");
try
{
IObjectPrx.Parse("object @ oa1", communicator).IcePing();
test(false);
}
catch (ObjectNotExistException)
{
}
proxies[0].deactivateObjectAdapter("oa");
try
{
IObjectPrx.Parse("object @ oa1", communicator).IcePing();
test(false);
}
catch (NoEndpointException)
{
}
}
output.WriteLine("ok");
output.Write("testing object adapter migration...");
output.Flush();
{
proxies[0].activateObjectAdapter("oa", "oa1", "");
proxies[0].addObject("oa", "object");
IObjectPrx.Parse("object @ oa1", communicator).IcePing();
proxies[0].removeObject("oa", "object");
proxies[0].deactivateObjectAdapter("oa");
proxies[1].activateObjectAdapter("oa", "oa1", "");
proxies[1].addObject("oa", "object");
IObjectPrx.Parse("object @ oa1", communicator).IcePing();
proxies[1].removeObject("oa", "object");
proxies[1].deactivateObjectAdapter("oa");
}
output.WriteLine("ok");
output.Write("testing object migration...");
output.Flush();
{
proxies[0].activateObjectAdapter("oa", "oa1", "");
proxies[1].activateObjectAdapter("oa", "oa2", "");
proxies[0].addObject("oa", "object");
IObjectPrx.Parse("object @ oa1", communicator).IcePing();
IObjectPrx.Parse("object", communicator).IcePing();
proxies[0].removeObject("oa", "object");
proxies[1].addObject("oa", "object");
IObjectPrx.Parse("object @ oa2", communicator).IcePing();
IObjectPrx.Parse("object", communicator).IcePing();
proxies[1].removeObject("oa", "object");
try
{
IObjectPrx.Parse("object @ oa1", communicator).IcePing();
}
catch (ObjectNotExistException)
{
}
try
{
IObjectPrx.Parse("object @ oa2", communicator).IcePing();
}
catch (ObjectNotExistException)
{
}
proxies[0].deactivateObjectAdapter("oa");
proxies[1].deactivateObjectAdapter("oa");
}
output.WriteLine("ok");
output.Write("testing replica groups...");
output.Flush();
{
proxies[0].activateObjectAdapter("oa", "oa1", "rg");
proxies[1].activateObjectAdapter("oa", "oa2", "rg");
proxies[2].activateObjectAdapter("oa", "oa3", "rg");
proxies[0].addObject("oa", "object");
proxies[1].addObject("oa", "object");
proxies[2].addObject("oa", "object");
IObjectPrx.Parse("object @ oa1", communicator).IcePing();
IObjectPrx.Parse("object @ oa2", communicator).IcePing();
IObjectPrx.Parse("object @ oa3", communicator).IcePing();
IObjectPrx.Parse("object @ rg", communicator).IcePing();
List <string> adapterIds = new List <string>();
adapterIds.Add("oa1");
adapterIds.Add("oa2");
adapterIds.Add("oa3");
ITestIntfPrx intf = ITestIntfPrx.Parse("object", communicator).Clone(
connectionCached: false,
locatorCacheTimeout: 0);
while (adapterIds.Count > 0)
{
adapterIds.Remove(intf.getAdapterId());
}
while (true)
{
adapterIds.Add("oa1");
adapterIds.Add("oa2");
adapterIds.Add("oa3");
intf = ITestIntfPrx.Parse("object @ rg", communicator).Clone(connectionCached: false);
int nRetry = 100;
while (adapterIds.Count > 0 && --nRetry > 0)
{
adapterIds.Remove(intf.getAdapterId());
}
if (nRetry > 0)
{
break;
}
// The previous locator lookup probably didn't return all the replicas... try again.
IObjectPrx.Parse("object @ rg", communicator).Clone(locatorCacheTimeout: 0).IcePing();
}
proxies[0].deactivateObjectAdapter("oa");
proxies[1].deactivateObjectAdapter("oa");
test(ITestIntfPrx.Parse("object @ rg", communicator).getAdapterId().Equals("oa3"));
proxies[2].deactivateObjectAdapter("oa");
proxies[0].activateObjectAdapter("oa", "oa1", "rg");
proxies[0].addObject("oa", "object");
test(ITestIntfPrx.Parse("object @ rg", communicator).getAdapterId().Equals("oa1"));
proxies[0].deactivateObjectAdapter("oa");
}
output.WriteLine("ok");
output.Write("testing invalid lookup endpoints... ");
output.Flush();
{
string multicast;
if (communicator.GetProperty("Ice.IPv6") == "1")
{
multicast = "\"ff15::1\"";
}
else
{
multicast = "239.255.0.1";
}
{
var properties = communicator.GetProperties();
properties["IceDiscovery.Lookup"] = $"udp -h {multicast} --interface unknown";
Communicator comm = new Communicator(properties);
test(comm.GetDefaultLocator() != null);
try
{
IObjectPrx.Parse("controller0@control0", comm).IcePing();
test(false);
}
catch (LocalException)
{
}
comm.Destroy();
}
{
var properties = communicator.GetProperties();
string intf = communicator.GetProperty("IceDiscovery.Interface") ?? "";
if (intf != "")
{
intf = $" --interface \"{intf}\"";
}
string port = communicator.GetProperty("IceDiscovery.Port") ?? "";
properties["IceDiscovery.Lookup"] =
$"udp -h {multicast} --interface unknown:udp -h {multicast} -p {port}{intf}";
Communicator comm = new Communicator(properties);
test(comm.GetDefaultLocator() != null);
IObjectPrx.Parse("controller0@control0", comm).IcePing();
comm.Destroy();
}
}
output.WriteLine("ok");
output.Write("shutting down... ");
output.Flush();
foreach (IControllerPrx prx in proxies)
{
prx.shutdown();
}
output.WriteLine("ok");
}
public static void allTestsWithController(TestHelper helper, IControllerPrx controller)
{
Communicator?communicator = helper.Communicator();
TestHelper.Assert(communicator != null);
var timeout = ITimeoutPrx.Parse($"timeout:{helper.GetTestEndpoint(0)}", communicator);
System.IO.TextWriter output = helper.GetWriter();
output.Write("testing connect timeout... ");
output.Flush();
{
//
// Expect ConnectTimeoutException.
//
ITimeoutPrx to = timeout.Clone(connectionTimeout: 100);
controller.holdAdapter(-1);
try
{
to.op();
TestHelper.Assert(false);
}
catch (ConnectTimeoutException)
{
// Expected.
}
controller.resumeAdapter();
timeout.op(); // Ensure adapter is active.
}
{
//
// Expect success.
//
ITimeoutPrx to = timeout.Clone(connectionTimeout: -1);
controller.holdAdapter(100);
to.op();
}
output.WriteLine("ok");
// The sequence needs to be large enough to fill the write/recv buffers
byte[] seq = new byte[2000000];
// TODO: remove or refactor depending on what we decide for connection timeouts
// output.Write("testing connection timeout... ");
// output.Flush();
// {
// //
// // Expect TimeoutException.
// //
// var to = timeout.Clone(connectionTimeout: 250);
// connect(to);
// controller.holdAdapter(-1);
// try
// {
// to.sendData(seq);
// test(false);
// }
// catch (ConnectionTimeoutException)
// {
// // Expected.
// }
// controller.resumeAdapter();
// timeout.op(); // Ensure adapter is active.
// }
// {
// //
// // Expect success.
// //
// var to = timeout.Clone(connectionTimeout: 2000);
// controller.holdAdapter(100);
// try
// {
// to.sendData(new byte[1000000]);
// }
// catch (ConnectionTimeoutException)
// {
// test(false);
// }
// }
// output.WriteLine("ok");
output.Write("testing invocation timeout... ");
output.Flush();
{
timeout.IcePing(); // Makes sure a working connection is associated with the proxy
var connection = timeout.GetConnection();
var to = timeout.Clone(invocationTimeout: 100);
TestHelper.Assert(connection == to.GetConnection());
try
{
to.sleep(1000);
TestHelper.Assert(false);
}
catch (TimeoutException)
{
}
timeout.IcePing();
to = timeout.Clone(invocationTimeout: 1000);
TestHelper.Assert(connection == to.GetConnection());
try
{
to.sleep(100);
}
catch (TimeoutException)
{
TestHelper.Assert(false);
}
TestHelper.Assert(connection == to.GetConnection());
}
{
//
// Expect TimeoutException.
//
var to = timeout.Clone(invocationTimeout: 100);
try
{
to.sleepAsync(1000).Wait();
}
catch (AggregateException ex) when(ex.InnerException is TimeoutException)
{
}
timeout.IcePing();
}
{
//
// Expect success.
//
var to = timeout.Clone(invocationTimeout: 1000);
to.sleepAsync(100).Wait();
}
output.WriteLine("ok");
// TODO: remove or refactor depending on what we decide for connection timeouts
// output.Write("testing close timeout... ");
// output.Flush();
// {
// var to = timeout.Clone(connectionTimeout: 250);
// var connection = connect(to);
// controller.holdAdapter(-1);
// connection.Close(Ice.ConnectionClose.GracefullyWithWait);
// try
// {
// _ = connection.GetConnectionInfo(); // getInfo() doesn't throw in the closing state.
// }
// catch (System.Exception)
// {
// test(false);
// }
//
// while (true)
// {
// try
// {
// _ = connection.GetConnectionInfo();
// Thread.Sleep(10);
// }
// catch (ConnectionClosedLocallyException ex)
// {
// // Expected (graceful closure)
// break;
// }
// }
// controller.resumeAdapter();
// timeout.op(); // Ensure adapter is active.
// }
// output.WriteLine("ok");
output.Write("testing timeout overrides... ");
output.Flush();
// TODO: remove or refactor depending on what we decide for connection timeouts
// {
// //
// // Test Ice.Override.Timeout. This property overrides all
// // endpoint timeouts.
// //
// var properties = communicator.GetProperties();
// properties["Ice.Override.ConnectTimeout"] = "250";
// properties["Ice.Override.Timeout"] = "100";
// var comm = helper.initialize(properties);
// var to = ITimeoutPrx.Parse(sref, comm);
// connect(to);
// controller.holdAdapter(-1);
// try
// {
// to.sendData(seq);
// test(false);
// }
// catch (ConnectionTimeoutException)
// {
// // Expected.
// }
// controller.resumeAdapter();
// timeout.op(); // Ensure adapter is active.
// //
// // Calling ice_timeout() should have no effect.
// //
// to = to.Clone(connectionTimeout: 1000);
// connect(to);
// controller.holdAdapter(-1);
// try
// {
// to.sendData(seq);
// test(false);
// }
// catch (ConnectionTimeoutException)
// {
// // Expected.
// }
// controller.resumeAdapter();
// timeout.op(); // Ensure adapter is active.
// comm.Destroy();
// }
{
//
// Test Ice.Override.ConnectTimeout.
//
var properties = communicator.GetProperties();
properties["Ice.Override.ConnectTimeout"] = "250";
var comm = helper.Initialize(properties);
controller.holdAdapter(-1);
var to = ITimeoutPrx.Parse($"timeout:{helper.GetTestEndpoint(0)}", comm);
try
{
to.op();
TestHelper.Assert(false);
}
catch (ConnectTimeoutException)
{
// Expected.
}
controller.resumeAdapter();
timeout.op(); // Ensure adapter is active.
//
// Calling ice_timeout() should have no effect on the connect timeout.
//
controller.holdAdapter(-1);
to = to.Clone(connectionTimeout: 1000);
try
{
to.op();
TestHelper.Assert(false);
}
catch (ConnectTimeoutException)
{
// Expected.
}
controller.resumeAdapter();
timeout.op(); // Ensure adapter is active.
//
// Verify that timeout set via ice_timeout() is still used for requests.
//
// to = to.Clone(connectionTimeout: 250);
// connect(to);
// controller.holdAdapter(-1);
// try
// {
// to.sendData(seq);
// test(false);
// }
// catch (ConnectionTimeoutException)
// {
// // Expected.
// }
// controller.resumeAdapter();
// timeout.op(); // Ensure adapter is active.
comm.Destroy();
}
// TODO: remove or refactor depending on what we decide for connection timeouts
// {
// //
// // Test Ice.Override.CloseTimeout.
// //
// var properties = communicator.GetProperties();
// properties["Ice.Override.CloseTimeout"] = "100";
// var comm = helper.initialize(properties);
// IObjectPrx.Parse(sref, comm).GetConnection();
// controller.holdAdapter(-1);
// long begin = System.DateTime.Now.Ticks;
// comm.Destroy();
// test(((long)new System.TimeSpan(System.DateTime.Now.Ticks - begin).TotalMilliseconds - begin) < 1000);
// controller.resumeAdapter();
// }
output.WriteLine("ok");
output.Write("testing invocation timeouts with collocated calls... ");
output.Flush();
{
communicator.SetProperty("TimeoutCollocated.AdapterId", "timeoutAdapter");
var adapter = communicator.CreateObjectAdapter("TimeoutCollocated");
adapter.Activate();
var proxy = adapter.AddWithUUID(new Timeout(), ITimeoutPrx.Factory).Clone(invocationTimeout: 100);
try
{
proxy.sleep(500);
TestHelper.Assert(false);
}
catch (TimeoutException)
{
}
try
{
proxy.sleepAsync(500).Wait();
TestHelper.Assert(false);
}
catch (AggregateException ex) when(ex.InnerException is TimeoutException)
{
}
adapter.Destroy();
}
output.WriteLine("ok");
controller.shutdown();
}
public static void RunWithController(TestHelper helper, IControllerPrx controller)
{
Communicator?communicator = helper.Communicator;
TestHelper.Assert(communicator != null);
var timeout = ITimeoutPrx.Parse(helper.GetTestProxy("timeout", 0), communicator);
System.IO.TextWriter output = helper.Output;
output.Write("testing connect timeout... ");
output.Flush();
{
Dictionary <string, string>?properties = communicator.GetProperties();
properties["Ice.ConnectTimeout"] = "100ms";
using var comm = new Communicator(properties);
var to = ITimeoutPrx.Parse(helper.GetTestProxy("timeout", 0), comm);
// Expect ConnectTimeoutException.
controller.HoldAdapter(-1);
try
{
to.Op();
TestHelper.Assert(false);
}
catch (ConnectTimeoutException)
{
// Expected.
}
controller.ResumeAdapter();
timeout.Op(); // Ensure adapter is active.
}
{
// Expect success.
controller.HoldAdapter(100);
timeout.Op();
}
output.WriteLine("ok");
// The sequence needs to be large enough to fill the write/recv buffers
byte[] seq = new byte[2000000];
output.Write("testing connection timeout... ");
output.Flush();
{
// Expect TimeoutException.
controller.HoldAdapter(-1);
timeout.GetConnection() !.Acm = new Acm(TimeSpan.FromMilliseconds(50),
AcmClose.OnInvocationAndIdle,
AcmHeartbeat.Off);
try
{
timeout.SendData(seq);
TestHelper.Assert(false);
}
catch (ConnectionTimeoutException)
{
// Expected.
}
controller.ResumeAdapter();
timeout.Op(); // Ensure adapter is active.
}
{
// Expect success.
controller.HoldAdapter(100);
try
{
timeout.SendData(new byte[1000000]);
}
catch (ConnectionTimeoutException)
{
TestHelper.Assert(false);
}
}
output.WriteLine("ok");
output.Write("testing invocation timeout... ");
output.Flush();
{
timeout.IcePing(); // Makes sure a working connection is associated with the proxy
Connection?connection = timeout.GetConnection();
try
{
using var timeoutTokenSource = new CancellationTokenSource(TimeSpan.FromMilliseconds(100));
timeout.SleepAsync(1000, cancel: timeoutTokenSource.Token).Wait();
TestHelper.Assert(false);
}
catch (AggregateException ex) when(ex.InnerException is OperationCanceledException)
{
}
timeout.IcePing();
TestHelper.Assert(connection == timeout.GetConnection());
try
{
using var timeoutTokenSource = new CancellationTokenSource(TimeSpan.FromMilliseconds(1000));
timeout.SleepAsync(100, cancel: timeoutTokenSource.Token).Wait();
}
catch (AggregateException ex) when(ex.InnerException is OperationCanceledException)
{
TestHelper.Assert(false);
}
TestHelper.Assert(connection == timeout.GetConnection());
}
output.WriteLine("ok");
output.Write("testing close timeout... ");
output.Flush();
{
Dictionary <string, string> properties = communicator.GetProperties();
properties["Ice.CloseTimeout"] = "100ms";
using var comm = new Communicator(properties);
var to = ITimeoutPrx.Parse(helper.GetTestProxy("timeout", 0), comm);
Connection?connection = to.GetConnection();
Connection?connection2 = timeout.GetConnection(); // No close timeout
TestHelper.Assert(connection != null && connection2 != null);
controller.HoldAdapter(-1);
// Make sure there's no ReadAsync pending
_ = to.IcePingAsync();
_ = timeout.IcePingAsync();
var semaphore = new System.Threading.SemaphoreSlim(0);
connection.Closed += (sender, args) => semaphore.Release();
connection.Close(ConnectionClose.Gracefully);
TestHelper.Assert(semaphore.Wait(500));
connection2.Closed += (sender, args) => semaphore.Release();
connection2.Close(ConnectionClose.Gracefully);
TestHelper.Assert(!semaphore.Wait(500));
controller.ResumeAdapter();
timeout.Op(); // Ensure adapter is active.
}
output.WriteLine("ok");
output.Write("testing invocation timeouts with collocated calls... ");
output.Flush();
{
communicator.SetProperty("TimeoutCollocated.AdapterId", "timeoutAdapter");
ObjectAdapter adapter = communicator.CreateObjectAdapter("TimeoutCollocated");
adapter.Activate();
ITimeoutPrx proxy = adapter.AddWithUUID(new Timeout(), ITimeoutPrx.Factory);
try
{
using var timeoutTokenSource = new CancellationTokenSource(TimeSpan.FromMilliseconds(100));
proxy.SleepAsync(500, cancel: timeoutTokenSource.Token).Wait();
TestHelper.Assert(false);
}
catch (AggregateException ex) when(ex.InnerException is OperationCanceledException)
{
}
adapter.Dispose();
}
output.WriteLine("ok");
controller.Shutdown();
}
public static IMetricsPrx allTests(TestHelper helper, CommunicatorObserver obsv)
{
Communicator communicator = helper.communicator();
string host = helper.getTestHost();
string port = helper.getTestPort(0).ToString();
string hostAndPort = host + ":" + port;
string protocol = helper.getTestProtocol();
string endpoint = protocol + " -h " + host + " -p " + port;
string timeout = communicator.GetProperty("Ice.Default.Timeout") ?? "60000";
IMetricsPrx metrics = IMetricsPrx.Parse($"metrics:{endpoint}", communicator);
bool collocated = metrics.GetConnection() == null;
var output = helper.getWriter();
output.Write("testing metrics admin facet checkedCast... ");
output.Flush();
IObjectPrx admin = communicator.GetAdmin();
IPropertiesAdminPrx clientProps = IPropertiesAdminPrx.CheckedCast(admin.Clone(facet: "Properties"));
IceMX.IMetricsAdminPrx clientMetrics = IceMX.IMetricsAdminPrx.CheckedCast(admin.Clone(facet: "Metrics"));
test(clientProps != null && clientMetrics != null);
admin = metrics.getAdmin();
IPropertiesAdminPrx serverProps = IPropertiesAdminPrx.CheckedCast(admin.Clone(facet: "Properties"));
IceMX.IMetricsAdminPrx serverMetrics = IceMX.IMetricsAdminPrx.CheckedCast(admin.Clone(facet: "Metrics"));
test(serverProps != null && serverMetrics != null);
UpdateCallbackI update = new UpdateCallbackI(serverProps);
((INativePropertiesAdmin)communicator.FindAdminFacet("Properties")).AddUpdateCallback(update.updated);
output.WriteLine("ok");
Dictionary <string, string> props = new Dictionary <string, string>();
output.Write("testing group by none...");
output.Flush();
props.Add("IceMX.Metrics.View.GroupBy", "none");
updateProps(clientProps, serverProps, update, props, "");
Dictionary <string, IceMX.Metrics[]> view = clientMetrics.GetMetricsView("View").ReturnValue;
if (!collocated)
{
test(view["Connection"].Length == 1 && view["Connection"][0].Current == 1 &&
view["Connection"][0].Total == 1);
}
test(view["Thread"].Length == 1 && view["Thread"][0].Current == 5 && view["Thread"][0].Total == 5);
output.WriteLine("ok");
output.Write("testing group by id...");
output.Flush();
props["IceMX.Metrics.View.GroupBy"] = "id";
updateProps(clientProps, serverProps, update, props, "");
metrics.IcePing();
metrics.IcePing();
metrics.Clone(connectionId: "Con1").IcePing();
metrics.Clone(connectionId: "Con1").IcePing();
metrics.Clone(connectionId: "Con1").IcePing();
waitForCurrent(clientMetrics, "View", "Invocation", 0);
waitForCurrent(serverMetrics, "View", "Dispatch", 0);
view = clientMetrics.GetMetricsView("View").ReturnValue;
test(view["Thread"].Length == 5);
if (!collocated)
{
test(view["Connection"].Length == 2);
}
test(view["Invocation"].Length == 1);
IceMX.InvocationMetrics invoke = (IceMX.InvocationMetrics)view["Invocation"][0];
test(invoke.Id.IndexOf("[ice_ping]") > 0 && invoke.Current == 0 && invoke.Total == 5);
if (!collocated)
{
test(invoke.Remotes.Length == 2);
test(invoke.Remotes[0].Total >= 2 && invoke.Remotes[1].Total >= 2);
test((invoke.Remotes[0].Total + invoke.Remotes[1].Total) == 5);
}
else
{
test(invoke.Collocated.Length == 1);
test(invoke.Collocated[0].Total == 5);
}
view = serverMetrics.GetMetricsView("View").ReturnValue;
// With Ice for .NET, a new dispatching thread isn't necessarily created.
//test(view["Thread"].Length > 5);
if (!collocated)
{
test(view["Connection"].Length == 2);
}
test(view["Dispatch"].Length == 1);
test(view["Dispatch"][0].Current == 0 && view["Dispatch"][0].Total == 5);
test(view["Dispatch"][0].Id.IndexOf("[ice_ping]") > 0);
if (!collocated)
{
metrics.GetConnection().Close(ConnectionClose.GracefullyWithWait);
metrics.Clone(connectionId: "Con1").GetConnection().Close(ConnectionClose.GracefullyWithWait);
waitForCurrent(clientMetrics, "View", "Connection", 0);
waitForCurrent(serverMetrics, "View", "Connection", 0);
}
clearView(clientProps, serverProps, update);
output.WriteLine("ok");
string type = "";
string isSecure = "";
if (!collocated)
{
Ice.EndpointInfo endpointInfo = metrics.GetConnection().Endpoint.GetInfo();
type = endpointInfo.Type().ToString();
isSecure = endpointInfo.Secure() ? "True" : "False";
}
Dictionary <string, IceMX.Metrics> map;
if (!collocated)
{
output.Write("testing connection metrics... ");
output.Flush();
props["IceMX.Metrics.View.Map.Connection.GroupBy"] = "none";
updateProps(clientProps, serverProps, update, props, "Connection");
test(clientMetrics.GetMetricsView("View").ReturnValue["Connection"].Length == 0);
test(serverMetrics.GetMetricsView("View").ReturnValue["Connection"].Length == 0);
metrics.IcePing();
IceMX.ConnectionMetrics cm1, sm1, cm2, sm2;
cm1 = (IceMX.ConnectionMetrics)clientMetrics.GetMetricsView("View").ReturnValue["Connection"][0];
sm1 = getServerConnectionMetrics(serverMetrics, 25);
metrics.IcePing();
cm2 = (IceMX.ConnectionMetrics)clientMetrics.GetMetricsView("View").ReturnValue["Connection"][0];
sm2 = getServerConnectionMetrics(serverMetrics, 50);
test(cm2.SentBytes - cm1.SentBytes == 45); // 45 for IcePing request
test(cm2.ReceivedBytes - cm1.ReceivedBytes == 25); // 25 bytes for IcePing response
test(sm2.ReceivedBytes - sm1.ReceivedBytes == 45);
test(sm2.SentBytes - sm1.SentBytes == 25);
cm1 = cm2;
sm1 = sm2;
byte[] bs = new byte[0];
metrics.opByteS(bs);
cm2 = (IceMX.ConnectionMetrics)clientMetrics.GetMetricsView("View").ReturnValue["Connection"][0];
sm2 = getServerConnectionMetrics(serverMetrics, sm1.SentBytes + cm2.ReceivedBytes - cm1.ReceivedBytes);
long requestSz = cm2.SentBytes - cm1.SentBytes;
long replySz = cm2.ReceivedBytes - cm1.ReceivedBytes;
cm1 = cm2;
sm1 = sm2;
bs = new byte[456];
metrics.opByteS(bs);
cm2 = (IceMX.ConnectionMetrics)clientMetrics.GetMetricsView("View").ReturnValue["Connection"][0];
sm2 = getServerConnectionMetrics(serverMetrics, sm1.SentBytes + replySz);
test(cm2.SentBytes - cm1.SentBytes == requestSz + bs.Length + 4); // 4 is for the seq variable size
test(cm2.ReceivedBytes - cm1.ReceivedBytes == replySz);
test(sm2.ReceivedBytes - sm1.ReceivedBytes == requestSz + bs.Length + 4);
test(sm2.SentBytes - sm1.SentBytes == replySz);
cm1 = cm2;
sm1 = sm2;
bs = new byte[1024 * 1024 * 10]; // Try with large amount of data which should be sent in several chunks
metrics.opByteS(bs);
cm2 = (IceMX.ConnectionMetrics)clientMetrics.GetMetricsView("View").ReturnValue["Connection"][0];
sm2 = getServerConnectionMetrics(serverMetrics, sm1.SentBytes + replySz);
test((cm2.SentBytes - cm1.SentBytes) == (requestSz + bs.Length + 4)); // 4 is for the seq variable size
test((cm2.ReceivedBytes - cm1.ReceivedBytes) == replySz);
test((sm2.ReceivedBytes - sm1.ReceivedBytes) == (requestSz + bs.Length + 4));
test((sm2.SentBytes - sm1.SentBytes) == replySz);
props["IceMX.Metrics.View.Map.Connection.GroupBy"] = "state";
updateProps(clientProps, serverProps, update, props, "Connection");
map = toMap(serverMetrics.GetMetricsView("View").ReturnValue["Connection"]);
test(map["active"].Current == 1);
IControllerPrx controller = IControllerPrx.Parse($"controller:{helper.getTestEndpoint(1)}", communicator);
controller.hold();
map = toMap(clientMetrics.GetMetricsView("View").ReturnValue["Connection"]);
test(map["active"].Current == 1);
map = toMap(serverMetrics.GetMetricsView("View").ReturnValue["Connection"]);
test(map["holding"].Current == 1);
metrics.GetConnection().Close(Ice.ConnectionClose.GracefullyWithWait);
map = toMap(clientMetrics.GetMetricsView("View").ReturnValue["Connection"]);
test(map["closing"].Current == 1);
map = toMap(serverMetrics.GetMetricsView("View").ReturnValue["Connection"]);
test(map["holding"].Current == 1);
controller.resume();
map = toMap(serverMetrics.GetMetricsView("View").ReturnValue["Connection"]);
test(map["holding"].Current == 0);
props["IceMX.Metrics.View.Map.Connection.GroupBy"] = "none";
updateProps(clientProps, serverProps, update, props, "Connection");
metrics.GetConnection().Close(Ice.ConnectionClose.GracefullyWithWait);
metrics.Clone(connectionTimeout: 500).IcePing();
controller.hold();
try
{
metrics.Clone(connectionTimeout: 500).opByteS(new byte[10000000]);
test(false);
}
catch (Ice.TimeoutException)
{
}
controller.resume();
cm1 = (IceMX.ConnectionMetrics)clientMetrics.GetMetricsView("View").ReturnValue["Connection"][0];
while (true)
{
sm1 = (IceMX.ConnectionMetrics)serverMetrics.GetMetricsView("View").ReturnValue["Connection"][0];
if (sm1.Failures >= 2)
{
break;
}
Thread.Sleep(10);
}
test(cm1.Failures == 2 && sm1.Failures >= 2);
checkFailure(clientMetrics, "Connection", cm1.Id, "::Ice::TimeoutException", 1, output);
checkFailure(clientMetrics, "Connection", cm1.Id, "::Ice::ConnectTimeoutException", 1, output);
checkFailure(serverMetrics, "Connection", sm1.Id, "::Ice::ConnectionLostException", 0, output);
IMetricsPrx m = metrics.Clone(connectionTimeout: 500, connectionId: "Con1");
m.IcePing();
testAttribute(clientMetrics, clientProps, update, "Connection", "parent", "Communicator", output);
//testAttribute(clientMetrics, clientProps, update, "Connection", "id", "");
testAttribute(clientMetrics, clientProps, update, "Connection", "endpoint",
endpoint + " -t 500", output);
testAttribute(clientMetrics, clientProps, update, "Connection", "endpointType", type, output);
testAttribute(clientMetrics, clientProps, update, "Connection", "endpointIsDatagram", "False", output);
testAttribute(clientMetrics, clientProps, update, "Connection", "endpointIsSecure", isSecure, output);
testAttribute(clientMetrics, clientProps, update, "Connection", "endpointTimeout", "500", output);
testAttribute(clientMetrics, clientProps, update, "Connection", "endpointCompress", "False", output);
testAttribute(clientMetrics, clientProps, update, "Connection", "endpointHost", host, output);
testAttribute(clientMetrics, clientProps, update, "Connection", "endpointPort", port, output);
testAttribute(clientMetrics, clientProps, update, "Connection", "incoming", "False", output);
testAttribute(clientMetrics, clientProps, update, "Connection", "adapterName", "", output);
testAttribute(clientMetrics, clientProps, update, "Connection", "connectionId", "Con1", output);
testAttribute(clientMetrics, clientProps, update, "Connection", "localHost", host, output);
//testAttribute(clientMetrics, clientProps, update, "Connection", "localPort", "", output);
testAttribute(clientMetrics, clientProps, update, "Connection", "remoteHost", host, output);
testAttribute(clientMetrics, clientProps, update, "Connection", "remotePort", port, output);
testAttribute(clientMetrics, clientProps, update, "Connection", "mcastHost", "", output);
testAttribute(clientMetrics, clientProps, update, "Connection", "mcastPort", "", output);
m.GetConnection().Close(Ice.ConnectionClose.GracefullyWithWait);
waitForCurrent(clientMetrics, "View", "Connection", 0);
waitForCurrent(serverMetrics, "View", "Connection", 0);
output.WriteLine("ok");
output.Write("testing connection establishment metrics... ");
output.Flush();
props["IceMX.Metrics.View.Map.ConnectionEstablishment.GroupBy"] = "id";
updateProps(clientProps, serverProps, update, props, "ConnectionEstablishment");
test(clientMetrics.GetMetricsView("View").ReturnValue["ConnectionEstablishment"].Length == 0);
metrics.IcePing();
test(clientMetrics.GetMetricsView("View").ReturnValue["ConnectionEstablishment"].Length == 1);
IceMX.Metrics m1 = clientMetrics.GetMetricsView("View").ReturnValue["ConnectionEstablishment"][0];
test(m1.Current == 0 && m1.Total == 1 && m1.Id.Equals(hostAndPort));
metrics.GetConnection().Close(Ice.ConnectionClose.GracefullyWithWait);
controller.hold();
try
{
IObjectPrx.Parse($"test:tcp -h 127.0.0.1 -p {port}", communicator).Clone(connectionTimeout: 10).IcePing();
test(false);
}
catch (Ice.ConnectTimeoutException)
{
}
catch (Ice.LocalException)
{
test(false);
}
controller.resume();
test(clientMetrics.GetMetricsView("View").ReturnValue["ConnectionEstablishment"].Length == 1);
m1 = clientMetrics.GetMetricsView("View").ReturnValue["ConnectionEstablishment"][0];
test(m1.Id.Equals(hostAndPort) && m1.Total == 3 && m1.Failures == 2);
checkFailure(clientMetrics, "ConnectionEstablishment", m1.Id, "::Ice::ConnectTimeoutException", 2, output);
System.Action c = () => { connect(metrics); };
testAttribute(clientMetrics, clientProps, update, "ConnectionEstablishment", "parent", "Communicator", c, output);
testAttribute(clientMetrics, clientProps, update, "ConnectionEstablishment", "id", hostAndPort, c, output);
testAttribute(clientMetrics, clientProps, update, "ConnectionEstablishment", "endpoint",
endpoint + " -t " + timeout, c, output);
testAttribute(clientMetrics, clientProps, update, "ConnectionEstablishment", "endpointType", type, c, output);
testAttribute(clientMetrics, clientProps, update, "ConnectionEstablishment", "endpointIsDatagram", "False",
c, output);
testAttribute(clientMetrics, clientProps, update, "ConnectionEstablishment", "endpointIsSecure", isSecure,
c, output);
testAttribute(clientMetrics, clientProps, update, "ConnectionEstablishment", "endpointTimeout", timeout, c, output);
testAttribute(clientMetrics, clientProps, update, "ConnectionEstablishment", "endpointCompress", "False",
c, output);
testAttribute(clientMetrics, clientProps, update, "ConnectionEstablishment", "endpointHost", host, c, output);
testAttribute(clientMetrics, clientProps, update, "ConnectionEstablishment", "endpointPort", port, c, output);
output.WriteLine("ok");
output.Write("testing endpoint lookup metrics... ");
output.Flush();
props["IceMX.Metrics.View.Map.ConnectionEstablishment.GroupBy"] = "id";
updateProps(clientProps, serverProps, update, props, "EndpointLookup");
test(clientMetrics.GetMetricsView("View").ReturnValue["EndpointLookup"].Length == 0);
var prx = IObjectPrx.Parse($"metrics:{protocol} -p {port} -h localhost -t 500", communicator);
try
{
prx.IcePing();
prx.GetConnection().Close(ConnectionClose.GracefullyWithWait);
}
catch (LocalException)
{
}
test(clientMetrics.GetMetricsView("View").ReturnValue["EndpointLookup"].Length == 1);
m1 = clientMetrics.GetMetricsView("View").ReturnValue["EndpointLookup"][0];
test(m1.Current <= 1 && m1.Total == 1);
bool dnsException = false;
try
{
IObjectPrx.Parse($"test:tcp -t 500 -h unknownfoo.zeroc.com -p {port}", communicator).IcePing();
test(false);
}
catch (DNSException)
{
dnsException = true;
}
catch (LocalException)
{
// Some DNS servers don't fail on unknown DNS names.
}
test(clientMetrics.GetMetricsView("View").ReturnValue["EndpointLookup"].Length == 2);
m1 = clientMetrics.GetMetricsView("View").ReturnValue["EndpointLookup"][0];
if (!m1.Id.Equals("tcp -h unknownfoo.zeroc.com -p " + port + " -t 500"))
{
m1 = clientMetrics.GetMetricsView("View").ReturnValue["EndpointLookup"][1];
}
test(m1.Id.Equals("tcp -h unknownfoo.zeroc.com -p " + port + " -t 500") && m1.Total == 2 &&
(!dnsException || m1.Failures == 2));
if (dnsException)
{
checkFailure(clientMetrics, "EndpointLookup", m1.Id, "::Ice::DNSException", 2, output);
}
c = () => { connect(prx); };
testAttribute(clientMetrics, clientProps, update, "EndpointLookup", "parent", "Communicator", c, output);
testAttribute(clientMetrics, clientProps, update, "EndpointLookup", "id",
prx.GetConnection().Endpoint.ToString(), c, output);
testAttribute(clientMetrics, clientProps, update, "EndpointLookup", "endpoint",
prx.GetConnection().Endpoint.ToString(), c, output);
testAttribute(clientMetrics, clientProps, update, "EndpointLookup", "endpointType", type, c, output);
testAttribute(clientMetrics, clientProps, update, "EndpointLookup", "endpointIsDatagram", "False", c, output);
testAttribute(clientMetrics, clientProps, update, "EndpointLookup", "endpointIsSecure", isSecure, c, output);
testAttribute(clientMetrics, clientProps, update, "EndpointLookup", "endpointTimeout", "500", c, output);
testAttribute(clientMetrics, clientProps, update, "EndpointLookup", "endpointCompress", "False", c, output);
testAttribute(clientMetrics, clientProps, update, "EndpointLookup", "endpointHost", "localhost", c, output);
testAttribute(clientMetrics, clientProps, update, "EndpointLookup", "endpointPort", port, c, output);
output.WriteLine("ok");
}
output.Write("testing dispatch metrics... ");
output.Flush();
props["IceMX.Metrics.View.Map.Dispatch.GroupBy"] = "operation";
updateProps(clientProps, serverProps, update, props, "Dispatch");
test(serverMetrics.GetMetricsView("View").ReturnValue["Dispatch"].Length == 0);
metrics.op();
try
{
metrics.opWithUserException();
test(false);
}
catch (UserEx)
{
}
try
{
metrics.opWithRequestFailedException();
test(false);
}
catch (RequestFailedException)
{
}
try
{
metrics.opWithLocalException();
test(false);
}
catch (Ice.LocalException)
{
}
try
{
metrics.opWithUnknownException();
test(false);
}
catch (Ice.UnknownException)
{
}
if (!collocated)
{
try
{
metrics.fail();
test(false);
}
catch (Ice.ConnectionLostException)
{
}
}
map = toMap(serverMetrics.GetMetricsView("View").ReturnValue["Dispatch"]);
test(collocated ? map.Count == 5 : map.Count == 6);
IceMX.DispatchMetrics dm1;
dm1 = (IceMX.DispatchMetrics)map["op"];
test(dm1.Current <= 1 && dm1.Total == 1 && dm1.Failures == 0 && dm1.UserException == 0);
test(dm1.Size == 21 && dm1.ReplySize == 7);
dm1 = (IceMX.DispatchMetrics)map["opWithUserException"];
test(dm1.Current <= 1 && dm1.Total == 1 && dm1.Failures == 0 && dm1.UserException == 1);
test(dm1.Size == 38 && dm1.ReplySize == 23);
dm1 = (IceMX.DispatchMetrics)map["opWithLocalException"];
test(dm1.Current <= 1 && dm1.Total == 1 && dm1.Failures == 1 && dm1.UserException == 0);
checkFailure(serverMetrics, "Dispatch", dm1.Id, "::Ice::SyscallException", 1, output);
test(dm1.Size == 39 && dm1.ReplySize > 7); // Reply contains the exception stack depending on the OS.
dm1 = (IceMX.DispatchMetrics)map["opWithRequestFailedException"];
test(dm1.Current <= 1 && dm1.Total == 1 && dm1.Failures == 1 && dm1.UserException == 0);
checkFailure(serverMetrics, "Dispatch", dm1.Id, "::Ice::ObjectNotExistException", 1, output);
test(dm1.Size == 47 && dm1.ReplySize == 40);
dm1 = (IceMX.DispatchMetrics)map["opWithUnknownException"];
test(dm1.Current <= 1 && dm1.Total == 1 && dm1.Failures == 1 && dm1.UserException == 0);
checkFailure(serverMetrics, "Dispatch", dm1.Id, "System.ArgumentOutOfRangeException", 1, output);
test(dm1.Size == 41 && dm1.ReplySize > 7); // Reply contains the exception stack depending on the OS.
System.Action op = () => { invokeOp(metrics); };
testAttribute(serverMetrics, serverProps, update, "Dispatch", "parent", "TestAdapter", op, output);
testAttribute(serverMetrics, serverProps, update, "Dispatch", "id", "metrics [op]", op, output);
if (!collocated)
{
testAttribute(serverMetrics, serverProps, update, "Dispatch", "endpoint",
endpoint + " -t 60000", op, output);
//testAttribute(serverMetrics, serverProps, update, "Dispatch", "connection", "", op);
testAttribute(serverMetrics, serverProps, update, "Dispatch", "endpointType", type, op, output);
testAttribute(serverMetrics, serverProps, update, "Dispatch", "endpointIsDatagram", "False", op, output);
testAttribute(serverMetrics, serverProps, update, "Dispatch", "endpointIsSecure", isSecure, op, output);
testAttribute(serverMetrics, serverProps, update, "Dispatch", "endpointTimeout", "60000", op, output);
testAttribute(serverMetrics, serverProps, update, "Dispatch", "endpointCompress", "False", op, output);
testAttribute(serverMetrics, serverProps, update, "Dispatch", "endpointHost", host, op, output);
testAttribute(serverMetrics, serverProps, update, "Dispatch", "endpointPort", port, op, output);
testAttribute(serverMetrics, serverProps, update, "Dispatch", "incoming", "True", op, output);
testAttribute(serverMetrics, serverProps, update, "Dispatch", "adapterName", "TestAdapter", op, output);
testAttribute(serverMetrics, serverProps, update, "Dispatch", "connectionId", "", op, output);
testAttribute(serverMetrics, serverProps, update, "Dispatch", "localHost", host, op, output);
testAttribute(serverMetrics, serverProps, update, "Dispatch", "localPort", port, op, output);
testAttribute(serverMetrics, serverProps, update, "Dispatch", "remoteHost", host, op, output);
//testAttribute(serverMetrics, serverProps, update, "Dispatch", "remotePort", port, op, output);
testAttribute(serverMetrics, serverProps, update, "Dispatch", "mcastHost", "", op, output);
testAttribute(serverMetrics, serverProps, update, "Dispatch", "mcastPort", "", op, output);
}
testAttribute(serverMetrics, serverProps, update, "Dispatch", "operation", "op", op, output);
testAttribute(serverMetrics, serverProps, update, "Dispatch", "identity", "metrics", op, output);
testAttribute(serverMetrics, serverProps, update, "Dispatch", "facet", "", op, output);
testAttribute(serverMetrics, serverProps, update, "Dispatch", "mode", "twoway", op, output);
testAttribute(serverMetrics, serverProps, update, "Dispatch", "context.entry1", "test", op, output);
testAttribute(serverMetrics, serverProps, update, "Dispatch", "context.entry2", "", op, output);
testAttribute(serverMetrics, serverProps, update, "Dispatch", "context.entry3", "", op, output);
output.WriteLine("ok");
output.Write("testing invocation metrics... ");
output.Flush();
//
// Tests for twoway
//
props["IceMX.Metrics.View.Map.Invocation.GroupBy"] = "operation";
props["IceMX.Metrics.View.Map.Invocation.Map.Remote.GroupBy"] = "id";
props["IceMX.Metrics.View.Map.Invocation.Map.Collocated.GroupBy"] = "id";
updateProps(clientProps, serverProps, update, props, "Invocation");
test(serverMetrics.GetMetricsView("View").ReturnValue["Invocation"].Length == 0);
metrics.op();
metrics.opAsync().Wait();
try
{
metrics.opWithUserException();
test(false);
}
catch (UserEx)
{
}
try
{
metrics.opWithUserExceptionAsync().Wait();
test(false);
}
catch (System.AggregateException ex)
{
test(ex.InnerException is UserEx);
}
try
{
metrics.opWithRequestFailedException();
test(false);
}
catch (Ice.RequestFailedException)
{
}
try
{
metrics.opWithRequestFailedExceptionAsync().Wait();
test(false);
}
catch (System.AggregateException ex)
{
test(ex.InnerException is Ice.RequestFailedException);
}
try
{
metrics.opWithLocalException();
test(false);
}
catch (Ice.LocalException)
{
}
try
{
metrics.opWithLocalExceptionAsync().Wait();
test(false);
}
catch (System.AggregateException ex)
{
test(ex.InnerException is Ice.LocalException);
}
try
{
metrics.opWithUnknownException();
test(false);
}
catch (Ice.UnknownException)
{
}
try
{
metrics.opWithUnknownExceptionAsync().Wait();
test(false);
}
catch (System.AggregateException ex)
{
test(ex.InnerException is Ice.UnknownException);
}
if (!collocated)
{
try
{
metrics.fail();
test(false);
}
catch (Ice.ConnectionLostException)
{
}
try
{
metrics.failAsync().Wait();
test(false);
}
catch (System.AggregateException ex)
{
test(ex.InnerException is Ice.ConnectionLostException);
}
}
map = toMap(clientMetrics.GetMetricsView("View").ReturnValue["Invocation"]);
test(map.Count == (collocated ? 5 : 6));
IceMX.InvocationMetrics im1;
IceMX.ChildInvocationMetrics rim1;
im1 = (IceMX.InvocationMetrics)map["op"];
test(im1.Current <= 1 && im1.Total == 2 && im1.Failures == 0 && im1.Retry == 0);
test(collocated ? im1.Collocated.Length == 1 : im1.Remotes.Length == 1);
rim1 = (IceMX.ChildInvocationMetrics)(collocated ? im1.Collocated[0] : im1.Remotes[0]);
test(rim1.Current == 0 && rim1.Total == 2 && rim1.Failures == 0);
test(rim1.Size == 42 && rim1.ReplySize == 14);
im1 = (IceMX.InvocationMetrics)map["opWithUserException"];
test(im1.Current <= 1 && im1.Total == 2 && im1.Failures == 0 && im1.Retry == 0);
test(collocated ? im1.Collocated.Length == 1 : im1.Remotes.Length == 1);
rim1 = (IceMX.ChildInvocationMetrics)(collocated ? im1.Collocated[0] : im1.Remotes[0]);
test(rim1.Current == 0 && rim1.Total == 2 && rim1.Failures == 0);
test(rim1.Size == 76 && rim1.ReplySize == 46);
test(im1.UserException == 2);
im1 = (IceMX.InvocationMetrics)map["opWithLocalException"];
test(im1.Current <= 1 && im1.Total == 2 && im1.Failures == 2 && im1.Retry == 0);
test(collocated ? im1.Collocated.Length == 1 : im1.Remotes.Length == 1);
rim1 = (IceMX.ChildInvocationMetrics)(collocated ? im1.Collocated[0] : im1.Remotes[0]);
test(rim1.Current == 0 && rim1.Total == 2 && rim1.Failures == 0);
test(rim1.Size == 78 && rim1.ReplySize > 7);
checkFailure(clientMetrics, "Invocation", im1.Id, "::Ice::UnknownLocalException", 2, output);
im1 = (IceMX.InvocationMetrics)map["opWithRequestFailedException"];
test(im1.Current <= 1 && im1.Total == 2 && im1.Failures == 2 && im1.Retry == 0);
test(collocated ? im1.Collocated.Length == 1 : im1.Remotes.Length == 1);
rim1 = (IceMX.ChildInvocationMetrics)(collocated ? im1.Collocated[0] : im1.Remotes[0]);
test(rim1.Current == 0 && rim1.Total == 2 && rim1.Failures == 0);
test(rim1.Size == 94 && rim1.ReplySize == 80);
checkFailure(clientMetrics, "Invocation", im1.Id, "::Ice::ObjectNotExistException", 2, output);
im1 = (IceMX.InvocationMetrics)map["opWithUnknownException"];
test(im1.Current <= 1 && im1.Total == 2 && im1.Failures == 2 && im1.Retry == 0);
test(collocated ? im1.Collocated.Length == 1 : im1.Remotes.Length == 1);
rim1 = (IceMX.ChildInvocationMetrics)(collocated ? im1.Collocated[0] : im1.Remotes[0]);
test(rim1.Current == 0 && rim1.Total == 2 && rim1.Failures == 0);
test(rim1.Size == 82 && rim1.ReplySize > 7);
checkFailure(clientMetrics, "Invocation", im1.Id, "::Ice::UnknownException", 2, output);
if (!collocated)
{
im1 = (IceMX.InvocationMetrics)map["fail"];
test(im1.Current <= 1 && im1.Total == 2 && im1.Failures == 2 && im1.Retry == 2 && im1.Remotes.Length == 1);
rim1 = (IceMX.ChildInvocationMetrics)(collocated ? im1.Collocated[0] : im1.Remotes[0]);
test(rim1.Current == 0);
test(rim1.Total == 4);
test(rim1.Failures == 4);
checkFailure(clientMetrics, "Invocation", im1.Id, "::Ice::ConnectionLostException", 2, output);
}
testAttribute(clientMetrics, clientProps, update, "Invocation", "parent", "Communicator", op, output);
testAttribute(clientMetrics, clientProps, update, "Invocation", "id", "metrics -t -e 1.1 [op]", op, output);
testAttribute(clientMetrics, clientProps, update, "Invocation", "operation", "op", op, output);
testAttribute(clientMetrics, clientProps, update, "Invocation", "identity", "metrics", op, output);
testAttribute(clientMetrics, clientProps, update, "Invocation", "facet", "", op, output);
testAttribute(clientMetrics, clientProps, update, "Invocation", "encoding", "1.1", op, output);
testAttribute(clientMetrics, clientProps, update, "Invocation", "mode", "twoway", op, output);
testAttribute(clientMetrics, clientProps, update, "Invocation", "proxy",
"metrics -t -e 1.1:" + endpoint + " -t " + timeout, op, output);
testAttribute(clientMetrics, clientProps, update, "Invocation", "context.entry1", "test", op, output);
testAttribute(clientMetrics, clientProps, update, "Invocation", "context.entry2", "", op, output);
testAttribute(clientMetrics, clientProps, update, "Invocation", "context.entry3", "", op, output);
//
// Oneway tests
//
clearView(clientProps, serverProps, update);
props["IceMX.Metrics.View.Map.Invocation.GroupBy"] = "operation";
props["IceMX.Metrics.View.Map.Invocation.Map.Remote.GroupBy"] = "localPort";
updateProps(clientProps, serverProps, update, props, "Invocation");
IMetricsPrx metricsOneway = metrics.Clone(oneway: true);
metricsOneway.op();
metricsOneway.opAsync().Wait();
map = toMap(clientMetrics.GetMetricsView("View").ReturnValue["Invocation"]);
test(map.Count == 1);
im1 = (IceMX.InvocationMetrics)map["op"];
test(im1.Current <= 1 && im1.Total == 2 && im1.Failures == 0 && im1.Retry == 0);
test(collocated ? (im1.Collocated.Length == 1) : (im1.Remotes.Length == 1));
rim1 = (IceMX.ChildInvocationMetrics)(collocated ? im1.Collocated[0] : im1.Remotes[0]);
test(rim1.Current <= 1 && rim1.Total == 2 && rim1.Failures == 0);
test(rim1.Size == 42 && rim1.ReplySize == 0);
testAttribute(clientMetrics, clientProps, update, "Invocation", "mode", "oneway",
() => { invokeOp(metricsOneway); }, output);
output.Write("testing metrics view enable/disable...");
output.Flush();
props["IceMX.Metrics.View.GroupBy"] = "none";
props["IceMX.Metrics.View.Disabled"] = "0";
updateProps(clientProps, serverProps, update, props, "Thread");
test(clientMetrics.GetMetricsView("View").ReturnValue["Thread"].Length != 0);
var(names, disabledViews) = clientMetrics.GetMetricsViewNames();
test(names.Length == 1 && disabledViews.Length == 0);
props["IceMX.Metrics.View.Disabled"] = "1";
updateProps(clientProps, serverProps, update, props, "Thread");
test(!clientMetrics.GetMetricsView("View").ReturnValue.ContainsKey("Thread"));
(names, disabledViews) = clientMetrics.GetMetricsViewNames();
test(names.Length == 0 && disabledViews.Length == 1);
clientMetrics.EnableMetricsView("View");
test(clientMetrics.GetMetricsView("View").ReturnValue["Thread"].Length != 0);
(names, disabledViews) = clientMetrics.GetMetricsViewNames();
test(names.Length == 1 && disabledViews.Length == 0);
clientMetrics.DisableMetricsView("View");
test(!clientMetrics.GetMetricsView("View").ReturnValue.ContainsKey("Thread"));
(names, disabledViews) = clientMetrics.GetMetricsViewNames();
test(names.Length == 0 && disabledViews.Length == 1);
try
{
clientMetrics.EnableMetricsView("UnknownView");
}
catch (IceMX.UnknownMetricsView)
{
}
output.WriteLine("ok");
output.Write("testing instrumentation observer delegate... ");
output.Flush();
test(obsv.threadObserver.getTotal() > 0);
if (!collocated)
{
test(obsv.connectionObserver.getTotal() > 0);
test(obsv.connectionEstablishmentObserver.getTotal() > 0);
test(obsv.endpointLookupObserver.getTotal() > 0);
test(obsv.invocationObserver.remoteObserver.getTotal() > 0);
}
else
{
test(obsv.invocationObserver.collocatedObserver.getTotal() > 0);
}
test(obsv.dispatchObserver.getTotal() > 0);
test(obsv.invocationObserver.getTotal() > 0);
test(obsv.threadObserver.GetCurrent() > 0);
if (!collocated)
{
test(obsv.connectionObserver.GetCurrent() > 0);
test(obsv.connectionEstablishmentObserver.GetCurrent() == 0);
test(obsv.endpointLookupObserver.GetCurrent() == 0);
waitForObserverCurrent(obsv.invocationObserver.remoteObserver, 0);
test(obsv.invocationObserver.remoteObserver.GetCurrent() == 0);
}
else
{
waitForObserverCurrent(obsv.invocationObserver.collocatedObserver, 0);
test(obsv.invocationObserver.collocatedObserver.GetCurrent() == 0);
}
waitForObserverCurrent(obsv.dispatchObserver, 0);
test(obsv.dispatchObserver.GetCurrent() == 0);
waitForObserverCurrent(obsv.invocationObserver, 0);
test(obsv.invocationObserver.GetCurrent() == 0);
test(obsv.threadObserver.GetFailedCount() == 0);
if (!collocated)
{
test(obsv.connectionObserver.GetFailedCount() > 0);
test(obsv.connectionEstablishmentObserver.GetFailedCount() > 0);
test(obsv.endpointLookupObserver.GetFailedCount() > 0);
test(obsv.invocationObserver.remoteObserver.GetFailedCount() > 0);
}
//test(obsv.dispatchObserver.getFailedCount() > 0);
test(obsv.invocationObserver.GetFailedCount() > 0);
if (!collocated)
{
test(obsv.threadObserver.states > 0);
test(obsv.connectionObserver.received > 0 && obsv.connectionObserver.sent > 0);
test(obsv.invocationObserver.retriedCount > 0);
test(obsv.invocationObserver.remoteObserver.replySize > 0);
}
else
{
test(obsv.invocationObserver.collocatedObserver.replySize > 0);
}
//test(obsv.dispatchObserver.userExceptionCount > 0);
test(obsv.invocationObserver.userExceptionCount > 0);
output.WriteLine("ok");
return(metrics);
}
public static async Task RunAsync(TestHelper helper, int num)
{
TextWriter output = helper.Output;
Communicator communicator = helper.Communicator;
var proxies = new List <IControllerPrx>();
var facetedProxies = new List <IControllerPrx>();
var indirectProxies = new List <IControllerPrx>();
bool ice1 = helper.Protocol == Protocol.Ice1;
for (int i = 0; i < num; ++i)
{
proxies.Add(IControllerPrx.Parse(ice1 ? $"controller{i}" : $"ice:controller{i}", communicator));
facetedProxies.Add(IControllerPrx.Parse(
ice1 ? $"faceted-controller{i} -f abc" : $"ice:faceted-controller{i}#abc",
communicator));
indirectProxies.Add(
IControllerPrx.Parse(ice1 ? $"controller{i} @ control{i}" : $"ice:control{i}//controller{i}",
communicator));
}
output.Write("testing indirect proxies... ");
output.Flush();
{
foreach (IControllerPrx prx in indirectProxies)
{
prx.IcePing();
}
}
output.WriteLine("ok");
output.Write("testing well-known proxies... ");
output.Flush();
{
foreach (IControllerPrx prx in proxies)
{
prx.IcePing();
}
}
output.WriteLine("ok");
output.Write("testing faceted well-known proxies... ");
output.Flush();
{
foreach (IControllerPrx prx in facetedProxies)
{
prx.IcePing();
}
}
output.WriteLine("ok");
output.Write("testing object adapter registration... ");
output.Flush();
{
try
{
IObjectPrx.Parse(ice1 ? "object @ oa1" : "ice:oa1//object", communicator).IcePing();
TestHelper.Assert(false);
}
catch (NoEndpointException)
{
}
proxies[0].ActivateObjectAdapter("oa", "oa1", "");
try
{
IObjectPrx.Parse(ice1 ? "object @ oa1" : "ice:oa1//object", communicator).IcePing();
TestHelper.Assert(false);
}
catch (ObjectNotExistException)
{
}
proxies[0].DeactivateObjectAdapter("oa");
try
{
IObjectPrx.Parse(ice1 ? "object @ oa1" : "ice:oa1//object", communicator).IcePing();
TestHelper.Assert(false);
}
catch (NoEndpointException)
{
}
}
output.WriteLine("ok");
output.Write("testing object adapter migration... ");
output.Flush();
{
proxies[0].ActivateObjectAdapter("oa", "oa1", "");
proxies[0].AddObject("oa", "object");
IObjectPrx.Parse(ice1 ? "object @ oa1" : "ice:oa1//object", communicator).IcePing();
proxies[0].RemoveObject("oa", "object");
proxies[0].DeactivateObjectAdapter("oa");
proxies[1].ActivateObjectAdapter("oa", "oa1", "");
proxies[1].AddObject("oa", "object");
IObjectPrx.Parse(ice1 ? "object @ oa1" : "ice:oa1//object", communicator).IcePing();
proxies[1].RemoveObject("oa", "object");
proxies[1].DeactivateObjectAdapter("oa");
}
output.WriteLine("ok");
output.Write("testing object migration... ");
output.Flush();
{
proxies[0].ActivateObjectAdapter("oa", "oa1", "");
proxies[1].ActivateObjectAdapter("oa", "oa2", "");
proxies[0].AddObject("oa", "object");
IObjectPrx.Parse(ice1 ? "object @ oa1" : "ice:oa1//object", communicator).IcePing();
IObjectPrx.Parse(ice1 ? "object" : "ice:object", communicator).IcePing();
proxies[0].RemoveObject("oa", "object");
proxies[1].AddObject("oa", "object");
IObjectPrx.Parse(ice1 ? "object @ oa2" : "ice:oa2//object", communicator).IcePing();
IObjectPrx.Parse(ice1 ? "object" : "ice:object", communicator).IcePing();
proxies[1].RemoveObject("oa", "object");
try
{
IObjectPrx.Parse(ice1 ? "object @ oa1" : "ice:oa1//object", communicator).IcePing();
}
catch (ObjectNotExistException)
{
}
try
{
IObjectPrx.Parse(ice1 ? "object @ oa2" : "ice:oa2//object", communicator).IcePing();
}
catch (ObjectNotExistException)
{
}
proxies[0].DeactivateObjectAdapter("oa");
proxies[1].DeactivateObjectAdapter("oa");
}
output.WriteLine("ok");
output.Write("testing replica groups... ");
output.Flush();
{
proxies[0].ActivateObjectAdapter("oa", "oa1", "rg");
proxies[1].ActivateObjectAdapter("oa", "oa2", "rg");
proxies[2].ActivateObjectAdapter("oa", "oa3", "rg");
proxies[0].AddObject("oa", "object");
proxies[1].AddObject("oa", "object");
proxies[2].AddObject("oa", "object");
IObjectPrx.Parse(ice1 ? "object @ oa1" : "ice:oa1//object", communicator).IcePing();
IObjectPrx.Parse(ice1 ? "object @ oa2" : "ice:oa2//object", communicator).IcePing();
IObjectPrx.Parse(ice1 ? "object @ oa3" : "ice:oa3//object", communicator).IcePing();
IObjectPrx.Parse(ice1 ? "object @ rg" : "ice:rg//object", communicator).IcePing();
var adapterIds = new List <string>
{
"oa1",
"oa2",
"oa3"
};
// Check that the well known object is reachable with all replica group members
ITestIntfPrx intf = ITestIntfPrx.Parse(ice1 ? "object" : "ice:object", communicator).Clone(
cacheConnection: false,
preferExistingConnection: false,
locatorCacheTimeout: TimeSpan.Zero);
while (adapterIds.Count > 0)
{
string id = intf.GetAdapterId();
adapterIds.Remove(id);
switch (id)
{
case "oa1":
{
proxies[0].DeactivateObjectAdapter("oa");
break;
}
case "oa2":
{
proxies[1].DeactivateObjectAdapter("oa");
break;
}
case "oa3":
{
proxies[2].DeactivateObjectAdapter("oa");
break;
}
}
}
proxies[0].ActivateObjectAdapter("oa", "oa1", "rg");
proxies[1].ActivateObjectAdapter("oa", "oa2", "rg");
proxies[2].ActivateObjectAdapter("oa", "oa3", "rg");
proxies[0].AddObject("oa", "object");
proxies[1].AddObject("oa", "object");
proxies[2].AddObject("oa", "object");
IObjectPrx.Parse(ice1 ? "object @ oa1" : "ice:oa1//object", communicator).IcePing();
IObjectPrx.Parse(ice1 ? "object @ oa2" : "ice:oa2//object", communicator).IcePing();
IObjectPrx.Parse(ice1 ? "object @ oa3" : "ice:oa3//object", communicator).IcePing();
IObjectPrx.Parse(ice1 ? "object @ rg" : "ice:rg//object", communicator).IcePing();
adapterIds = new List <string>
{
"oa1",
"oa2",
"oa3"
};
// Check that the indirect reference is reachable with all replica group members
intf = ITestIntfPrx.Parse(ice1 ? "object @ rg" : "ice:rg//object", communicator).Clone(
cacheConnection: false,
preferExistingConnection: false,
locatorCacheTimeout: TimeSpan.Zero);
while (adapterIds.Count > 0)
{
var id = intf.GetAdapterId();
adapterIds.Remove(id);
switch (id)
{
case "oa1":
{
proxies[0].DeactivateObjectAdapter("oa");
break;
}
case "oa2":
{
proxies[1].DeactivateObjectAdapter("oa");
break;
}
case "oa3":
{
proxies[2].DeactivateObjectAdapter("oa");
break;
}
}
}
}
output.WriteLine("ok");
output.Write("testing invalid lookup endpoints... ");
output.Flush();
{
string multicast;
if (helper.Host.Contains(":"))
{
multicast = "\"ff15::1\"";
}
else
{
multicast = "239.255.0.1";
}
{
Dictionary <string, string> properties = communicator.GetProperties();
properties["Ice.Discovery.Lookup"] = $"udp -h {multicast} --interface unknown";
await using var comm = new Communicator(properties);
TestHelper.Assert(comm.DefaultLocator != null);
try
{
IObjectPrx.Parse(ice1 ? "controller0@control0" : "ice:control0//controller0", comm).IcePing();
TestHelper.Assert(false);
}
catch
{
}
}
{
Dictionary <string, string> properties = communicator.GetProperties();
string port = $"{helper.BasePort + 10}";
string intf = helper.Host.Contains(":") ? $"\"{helper.Host}\"" : helper.Host;
string lookup = $"udp -h {multicast} --interface unknown:udp -h {multicast} -p {port}";
if (!OperatingSystem.IsLinux())
{
lookup += " --interface {intf}";
}
await using var comm = new Communicator(properties);
TestHelper.Assert(comm.DefaultLocator != null);
IObjectPrx.Parse(ice1 ? "controller0@control0" : "ice:control0//controller0", comm).IcePing();
}
}
output.WriteLine("ok");
output.Write("shutting down... ");
output.Flush();
foreach (IControllerPrx prx in proxies)
{
await prx.ShutdownAsync();
}
output.WriteLine("ok");
}
public static void Run(TestHelper helper, int num)
{
TextWriter output = helper.Output;
Communicator?communicator = helper.Communicator;
TestHelper.Assert(communicator != null);
var proxies = new List <IControllerPrx>();
var indirectProxies = new List <IControllerPrx>();
bool ice1 = helper.Protocol == Protocol.Ice1;
for (int i = 0; i < num; ++i)
{
proxies.Add(IControllerPrx.Parse(ice1 ? $"controller{i}" : $"ice:controller{i}", communicator));
indirectProxies.Add(
IControllerPrx.Parse(ice1 ? $"controller{i} @ control{i}" : $"ice:control{i}//controller{i}",
communicator));
}
output.Write("testing indirect proxies... ");
output.Flush();
{
foreach (IControllerPrx prx in indirectProxies)
{
prx.IcePing();
}
}
output.WriteLine("ok");
output.Write("testing well-known proxies... ");
output.Flush();
{
foreach (IControllerPrx prx in proxies)
{
prx.IcePing();
}
}
output.WriteLine("ok");
output.Write("testing object adapter registration... ");
output.Flush();
{
try
{
IObjectPrx.Parse(ice1 ? "object @ oa1" : "ice:oa1//object", communicator).IcePing();
TestHelper.Assert(false);
}
catch (NoEndpointException)
{
}
proxies[0].ActivateObjectAdapter("oa", "oa1", "");
try
{
IObjectPrx.Parse(ice1 ? "object @ oa1" : "ice:oa1//object", communicator).IcePing();
TestHelper.Assert(false);
}
catch (ObjectNotExistException)
{
}
proxies[0].DeactivateObjectAdapter("oa");
try
{
IObjectPrx.Parse(ice1 ? "object @ oa1" : "ice:oa1//object", communicator).IcePing();
TestHelper.Assert(false);
}
catch (NoEndpointException)
{
}
}
output.WriteLine("ok");
output.Write("testing object adapter migration...");
output.Flush();
{
proxies[0].ActivateObjectAdapter("oa", "oa1", "");
proxies[0].AddObject("oa", "object");
IObjectPrx.Parse(ice1 ? "object @ oa1" : "ice:oa1//object", communicator).IcePing();
proxies[0].RemoveObject("oa", "object");
proxies[0].DeactivateObjectAdapter("oa");
proxies[1].ActivateObjectAdapter("oa", "oa1", "");
proxies[1].AddObject("oa", "object");
IObjectPrx.Parse(ice1 ? "object @ oa1" : "ice:oa1//object", communicator).IcePing();
proxies[1].RemoveObject("oa", "object");
proxies[1].DeactivateObjectAdapter("oa");
}
output.WriteLine("ok");
output.Write("testing object migration...");
output.Flush();
{
proxies[0].ActivateObjectAdapter("oa", "oa1", "");
proxies[1].ActivateObjectAdapter("oa", "oa2", "");
proxies[0].AddObject("oa", "object");
IObjectPrx.Parse(ice1 ? "object @ oa1" : "ice:oa1//object", communicator).IcePing();
IObjectPrx.Parse("object", communicator).IcePing();
proxies[0].RemoveObject("oa", "object");
proxies[1].AddObject("oa", "object");
IObjectPrx.Parse(ice1 ? "object @ oa2" : "ice:oa2//object", communicator).IcePing();
IObjectPrx.Parse("object", communicator).IcePing();
proxies[1].RemoveObject("oa", "object");
try
{
IObjectPrx.Parse(ice1 ? "object @ oa1" : "ice:oa1//object", communicator).IcePing();
}
catch (ObjectNotExistException)
{
}
try
{
IObjectPrx.Parse(ice1 ? "object @ oa2" : "ice:oa2//object", communicator).IcePing();
}
catch (ObjectNotExistException)
{
}
proxies[0].DeactivateObjectAdapter("oa");
proxies[1].DeactivateObjectAdapter("oa");
}
output.WriteLine("ok");
output.Write("testing replica groups...");
output.Flush();
{
proxies[0].ActivateObjectAdapter("oa", "oa1", "rg");
proxies[1].ActivateObjectAdapter("oa", "oa2", "rg");
proxies[2].ActivateObjectAdapter("oa", "oa3", "rg");
proxies[0].AddObject("oa", "object");
proxies[1].AddObject("oa", "object");
proxies[2].AddObject("oa", "object");
IObjectPrx.Parse(ice1 ? "object @ oa1" : "ice:oa1//object", communicator).IcePing();
IObjectPrx.Parse(ice1 ? "object @ oa2" : "ice:oa2//object", communicator).IcePing();
IObjectPrx.Parse(ice1 ? "object @ oa3" : "ice:oa3//object", communicator).IcePing();
IObjectPrx.Parse(ice1 ? "object @ rg" : "ice:rg//object", communicator).IcePing();
var adapterIds = new List <string>
{
"oa1",
"oa2",
"oa3"
};
ITestIntfPrx intf = ITestIntfPrx.Parse(ice1 ? "object" : "ice:object", communicator).Clone(
cacheConnection: false,
locatorCacheTimeout: TimeSpan.Zero);
while (adapterIds.Count > 0)
{
adapterIds.Remove(intf.GetAdapterId());
}
while (true)
{
adapterIds.Add("oa1");
adapterIds.Add("oa2");
adapterIds.Add("oa3");
intf = ITestIntfPrx.Parse(ice1 ? "object @ rg" : "ice:rg//object", communicator).Clone(
cacheConnection: false);
int nRetry = 100;
while (adapterIds.Count > 0 && --nRetry > 0)
{
adapterIds.Remove(intf.GetAdapterId());
}
if (nRetry > 0)
{
break;
}
// The previous locator lookup probably didn't return all the replicas... try again.
IObjectPrx.Parse("object @ rg", communicator).Clone(locatorCacheTimeout: TimeSpan.Zero).IcePing();
}
proxies[0].DeactivateObjectAdapter("oa");
proxies[1].DeactivateObjectAdapter("oa");
TestHelper.Assert(
ITestIntfPrx.Parse(
ice1 ? "object @ rg" : "ice:rg//object", communicator).GetAdapterId().Equals("oa3"));
proxies[2].DeactivateObjectAdapter("oa");
proxies[0].ActivateObjectAdapter("oa", "oa1", "rg");
proxies[0].AddObject("oa", "object");
TestHelper.Assert(
ITestIntfPrx.Parse(
ice1 ? "object @ rg" : "ice:rg//object", communicator).GetAdapterId().Equals("oa1"));
proxies[0].DeactivateObjectAdapter("oa");
}
output.WriteLine("ok");
output.Write("testing invalid lookup endpoints... ");
output.Flush();
{
string multicast;
if (communicator.GetProperty("Ice.IPv6") == "1")
{
multicast = "\"ff15::1\"";
}
else
{
multicast = "239.255.0.1";
}
{
Dictionary <string, string> properties = communicator.GetProperties();
properties["IceDiscovery.Lookup"] = $"udp -h {multicast} --interface unknown";
using var comm = new Communicator(properties);
TestHelper.Assert(comm.DefaultLocator != null);
try
{
IObjectPrx.Parse("controller0@control0", comm).IcePing();
TestHelper.Assert(false);
}
catch
{
}
}
{
Dictionary <string, string> properties = communicator.GetProperties();
string intf = communicator.GetProperty("IceDiscovery.Interface") ?? "";
if (intf.Length > 0)
{
intf = $" --interface \"{intf}\"";
}
string port = communicator.GetProperty("IceDiscovery.Port") ?? "";
properties["IceDiscovery.Lookup"] =
$"udp -h {multicast} --interface unknown:udp -h {multicast} -p {port}{intf}";
using var comm = new Communicator(properties);
TestHelper.Assert(comm.DefaultLocator != null);
IObjectPrx.Parse("controller0@control0", comm).IcePing();
}
}
output.WriteLine("ok");
output.Write("shutting down... ");
output.Flush();
foreach (IControllerPrx prx in proxies)
{
prx.Shutdown();
}
output.WriteLine("ok");
}
public static async Task RunWithControllerAsync(TestHelper helper, IControllerPrx controller)
{
Communicator communicator = helper.Communicator;
bool ice1 = TestHelper.GetTestProtocol(communicator.GetProperties()) == Protocol.Ice1;
var timeout = ITimeoutPrx.Parse(helper.GetTestProxy("timeout", 0), communicator);
System.IO.TextWriter output = helper.Output;
output.Write("testing connect timeout... ");
output.Flush();
{
Dictionary <string, string> properties = communicator.GetProperties();
properties["Ice.ConnectTimeout"] = "100ms";
await using var comm = new Communicator(properties);
var to = ITimeoutPrx.Parse(helper.GetTestProxy("timeout", 0), comm);
// Expect ConnectTimeoutException.
controller.HoldAdapter(-1);
try
{
to.Op();
TestHelper.Assert(false);
}
catch (ConnectTimeoutException)
{
// Expected.
}
controller.ResumeAdapter();
timeout.Op(); // Ensure adapter is active.
}
{
// Expect success.
controller.HoldAdapter(100);
timeout.Op();
}
output.WriteLine("ok");
output.Write("testing invocation timeout... ");
output.Flush();
{
timeout.IcePing(); // Makes sure a working connection is associated with the proxy
Connection connection = await timeout.GetConnectionAsync();
try
{
timeout.Clone(invocationTimeout: TimeSpan.FromMilliseconds(100)).SleepAsync(1000).Wait();
TestHelper.Assert(false);
}
catch (AggregateException ex) when(ex.InnerException is OperationCanceledException)
{
}
timeout.IcePing();
TestHelper.Assert(connection == await timeout.GetConnectionAsync());
try
{
timeout.Clone(invocationTimeout: TimeSpan.FromMilliseconds(1000)).SleepAsync(100).Wait();
}
catch (AggregateException ex) when(ex.InnerException is OperationCanceledException)
{
TestHelper.Assert(false);
}
TestHelper.Assert(connection == await timeout.GetConnectionAsync());
try
{
timeout.Clone(invocationTimeout: TimeSpan.FromMilliseconds(100)).Sleep(1000);
TestHelper.Assert(false);
}
catch (OperationCanceledException)
{
}
}
output.WriteLine("ok");
output.Write("testing close timeout... ");
output.Flush();
{
Dictionary <string, string> properties = communicator.GetProperties();
properties["Ice.CloseTimeout"] = "100ms";
await using var comm = new Communicator(properties);
var to = ITimeoutPrx.Parse(helper.GetTestProxy("timeout", 0), comm);
Connection connection = await to.GetConnectionAsync();
Connection connection2 = await timeout.GetConnectionAsync(); // No close timeout
TestHelper.Assert(connection != null && connection2 != null);
controller.HoldAdapter(-1);
// Make sure there's no ReadAsync pending
_ = to.IcePingAsync();
_ = timeout.IcePingAsync();
var semaphore = new System.Threading.SemaphoreSlim(0);
connection.Closed += (sender, args) => semaphore.Release();
_ = connection.GoAwayAsync();
TestHelper.Assert(semaphore.Wait(500));
connection2.Closed += (sender, args) => semaphore.Release();
_ = connection2.GoAwayAsync();
TestHelper.Assert(!semaphore.Wait(500));
controller.ResumeAdapter();
timeout.Op(); // Ensure adapter is active.
}
output.WriteLine("ok");
if (!ice1)
{
output.Write("testing deadlines... ");
output.Flush();
{
var comm1 = new Communicator(communicator.GetProperties());
comm1.DefaultInvocationInterceptors = ImmutableList.Create <InvocationInterceptor>(
(target, request, next, cancel) =>
{
request.BinaryContextOverride.Add(10, ostr =>
{
var deadline = (request.Deadline - DateTime.UnixEpoch).TotalMilliseconds;
ostr.WriteVarLong((long)deadline);
});
return(next(target, request, cancel));
});
for (int i = 1000; i < 5000;)
{
i += 33;
ITimeoutPrx to = ITimeoutPrx.Parse(helper.GetTestProxy("timeout", 0), comm1).Clone(
invocationTimeout: TimeSpan.FromMilliseconds(i));
TestHelper.Assert(to.CheckDeadline());
}
}
output.WriteLine("ok");
}
controller.Shutdown();
}
public static void RunWithController(TestHelper helper, IControllerPrx controller)
{
Communicator?communicator = helper.Communicator;
TestHelper.Assert(communicator != null);
bool ice1 = TestHelper.GetTestProtocol(communicator.GetProperties()) == Protocol.Ice1;
var timeout = ITimeoutPrx.Parse(helper.GetTestProxy("timeout", 0), communicator);
System.IO.TextWriter output = helper.Output;
output.Write("testing connect timeout... ");
output.Flush();
{
Dictionary <string, string>?properties = communicator.GetProperties();
properties["Ice.ConnectTimeout"] = "100ms";
using var comm = new Communicator(properties);
var to = ITimeoutPrx.Parse(helper.GetTestProxy("timeout", 0), comm);
// Expect ConnectTimeoutException.
controller.HoldAdapter(-1);
try
{
to.Op();
TestHelper.Assert(false);
}
catch (ConnectTimeoutException)
{
// Expected.
}
controller.ResumeAdapter();
timeout.Op(); // Ensure adapter is active.
}
{
// Expect success.
controller.HoldAdapter(100);
timeout.Op();
}
output.WriteLine("ok");
// The sequence needs to be large enough to fill the write/recv buffers
byte[] seq = new byte[2000000];
output.Write("testing connection timeout... ");
output.Flush();
{
// Expect TimeoutException.
controller.HoldAdapter(-1);
timeout.GetConnection().Acm = new Acm(TimeSpan.FromMilliseconds(50),
AcmClose.OnInvocationAndIdle,
AcmHeartbeat.Off);
try
{
timeout.SendData(seq);
TestHelper.Assert(false);
}
catch (ConnectionClosedException)
{
// Expected.
}
controller.ResumeAdapter();
timeout.Op(); // Ensure adapter is active.
}
{
// Expect success.
controller.HoldAdapter(100);
try
{
timeout.SendData(new byte[1000000]);
}
catch (ConnectionClosedException)
{
TestHelper.Assert(false);
}
}
output.WriteLine("ok");
output.Write("testing invocation timeout... ");
output.Flush();
{
timeout.IcePing(); // Makes sure a working connection is associated with the proxy
Connection?connection = timeout.GetConnection();
try
{
timeout.Clone(invocationTimeout: TimeSpan.FromMilliseconds(100)).SleepAsync(1000).Wait();
TestHelper.Assert(false);
}
catch (AggregateException ex) when(ex.InnerException is OperationCanceledException)
{
}
timeout.IcePing();
TestHelper.Assert(connection == timeout.GetConnection());
try
{
timeout.Clone(invocationTimeout: TimeSpan.FromMilliseconds(1000)).SleepAsync(100).Wait();
}
catch (AggregateException ex) when(ex.InnerException is OperationCanceledException)
{
TestHelper.Assert(false);
}
TestHelper.Assert(connection == timeout.GetConnection());
}
output.WriteLine("ok");
output.Write("testing close timeout... ");
output.Flush();
{
Dictionary <string, string> properties = communicator.GetProperties();
properties["Ice.CloseTimeout"] = "100ms";
using var comm = new Communicator(properties);
var to = ITimeoutPrx.Parse(helper.GetTestProxy("timeout", 0), comm);
Connection?connection = to.GetConnection();
Connection?connection2 = timeout.GetConnection(); // No close timeout
TestHelper.Assert(connection != null && connection2 != null);
controller.HoldAdapter(-1);
// Make sure there's no ReadAsync pending
_ = to.IcePingAsync();
_ = timeout.IcePingAsync();
var semaphore = new System.Threading.SemaphoreSlim(0);
connection.Closed += (sender, args) => semaphore.Release();
connection.GoAwayAsync();
TestHelper.Assert(semaphore.Wait(500));
connection2.Closed += (sender, args) => semaphore.Release();
connection2.GoAwayAsync();
TestHelper.Assert(!semaphore.Wait(500));
controller.ResumeAdapter();
timeout.Op(); // Ensure adapter is active.
}
output.WriteLine("ok");
output.Write("testing invocation timeouts with collocated calls... ");
output.Flush();
{
communicator.SetProperty("TimeoutCollocated.AdapterId", "timeoutAdapter");
ObjectAdapter adapter = communicator.CreateObjectAdapter("TimeoutCollocated");
adapter.Activate();
ITimeoutPrx proxy = adapter.AddWithUUID(new Timeout(), ITimeoutPrx.Factory);
try
{
proxy.Clone(invocationTimeout: TimeSpan.FromMilliseconds(100)).SleepAsync(500).Wait();
TestHelper.Assert(false);
}
catch (AggregateException ex) when(ex.InnerException is OperationCanceledException)
{
}
adapter.Dispose();
}
output.WriteLine("ok");
if (!ice1)
{
output.Write("testing deadlines... ");
output.Flush();
{
var comm1 = new Communicator(
communicator.GetProperties(),
invocationInterceptors: new InvocationInterceptor[]
{
(target, request, next, cancel) =>
{
request.AddBinaryContextEntry(10, request.Deadline, (ostr, value) =>
{
var deadline = (value - DateTime.UnixEpoch).TotalMilliseconds;
ostr.WriteVarLong((long)deadline);
});
return(next(target, request, cancel));
}
});
for (int i = 1000; i < 5000;)
{
i += 33;
ITimeoutPrx to = ITimeoutPrx.Parse(helper.GetTestProxy("timeout", 0), comm1).Clone(
invocationTimeout: TimeSpan.FromMilliseconds(i));
TestHelper.Assert(to.CheckDeadline());
}
}
output.WriteLine("ok");
}
controller.Shutdown();
}
public static void Run(TestHelper helper, int num)
{
TextWriter output = helper.Output;
Communicator?communicator = helper.Communicator;
TestHelper.Assert(communicator != null);
var proxies = new List <IControllerPrx>();
var facetedProxies = new List <IControllerPrx>();
var indirectProxies = new List <IControllerPrx>();
bool ice1 = helper.Protocol == Protocol.Ice1;
for (int i = 0; i < num; ++i)
{
proxies.Add(IControllerPrx.Parse(ice1 ? $"controller{i}" : $"ice:controller{i}", communicator));
facetedProxies.Add(IControllerPrx.Parse(
ice1 ? $"faceted-controller{i} -f abc" : $"ice:faceted-controller{i}#abc",
communicator));
indirectProxies.Add(
IControllerPrx.Parse(ice1 ? $"controller{i} @ control{i}" : $"ice:control{i}//controller{i}",
communicator));
}
output.Write("testing indirect proxies... ");
output.Flush();
{
foreach (IControllerPrx prx in indirectProxies)
{
prx.IcePing();
}
}
output.WriteLine("ok");
output.Write("testing well-known proxies... ");
output.Flush();
{
foreach (IControllerPrx prx in proxies)
{
prx.IcePing();
}
}
output.WriteLine("ok");
output.Write("testing faceted well-known proxies... ");
output.Flush();
{
foreach (IControllerPrx prx in facetedProxies)
{
prx.IcePing();
}
}
output.WriteLine("ok");
output.Write("testing object adapter registration... ");
output.Flush();
{
try
{
IObjectPrx.Parse(ice1 ? "object @ oa1" : "ice:oa1//object", communicator).IcePing();
TestHelper.Assert(false);
}
catch (NoEndpointException)
{
}
proxies[0].ActivateObjectAdapter("oa", "oa1", "");
try
{
IObjectPrx.Parse(ice1 ? "object @ oa1" : "ice:oa1//object", communicator).IcePing();
TestHelper.Assert(false);
}
catch (ObjectNotExistException)
{
}
proxies[0].DeactivateObjectAdapter("oa");
try
{
IObjectPrx.Parse(ice1 ? "object @ oa1" : "ice:oa1//object", communicator).IcePing();
TestHelper.Assert(false);
}
catch (NoEndpointException)
{
}
}
output.WriteLine("ok");
output.Write("testing object adapter migration... ");
output.Flush();
{
proxies[0].ActivateObjectAdapter("oa", "oa1", "");
proxies[0].AddObject("oa", "object");
IObjectPrx.Parse(ice1 ? "object @ oa1" : "ice:oa1//object", communicator).IcePing();
proxies[0].RemoveObject("oa", "object");
proxies[0].DeactivateObjectAdapter("oa");
proxies[1].ActivateObjectAdapter("oa", "oa1", "");
proxies[1].AddObject("oa", "object");
IObjectPrx.Parse(ice1 ? "object @ oa1" : "ice:oa1//object", communicator).IcePing();
proxies[1].RemoveObject("oa", "object");
proxies[1].DeactivateObjectAdapter("oa");
}
output.WriteLine("ok");
output.Write("testing object migration... ");
output.Flush();
{
proxies[0].ActivateObjectAdapter("oa", "oa1", "");
proxies[1].ActivateObjectAdapter("oa", "oa2", "");
proxies[0].AddObject("oa", "object");
IObjectPrx.Parse(ice1 ? "object @ oa1" : "ice:oa1//object", communicator).IcePing();
IObjectPrx.Parse(ice1 ? "object" : "ice:object", communicator).IcePing();
proxies[0].RemoveObject("oa", "object");
proxies[1].AddObject("oa", "object");
IObjectPrx.Parse(ice1 ? "object @ oa2" : "ice:oa2//object", communicator).IcePing();
if (ice1)
{
// TODO: this currently does not work with ice2 because the previous object (in oa1) is still in
// the cache and we don't retry on ONE.
IObjectPrx.Parse("object", communicator).IcePing();
}
proxies[1].RemoveObject("oa", "object");
try
{
IObjectPrx.Parse(ice1 ? "object @ oa1" : "ice:oa1//object", communicator).IcePing();
}
catch (ObjectNotExistException)
{
}
try
{
IObjectPrx.Parse(ice1 ? "object @ oa2" : "ice:oa2//object", communicator).IcePing();
}
catch (ObjectNotExistException)
{
}
proxies[0].DeactivateObjectAdapter("oa");
proxies[1].DeactivateObjectAdapter("oa");
}
output.WriteLine("ok");
output.Write("testing replica groups... ");
output.Flush();
{
proxies[0].ActivateObjectAdapter("oa", "oa1", "rg");
proxies[1].ActivateObjectAdapter("oa", "oa2", "rg");
proxies[2].ActivateObjectAdapter("oa", "oa3", "rg");
proxies[0].AddObject("oa", "object");
proxies[1].AddObject("oa", "object");
proxies[2].AddObject("oa", "object");
IObjectPrx.Parse(ice1 ? "object @ oa1" : "ice:oa1//object", communicator).IcePing();
IObjectPrx.Parse(ice1 ? "object @ oa2" : "ice:oa2//object", communicator).IcePing();
IObjectPrx.Parse(ice1 ? "object @ oa3" : "ice:oa3//object", communicator).IcePing();
IObjectPrx.Parse(ice1 ? "object @ rg" : "ice:rg//object", communicator).IcePing();
var adapterIds = new List <string>
{
"oa1",
"oa2",
"oa3"
};
ITestIntfPrx intf = ITestIntfPrx.Parse(ice1 ? "object" : "ice:object", communicator).Clone(
cacheConnection: false,
locatorCacheTimeout: TimeSpan.Zero);
while (adapterIds.Count > 0)
{
adapterIds.Remove(intf.GetAdapterId());
}
// TODO: describe what this test is testing and make sure it does not hang forever!
while (true)
{
adapterIds.Add("oa1");
adapterIds.Add("oa2");
adapterIds.Add("oa3");
intf = ITestIntfPrx.Parse(ice1 ? "object @ rg" : "ice:rg//object", communicator).Clone(
cacheConnection: false,
locatorCacheTimeout: TimeSpan.Zero);
int nRetry = 100;
while (adapterIds.Count > 0 && --nRetry > 0)
{
adapterIds.Remove(intf.GetAdapterId());
}
if (nRetry > 0)
{
break;
}
adapterIds.Clear();
}
proxies[0].DeactivateObjectAdapter("oa");
proxies[1].DeactivateObjectAdapter("oa");
TestHelper.Assert(
ITestIntfPrx.Parse(
ice1 ? "object @ rg" : "ice:rg//object", communicator).GetAdapterId().Equals("oa3"));
proxies[2].DeactivateObjectAdapter("oa");
proxies[0].ActivateObjectAdapter("oa", "oa1", "rg");
proxies[0].AddObject("oa", "object");
TestHelper.Assert(
ITestIntfPrx.Parse(
ice1 ? "object @ rg" : "ice:rg//object", communicator).GetAdapterId().Equals("oa1"));
proxies[0].DeactivateObjectAdapter("oa");
}
output.WriteLine("ok");
output.Write("testing invalid lookup endpoints... ");
output.Flush();
{
string multicast;
if (helper.Host.Contains(":"))
{
multicast = "\"ff15::1\"";
}
else
{
multicast = "239.255.0.1";
}
{
Dictionary <string, string> properties = communicator.GetProperties();
properties["IceDiscovery.Lookup"] = $"udp -h {multicast} --interface unknown";
using var comm = new Communicator(properties);
TestHelper.Assert(comm.DefaultLocator != null);
try
{
IObjectPrx.Parse(ice1 ? "controller0@control0" : "ice:control0//controller0", comm).IcePing();
TestHelper.Assert(false);
}
catch
{
}
}
{
Dictionary <string, string> properties = communicator.GetProperties();
string port = $"{helper.BasePort + 10}";
string intf = helper.Host.Contains(":") ? $"\"{helper.Host}\"" : helper.Host;
properties["IceDiscovery.Lookup"] =
$"udp -h {multicast} --interface unknown:udp -h {multicast} -p {port} --interface {intf}";
using var comm = new Communicator(properties);
TestHelper.Assert(comm.DefaultLocator != null);
IObjectPrx.Parse(ice1 ? "controller0@control0" : "ice:control0//controller0", comm).IcePing();
}
}
output.WriteLine("ok");
output.Write("shutting down... ");
output.Flush();
foreach (IControllerPrx prx in proxies)
{
prx.Shutdown();
}
output.WriteLine("ok");
}
