public override void Run(string[] args)
{
Dictionary <string, string> properties = CreateTestProperties(ref args);
properties["Ice.Admin.Endpoints"] = "tcp";
properties["Ice.Admin.InstanceName"] = "server";
properties["Ice.Warn.Connections"] = "0";
properties["Ice.Warn.Dispatch"] = "0";
properties["Ice.MessageSizeMax"] = "50000";
properties["Ice.Default.Host"] = "127.0.0.1";
using Ice.Communicator communicator = Initialize(properties);
communicator.SetProperty("TestAdapter.Endpoints", GetTestEndpoint(0));
communicator.SetProperty("TestAdapter.ThreadPool.SizeMax",
communicator.GetProperty("Ice.ThreadPool.Server.SizeMax") ?? "");
communicator.SetProperty("ControllerAdapter.Endpoints", GetTestEndpoint(1));
Ice.ObjectAdapter controllerAdapter = communicator.CreateObjectAdapter("ControllerAdapter");
controllerAdapter.Add("controller", new Controller(() => {
Ice.ObjectAdapter adapter = communicator.CreateObjectAdapter("TestAdapter");
adapter.Add("metrics", new Metrics());
return(adapter);
}));
controllerAdapter.Activate();
communicator.WaitForShutdown();
}
internal HelperThread(Communicator communicator)
{
_communicator = communicator;
string name = communicator.GetProperty("Ice.ProgramName") ?? "";
if (name.Length > 0)
{
name += "-";
}
name += "Ice.HostResolver";
_thread = new Thread(new ThreadStart(Run));
_thread.IsBackground = true;
_thread.Name = name;
}
public LookupI(LocatorRegistryI registry, LookupPrx lookup, Ice.Communicator communicator)
{
_registry = registry;
_lookup = lookup;
_timeout = communicator.GetPropertyAsInt("IceDiscovery.Timeout") ?? 300;
_retryCount = communicator.GetPropertyAsInt("IceDiscovery.RetryCount") ?? 3;
_latencyMultiplier = communicator.GetPropertyAsInt("IceDiscovery.LatencyMultiplier") ?? 1;
_domainId = communicator.GetProperty("IceDiscovery.DomainId") ?? "";
_timer = lookup.Communicator.timer();
//
// Create one lookup proxy per endpoint from the given proxy. We want to send a multicast
// datagram on each endpoint.
//
var single = new Ice.Endpoint[1];
foreach (var endpt in lookup.Endpoints)
{
single[0] = endpt;
_lookups[lookup.Clone(endpoints: single)] = null;
}
Debug.Assert(_lookups.Count > 0);
}
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");
}
internal void Initialize()
{
if (_initialized)
{
return;
}
Ice.Communicator ic = Communicator();
//
// Check for a default directory. We look in this directory for
// files mentioned in the configuration.
//
_defaultDir = ic.GetProperty("IceSSL.DefaultDir") ?? "";
string certStoreLocation = ic.GetProperty("IceSSL.CertStoreLocation") ?? "CurrentUser";
StoreLocation storeLocation;
if (certStoreLocation == "CurrentUser")
{
storeLocation = StoreLocation.CurrentUser;
}
else if (certStoreLocation == "LocalMachine")
{
storeLocation = StoreLocation.LocalMachine;
}
else
{
_logger.Warning($"Invalid IceSSL.CertStoreLocation value `{certStoreLocation}' adjusted to `CurrentUser'");
storeLocation = StoreLocation.CurrentUser;
}
_useMachineContext = certStoreLocation == "LocalMachine";
//
// Protocols selects which protocols to enable, by default we only enable TLS1.0
// TLS1.1 and TLS1.2 to avoid security issues with SSLv3
//
string[]? protocols = ic.GetPropertyAsList("IceSSL.Protocols");
if (protocols != null)
{
_protocols = ParseProtocols(protocols);
}
else
{
_protocols = 0;
foreach (int v in Enum.GetValues(typeof(SslProtocols)))
{
if (v > (int)SslProtocols.Ssl3 && v != (int)SslProtocols.Default)
{
_protocols |= (SslProtocols)v;
}
}
}
//
// CheckCertName determines whether we compare the name in a peer's
// certificate against its hostname.
//
_checkCertName = ic.GetPropertyAsInt("IceSSL.CheckCertName") > 0;
//
// VerifyDepthMax establishes the maximum length of a peer's certificate
// chain, including the peer's certificate. A value of 0 means there is
// no maximum.
//
_verifyDepthMax = ic.GetPropertyAsInt("IceSSL.VerifyDepthMax") ?? 3;
//
// CheckCRL determines whether the certificate revocation list is checked, and how strictly.
//
_checkCRL = ic.GetPropertyAsInt("IceSSL.CheckCRL") ?? 0;
//
// Check for a certificate verifier.
//
string?certVerifierClass = ic.GetProperty("IceSSL.CertVerifier");
if (certVerifierClass != null)
{
if (_verifier != null)
{
throw new InvalidOperationException("IceSSL: certificate verifier already installed");
}
Type?cls = _facade.FindType(certVerifierClass);
if (cls == null)
{
throw new InvalidConfigurationException(
$"IceSSL: unable to load certificate verifier class `{certVerifierClass}'");
}
try
{
_verifier = (ICertificateVerifier)IceInternal.AssemblyUtil.CreateInstance(cls);
}
catch (Exception ex)
{
throw new LoadException(
$"IceSSL: unable to instantiate certificate verifier class `{certVerifierClass}", ex);
}
}
//
// Check for a password callback.
//
string?passwordCallbackClass = ic.GetProperty("IceSSL.PasswordCallback");
if (passwordCallbackClass != null)
{
if (_passwordCallback != null)
{
throw new InvalidOperationException("IceSSL: password callback already installed");
}
Type?cls = _facade.FindType(passwordCallbackClass);
if (cls == null)
{
throw new InvalidConfigurationException(
$"IceSSL: unable to load password callback class `{passwordCallbackClass}'");
}
try
{
_passwordCallback = (IPasswordCallback)IceInternal.AssemblyUtil.CreateInstance(cls);
}
catch (Exception ex)
{
throw new LoadException(
$"IceSSL: unable to load password callback class {passwordCallbackClass}", ex);
}
}
//
// If the user hasn't supplied a certificate collection, we need to examine
// the property settings.
//
if (_certs == null)
{
//
// If IceSSL.CertFile is defined, load a certificate from a file and
// add it to the collection.
//
// TODO: tracing?
_certs = new X509Certificate2Collection();
string? certFile = ic.GetProperty("IceSSL.CertFile");
string? passwordStr = ic.GetProperty("IceSSL.Password");
string? findCert = ic.GetProperty("IceSSL.FindCert");
const string findPrefix = "IceSSL.FindCert.";
Dictionary <string, string> findCertProps = ic.GetProperties(forPrefix: findPrefix);
if (certFile != null)
{
if (!CheckPath(ref certFile))
{
throw new FileNotFoundException($"IceSSL: certificate file not found: `{certFile}'", certFile);
}
SecureString?password = null;
if (passwordStr != null)
{
password = CreateSecureString(passwordStr);
}
else if (_passwordCallback != null)
{
password = _passwordCallback.GetPassword(certFile);
}
try
{
X509Certificate2 cert;
X509KeyStorageFlags importFlags;
if (_useMachineContext)
{
importFlags = X509KeyStorageFlags.MachineKeySet;
}
else
{
importFlags = X509KeyStorageFlags.UserKeySet;
}
if (password != null)
{
cert = new X509Certificate2(certFile, password, importFlags);
}
else
{
cert = new X509Certificate2(certFile, "", importFlags);
}
_certs.Add(cert);
}
catch (CryptographicException ex)
{
throw new InvalidConfigurationException(
$"IceSSL: error while attempting to load certificate from `{certFile}'", ex);
}
}
else if (findCert != null)
{
string certStore = ic.GetProperty("IceSSL.CertStore") ?? "My";
_certs.AddRange(FindCertificates("IceSSL.FindCert", storeLocation, certStore, findCert));
if (_certs.Count == 0)
{
throw new InvalidConfigurationException("IceSSL: no certificates found");
}
}
else if (findCertProps.Count > 0)
{
//
// If IceSSL.FindCert.* properties are defined, add the selected certificates
// to the collection.
//
foreach (KeyValuePair <string, string> entry in findCertProps)
{
string name = entry.Key;
string val = entry.Value;
if (val.Length > 0)
{
string storeSpec = name.Substring(findPrefix.Length);
StoreLocation storeLoc = 0;
StoreName storeName = 0;
string? sname = null;
ParseStore(name, storeSpec, ref storeLoc, ref storeName, ref sname);
if (sname == null)
{
sname = storeName.ToString();
}
X509Certificate2Collection coll = FindCertificates(name, storeLoc, sname, val);
_certs.AddRange(coll);
}
}
if (_certs.Count == 0)
{
throw new InvalidConfigurationException("IceSSL: no certificates found");
}
}
}
if (_caCerts == null)
{
string?certAuthFile = ic.GetProperty("IceSSL.CAs");
if (certAuthFile == null)
{
certAuthFile = ic.GetProperty("IceSSL.CertAuthFile");
}
if (certAuthFile != null || (ic.GetPropertyAsInt("IceSSL.UsePlatformCAs") ?? 0) <= 0)
{
_caCerts = new X509Certificate2Collection();
}
if (certAuthFile != null)
{
if (!CheckPath(ref certAuthFile))
{
throw new FileNotFoundException("IceSSL: CA certificate file not found: `{certAuthFile}'",
certAuthFile);
}
try
{
using FileStream fs = File.OpenRead(certAuthFile);
byte[] data = new byte[fs.Length];
fs.Read(data, 0, data.Length);
string strbuf = "";
try
{
strbuf = System.Text.Encoding.UTF8.GetString(data);
}
catch (Exception)
{
// Ignore
}
if (strbuf.Length == data.Length)
{
int size, startpos, endpos = 0;
bool first = true;
while (true)
{
startpos = strbuf.IndexOf("-----BEGIN CERTIFICATE-----", endpos);
if (startpos != -1)
{
endpos = strbuf.IndexOf("-----END CERTIFICATE-----", startpos);
size = endpos - startpos + "-----END CERTIFICATE-----".Length;
}
else if (first)
{
startpos = 0;
endpos = strbuf.Length;
size = strbuf.Length;
}
else
{
break;
}
byte[] cert = new byte[size];
Buffer.BlockCopy(data, startpos, cert, 0, size);
_caCerts !.Import(cert);
first = false;
}
}
else
{
_caCerts !.Import(data);
}
}
catch (Exception ex)
{
throw new InvalidConfigurationException(
$"IceSSL: error while attempting to load CA certificate from {certAuthFile}", ex);
}
}
}
_initialized = true;
}
public static void allTests(Test.TestHelper helper)
{
Ice.Communicator communicator = helper.communicator();
Console.Out.Write("testing stringToProxy... ");
Console.Out.Flush();
string rf = "test @ TestAdapter";
var @base = IObjectPrx.Parse(rf, communicator);
Console.Out.WriteLine("ok");
Console.Out.Write("testing IceGrid.Locator is present... ");
IceGrid.ILocatorPrx locator = IceGrid.ILocatorPrx.UncheckedCast(@base);
Console.Out.WriteLine("ok");
Console.Out.Write("testing checked cast... ");
Console.Out.Flush();
ITestIntfPrx obj = ITestIntfPrx.CheckedCast(@base);
test(obj.Equals(@base));
Console.Out.WriteLine("ok");
Console.Out.Write("pinging server... ");
Console.Out.Flush();
obj.IcePing();
Console.Out.WriteLine("ok");
Console.Out.Write("testing locator finder... ");
Ice.Identity finderId = new Ice.Identity();
finderId.category = "Ice";
finderId.name = "LocatorFinder";
Ice.ILocatorFinderPrx finder = Ice.ILocatorFinderPrx.CheckedCast(communicator.getDefaultLocator().Clone(finderId));
test(finder.GetLocator() != null);
Console.Out.WriteLine("ok");
Console.Out.Write("testing discovery... ");
{
// Add test well-known object
IceGrid.IRegistryPrx registry = IceGrid.IRegistryPrx.Parse(
communicator.getDefaultLocator().Identity.category + "/Registry", communicator);
IceGrid.IAdminSessionPrx session = registry.CreateAdminSession("foo", "bar");
session.GetAdmin().AddObjectWithType(@base, "::Test");
session.Destroy();
//
// Ensure the IceGrid discovery locator can discover the
// registries and make sure locator requests are forwarded.
//
var properties = communicator.GetProperties();
properties.Remove("Ice.Default.Locator");
properties["Ice.Plugin.IceLocatorDiscovery"] = "IceLocatorDiscovery:IceLocatorDiscovery.PluginFactory";
properties["IceLocatorDiscovery.Port"] = helper.getTestPort(99).ToString();
properties["AdapterForDiscoveryTest.AdapterId"] = "discoveryAdapter";
properties["AdapterForDiscoveryTest.Endpoints"] = "default";
Communicator com = new Communicator(properties);
test(com.getDefaultLocator() != null);
IObjectPrx.Parse("test @ TestAdapter", com).IcePing();
IObjectPrx.Parse("test", com).IcePing();
test(com.getDefaultLocator().GetRegistry() != null);
test(IceGrid.ILocatorPrx.UncheckedCast(com.getDefaultLocator()).GetLocalRegistry() != null);
test(IceGrid.ILocatorPrx.UncheckedCast(com.getDefaultLocator()).GetLocalQuery() != null);
Ice.ObjectAdapter adapter = com.createObjectAdapter("AdapterForDiscoveryTest");
adapter.Activate();
adapter.Deactivate();
com.destroy();
//
// Now, ensure that the IceGrid discovery locator correctly
// handles failure to find a locator.
//
properties["IceLocatorDiscovery.InstanceName"] = "unknown";
properties["IceLocatorDiscovery.RetryCount"] = "1";
properties["IceLocatorDiscovery.Timeout"] = "100";
com = new Communicator(properties);
test(com.getDefaultLocator() != null);
try
{
IObjectPrx.Parse("test @ TestAdapter", com).IcePing();
}
catch (Ice.NoEndpointException)
{
}
try
{
IObjectPrx.Parse("test", com).IcePing();
}
catch (Ice.NoEndpointException)
{
}
test(com.getDefaultLocator().GetRegistry() == null);
test(IceGrid.ILocatorPrx.CheckedCast(com.getDefaultLocator()) == null);
try
{
IceGrid.ILocatorPrx.UncheckedCast(com.getDefaultLocator()).GetLocalRegistry();
}
catch (Ice.OperationNotExistException)
{
}
adapter = com.createObjectAdapter("AdapterForDiscoveryTest");
adapter.Activate();
adapter.Deactivate();
com.destroy();
string multicast;
if (communicator.GetProperty("Ice.IPv6") == "1")
{
multicast = "\"ff15::1\"";
}
else
{
multicast = "239.255.0.1";
}
//
// Test invalid lookup endpoints
//
properties = communicator.GetProperties();
properties.Remove("Ice.Default.Locator");
properties["Ice.Plugin.IceLocatorDiscovery"] = "IceLocatorDiscovery:IceLocatorDiscovery.PluginFactory";
properties["IceLocatorDiscovery.Lookup"] = $"udp -h {multicast} --interface unknown";
com = new Communicator(properties);
test(com.getDefaultLocator() != null);
try
{
IObjectPrx.Parse("test @ TestAdapter", com).IcePing();
test(false);
}
catch (NoEndpointException)
{
}
com.destroy();
properties = communicator.GetProperties();
properties.Remove("Ice.Default.Locator");
properties["IceLocatorDiscovery.RetryCount"] = "0";
properties["Ice.Plugin.IceLocatorDiscovery"] = "IceLocatorDiscovery:IceLocatorDiscovery.PluginFactory";
properties["IceLocatorDiscovery.Lookup"] = $"udp -h {multicast} --interface unknown";
com = new Communicator(properties);
test(com.getDefaultLocator() != null);
try
{
IObjectPrx.Parse("test @ TestAdapter", com).IcePing();
test(false);
}
catch (NoEndpointException)
{
}
com.destroy();
properties = communicator.GetProperties();
properties.Remove("Ice.Default.Locator");
properties["IceLocatorDiscovery.RetryCount"] = "1";
properties["Ice.Plugin.IceLocatorDiscovery"] = "IceLocatorDiscovery:IceLocatorDiscovery.PluginFactory";
{
string intf = communicator.GetProperty("IceLocatorDiscovery.Interface") ?? "";
if (intf != "")
{
intf = $" --interface \"{intf}\"";
}
string port = helper.getTestPort(99).ToString();
properties["IceLocatorDiscovery.Lookup"] =
$"udp -h {multicast} --interface unknown:udp -h {multicast} -p {port}{intf}";
}
com = new Communicator(properties);
test(com.getDefaultLocator() != null);
try
{
IObjectPrx.Parse("test @ TestAdapter", com).IcePing();
}
catch (NoEndpointException)
{
test(false);
}
com.destroy();
}
Console.Out.WriteLine("ok");
Console.Out.Write("shutting down server... ");
Console.Out.Flush();
obj.shutdown();
Console.Out.WriteLine("ok");
}
internal MetricsMap(string mapPrefix, Ice.Communicator communicator, Dictionary <string, ISubMapFactory>?subMaps)
{
MetricsAdminI.ValidateProperties(mapPrefix, communicator);
_properties = communicator.GetProperties(forPrefix: mapPrefix);
_retain = communicator.GetPropertyAsInt($"{mapPrefix}RetainDetached") ?? 10;
_accept = ParseRule(communicator, $"{mapPrefix}Accept");
_reject = ParseRule(communicator, $"{mapPrefix}Reject");
_groupByAttributes = new List <string>();
_groupBySeparators = new List <string>();
string groupBy = communicator.GetProperty($"{mapPrefix}GroupBy") ?? "id";
if (groupBy.Length > 0)
{
string v = "";
bool attribute = char.IsLetter(groupBy[0]) || char.IsDigit(groupBy[0]);
if (!attribute)
{
_groupByAttributes.Add("");
}
foreach (char p in groupBy)
{
bool isAlphaNum = char.IsLetter(p) || char.IsDigit(p) || p == '.';
if (attribute && !isAlphaNum)
{
_groupByAttributes.Add(v);
v = "" + p;
attribute = false;
}
else if (!attribute && isAlphaNum)
{
_groupBySeparators.Add(v);
v = "" + p;
attribute = true;
}
else
{
v += p;
}
}
if (attribute)
{
_groupByAttributes.Add(v);
}
else
{
_groupBySeparators.Add(v);
}
}
if (subMaps != null && subMaps.Count > 0)
{
_subMaps = new Dictionary <string, ISubMapCloneFactory>();
var subMapNames = new List <string>();
foreach (KeyValuePair <string, ISubMapFactory> e in subMaps)
{
subMapNames.Add(e.Key);
string subAllMapsPrefix = mapPrefix + "Map.";
string subMapPrefix = subAllMapsPrefix + e.Key + '.';
if (communicator.GetProperties(forPrefix: subMapPrefix).Count == 0)
{
if (communicator.GetProperties(forPrefix: subAllMapsPrefix).Count == 0)
{
subMapPrefix = mapPrefix;
}
else
{
continue; // This sub-map isn't configured.
}
}
_subMaps.Add(e.Key, e.Value.CreateCloneFactory(subMapPrefix, communicator));
}
}
else
{
_subMaps = null;
}
}
public static MetricsPrx allTests(Test.TestHelper helper, CommunicatorObserverI obsv)
{
Ice.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";
MetricsPrx metrics = MetricsPrx.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();
PropertiesAdminPrx clientProps = PropertiesAdminPrx.CheckedCast(admin.Clone(facet: "Properties"));
IceMX.MetricsAdminPrx clientMetrics = IceMX.MetricsAdminPrx.CheckedCast(admin.Clone(facet: "Metrics"));
test(clientProps != null && clientMetrics != null);
admin = metrics.getAdmin();
Ice.PropertiesAdminPrx serverProps = Ice.PropertiesAdminPrx.CheckedCast(admin.Clone(facet: "Properties"));
IceMX.MetricsAdminPrx serverMetrics = IceMX.MetricsAdminPrx.CheckedCast(admin.Clone(facet: "Metrics"));
test(serverProps != null && serverMetrics != null);
UpdateCallbackI update = new UpdateCallbackI(serverProps);
((Ice.NativePropertiesAdmin)communicator.FindAdminFacet("Properties").servant).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, "");
long timestamp;
Dictionary <string, IceMX.Metrics[]> view = clientMetrics.getMetricsView("View", out timestamp);
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", out timestamp);
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", out timestamp);
// 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().getEndpoint().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", out timestamp)["Connection"].Length == 0);
test(serverMetrics.getMetricsView("View", out timestamp)["Connection"].Length == 0);
metrics.IcePing();
IceMX.ConnectionMetrics cm1, sm1, cm2, sm2;
cm1 = (IceMX.ConnectionMetrics)clientMetrics.getMetricsView("View", out timestamp)["Connection"][0];
sm1 = getServerConnectionMetrics(serverMetrics, 25);
metrics.IcePing();
cm2 = (IceMX.ConnectionMetrics)clientMetrics.getMetricsView("View", out timestamp)["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", out timestamp)["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", out timestamp)["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", out timestamp)["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", out timestamp)["Connection"]);
test(map["active"].current == 1);
ControllerPrx controller = ControllerPrx.Parse($"controller:{helper.getTestEndpoint(1)}", communicator);
controller.hold();
map = toMap(clientMetrics.getMetricsView("View", out timestamp)["Connection"]);
test(map["active"].current == 1);
map = toMap(serverMetrics.getMetricsView("View", out timestamp)["Connection"]);
test(map["holding"].current == 1);
metrics.GetConnection().close(Ice.ConnectionClose.GracefullyWithWait);
map = toMap(clientMetrics.getMetricsView("View", out timestamp)["Connection"]);
test(map["closing"].current == 1);
map = toMap(serverMetrics.getMetricsView("View", out timestamp)["Connection"]);
test(map["holding"].current == 1);
controller.resume();
map = toMap(serverMetrics.getMetricsView("View", out timestamp)["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", out timestamp)["Connection"][0];
while (true)
{
sm1 = (IceMX.ConnectionMetrics)serverMetrics.getMetricsView("View", out timestamp)["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);
MetricsPrx 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", out timestamp)["ConnectionEstablishment"].Length == 0);
metrics.IcePing();
test(clientMetrics.getMetricsView("View", out timestamp)["ConnectionEstablishment"].Length == 1);
IceMX.Metrics m1 = clientMetrics.getMetricsView("View", out timestamp)["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", out timestamp)["ConnectionEstablishment"].Length == 1);
m1 = clientMetrics.getMetricsView("View", out timestamp)["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", out timestamp)["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", out timestamp)["EndpointLookup"].Length == 1);
m1 = clientMetrics.getMetricsView("View", out timestamp)["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", out timestamp)["EndpointLookup"].Length == 2);
m1 = clientMetrics.getMetricsView("View", out timestamp)["EndpointLookup"][0];
if (!m1.id.Equals("tcp -h unknownfoo.zeroc.com -p " + port + " -t 500"))
{
m1 = clientMetrics.getMetricsView("View", out timestamp)["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().getEndpoint().ToString(), c, output);
testAttribute(clientMetrics, clientProps, update, "EndpointLookup", "endpoint",
prx.GetConnection().getEndpoint().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", out timestamp)["Dispatch"].Length == 0);
metrics.op();
try
{
metrics.opWithUserException();
test(false);
}
catch (UserEx)
{
}
try
{
metrics.opWithRequestFailedException();
test(false);
}
catch (Ice.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", out timestamp)["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", out timestamp)["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", out timestamp)["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");
MetricsPrx metricsOneway = metrics.Clone(oneway: true);
metricsOneway.op();
metricsOneway.opAsync().Wait();
map = toMap(clientMetrics.getMetricsView("View", out timestamp)["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();
string[] disabledViews;
props["IceMX.Metrics.View.GroupBy"] = "none";
props["IceMX.Metrics.View.Disabled"] = "0";
updateProps(clientProps, serverProps, update, props, "Thread");
test(clientMetrics.getMetricsView("View", out timestamp)["Thread"].Length != 0);
test(clientMetrics.getMetricsViewNames(out disabledViews).Length == 1 && disabledViews.Length == 0);
props["IceMX.Metrics.View.Disabled"] = "1";
updateProps(clientProps, serverProps, update, props, "Thread");
test(!clientMetrics.getMetricsView("View", out timestamp).ContainsKey("Thread"));
test(clientMetrics.getMetricsViewNames(out disabledViews).Length == 0 && disabledViews.Length == 1);
clientMetrics.enableMetricsView("View");
test(clientMetrics.getMetricsView("View", out timestamp)["Thread"].Length != 0);
test(clientMetrics.getMetricsViewNames(out disabledViews).Length == 1 && disabledViews.Length == 0);
clientMetrics.disableMetricsView("View");
test(!clientMetrics.getMetricsView("View", out timestamp).ContainsKey("Thread"));
test(clientMetrics.getMetricsViewNames(out disabledViews).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);
}
