public ServiceManagerI(Ice.Communicator communicator, string[] args)
{
_communicator = communicator;
_logger = _communicator.getLogger();
Ice.Properties props = _communicator.getProperties();
if (props.getProperty("Ice.Admin.Enabled").Length == 0)
{
_adminEnabled = props.getProperty("Ice.Admin.Endpoints").Length > 0;
}
else
{
_adminEnabled = props.getPropertyAsInt("Ice.Admin.Enabled") > 0;
}
if (_adminEnabled)
{
string[] facetFilter = props.getPropertyAsList("Ice.Admin.Facets");
if (facetFilter.Length > 0)
{
_adminFacetFilter = new HashSet <string>(facetFilter);
}
else
{
_adminFacetFilter = new HashSet <string>();
}
}
_argv = args;
_traceServiceObserver = _communicator.getProperties().getPropertyAsInt("IceBox.Trace.ServiceObserver");
}
public ServiceManagerI(Ice.Communicator communicator, string[] args)
{
_communicator = communicator;
_logger = _communicator.getLogger();
Ice.Properties props = _communicator.getProperties();
if(props.getProperty("Ice.Admin.Enabled").Length == 0)
{
_adminEnabled = props.getProperty("Ice.Admin.Endpoints").Length > 0;
}
else
{
_adminEnabled = props.getPropertyAsInt("Ice.Admin.Enabled") > 0;
}
if(_adminEnabled)
{
string[] facetFilter = props.getPropertyAsList("Ice.Admin.Facets");
if(facetFilter.Length > 0)
{
_adminFacetFilter = new HashSet<string>(facetFilter);
}
else
{
_adminFacetFilter = new HashSet<string>();
}
}
_argv = args;
_traceServiceObserver = _communicator.getProperties().getPropertyAsInt("IceBox.Trace.ServiceObserver");
}
createObjectAdapter(string name, string endpts, Ice.Current current)
{
int retry = 5;
while (true)
{
try
{
Ice.Communicator communicator = current.adapter.getCommunicator();
string endpoints = endpts;
if (endpoints.IndexOf("-p") < 0)
{
endpoints = global::Test.TestHelper.getTestEndpoint(communicator.getProperties(), _nextPort++, endpoints);
}
communicator.getProperties().setProperty(name + ".ThreadPool.Size", "1");
Ice.ObjectAdapter adapter = communicator.createObjectAdapterWithEndpoints(name, endpoints);
return(Test.RemoteObjectAdapterPrxHelper.uncheckedCast(
current.adapter.addWithUUID(new RemoteObjectAdapterI(adapter))));
}
catch (Ice.SocketException)
{
if (--retry == 0)
{
throw;
}
}
}
}
public static void allTests(Test.TestHelper helper)
{
Ice.Communicator communicator = helper.communicator();
string sref = "test:" + helper.getTestEndpoint(0);
Ice.ObjectPrx obj = communicator.stringToProxy(sref);
test(obj != null);
int proxyPort = communicator.getProperties().getPropertyAsInt("Ice.HTTPProxyPort");
if (proxyPort == 0)
{
proxyPort = communicator.getProperties().getPropertyAsInt("Ice.SOCKSProxyPort");
}
Test.TestIntfPrx testPrx = Test.TestIntfPrxHelper.checkedCast(obj);
test(testPrx != null);
var output = helper.getWriter();
output.Write("testing connection... ");
output.Flush();
{
testPrx.ice_ping();
}
output.WriteLine("ok");
output.Write("testing connection information... ");
output.Flush();
{
Ice.IPConnectionInfo info = getIPConnectionInfo(testPrx.ice_getConnection().getInfo());
test(info.remotePort == proxyPort); // make sure we are connected to the proxy port.
}
output.WriteLine("ok");
output.Write("shutting down server... ");
output.Flush();
{
testPrx.shutdown();
}
output.WriteLine("ok");
output.Write("testing connection failure... ");
output.Flush();
{
try
{
testPrx.ice_ping();
test(false);
}
catch (Ice.LocalException)
{
}
}
output.WriteLine("ok");
}
createObjectAdapter(int timeout, int close, int heartbeat, Ice.Current current)
{
Ice.Communicator com = current.adapter.getCommunicator();
Ice.Properties properties = com.getProperties();
string protocol = properties.getPropertyWithDefault("Ice.Default.Protocol", "tcp");
string host = properties.getPropertyWithDefault("Ice.Default.Host", "127.0.0.1");
string name = System.Guid.NewGuid().ToString();
if (timeout >= 0)
{
properties.setProperty(name + ".ACM.Timeout", timeout.ToString());
}
if (close >= 0)
{
properties.setProperty(name + ".ACM.Close", close.ToString());
}
if (heartbeat >= 0)
{
properties.setProperty(name + ".ACM.Heartbeat", heartbeat.ToString());
}
properties.setProperty(name + ".ThreadPool.Size", "2");
Ice.ObjectAdapter adapter = com.createObjectAdapterWithEndpoints(name, protocol + " -h \"" + host + "\"");
return(Test.RemoteObjectAdapterPrxHelper.uncheckedCast(
current.adapter.addWithUUID(new RemoteObjectAdapterI(adapter))));
}
public ServiceManagerI(Ice.Communicator communicator, string[] args)
{
_communicator = communicator;
_logger = _communicator.getLogger();
_argv = args;
_traceServiceObserver = _communicator.getProperties().getPropertyAsInt("IceBox.Trace.ServiceObserver");
}
public ServiceManagerI(Ice.Communicator communicator, string[] args)
{
_communicator = communicator;
_logger = _communicator.getLogger();
_argv = args;
_traceServiceObserver = _communicator.getProperties().getPropertyAsInt("IceBox.Trace.ServiceObserver");
}
private static Ice.Communicator createSendLogCommunicator(Ice.Communicator communicator, Ice.Logger logger)
{
Ice.InitializationData initData = new Ice.InitializationData();
initData.logger = logger;
initData.properties = Ice.Util.createProperties();
Ice.Properties mainProps = communicator.getProperties();
copyProperties("Ice.Default.Locator", mainProps, initData.properties);
copyProperties("Ice.Plugin.IceSSL", mainProps, initData.properties);
copyProperties("IceSSL.", mainProps, initData.properties);
string[] extraProps = mainProps.getPropertyAsList("Ice.Admin.Logger.Properties");
if (extraProps.Length > 0)
{
for (int i = 0; i < extraProps.Length; ++i)
{
string p = extraProps[i];
if (!p.StartsWith("--"))
{
extraProps[i] = "--" + p;
}
}
initData.properties.parseCommandLineOptions("", extraProps);
}
return(Ice.Util.initialize(initData));
}
internal Instance(Ice.Communicator communicator)
{
_logger = communicator.getLogger();
_facade = IceInternal.Util.getProtocolPluginFacade(communicator);
_securityTraceLevel = communicator.getProperties().getPropertyAsIntWithDefault("IceSSL.Trace.Security", 0);
_securityTraceCategory = "Security";
_initialized = false;
_trustManager = new TrustManager(communicator);
//
// Register the endpoint factory. We have to do this now, rather than
// in initialize, because the communicator may need to interpret
// proxies before the plug-in is fully initialized.
//
_facade.addEndpointFactory(new EndpointFactoryI(this));
}
internal SSLEngine(IceInternal.ProtocolPluginFacade facade)
{
_communicator = facade.getCommunicator();
_logger = _communicator.getLogger();
_facade = facade;
_securityTraceLevel = _communicator.getProperties().getPropertyAsIntWithDefault("IceSSL.Trace.Security", 0);
_securityTraceCategory = "Security";
_initialized = false;
_trustManager = new TrustManager(_communicator);
_tls12Support = false;
try
{
Enum.Parse(typeof(System.Security.Authentication.SslProtocols), "Tls12");
_tls12Support = true;
}
catch(Exception)
{
}
}
internal TrustManager(Ice.Communicator communicator)
{
Debug.Assert(communicator != null);
communicator_ = communicator;
Ice.Properties properties = communicator.getProperties();
traceLevel_ = properties.getPropertyAsInt("IceSSL.Trace.Security");
string key = null;
try
{
key = "IceSSL.TrustOnly";
parse(properties.getProperty(key), rejectAll_, acceptAll_);
key = "IceSSL.TrustOnly.Client";
parse(properties.getProperty(key), rejectClient_, acceptClient_);
key = "IceSSL.TrustOnly.Server";
parse(properties.getProperty(key), rejectAllServer_, acceptAllServer_);
Dictionary <string, string> dict = properties.getPropertiesForPrefix("IceSSL.TrustOnly.Server.");
foreach (KeyValuePair <string, string> entry in dict)
{
key = entry.Key;
string name = key.Substring("IceSSL.TrustOnly.Server.".Length);
List <List <RFC2253.RDNPair> > reject = new List <List <RFC2253.RDNPair> >();
List <List <RFC2253.RDNPair> > accept = new List <List <RFC2253.RDNPair> >();
parse(entry.Value, reject, accept);
if (reject.Count > 0)
{
rejectServer_[name] = reject;
}
if (accept.Count > 0)
{
acceptServer_[name] = accept;
}
}
}
catch (RFC2253.ParseException e)
{
Ice.PluginInitializationException ex = new Ice.PluginInitializationException();
ex.reason = "IceSSL: invalid property " + key + ":\n" + e.reason;
throw ex;
}
}
public void Init(IceOptions options, IClusterClient orleansClient, IObserverClient observerClient)
{
try
{
var initData = new Ice.InitializationData();
//设置日志输出
if (options.Logger == null)
{
options.Logger = new FootStone.Core.NLogice(NLog.LogManager.GetLogger("Ice"));
}
initData.logger = options.Logger;
initData.properties = Ice.Util.createProperties();
initData.properties.load(options.ConfigFile);
communicator = Ice.Util.initialize(initData);
var adapter = communicator.createObjectAdapter("SessionFactoryAdapter");
var properties = communicator.getProperties();
var id = Ice.Util.stringToIdentity(properties.getProperty("Identity"));
var serverName = properties.getProperty("Ice.ProgramName");
adapter.add(new SessionFactoryI(serverName, initData.logger), id);
//添加facet
foreach (var facet in options.FacetTypes)
{
if (facet.type is IServantBase)
{
options.Logger.error($"Facet(${facet.type.Name}) must inherit IServantBase!!!");
continue;
}
object[] args = new object[] { orleansClient, observerClient };
var servant = (IServantBase)Activator.CreateInstance(facet.type, args);
var intercpetor = new FSInterceptor((Ice.Object)servant, options.Logger);
adapter.addFacet(intercpetor, id, facet.name);
}
adapter.activate();
options.Logger.print("Ice inited!");
}
catch (Ice.Exception ex)
{
options.Logger.error("Ice init failed:" + ex.ToString());
}
}
private static int run(Ice.Communicator communicator, string[] args)
{
const string prefix = "IceBox.Service.";
Ice.Properties properties = communicator.getProperties();
Dictionary <string, string> services = properties.getPropertiesForPrefix(prefix);
var argSeq = new List <string>(args);
foreach (KeyValuePair <string, string> pair in services)
{
string name = pair.Key.Substring(prefix.Length);
argSeq.RemoveAll(v => v.StartsWith("--" + name));
}
foreach (string arg in args)
{
if (arg.Equals("-h") || arg.Equals("--help"))
{
usage();
return(0);
}
else if (arg.Equals("-v") || arg.Equals("--version"))
{
Console.Out.WriteLine(Ice.Util.stringVersion());
return(0);
}
else
{
Console.Error.WriteLine("IceBox.Server: unknown option `" + arg + "'");
usage();
return(1);
}
}
ServiceManagerI serviceManagerImpl = new ServiceManagerI(communicator, args);
return(serviceManagerImpl.run());
}
public static void allTests(global::Test.TestHelper helper)
{
Ice.Communicator communicator = helper.communicator();
communicator.getProperties().setProperty("ReplyAdapter.Endpoints", "udp");
Ice.ObjectAdapter adapter = communicator.createObjectAdapter("ReplyAdapter");
PingReplyI replyI = new PingReplyI();
Test.PingReplyPrx reply =
(Test.PingReplyPrx)Test.PingReplyPrxHelper.uncheckedCast(adapter.addWithUUID(replyI)).ice_datagram();
adapter.activate();
Console.Out.Write("testing udp... ");
Console.Out.Flush();
Ice.ObjectPrx @base = communicator.stringToProxy("test:" + helper.getTestEndpoint(0, "udp")).ice_datagram();
Test.TestIntfPrx obj = Test.TestIntfPrxHelper.uncheckedCast(@base);
int nRetry = 5;
bool ret = false;
while (nRetry-- > 0)
{
replyI.reset();
obj.ping(reply);
obj.ping(reply);
obj.ping(reply);
ret = replyI.waitReply(3, 2000);
if (ret)
{
break; // Success
}
// If the 3 datagrams were not received within the 2 seconds, we try again to
// receive 3 new datagrams using a new object. We give up after 5 retries.
replyI = new PingReplyI();
reply = (Test.PingReplyPrx)Test.PingReplyPrxHelper.uncheckedCast(adapter.addWithUUID(replyI)).ice_datagram();
}
test(ret == true);
if (communicator.getProperties().getPropertyAsInt("Ice.Override.Compress") == 0)
{
//
// Only run this test if compression is disabled, the test expect fixed message size
// to be sent over the wire.
//
byte[] seq = null;
try
{
seq = new byte[1024];
while (true)
{
seq = new byte[seq.Length * 2 + 10];
replyI.reset();
obj.sendByteSeq(seq, reply);
replyI.waitReply(1, 10000);
}
}
catch (Ice.DatagramLimitException)
{
//
// The server's Ice.UDP.RcvSize property is set to 16384, which means that DatagramLimitException
// will be throw when try to send a packet bigger than that.
//
test(seq.Length > 16384);
}
obj.ice_getConnection().close(Ice.ConnectionClose.GracefullyWithWait);
communicator.getProperties().setProperty("Ice.UDP.SndSize", "64000");
seq = new byte[50000];
try
{
replyI.reset();
obj.sendByteSeq(seq, reply);
bool b = replyI.waitReply(1, 500);
//
// The server's Ice.UDP.RcvSize property is set to 16384, which means this packet
// should not be delivered.
//
test(!b);
}
catch (Ice.DatagramLimitException)
{
}
catch (Ice.LocalException ex)
{
Console.Out.WriteLine(ex);
test(false);
}
}
Console.Out.WriteLine("ok");
Console.Out.Write("testing udp multicast... ");
Console.Out.Flush();
StringBuilder endpoint = new StringBuilder();
//
// Use loopback to prevent other machines to answer.
//
if (communicator.getProperties().getProperty("Ice.IPv6") == "1")
{
endpoint.Append("udp -h \"ff15::1:1\"");
if (IceInternal.AssemblyUtil.isWindows || IceInternal.AssemblyUtil.isMacOS)
{
endpoint.Append(" --interface \"::1\"");
}
}
else
{
endpoint.Append("udp -h 239.255.1.1");
if (IceInternal.AssemblyUtil.isWindows || IceInternal.AssemblyUtil.isMacOS)
{
endpoint.Append(" --interface 127.0.0.1");
}
}
endpoint.Append(" -p ");
endpoint.Append(helper.getTestPort(10));
@base = communicator.stringToProxy("test -d:" + endpoint.ToString());
var objMcast = Test.TestIntfPrxHelper.uncheckedCast(@base);
nRetry = 5;
while (nRetry-- > 0)
{
replyI.reset();
try
{
objMcast.ping(reply);
}
catch (Ice.SocketException)
{
if (communicator.getProperties().getProperty("Ice.IPv6") == "1")
{
// Multicast IPv6 not supported on the platform. This occurs for example on macOS big_suir
Console.Out.Write("(not supported) ");
ret = true;
break;
}
throw;
}
ret = replyI.waitReply(5, 5000);
if (ret)
{
break;
}
replyI = new PingReplyI();
reply = (Test.PingReplyPrx)Test.PingReplyPrxHelper.uncheckedCast(adapter.addWithUUID(replyI)).ice_datagram();
}
if (!ret)
{
Console.Out.WriteLine("failed(is a firewall enabled?)");
}
else
{
Console.Out.WriteLine("ok");
}
Console.Out.Write("testing udp bi-dir connection... ");
Console.Out.Flush();
obj.ice_getConnection().setAdapter(adapter);
nRetry = 5;
while (nRetry-- > 0)
{
replyI.reset();
obj.pingBiDir(reply.ice_getIdentity());
obj.pingBiDir(reply.ice_getIdentity());
obj.pingBiDir(reply.ice_getIdentity());
ret = replyI.waitReply(3, 2000);
if (ret)
{
break; // Success
}
replyI = new PingReplyI();
reply = (Test.PingReplyPrx)Test.PingReplyPrxHelper.uncheckedCast(adapter.addWithUUID(replyI)).ice_datagram();
}
test(ret);
Console.Out.WriteLine("ok");
//
// Sending the replies back on the multicast UDP connection doesn't work for most
// platform(it works for macOS Leopard but not Snow Leopard, doesn't work on SLES,
// Windows...). For Windows, see UdpTransceiver constructor for the details. So
// we don't run this test.
//
// Console.Out.Write("testing udp bi-dir connection... ");
// nRetry = 5;
// while(nRetry-- > 0)
// {
// replyI.reset();
// objMcast.pingBiDir(reply.ice_getIdentity());
// ret = replyI.waitReply(5, 2000);
// if(ret)
// {
// break; // Success
// }
// replyI = new PingReplyI();
// reply =(PingReplyPrx)PingReplyPrxHelper.uncheckedCast(adapter.addWithUUID(replyI)).ice_datagram();
// }
// if(!ret)
// {
// Console.Out.WriteLine("failed(is a firewall enabled?)");
// }
// else
// {
// Console.Out.WriteLine("ok");
// }
}
public static void allTests(global::Test.TestHelper helper)
{
Ice.Communicator communicator = helper.communicator();
string @ref = "communicator:" + helper.getTestEndpoint(0);
Test.RemoteCommunicatorPrx com = Test.RemoteCommunicatorPrxHelper.uncheckedCast(communicator.stringToProxy(@ref));
var rand = new Random(unchecked ((int)DateTime.Now.Ticks));
var output = helper.getWriter();
output.Write("testing binding with single endpoint... ");
output.Flush();
{
Test.RemoteObjectAdapterPrx adapter = com.createObjectAdapter("Adapter", "default");
var test1 = adapter.getTestIntf();
var test2 = adapter.getTestIntf();
test(test1.ice_getConnection() == test2.ice_getConnection());
test1.ice_ping();
test2.ice_ping();
com.deactivateObjectAdapter(adapter);
var test3 = Test.TestIntfPrxHelper.uncheckedCast(test1);
test(test3.ice_getConnection() == test1.ice_getConnection());
test(test3.ice_getConnection() == test2.ice_getConnection());
try
{
test3.ice_ping();
test(false);
}
catch (Ice.ConnectFailedException)
{
}
catch (Ice.ConnectTimeoutException)
{
}
}
output.WriteLine("ok");
output.Write("testing binding with multiple endpoints... ");
output.Flush();
{
var adapters = new List <Test.RemoteObjectAdapterPrx>();
adapters.Add(com.createObjectAdapter("Adapter11", "default"));
adapters.Add(com.createObjectAdapter("Adapter12", "default"));
adapters.Add(com.createObjectAdapter("Adapter13", "default"));
//
// Ensure that when a connection is opened it's reused for new
// proxies and that all endpoints are eventually tried.
//
List <string> names = new List <string>();
names.Add("Adapter11");
names.Add("Adapter12");
names.Add("Adapter13");
while (names.Count > 0)
{
var adpts = new List <Test.RemoteObjectAdapterPrx>(adapters);
var test1 = createTestIntfPrx(adpts);
shuffle(ref adpts);
var test2 = createTestIntfPrx(adpts);
shuffle(ref adpts);
var test3 = createTestIntfPrx(adpts);
test1.ice_ping();
test(test1.ice_getConnection() == test2.ice_getConnection());
test(test2.ice_getConnection() == test3.ice_getConnection());
names.Remove(test1.getAdapterName());
test1.ice_getConnection().close(Ice.ConnectionClose.GracefullyWithWait);
}
//
// Ensure that the proxy correctly caches the connection(we
// always send the request over the same connection.)
//
{
foreach (var adpt in adapters)
{
adpt.getTestIntf().ice_ping();
}
var t = createTestIntfPrx(adapters);
string name = t.getAdapterName();
int nRetry = 10;
int i;
for (i = 0; i < nRetry && t.getAdapterName().Equals(name); i++)
{
;
}
test(i == nRetry);
foreach (var adpt in adapters)
{
adpt.getTestIntf().ice_getConnection().close(Ice.ConnectionClose.GracefullyWithWait);
}
}
//
// Deactivate an adapter and ensure that we can still
// establish the connection to the remaining adapters.
//
com.deactivateObjectAdapter((Test.RemoteObjectAdapterPrx)adapters[0]);
names.Add("Adapter12");
names.Add("Adapter13");
while (names.Count > 0)
{
var adpts = new List <Test.RemoteObjectAdapterPrx>(adapters);
var test1 = createTestIntfPrx(adpts);
shuffle(ref adpts);
var test2 = createTestIntfPrx(adpts);
shuffle(ref adpts);
var test3 = createTestIntfPrx(adpts);
test(test1.ice_getConnection() == test2.ice_getConnection());
test(test2.ice_getConnection() == test3.ice_getConnection());
names.Remove(test1.getAdapterName());
test1.ice_getConnection().close(Ice.ConnectionClose.GracefullyWithWait);
}
//
// Deactivate an adapter and ensure that we can still
// establish the connection to the remaining adapter.
//
com.deactivateObjectAdapter((Test.RemoteObjectAdapterPrx)adapters[2]);
var obj = createTestIntfPrx(adapters);
test(obj.getAdapterName().Equals("Adapter12"));
deactivate(com, adapters);
}
output.WriteLine("ok");
output.Write("testing binding with multiple random endpoints... ");
output.Flush();
{
var adapters = new Test.RemoteObjectAdapterPrx[5];
adapters[0] = com.createObjectAdapter("AdapterRandom11", "default");
adapters[1] = com.createObjectAdapter("AdapterRandom12", "default");
adapters[2] = com.createObjectAdapter("AdapterRandom13", "default");
adapters[3] = com.createObjectAdapter("AdapterRandom14", "default");
adapters[4] = com.createObjectAdapter("AdapterRandom15", "default");
int count = 20;
int adapterCount = adapters.Length;
while (--count > 0)
{
Test.TestIntfPrx[] proxies;
if (count == 1)
{
com.deactivateObjectAdapter(adapters[4]);
--adapterCount;
}
proxies = new Test.TestIntfPrx[10];
int i;
for (i = 0; i < proxies.Length; ++i)
{
var adpts = new Test.RemoteObjectAdapterPrx[rand.Next(adapters.Length)];
if (adpts.Length == 0)
{
adpts = new Test.RemoteObjectAdapterPrx[1];
}
for (int j = 0; j < adpts.Length; ++j)
{
adpts[j] = adapters[rand.Next(adapters.Length)];
}
proxies[i] = createTestIntfPrx(new List <Test.RemoteObjectAdapterPrx>(adpts));
}
for (i = 0; i < proxies.Length; i++)
{
proxies[i].begin_getAdapterName();
}
for (i = 0; i < proxies.Length; i++)
{
try
{
proxies[i].ice_ping();
}
catch (Ice.LocalException)
{
}
}
List <Ice.Connection> connections = new List <Ice.Connection>();
for (i = 0; i < proxies.Length; i++)
{
if (proxies[i].ice_getCachedConnection() != null)
{
if (!connections.Contains(proxies[i].ice_getCachedConnection()))
{
connections.Add(proxies[i].ice_getCachedConnection());
}
}
}
test(connections.Count <= adapterCount);
foreach (var a in adapters)
{
try
{
a.getTestIntf().ice_getConnection().close(Ice.ConnectionClose.GracefullyWithWait);
}
catch (Ice.LocalException)
{
// Expected if adapter is down.
}
}
}
}
output.WriteLine("ok");
output.Write("testing binding with multiple endpoints and AMI... ");
output.Flush();
{
var adapters = new List <Test.RemoteObjectAdapterPrx>();
adapters.Add(com.createObjectAdapter("AdapterAMI11", "default"));
adapters.Add(com.createObjectAdapter("AdapterAMI12", "default"));
adapters.Add(com.createObjectAdapter("AdapterAMI13", "default"));
//
// Ensure that when a connection is opened it's reused for new
// proxies and that all endpoints are eventually tried.
//
List <string> names = new List <string>();
names.Add("AdapterAMI11");
names.Add("AdapterAMI12");
names.Add("AdapterAMI13");
while (names.Count > 0)
{
var adpts = new List <Test.RemoteObjectAdapterPrx>(adapters);
var test1 = createTestIntfPrx(adpts);
shuffle(ref adpts);
var test2 = createTestIntfPrx(adpts);
shuffle(ref adpts);
var test3 = createTestIntfPrx(adpts);
test1.ice_ping();
test(test1.ice_getConnection() == test2.ice_getConnection());
test(test2.ice_getConnection() == test3.ice_getConnection());
names.Remove(getAdapterNameWithAMI(test1));
test1.ice_getConnection().close(Ice.ConnectionClose.GracefullyWithWait);
}
//
// Ensure that the proxy correctly caches the connection(we
// always send the request over the same connection.)
//
{
foreach (var adpt in adapters)
{
adpt.getTestIntf().ice_ping();
}
var t = createTestIntfPrx(adapters);
string name = getAdapterNameWithAMI(t);
int nRetry = 10;
int i;
for (i = 0; i < nRetry && getAdapterNameWithAMI(t).Equals(name); i++)
{
;
}
test(i == nRetry);
foreach (var adpt in adapters)
{
adpt.getTestIntf().ice_getConnection().close(Ice.ConnectionClose.GracefullyWithWait);
}
}
//
// Deactivate an adapter and ensure that we can still
// establish the connection to the remaining adapters.
//
com.deactivateObjectAdapter(adapters[0]);
names.Add("AdapterAMI12");
names.Add("AdapterAMI13");
while (names.Count > 0)
{
var adpts = new List <Test.RemoteObjectAdapterPrx>(adapters);
var test1 = createTestIntfPrx(adpts);
shuffle(ref adpts);
var test2 = createTestIntfPrx(adpts);
shuffle(ref adpts);
var test3 = createTestIntfPrx(adpts);
test(test1.ice_getConnection() == test2.ice_getConnection());
test(test2.ice_getConnection() == test3.ice_getConnection());
names.Remove(getAdapterNameWithAMI(test1));
test1.ice_getConnection().close(Ice.ConnectionClose.GracefullyWithWait);
}
//
// Deactivate an adapter and ensure that we can still
// establish the connection to the remaining adapter.
//
com.deactivateObjectAdapter(adapters[2]);
var obj = createTestIntfPrx(adapters);
test(getAdapterNameWithAMI(obj).Equals("AdapterAMI12"));
deactivate(com, adapters);
}
output.WriteLine("ok");
output.Write("testing random endpoint selection... ");
output.Flush();
{
var adapters = new List <Test.RemoteObjectAdapterPrx>();
adapters.Add(com.createObjectAdapter("Adapter21", "default"));
adapters.Add(com.createObjectAdapter("Adapter22", "default"));
adapters.Add(com.createObjectAdapter("Adapter23", "default"));
var obj = createTestIntfPrx(adapters);
test(obj.ice_getEndpointSelection() == Ice.EndpointSelectionType.Random);
var names = new List <string>();
names.Add("Adapter21");
names.Add("Adapter22");
names.Add("Adapter23");
while (names.Count > 0)
{
names.Remove(obj.getAdapterName());
obj.ice_getConnection().close(Ice.ConnectionClose.GracefullyWithWait);
}
obj = Test.TestIntfPrxHelper.uncheckedCast(obj.ice_endpointSelection(Ice.EndpointSelectionType.Random));
test(obj.ice_getEndpointSelection() == Ice.EndpointSelectionType.Random);
names.Add("Adapter21");
names.Add("Adapter22");
names.Add("Adapter23");
while (names.Count > 0)
{
names.Remove(obj.getAdapterName());
obj.ice_getConnection().close(Ice.ConnectionClose.GracefullyWithWait);
}
deactivate(com, adapters);
}
output.WriteLine("ok");
output.Write("testing ordered endpoint selection... ");
output.Flush();
{
var adapters = new List <Test.RemoteObjectAdapterPrx>();
adapters.Add(com.createObjectAdapter("Adapter31", "default"));
adapters.Add(com.createObjectAdapter("Adapter32", "default"));
adapters.Add(com.createObjectAdapter("Adapter33", "default"));
var obj = createTestIntfPrx(adapters);
obj = Test.TestIntfPrxHelper.uncheckedCast(obj.ice_endpointSelection(Ice.EndpointSelectionType.Ordered));
test(obj.ice_getEndpointSelection() == Ice.EndpointSelectionType.Ordered);
int nRetry = 3;
int i;
//
// Ensure that endpoints are tried in order by deactiving the adapters
// one after the other.
//
for (i = 0; i < nRetry && obj.getAdapterName().Equals("Adapter31"); i++)
{
;
}
test(i == nRetry);
com.deactivateObjectAdapter(adapters[0]);
for (i = 0; i < nRetry && obj.getAdapterName().Equals("Adapter32"); i++)
{
;
}
test(i == nRetry);
com.deactivateObjectAdapter(adapters[1]);
for (i = 0; i < nRetry && obj.getAdapterName().Equals("Adapter33"); i++)
{
;
}
test(i == nRetry);
com.deactivateObjectAdapter(adapters[2]);
try
{
obj.getAdapterName();
}
catch (Ice.ConnectFailedException)
{
}
catch (Ice.ConnectTimeoutException)
{
}
Ice.Endpoint[] endpoints = obj.ice_getEndpoints();
adapters.Clear();
//
// Now, re-activate the adapters with the same endpoints in the opposite
// order.
//
adapters.Add(com.createObjectAdapter("Adapter36", endpoints[2].ToString()));
for (i = 0; i < nRetry && obj.getAdapterName().Equals("Adapter36"); i++)
{
;
}
test(i == nRetry);
obj.ice_getConnection().close(Ice.ConnectionClose.GracefullyWithWait);
adapters.Add(com.createObjectAdapter("Adapter35", endpoints[1].ToString()));
for (i = 0; i < nRetry && obj.getAdapterName().Equals("Adapter35"); i++)
{
;
}
test(i == nRetry);
obj.ice_getConnection().close(Ice.ConnectionClose.GracefullyWithWait);
adapters.Add(com.createObjectAdapter("Adapter34", endpoints[0].ToString()));
for (i = 0; i < nRetry && obj.getAdapterName().Equals("Adapter34"); i++)
{
;
}
test(i == nRetry);
deactivate(com, adapters);
}
output.WriteLine("ok");
output.Write("testing per request binding with single endpoint... ");
output.Flush();
{
var adapter = com.createObjectAdapter("Adapter41", "default");
var test1 = Test.TestIntfPrxHelper.uncheckedCast(adapter.getTestIntf().ice_connectionCached(false));
var test2 = Test.TestIntfPrxHelper.uncheckedCast(adapter.getTestIntf().ice_connectionCached(false));
test(!test1.ice_isConnectionCached());
test(!test2.ice_isConnectionCached());
test(test1.ice_getConnection() != null && test2.ice_getConnection() != null);
test(test1.ice_getConnection() == test2.ice_getConnection());
test1.ice_ping();
com.deactivateObjectAdapter(adapter);
var test3 = Test.TestIntfPrxHelper.uncheckedCast(test1);
try
{
test(test3.ice_getConnection() == test1.ice_getConnection());
test(false);
}
catch (Ice.ConnectFailedException)
{
}
catch (Ice.ConnectTimeoutException)
{
}
}
output.WriteLine("ok");
output.Write("testing per request binding with multiple endpoints... ");
output.Flush();
{
var adapters = new List <Test.RemoteObjectAdapterPrx>();
adapters.Add(com.createObjectAdapter("Adapter51", "default"));
adapters.Add(com.createObjectAdapter("Adapter52", "default"));
adapters.Add(com.createObjectAdapter("Adapter53", "default"));
var obj = Test.TestIntfPrxHelper.uncheckedCast(createTestIntfPrx(adapters).ice_connectionCached(false));
test(!obj.ice_isConnectionCached());
List <string> names = new List <string>();
names.Add("Adapter51");
names.Add("Adapter52");
names.Add("Adapter53");
while (names.Count > 0)
{
names.Remove(obj.getAdapterName());
}
com.deactivateObjectAdapter(adapters[0]);
names.Add("Adapter52");
names.Add("Adapter53");
while (names.Count > 0)
{
names.Remove(obj.getAdapterName());
}
com.deactivateObjectAdapter(adapters[2]);
test(obj.getAdapterName().Equals("Adapter52"));
deactivate(com, adapters);
}
output.WriteLine("ok");
output.Write("testing per request binding with multiple endpoints and AMI... ");
output.Flush();
{
var adapters = new List <Test.RemoteObjectAdapterPrx>();
adapters.Add(com.createObjectAdapter("AdapterAMI51", "default"));
adapters.Add(com.createObjectAdapter("AdapterAMI52", "default"));
adapters.Add(com.createObjectAdapter("AdapterAMI53", "default"));
var obj = Test.TestIntfPrxHelper.uncheckedCast(createTestIntfPrx(adapters).ice_connectionCached(false));
test(!obj.ice_isConnectionCached());
var names = new List <string>();
names.Add("AdapterAMI51");
names.Add("AdapterAMI52");
names.Add("AdapterAMI53");
while (names.Count > 0)
{
names.Remove(getAdapterNameWithAMI(obj));
}
com.deactivateObjectAdapter(adapters[0]);
names.Add("AdapterAMI52");
names.Add("AdapterAMI53");
while (names.Count > 0)
{
names.Remove(getAdapterNameWithAMI(obj));
}
com.deactivateObjectAdapter(adapters[2]);
test(getAdapterNameWithAMI(obj).Equals("AdapterAMI52"));
deactivate(com, adapters);
}
output.WriteLine("ok");
output.Write("testing per request binding and ordered endpoint selection... ");
output.Flush();
{
var adapters = new List <Test.RemoteObjectAdapterPrx>();
adapters.Add(com.createObjectAdapter("Adapter61", "default"));
adapters.Add(com.createObjectAdapter("Adapter62", "default"));
adapters.Add(com.createObjectAdapter("Adapter63", "default"));
var obj = createTestIntfPrx(adapters);
obj = Test.TestIntfPrxHelper.uncheckedCast(obj.ice_endpointSelection(Ice.EndpointSelectionType.Ordered));
test(obj.ice_getEndpointSelection() == Ice.EndpointSelectionType.Ordered);
obj = Test.TestIntfPrxHelper.uncheckedCast(obj.ice_connectionCached(false));
test(!obj.ice_isConnectionCached());
int nRetry = 3;
int i;
//
// Ensure that endpoints are tried in order by deactiving the adapters
// one after the other.
//
for (i = 0; i < nRetry && obj.getAdapterName().Equals("Adapter61"); i++)
{
;
}
test(i == nRetry);
com.deactivateObjectAdapter(adapters[0]);
for (i = 0; i < nRetry && obj.getAdapterName().Equals("Adapter62"); i++)
{
;
}
test(i == nRetry);
com.deactivateObjectAdapter(adapters[1]);
for (i = 0; i < nRetry && obj.getAdapterName().Equals("Adapter63"); i++)
{
;
}
test(i == nRetry);
com.deactivateObjectAdapter(adapters[2]);
try
{
obj.getAdapterName();
}
catch (Ice.ConnectFailedException)
{
}
catch (Ice.ConnectTimeoutException)
{
}
Ice.Endpoint[] endpoints = obj.ice_getEndpoints();
adapters.Clear();
//
// Now, re-activate the adapters with the same endpoints in the opposite
// order.
//
adapters.Add(com.createObjectAdapter("Adapter66", endpoints[2].ToString()));
for (i = 0; i < nRetry && obj.getAdapterName().Equals("Adapter66"); i++)
{
;
}
test(i == nRetry);
adapters.Add(com.createObjectAdapter("Adapter65", endpoints[1].ToString()));
for (i = 0; i < nRetry && obj.getAdapterName().Equals("Adapter65"); i++)
{
;
}
test(i == nRetry);
adapters.Add(com.createObjectAdapter("Adapter64", endpoints[0].ToString()));
for (i = 0; i < nRetry && obj.getAdapterName().Equals("Adapter64"); i++)
{
;
}
test(i == nRetry);
deactivate(com, adapters);
}
output.WriteLine("ok");
output.Write("testing per request binding and ordered endpoint selection and AMI... ");
output.Flush();
{
var adapters = new List <Test.RemoteObjectAdapterPrx>();
adapters.Add(com.createObjectAdapter("AdapterAMI61", "default"));
adapters.Add(com.createObjectAdapter("AdapterAMI62", "default"));
adapters.Add(com.createObjectAdapter("AdapterAMI63", "default"));
var obj = createTestIntfPrx(adapters);
obj = Test.TestIntfPrxHelper.uncheckedCast(obj.ice_endpointSelection(Ice.EndpointSelectionType.Ordered));
test(obj.ice_getEndpointSelection() == Ice.EndpointSelectionType.Ordered);
obj = Test.TestIntfPrxHelper.uncheckedCast(obj.ice_connectionCached(false));
test(!obj.ice_isConnectionCached());
int nRetry = 3;
int i;
//
// Ensure that endpoints are tried in order by deactiving the adapters
// one after the other.
//
for (i = 0; i < nRetry && getAdapterNameWithAMI(obj).Equals("AdapterAMI61"); i++)
{
;
}
test(i == nRetry);
com.deactivateObjectAdapter(adapters[0]);
for (i = 0; i < nRetry && getAdapterNameWithAMI(obj).Equals("AdapterAMI62"); i++)
{
;
}
test(i == nRetry);
com.deactivateObjectAdapter(adapters[1]);
for (i = 0; i < nRetry && getAdapterNameWithAMI(obj).Equals("AdapterAMI63"); i++)
{
;
}
test(i == nRetry);
com.deactivateObjectAdapter(adapters[2]);
try
{
obj.getAdapterName();
}
catch (Ice.ConnectFailedException)
{
}
catch (Ice.ConnectTimeoutException)
{
}
Ice.Endpoint[] endpoints = obj.ice_getEndpoints();
adapters.Clear();
//
// Now, re-activate the adapters with the same endpoints in the opposite
// order.
//
adapters.Add(com.createObjectAdapter("AdapterAMI66", endpoints[2].ToString()));
for (i = 0; i < nRetry && getAdapterNameWithAMI(obj).Equals("AdapterAMI66"); i++)
{
;
}
test(i == nRetry);
adapters.Add(com.createObjectAdapter("AdapterAMI65", endpoints[1].ToString()));
for (i = 0; i < nRetry && getAdapterNameWithAMI(obj).Equals("AdapterAMI65"); i++)
{
;
}
test(i == nRetry);
adapters.Add(com.createObjectAdapter("AdapterAMI64", endpoints[0].ToString()));
for (i = 0; i < nRetry && getAdapterNameWithAMI(obj).Equals("AdapterAMI64"); i++)
{
;
}
test(i == nRetry);
deactivate(com, adapters);
}
output.WriteLine("ok");
output.Write("testing endpoint mode filtering... ");
output.Flush();
{
var adapters = new List <Test.RemoteObjectAdapterPrx>();
adapters.Add(com.createObjectAdapter("Adapter71", "default"));
adapters.Add(com.createObjectAdapter("Adapter72", "udp"));
var obj = createTestIntfPrx(adapters);
test(obj.getAdapterName().Equals("Adapter71"));
var testUDP = Test.TestIntfPrxHelper.uncheckedCast(obj.ice_datagram());
test(obj.ice_getConnection() != testUDP.ice_getConnection());
try
{
testUDP.getAdapterName();
}
catch (Ice.TwowayOnlyException)
{
}
}
output.WriteLine("ok");
if (communicator.getProperties().getProperty("Ice.Plugin.IceSSL").Length > 0)
{
output.Write("testing unsecure vs. secure endpoints... ");
output.Flush();
{
var adapters = new List <Test.RemoteObjectAdapterPrx>();
adapters.Add(com.createObjectAdapter("Adapter81", "ssl"));
adapters.Add(com.createObjectAdapter("Adapter82", "tcp"));
var obj = createTestIntfPrx(adapters);
int i;
for (i = 0; i < 5; i++)
{
test(obj.getAdapterName().Equals("Adapter82"));
obj.ice_getConnection().close(Ice.ConnectionClose.GracefullyWithWait);
}
var testSecure = Test.TestIntfPrxHelper.uncheckedCast(obj.ice_secure(true));
test(testSecure.ice_isSecure());
testSecure = Test.TestIntfPrxHelper.uncheckedCast(obj.ice_secure(false));
test(!testSecure.ice_isSecure());
testSecure = Test.TestIntfPrxHelper.uncheckedCast(obj.ice_secure(true));
test(testSecure.ice_isSecure());
test(obj.ice_getConnection() != testSecure.ice_getConnection());
com.deactivateObjectAdapter(adapters[1]);
for (i = 0; i < 5; i++)
{
test(obj.getAdapterName().Equals("Adapter81"));
obj.ice_getConnection().close(Ice.ConnectionClose.GracefullyWithWait);
}
com.createObjectAdapter("Adapter83", (obj.ice_getEndpoints()[1]).ToString()); // Reactive tcp OA.
for (i = 0; i < 5; i++)
{
test(obj.getAdapterName().Equals("Adapter83"));
obj.ice_getConnection().close(Ice.ConnectionClose.GracefullyWithWait);
}
com.deactivateObjectAdapter(adapters[0]);
try
{
testSecure.ice_ping();
test(false);
}
catch (Ice.ConnectFailedException)
{
}
catch (Ice.ConnectTimeoutException)
{
}
deactivate(com, adapters);
}
output.WriteLine("ok");
}
{
output.Write("testing ipv4 & ipv6 connections... ");
output.Flush();
Ice.Properties ipv4 = Ice.Util.createProperties();
ipv4.setProperty("Ice.IPv4", "1");
ipv4.setProperty("Ice.IPv6", "0");
ipv4.setProperty("Adapter.Endpoints", "tcp -h localhost");
Ice.Properties ipv6 = Ice.Util.createProperties();
ipv6.setProperty("Ice.IPv4", "0");
ipv6.setProperty("Ice.IPv6", "1");
ipv6.setProperty("Adapter.Endpoints", "tcp -h localhost");
Ice.Properties bothPreferIPv4 = Ice.Util.createProperties();
bothPreferIPv4.setProperty("Ice.IPv4", "1");
bothPreferIPv4.setProperty("Ice.IPv6", "1");
bothPreferIPv4.setProperty("Ice.PreferIPv6Address", "0");
bothPreferIPv4.setProperty("Adapter.Endpoints", "tcp -h localhost");
Ice.Properties bothPreferIPv6 = Ice.Util.createProperties();
bothPreferIPv6.setProperty("Ice.IPv4", "1");
bothPreferIPv6.setProperty("Ice.IPv6", "1");
bothPreferIPv6.setProperty("Ice.PreferIPv6Address", "1");
bothPreferIPv6.setProperty("Adapter.Endpoints", "tcp -h localhost");
List <Ice.Properties> clientProps = new List <Ice.Properties>();
clientProps.Add(ipv4);
clientProps.Add(ipv6);
clientProps.Add(bothPreferIPv4);
clientProps.Add(bothPreferIPv6);
string endpoint = "tcp -p " + helper.getTestPort(2).ToString();
Ice.Properties anyipv4 = ipv4.ice_clone_();
anyipv4.setProperty("Adapter.Endpoints", endpoint);
anyipv4.setProperty("Adapter.PublishedEndpoints", endpoint + " -h 127.0.0.1");
Ice.Properties anyipv6 = ipv6.ice_clone_();
anyipv6.setProperty("Adapter.Endpoints", endpoint);
anyipv6.setProperty("Adapter.PublishedEndpoints", endpoint + " -h \".1\"");
Ice.Properties anyboth = Ice.Util.createProperties();
anyboth.setProperty("Ice.IPv4", "1");
anyboth.setProperty("Ice.IPv6", "1");
anyboth.setProperty("Adapter.Endpoints", endpoint);
anyboth.setProperty("Adapter.PublishedEndpoints", endpoint + " -h \"::1\":" + endpoint + " -h 127.0.0.1");
Ice.Properties localipv4 = ipv4.ice_clone_();
localipv4.setProperty("Adapter.Endpoints", "tcp -h 127.0.0.1");
Ice.Properties localipv6 = ipv6.ice_clone_();
localipv6.setProperty("Adapter.Endpoints", "tcp -h \"::1\"");
List <Ice.Properties> serverProps = new List <Ice.Properties>(clientProps);
serverProps.Add(anyipv4);
serverProps.Add(anyipv6);
serverProps.Add(anyboth);
serverProps.Add(localipv4);
serverProps.Add(localipv6);
bool ipv6NotSupported = false;
foreach (Ice.Properties p in serverProps)
{
Ice.InitializationData serverInitData = new Ice.InitializationData();
serverInitData.properties = p;
Ice.Communicator serverCommunicator = Ice.Util.initialize(serverInitData);
Ice.ObjectAdapter oa;
try
{
oa = serverCommunicator.createObjectAdapter("Adapter");
oa.activate();
}
catch (Ice.DNSException)
{
serverCommunicator.destroy();
continue; // IP version not supported.
}
catch (Ice.SocketException)
{
if (p == ipv6)
{
ipv6NotSupported = true;
}
serverCommunicator.destroy();
continue; // IP version not supported.
}
Ice.ObjectPrx prx = oa.createProxy(Ice.Util.stringToIdentity("dummy"));
try
{
prx.ice_collocationOptimized(false).ice_ping();
}
catch (Ice.LocalException)
{
serverCommunicator.destroy();
continue; // IP version not supported.
}
string strPrx = prx.ToString();
foreach (Ice.Properties q in clientProps)
{
Ice.InitializationData clientInitData = new Ice.InitializationData();
clientInitData.properties = q;
Ice.Communicator clientCommunicator = Ice.Util.initialize(clientInitData);
prx = clientCommunicator.stringToProxy(strPrx);
try
{
prx.ice_ping();
test(false);
}
catch (Ice.ObjectNotExistException)
{
// Expected, no object registered.
}
catch (Ice.DNSException)
{
// Expected if no IPv4 or IPv6 address is
// associated to localhost or if trying to connect
// to an any endpoint with the wrong IP version,
// e.g.: resolving an IPv4 address when only IPv6
// is enabled fails with a DNS exception.
}
catch (Ice.SocketException)
{
test((p == ipv4 && q == ipv6) || (p == ipv6 && q == ipv4) ||
(p == bothPreferIPv4 && q == ipv6) || (p == bothPreferIPv6 && q == ipv4) ||
(p == bothPreferIPv6 && q == ipv6 && ipv6NotSupported) ||
(p == anyipv4 && q == ipv6) || (p == anyipv6 && q == ipv4) ||
(p == localipv4 && q == ipv6) || (p == localipv6 && q == ipv4) ||
(p == ipv6 && q == bothPreferIPv4) || (p == ipv6 && q == bothPreferIPv6) ||
(p == bothPreferIPv6 && q == ipv6));
}
clientCommunicator.destroy();
}
serverCommunicator.destroy();
}
output.WriteLine("ok");
}
com.shutdown();
}
public override void startServer(Ice.Current current)
{
foreach (Ice.Communicator c in _communicators)
{
c.waitForShutdown();
c.destroy();
}
_communicators.Clear();
//
// Simulate a server: create a new communicator and object
// adapter. The object adapter is started on a system allocated
// port. The configuration used here contains the Ice.Locator
// configuration variable. The new object adapter will register
// its endpoints with the locator and create references containing
// the adapter id instead of the endpoints.
//
Ice.InitializationData initData = new Ice.InitializationData();
initData.properties = _helper.communicator().getProperties().ice_clone_();
initData.properties.setProperty("TestAdapter.AdapterId", "TestAdapter");
initData.properties.setProperty("TestAdapter.ReplicaGroupId", "ReplicatedAdapter");
initData.properties.setProperty("TestAdapter2.AdapterId", "TestAdapter2");
Ice.Communicator serverCommunicator = _helper.initialize(initData);
_communicators.Add(serverCommunicator);
//
// Use fixed port to ensure that OA re-activation doesn't re-use previous port from
// another OA(e.g.: TestAdapter2 is re-activated using port of TestAdapter).
//
int nRetry = 10;
while (--nRetry > 0)
{
Ice.ObjectAdapter adapter = null;
Ice.ObjectAdapter adapter2 = null;
try
{
serverCommunicator.getProperties().setProperty("TestAdapter.Endpoints",
_helper.getTestEndpoint(_nextPort++));
serverCommunicator.getProperties().setProperty("TestAdapter2.Endpoints",
_helper.getTestEndpoint(_nextPort++));
adapter = serverCommunicator.createObjectAdapter("TestAdapter");
adapter2 = serverCommunicator.createObjectAdapter("TestAdapter2");
Ice.ObjectPrx locator = serverCommunicator.stringToProxy("locator:" + _helper.getTestEndpoint(0));
adapter.setLocator(Ice.LocatorPrxHelper.uncheckedCast(locator));
adapter2.setLocator(Ice.LocatorPrxHelper.uncheckedCast(locator));
Ice.Object @object = new TestI(adapter, adapter2, _registry);
_registry.addObject(adapter.add(@object, Ice.Util.stringToIdentity("test")));
_registry.addObject(adapter.add(@object, Ice.Util.stringToIdentity("test2")));
adapter.add(@object, Ice.Util.stringToIdentity("test3"));
adapter.activate();
adapter2.activate();
break;
}
catch (Ice.SocketException ex)
{
if (nRetry == 0)
{
throw ex;
}
// Retry, if OA creation fails with EADDRINUSE(this can occur when running with JS web
// browser clients if the driver uses ports in the same range as this test, ICE-8148)
if (adapter != null)
{
adapter.destroy();
}
if (adapter2 != null)
{
adapter2.destroy();
}
}
}
}
public static Test.GPrx allTests(global::Test.TestHelper helper)
{
Ice.Communicator communicator = helper.communicator();
var output = helper.getWriter();
output.Write("testing Ice.Admin.Facets property... ");
test(communicator.getProperties().getPropertyAsList("Ice.Admin.Facets").Length == 0);
communicator.getProperties().setProperty("Ice.Admin.Facets", "foobar");
String[] facetFilter = communicator.getProperties().getPropertyAsList("Ice.Admin.Facets");
test(facetFilter.Length == 1 && facetFilter[0].Equals("foobar"));
communicator.getProperties().setProperty("Ice.Admin.Facets", "foo\\'bar");
facetFilter = communicator.getProperties().getPropertyAsList("Ice.Admin.Facets");
test(facetFilter.Length == 1 && facetFilter[0].Equals("foo'bar"));
communicator.getProperties().setProperty("Ice.Admin.Facets", "'foo bar' toto 'titi'");
facetFilter = communicator.getProperties().getPropertyAsList("Ice.Admin.Facets");
test(facetFilter.Length == 3 && facetFilter[0].Equals("foo bar") && facetFilter[1].Equals("toto") &&
facetFilter[2].Equals("titi"));
communicator.getProperties().setProperty("Ice.Admin.Facets", "'foo bar\\' toto' 'titi'");
facetFilter = communicator.getProperties().getPropertyAsList("Ice.Admin.Facets");
test(facetFilter.Length == 2 && facetFilter[0].Equals("foo bar' toto") && facetFilter[1].Equals("titi"));
// communicator.getProperties().setProperty("Ice.Admin.Facets", "'foo bar' 'toto titi");
// facetFilter = communicator.getProperties().getPropertyAsList("Ice.Admin.Facets");
// test(facetFilter.Length == 0);
communicator.getProperties().setProperty("Ice.Admin.Facets", "");
output.WriteLine("ok");
output.Write("testing facet registration exceptions... ");
communicator.getProperties().setProperty("FacetExceptionTestAdapter.Endpoints", "tcp -h *");
Ice.ObjectAdapter adapter = communicator.createObjectAdapter("FacetExceptionTestAdapter");
Ice.Object obj = new EmptyI();
adapter.add(obj, Ice.Util.stringToIdentity("d"));
adapter.addFacet(obj, Ice.Util.stringToIdentity("d"), "facetABCD");
try
{
adapter.addFacet(obj, Ice.Util.stringToIdentity("d"), "facetABCD");
test(false);
}
catch (Ice.AlreadyRegisteredException)
{
}
adapter.removeFacet(Ice.Util.stringToIdentity("d"), "facetABCD");
try
{
adapter.removeFacet(Ice.Util.stringToIdentity("d"), "facetABCD");
test(false);
}
catch (Ice.NotRegisteredException)
{
}
output.WriteLine("ok");
output.Write("testing removeAllFacets... ");
Ice.Object obj1 = new EmptyI();
Ice.Object obj2 = new EmptyI();
adapter.addFacet(obj1, Ice.Util.stringToIdentity("id1"), "f1");
adapter.addFacet(obj2, Ice.Util.stringToIdentity("id1"), "f2");
Ice.Object obj3 = new EmptyI();
adapter.addFacet(obj1, Ice.Util.stringToIdentity("id2"), "f1");
adapter.addFacet(obj2, Ice.Util.stringToIdentity("id2"), "f2");
adapter.addFacet(obj3, Ice.Util.stringToIdentity("id2"), "");
Dictionary <string, Ice.Object> fm
= adapter.removeAllFacets(Ice.Util.stringToIdentity("id1"));
test(fm.Count == 2);
test(fm["f1"] == obj1);
test(fm["f2"] == obj2);
try
{
adapter.removeAllFacets(Ice.Util.stringToIdentity("id1"));
test(false);
}
catch (Ice.NotRegisteredException)
{
}
fm = adapter.removeAllFacets(Ice.Util.stringToIdentity("id2"));
test(fm.Count == 3);
test(fm["f1"] == obj1);
test(fm["f2"] == obj2);
test(fm[""] == obj3);
output.WriteLine("ok");
adapter.deactivate();
output.Write("testing stringToProxy... ");
output.Flush();
string @ref = "d:" + helper.getTestEndpoint(0);
Ice.ObjectPrx db = communicator.stringToProxy(@ref);
test(db != null);
output.WriteLine("ok");
output.Write("testing unchecked cast... ");
output.Flush();
Ice.ObjectPrx prx = Ice.ObjectPrxHelper.uncheckedCast(db);
test(prx.ice_getFacet().Length == 0);
prx = Ice.ObjectPrxHelper.uncheckedCast(db, "facetABCD");
test(prx.ice_getFacet() == "facetABCD");
Ice.ObjectPrx prx2 = Ice.ObjectPrxHelper.uncheckedCast(prx);
test(prx2.ice_getFacet() == "facetABCD");
Ice.ObjectPrx prx3 = Ice.ObjectPrxHelper.uncheckedCast(prx, "");
test(prx3.ice_getFacet().Length == 0);
var d = Test.DPrxHelper.uncheckedCast(db);
test(d.ice_getFacet().Length == 0);
var df = Test.DPrxHelper.uncheckedCast(db, "facetABCD");
test(df.ice_getFacet() == "facetABCD");
var df2 = Test.DPrxHelper.uncheckedCast(df);
test(df2.ice_getFacet() == "facetABCD");
var df3 = Test.DPrxHelper.uncheckedCast(df, "");
test(df3.ice_getFacet().Length == 0);
output.WriteLine("ok");
output.Write("testing checked cast... ");
output.Flush();
prx = Ice.ObjectPrxHelper.checkedCast(db);
test(prx.ice_getFacet().Length == 0);
prx = Ice.ObjectPrxHelper.checkedCast(db, "facetABCD");
test(prx.ice_getFacet() == "facetABCD");
prx2 = Ice.ObjectPrxHelper.checkedCast(prx);
test(prx2.ice_getFacet() == "facetABCD");
prx3 = Ice.ObjectPrxHelper.checkedCast(prx, "");
test(prx3.ice_getFacet().Length == 0);
d = Test.DPrxHelper.checkedCast(db);
test(d.ice_getFacet().Length == 0);
df = Test.DPrxHelper.checkedCast(db, "facetABCD");
test(df.ice_getFacet() == "facetABCD");
df2 = Test.DPrxHelper.checkedCast(df);
test(df2.ice_getFacet() == "facetABCD");
df3 = Test.DPrxHelper.checkedCast(df, "");
test(df3.ice_getFacet().Length == 0);
output.WriteLine("ok");
output.Write("testing non-facets A, B, C, and D... ");
output.Flush();
d = Test.DPrxHelper.checkedCast(db);
test(d != null);
test(d.Equals(db));
test(d.callA().Equals("A"));
test(d.callB().Equals("B"));
test(d.callC().Equals("C"));
test(d.callD().Equals("D"));
output.WriteLine("ok");
output.Write("testing facets A, B, C, and D... ");
output.Flush();
df = Test.DPrxHelper.checkedCast(d, "facetABCD");
test(df != null);
test(df.callA().Equals("A"));
test(df.callB().Equals("B"));
test(df.callC().Equals("C"));
test(df.callD().Equals("D"));
output.WriteLine("ok");
output.Write("testing facets E and F... ");
output.Flush();
var ff = Test.FPrxHelper.checkedCast(d, "facetEF");
test(ff != null);
test(ff.callE().Equals("E"));
test(ff.callF().Equals("F"));
output.WriteLine("ok");
output.Write("testing facet G... ");
output.Flush();
var gf = Test.GPrxHelper.checkedCast(ff, "facetGH");
test(gf != null);
test(gf.callG().Equals("G"));
output.WriteLine("ok");
output.Write("testing whether casting preserves the facet... ");
output.Flush();
var hf = Test.HPrxHelper.checkedCast(gf);
test(hf != null);
test(hf.callG().Equals("G"));
test(hf.callH().Equals("H"));
output.WriteLine("ok");
return(gf);
}
public void Initialize(IScene scene)
{
try
{
if (!m_enabled)
{
return;
}
IMurmurService service = scene.RequestModuleInterface <IMurmurService>();
if (service == null)
{
return;
}
MurmurConfig config = service.GetConfiguration(scene.RegionInfo.RegionName);
if (config == null)
{
return;
}
bool justStarted = false;
if (!m_started)
{
justStarted = true;
m_started = true;
// retrieve configuration variables
m_murmurd_host = config.MurmurHost;
m_server_version = config.ServerVersion;
//Fix the callback URL, its our IP, so we deal with it
IConfig m_config = m_source.Configs["MurmurService"];
if (m_config != null)
{
config.IceCB = m_config.GetString("murmur_ice_cb", "tcp -h 127.0.0.1");
}
// Admin interface required values
if (String.IsNullOrEmpty(m_murmurd_host))
{
m_log.Error("[MurmurVoice] plugin disabled: incomplete configuration");
return;
}
Ice.Communicator comm = Ice.Util.initialize();
if (config.GlacierEnabled)
{
router = RouterPrxHelper.uncheckedCast(comm.stringToProxy(config.GlacierIce));
comm.setDefaultRouter(router);
router.createSession(config.GlacierUser, config.GlacierPass);
}
MetaPrx meta = MetaPrxHelper.checkedCast(comm.stringToProxy(config.MetaIce));
// Create the adapter
comm.getProperties().setProperty("Ice.PrintAdapterReady", "0");
if (config.GlacierEnabled)
{
adapter = comm.createObjectAdapterWithRouter("Callback.Client", comm.getDefaultRouter());
}
else
{
adapter = comm.createObjectAdapterWithEndpoints("Callback.Client", config.IceCB);
}
adapter.activate();
// Create identity and callback for Metaserver
Ice.Identity metaCallbackIdent = new Ice.Identity();
metaCallbackIdent.name = "metaCallback";
if (router != null)
{
metaCallbackIdent.category = router.getCategoryForClient();
}
MetaCallbackPrx meta_callback = MetaCallbackPrxHelper.checkedCast(adapter.add(new MetaCallbackImpl(), metaCallbackIdent));
meta.addCallback(meta_callback);
m_log.InfoFormat("[MurmurVoice] using murmur server ice '{0}'", config.MetaIce);
// create a server and figure out the port name
Dictionary <string, string> defaults = meta.getDefaultConf();
m_server = ServerPrxHelper.checkedCast(meta.getServer(config.ServerID));
// start thread to ping glacier2 router and/or determine if con$
m_keepalive = new KeepAlive(m_server);
ThreadStart ka_d = new ThreadStart(m_keepalive.StartPinging);
m_keepalive_t = new Thread(ka_d);
m_keepalive_t.Start();
// first check the conf for a port, if not then use server id and default port to find the right one.
string conf_port = m_server.getConf("port");
if (!String.IsNullOrEmpty(conf_port))
{
m_murmurd_port = Convert.ToInt32(conf_port);
}
else
{
m_murmurd_port = Convert.ToInt32(defaults["port"]) + config.ServerID - 1;
}
try
{
m_server.start();
}
catch
{
}
}
// starts the server and gets a callback
ServerManager manager = new ServerManager(m_server, config.ChannelName);
// Create identity and callback for this current server
AddServerCallback(scene, new ServerCallbackImpl(manager));
AddServerManager(scene, manager);
if (justStarted)
{
Ice.Identity serverCallbackIdent = new Ice.Identity();
serverCallbackIdent.name = "serverCallback";
if (router != null)
{
serverCallbackIdent.category = router.getCategoryForClient();
}
m_server.addCallback(ServerCallbackPrxHelper.checkedCast(adapter.add(GetServerCallback(scene), serverCallbackIdent)));
}
// Show information on console for debugging purposes
m_log.InfoFormat("[MurmurVoice] using murmur server '{0}:{1}', sid '{2}'", m_murmurd_host, m_murmurd_port, config.ServerID);
m_log.Info("[MurmurVoice] plugin enabled");
m_enabled = true;
}
catch (Exception e)
{
m_log.ErrorFormat("[MurmurVoice] plugin initialization failed: {0}", e.ToString());
return;
}
}
public static Test.TestIntfPrx allTests(global::Test.TestHelper helper)
{
Ice.Communicator communicator = helper.communicator();
string sref = "test:" + helper.getTestEndpoint(0);
var obj = IObjectPrx.Parse(sref, communicator);
test(obj != null);
var proxy = Test.TestIntfPrx.UncheckedCast(obj);
test(proxy != null);
var output = helper.getWriter();
output.Write("testing enum values... ");
output.Flush();
test((int)Test.ByteEnum.benum1 == 0);
test((int)Test.ByteEnum.benum2 == 1);
test((int)Test.ByteEnum.benum3 == Test.ByteConst1.value);
test((int)Test.ByteEnum.benum4 == Test.ByteConst1.value + 1);
test((int)Test.ByteEnum.benum5 == Test.ShortConst1.value);
test((int)Test.ByteEnum.benum6 == Test.ShortConst1.value + 1);
test((int)Test.ByteEnum.benum7 == Test.IntConst1.value);
test((int)Test.ByteEnum.benum8 == Test.IntConst1.value + 1);
test((int)Test.ByteEnum.benum9 == Test.LongConst1.value);
test((int)Test.ByteEnum.benum10 == Test.LongConst1.value + 1);
test((int)Test.ByteEnum.benum11 == Test.ByteConst2.value);
test((int)Test.ShortEnum.senum1 == 3);
test((int)Test.ShortEnum.senum2 == 4);
test((int)Test.ShortEnum.senum3 == Test.ByteConst1.value);
test((int)Test.ShortEnum.senum4 == Test.ByteConst1.value + 1);
test((int)Test.ShortEnum.senum5 == Test.ShortConst1.value);
test((int)Test.ShortEnum.senum6 == Test.ShortConst1.value + 1);
test((int)Test.ShortEnum.senum7 == Test.IntConst1.value);
test((int)Test.ShortEnum.senum8 == Test.IntConst1.value + 1);
test((int)Test.ShortEnum.senum9 == Test.LongConst1.value);
test((int)Test.ShortEnum.senum10 == Test.LongConst1.value + 1);
test((int)Test.ShortEnum.senum11 == Test.ShortConst2.value);
test((int)Test.IntEnum.ienum1 == 0);
test((int)Test.IntEnum.ienum2 == 1);
test((int)Test.IntEnum.ienum3 == Test.ByteConst1.value);
test((int)Test.IntEnum.ienum4 == Test.ByteConst1.value + 1);
test((int)Test.IntEnum.ienum5 == Test.ShortConst1.value);
test((int)Test.IntEnum.ienum6 == Test.ShortConst1.value + 1);
test((int)Test.IntEnum.ienum7 == Test.IntConst1.value);
test((int)Test.IntEnum.ienum8 == Test.IntConst1.value + 1);
test((int)Test.IntEnum.ienum9 == Test.LongConst1.value);
test((int)Test.IntEnum.ienum10 == Test.LongConst1.value + 1);
test((int)Test.IntEnum.ienum11 == Test.IntConst2.value);
test((int)Test.IntEnum.ienum12 == Test.LongConst2.value);
test((int)Test.SimpleEnum.red == 0);
test((int)Test.SimpleEnum.green == 1);
test((int)Test.SimpleEnum.blue == 2);
output.WriteLine("ok");
output.Write("testing enum streaming... ");
output.Flush();
Ice.OutputStream ostr;
byte[] bytes;
bool encoding_1_0 = communicator.getProperties().getProperty("Ice.Default.EncodingVersion").Equals("1.0");
ostr = new Ice.OutputStream(communicator);
ostr.writeEnum((int)Test.ByteEnum.benum11, (int)Test.ByteEnum.benum11);
bytes = ostr.finished();
test(bytes.Length == 1); // ByteEnum should require one byte
ostr = new Ice.OutputStream(communicator);
ostr.writeEnum((int)Test.ShortEnum.senum11, (int)Test.ShortEnum.senum11);
bytes = ostr.finished();
test(bytes.Length == (encoding_1_0 ? 2 : 5));
ostr = new Ice.OutputStream(communicator);
ostr.writeEnum((int)Test.IntEnum.ienum11, (int)Test.IntEnum.ienum12);
bytes = ostr.finished();
test(bytes.Length == (encoding_1_0 ? 4 : 5));
ostr = new Ice.OutputStream(communicator);
ostr.writeEnum((int)Test.SimpleEnum.blue, (int)Test.SimpleEnum.blue);
bytes = ostr.finished();
test(bytes.Length == 1); // SimpleEnum should require one byte
output.WriteLine("ok");
output.Write("testing enum operations... ");
output.Flush();
Test.ByteEnum byteEnum;
test(proxy.opByte(Test.ByteEnum.benum1, out byteEnum) == Test.ByteEnum.benum1);
test(byteEnum == Test.ByteEnum.benum1);
test(proxy.opByte(Test.ByteEnum.benum11, out byteEnum) == Test.ByteEnum.benum11);
test(byteEnum == Test.ByteEnum.benum11);
Test.ShortEnum shortEnum;
test(proxy.opShort(Test.ShortEnum.senum1, out shortEnum) == Test.ShortEnum.senum1);
test(shortEnum == Test.ShortEnum.senum1);
test(proxy.opShort(Test.ShortEnum.senum11, out shortEnum) == Test.ShortEnum.senum11);
test(shortEnum == Test.ShortEnum.senum11);
Test.IntEnum intEnum;
test(proxy.opInt(Test.IntEnum.ienum1, out intEnum) == Test.IntEnum.ienum1);
test(intEnum == Test.IntEnum.ienum1);
test(proxy.opInt(Test.IntEnum.ienum11, out intEnum) == Test.IntEnum.ienum11);
test(intEnum == Test.IntEnum.ienum11);
test(proxy.opInt(Test.IntEnum.ienum12, out intEnum) == Test.IntEnum.ienum12);
test(intEnum == Test.IntEnum.ienum12);
Test.SimpleEnum s;
test(proxy.opSimple(Test.SimpleEnum.green, out s) == Test.SimpleEnum.green);
test(s == Test.SimpleEnum.green);
output.WriteLine("ok");
output.Write("testing enum sequences operations... ");
output.Flush();
{
var b1 = new Test.ByteEnum[11]
{
Test.ByteEnum.benum1,
Test.ByteEnum.benum2,
Test.ByteEnum.benum3,
Test.ByteEnum.benum4,
Test.ByteEnum.benum5,
Test.ByteEnum.benum6,
Test.ByteEnum.benum7,
Test.ByteEnum.benum8,
Test.ByteEnum.benum9,
Test.ByteEnum.benum10,
Test.ByteEnum.benum11
};
Test.ByteEnum[] b2;
Test.ByteEnum[] b3 = proxy.opByteSeq(b1, out b2);
for (int i = 0; i < b1.Length; ++i)
{
test(b1[i] == b2[i]);
test(b1[i] == b3[i]);
}
}
{
var s1 = new Test.ShortEnum[11]
{
Test.ShortEnum.senum1,
Test.ShortEnum.senum2,
Test.ShortEnum.senum3,
Test.ShortEnum.senum4,
Test.ShortEnum.senum5,
Test.ShortEnum.senum6,
Test.ShortEnum.senum7,
Test.ShortEnum.senum8,
Test.ShortEnum.senum9,
Test.ShortEnum.senum10,
Test.ShortEnum.senum11
};
Test.ShortEnum[] s2;
Test.ShortEnum[] s3 = proxy.opShortSeq(s1, out s2);
for (int i = 0; i < s1.Length; ++i)
{
test(s1[i] == s2[i]);
test(s1[i] == s3[i]);
}
}
{
Test.IntEnum[] i1 = new Test.IntEnum[11]
{
Test.IntEnum.ienum1,
Test.IntEnum.ienum2,
Test.IntEnum.ienum3,
Test.IntEnum.ienum4,
Test.IntEnum.ienum5,
Test.IntEnum.ienum6,
Test.IntEnum.ienum7,
Test.IntEnum.ienum8,
Test.IntEnum.ienum9,
Test.IntEnum.ienum10,
Test.IntEnum.ienum11
};
Test.IntEnum[] i2;
Test.IntEnum[] i3 = proxy.opIntSeq(i1, out i2);
for (int i = 0; i < i1.Length; ++i)
{
test(i1[i] == i2[i]);
test(i1[i] == i3[i]);
}
}
{
var s1 = new Test.SimpleEnum[3]
{
Test.SimpleEnum.red,
Test.SimpleEnum.green,
Test.SimpleEnum.blue
};
Test.SimpleEnum[] s2;
Test.SimpleEnum[] s3 = proxy.opSimpleSeq(s1, out s2);
for (int i = 0; i < s1.Length; ++i)
{
test(s1[i] == s2[i]);
test(s1[i] == s3[i]);
}
}
output.WriteLine("ok");
return(proxy);
}
public static Test.TestIntfPrx allTests(global::Test.TestHelper helper)
{
Ice.Communicator communicator = helper.communicator();
var output = helper.getWriter();
output.Write("testing stringToProxy... ");
output.Flush();
string @ref = "test:" + helper.getTestEndpoint(0);
Ice.ObjectPrx @base = communicator.stringToProxy(@ref);
test(@base != null);
output.WriteLine("ok");
output.Write("testing checked cast... ");
output.Flush();
var obj = Test.TestIntfPrxHelper.checkedCast(@base);
test(obj != null);
test(obj.Equals(@base));
output.WriteLine("ok");
{
output.Write("creating/destroying/recreating object adapter... ");
output.Flush();
Ice.ObjectAdapter adapter =
communicator.createObjectAdapterWithEndpoints("TransientTestAdapter", "default");
try
{
communicator.createObjectAdapterWithEndpoints("TransientTestAdapter", "default");
test(false);
}
catch (Ice.AlreadyRegisteredException)
{
}
adapter.destroy();
//
// Use a different port than the first adapter to avoid an "address already in use" error.
//
adapter = communicator.createObjectAdapterWithEndpoints("TransientTestAdapter", "default");
adapter.destroy();
output.WriteLine("ok");
}
output.Write("creating/activating/deactivating object adapter in one operation... ");
output.Flush();
obj.transient();
obj.end_transient(obj.begin_transient());
output.WriteLine("ok");
{
output.Write("testing connection closure... ");
output.Flush();
for (int i = 0; i < 10; ++i)
{
Ice.InitializationData initData = new Ice.InitializationData();
initData.properties = communicator.getProperties().ice_clone_();
Ice.Communicator comm = Ice.Util.initialize(initData);
comm.stringToProxy("test:" + helper.getTestEndpoint(0)).begin_ice_ping();
comm.destroy();
}
output.WriteLine("ok");
}
output.Write("testing object adapter published endpoints... ");
output.Flush();
{
communicator.getProperties().setProperty("PAdapter.PublishedEndpoints", "tcp -h localhost -p 12345 -t 30000");
Ice.ObjectAdapter adapter = communicator.createObjectAdapter("PAdapter");
test(adapter.getPublishedEndpoints().Length == 1);
Ice.Endpoint endpt = adapter.getPublishedEndpoints()[0];
test(endpt.ToString().Equals("tcp -h localhost -p 12345 -t 30000"));
Ice.ObjectPrx prx =
communicator.stringToProxy("dummy:tcp -h localhost -p 12346 -t 20000:tcp -h localhost -p 12347 -t 10000");
adapter.setPublishedEndpoints(prx.ice_getEndpoints());
test(adapter.getPublishedEndpoints().Length == 2);
Ice.Identity id = new Ice.Identity();
id.name = "dummy";
test(IceUtilInternal.Arrays.Equals(adapter.createProxy(id).ice_getEndpoints(), prx.ice_getEndpoints()));
test(IceUtilInternal.Arrays.Equals(adapter.getPublishedEndpoints(), prx.ice_getEndpoints()));
adapter.refreshPublishedEndpoints();
test(adapter.getPublishedEndpoints().Length == 1);
test(adapter.getPublishedEndpoints()[0].Equals(endpt));
communicator.getProperties().setProperty("PAdapter.PublishedEndpoints", "tcp -h localhost -p 12345 -t 20000");
adapter.refreshPublishedEndpoints();
test(adapter.getPublishedEndpoints().Length == 1);
test(adapter.getPublishedEndpoints()[0].ToString().Equals("tcp -h localhost -p 12345 -t 20000"));
adapter.destroy();
test(adapter.getPublishedEndpoints().Length == 0);
}
output.WriteLine("ok");
if (obj.ice_getConnection() != null)
{
output.Write("testing object adapter with bi-dir connection... ");
output.Flush();
Ice.ObjectAdapter adapter = communicator.createObjectAdapter("");
obj.ice_getConnection().setAdapter(adapter);
obj.ice_getConnection().setAdapter(null);
adapter.deactivate();
try
{
obj.ice_getConnection().setAdapter(adapter);
test(false);
}
catch (Ice.ObjectAdapterDeactivatedException)
{
}
output.WriteLine("ok");
}
output.Write("testing object adapter with router... ");
output.Flush();
{
Ice.Identity routerId = new Ice.Identity();
routerId.name = "router";
Ice.RouterPrx router =
Ice.RouterPrxHelper.uncheckedCast(@base.ice_identity(routerId).ice_connectionId("rc"));
Ice.ObjectAdapter adapter = communicator.createObjectAdapterWithRouter("", router);
test(adapter.getPublishedEndpoints().Length == 1);
test(adapter.getPublishedEndpoints()[0].ToString().Equals("tcp -h localhost -p 23456 -t 30000"));
adapter.refreshPublishedEndpoints();
test(adapter.getPublishedEndpoints().Length == 1);
test(adapter.getPublishedEndpoints()[0].ToString().Equals("tcp -h localhost -p 23457 -t 30000"));
try
{
adapter.setPublishedEndpoints(router.ice_getEndpoints());
test(false);
}
catch (ArgumentException)
{
// Expected.
}
adapter.destroy();
try
{
routerId.name = "test";
router = Ice.RouterPrxHelper.uncheckedCast(@base.ice_identity(routerId));
communicator.createObjectAdapterWithRouter("", router);
test(false);
}
catch (Ice.OperationNotExistException)
{
// Expected: the "test" object doesn't implement Ice::Router!
}
try
{
router = Ice.RouterPrxHelper.uncheckedCast(communicator.stringToProxy("test:" +
helper.getTestEndpoint(1)));
communicator.createObjectAdapterWithRouter("", router);
test(false);
}
catch (Ice.ConnectFailedException)
{
}
}
output.WriteLine("ok");
output.Write("testing object adapter creation with port in use... ");
output.Flush();
{
var adapter1 = communicator.createObjectAdapterWithEndpoints("Adpt1", helper.getTestEndpoint(10));
try
{
communicator.createObjectAdapterWithEndpoints("Adpt2", helper.getTestEndpoint(10));
test(false);
}
catch (Ice.LocalException)
{
// Expected can't re-use the same endpoint.
}
adapter1.destroy();
}
output.WriteLine("ok");
output.Write("deactivating object adapter in the server... ");
output.Flush();
obj.deactivate();
output.WriteLine("ok");
output.Write("testing whether server is gone... ");
output.Flush();
try
{
obj.ice_timeout(100).ice_ping(); // Use timeout to speed up testing on Windows
test(false);
}
catch (Ice.LocalException)
{
output.WriteLine("ok");
}
return(obj);
}
public static void allTests(global::Test.TestHelper helper)
{
Ice.Communicator communicator = helper.communicator();
var manager = Test.ServerManagerPrxHelper.checkedCast(
communicator.stringToProxy("ServerManager :" + helper.getTestEndpoint(0)));
test(manager != null);
var locator = Test.TestLocatorPrxHelper.uncheckedCast(communicator.getDefaultLocator());
test(locator != null);
var registry = Test.TestLocatorRegistryPrxHelper.checkedCast(locator.getRegistry());
test(registry != null);
var output = helper.getWriter();
output.Write("testing stringToProxy... ");
output.Flush();
Ice.ObjectPrx @base = communicator.stringToProxy("test @ TestAdapter");
Ice.ObjectPrx base2 = communicator.stringToProxy("test @ TestAdapter");
Ice.ObjectPrx base3 = communicator.stringToProxy("test");
Ice.ObjectPrx base4 = communicator.stringToProxy("ServerManager");
Ice.ObjectPrx base5 = communicator.stringToProxy("test2");
Ice.ObjectPrx base6 = communicator.stringToProxy("test @ ReplicatedAdapter");
output.WriteLine("ok");
output.Write("testing ice_locator and ice_getLocator... ");
test(Ice.Util.proxyIdentityCompare(@base.ice_getLocator(), communicator.getDefaultLocator()) == 0);
Ice.LocatorPrx anotherLocator =
Ice.LocatorPrxHelper.uncheckedCast(communicator.stringToProxy("anotherLocator"));
@base = @base.ice_locator(anotherLocator);
test(Ice.Util.proxyIdentityCompare(@base.ice_getLocator(), anotherLocator) == 0);
communicator.setDefaultLocator(null);
@base = communicator.stringToProxy("test @ TestAdapter");
test(@base.ice_getLocator() == null);
@base = @base.ice_locator(anotherLocator);
test(Ice.Util.proxyIdentityCompare(@base.ice_getLocator(), anotherLocator) == 0);
communicator.setDefaultLocator(locator);
@base = communicator.stringToProxy("test @ TestAdapter");
test(Ice.Util.proxyIdentityCompare(@base.ice_getLocator(), communicator.getDefaultLocator()) == 0);
//
// We also test ice_router/ice_getRouter(perhaps we should add a
// test/Ice/router test?)
//
test(@base.ice_getRouter() == null);
Ice.RouterPrx anotherRouter =
Ice.RouterPrxHelper.uncheckedCast(communicator.stringToProxy("anotherRouter"));
@base = @base.ice_router(anotherRouter);
test(Ice.Util.proxyIdentityCompare(@base.ice_getRouter(), anotherRouter) == 0);
Ice.RouterPrx router = Ice.RouterPrxHelper.uncheckedCast(communicator.stringToProxy("dummyrouter"));
communicator.setDefaultRouter(router);
@base = communicator.stringToProxy("test @ TestAdapter");
test(Ice.Util.proxyIdentityCompare(@base.ice_getRouter(), communicator.getDefaultRouter()) == 0);
communicator.setDefaultRouter(null);
@base = communicator.stringToProxy("test @ TestAdapter");
test(@base.ice_getRouter() == null);
output.WriteLine("ok");
output.Write("starting server... ");
output.Flush();
manager.startServer();
output.WriteLine("ok");
output.Write("testing checked cast... ");
output.Flush();
var obj = Test.TestIntfPrxHelper.checkedCast(@base);
test(obj != null);
var obj2 = Test.TestIntfPrxHelper.checkedCast(base2);
test(obj2 != null);
var obj3 = Test.TestIntfPrxHelper.checkedCast(base3);
test(obj3 != null);
var obj4 = Test.ServerManagerPrxHelper.checkedCast(base4);
test(obj4 != null);
var obj5 = Test.TestIntfPrxHelper.checkedCast(base5);
test(obj5 != null);
var obj6 = Test.TestIntfPrxHelper.checkedCast(base6);
test(obj6 != null);
output.WriteLine("ok");
output.Write("testing id@AdapterId indirect proxy... ");
output.Flush();
obj.shutdown();
manager.startServer();
try
{
obj2.ice_ping();
}
catch (Ice.LocalException)
{
test(false);
}
output.WriteLine("ok");
output.Write("testing id@ReplicaGroupId indirect proxy... ");
output.Flush();
obj.shutdown();
manager.startServer();
try
{
obj6.ice_ping();
}
catch (Ice.LocalException)
{
test(false);
}
output.WriteLine("ok");
output.Write("testing identity indirect proxy... ");
output.Flush();
obj.shutdown();
manager.startServer();
try
{
obj3.ice_ping();
}
catch (Ice.LocalException)
{
test(false);
}
try
{
obj2.ice_ping();
}
catch (Ice.LocalException)
{
test(false);
}
obj.shutdown();
manager.startServer();
try
{
obj2.ice_ping();
}
catch (Ice.LocalException)
{
test(false);
}
try
{
obj3.ice_ping();
}
catch (Ice.LocalException)
{
test(false);
}
obj.shutdown();
manager.startServer();
try
{
obj2.ice_ping();
}
catch (Ice.LocalException)
{
test(false);
}
obj.shutdown();
manager.startServer();
try
{
obj3.ice_ping();
}
catch (Ice.LocalException)
{
test(false);
}
obj.shutdown();
manager.startServer();
try
{
obj5 = Test.TestIntfPrxHelper.checkedCast(base5);
obj5.ice_ping();
}
catch (Ice.LocalException)
{
test(false);
}
output.WriteLine("ok");
output.Write("testing proxy with unknown identity... ");
output.Flush();
try
{
@base = communicator.stringToProxy("unknown/unknown");
@base.ice_ping();
test(false);
}
catch (Ice.NotRegisteredException ex)
{
test(ex.kindOfObject.Equals("object"));
test(ex.id.Equals("unknown/unknown"));
}
output.WriteLine("ok");
output.Write("testing proxy with unknown adapter... ");
output.Flush();
try
{
@base = communicator.stringToProxy("test @ TestAdapterUnknown");
@base.ice_ping();
test(false);
}
catch (Ice.NotRegisteredException ex)
{
test(ex.kindOfObject.Equals("object adapter"));
test(ex.id.Equals("TestAdapterUnknown"));
}
output.WriteLine("ok");
output.Write("testing locator cache timeout... ");
output.Flush();
Ice.ObjectPrx basencc = communicator.stringToProxy("test@TestAdapter").ice_connectionCached(false);
int count = locator.getRequestCount();
basencc.ice_locatorCacheTimeout(0).ice_ping(); // No locator cache.
test(++count == locator.getRequestCount());
basencc.ice_locatorCacheTimeout(0).ice_ping(); // No locator cache.
test(++count == locator.getRequestCount());
basencc.ice_locatorCacheTimeout(2).ice_ping(); // 2s timeout.
test(count == locator.getRequestCount());
System.Threading.Thread.Sleep(1300); // 1300ms
basencc.ice_locatorCacheTimeout(1).ice_ping(); // 1s timeout.
test(++count == locator.getRequestCount());
communicator.stringToProxy("test").ice_locatorCacheTimeout(0).ice_ping(); // No locator cache.
count += 2;
test(count == locator.getRequestCount());
communicator.stringToProxy("test").ice_locatorCacheTimeout(2).ice_ping(); // 2s timeout
test(count == locator.getRequestCount());
System.Threading.Thread.Sleep(1300); // 1300ms
communicator.stringToProxy("test").ice_locatorCacheTimeout(1).ice_ping(); // 1s timeout
count += 2;
test(count == locator.getRequestCount());
communicator.stringToProxy("test@TestAdapter").ice_locatorCacheTimeout(-1).ice_ping();
test(count == locator.getRequestCount());
communicator.stringToProxy("test").ice_locatorCacheTimeout(-1).ice_ping();
test(count == locator.getRequestCount());
communicator.stringToProxy("test@TestAdapter").ice_ping();
test(count == locator.getRequestCount());
communicator.stringToProxy("test").ice_ping();
test(count == locator.getRequestCount());
test(communicator.stringToProxy("test").ice_locatorCacheTimeout(99).ice_getLocatorCacheTimeout() == 99);
output.WriteLine("ok");
output.Write("testing proxy from server... ");
output.Flush();
obj = Test.TestIntfPrxHelper.checkedCast(communicator.stringToProxy("test@TestAdapter"));
var hello = obj.getHello();
test(hello.ice_getAdapterId().Equals("TestAdapter"));
hello.sayHello();
hello = obj.getReplicatedHello();
test(hello.ice_getAdapterId().Equals("ReplicatedAdapter"));
hello.sayHello();
output.WriteLine("ok");
output.Write("testing locator request queuing... ");
output.Flush();
hello = (Test.HelloPrx)obj.getReplicatedHello().ice_locatorCacheTimeout(0).ice_connectionCached(false);
count = locator.getRequestCount();
hello.ice_ping();
test(++count == locator.getRequestCount());
List <Ice.AsyncResult <Test.Callback_Hello_sayHello> > results =
new List <Ice.AsyncResult <Test.Callback_Hello_sayHello> >();
for (int i = 0; i < 1000; i++)
{
Ice.AsyncResult <Test.Callback_Hello_sayHello> result = hello.begin_sayHello().
whenCompleted(
() =>
{
},
(Ice.Exception ex) =>
{
test(false);
});
results.Add(result);
}
foreach (Ice.AsyncResult <Test.Callback_Hello_sayHello> result in results)
{
result.waitForCompleted();
}
results.Clear();
test(locator.getRequestCount() > count && locator.getRequestCount() < count + 999);
if (locator.getRequestCount() > count + 800)
{
output.Write("queuing = " + (locator.getRequestCount() - count));
}
count = locator.getRequestCount();
hello = (Test.HelloPrx)hello.ice_adapterId("unknown");
for (int i = 0; i < 1000; i++)
{
Ice.AsyncResult <Test.Callback_Hello_sayHello> result = hello.begin_sayHello().
whenCompleted(
() =>
{
test(false);
},
(Ice.Exception ex) =>
{
test(ex is Ice.NotRegisteredException);
});
results.Add(result);
}
foreach (Ice.AsyncResult <Test.Callback_Hello_sayHello> result in results)
{
result.waitForCompleted();
}
results.Clear();
// XXX:
// Take into account the retries.
test(locator.getRequestCount() > count && locator.getRequestCount() < count + 1999);
if (locator.getRequestCount() > count + 800)
{
output.Write("queuing = " + (locator.getRequestCount() - count));
}
output.WriteLine("ok");
output.Write("testing adapter locator cache... ");
output.Flush();
try
{
communicator.stringToProxy("test@TestAdapter3").ice_ping();
test(false);
}
catch (Ice.NotRegisteredException ex)
{
test(ex.kindOfObject == "object adapter");
test(ex.id.Equals("TestAdapter3"));
}
registry.setAdapterDirectProxy("TestAdapter3", locator.findAdapterById("TestAdapter"));
try
{
communicator.stringToProxy("test@TestAdapter3").ice_ping();
registry.setAdapterDirectProxy("TestAdapter3", communicator.stringToProxy("dummy:tcp"));
communicator.stringToProxy("test@TestAdapter3").ice_ping();
}
catch (Ice.LocalException)
{
test(false);
}
try
{
communicator.stringToProxy("test@TestAdapter3").ice_locatorCacheTimeout(0).ice_ping();
test(false);
}
catch (Ice.LocalException)
{
}
try
{
communicator.stringToProxy("test@TestAdapter3").ice_ping();
test(false);
}
catch (Ice.LocalException)
{
}
registry.setAdapterDirectProxy("TestAdapter3", locator.findAdapterById("TestAdapter"));
try
{
communicator.stringToProxy("test@TestAdapter3").ice_ping();
}
catch (Ice.LocalException)
{
test(false);
}
output.WriteLine("ok");
output.Write("testing well-known object locator cache... ");
output.Flush();
registry.addObject(communicator.stringToProxy("test3@TestUnknown"));
try
{
communicator.stringToProxy("test3").ice_ping();
test(false);
}
catch (Ice.NotRegisteredException ex)
{
test(ex.kindOfObject == "object adapter");
test(ex.id.Equals("TestUnknown"));
}
registry.addObject(communicator.stringToProxy("test3@TestAdapter4")); // Update
registry.setAdapterDirectProxy("TestAdapter4", communicator.stringToProxy("dummy:tcp"));
try
{
communicator.stringToProxy("test3").ice_ping();
test(false);
}
catch (Ice.LocalException)
{
}
registry.setAdapterDirectProxy("TestAdapter4", locator.findAdapterById("TestAdapter"));
try
{
communicator.stringToProxy("test3").ice_ping();
}
catch (Ice.LocalException)
{
test(false);
}
registry.setAdapterDirectProxy("TestAdapter4", communicator.stringToProxy("dummy:tcp"));
try
{
communicator.stringToProxy("test3").ice_ping();
}
catch (Ice.LocalException)
{
test(false);
}
try
{
communicator.stringToProxy("test@TestAdapter4").ice_locatorCacheTimeout(0).ice_ping();
test(false);
}
catch (Ice.LocalException)
{
}
try
{
communicator.stringToProxy("test@TestAdapter4").ice_ping();
test(false);
}
catch (Ice.LocalException)
{
}
try
{
communicator.stringToProxy("test3").ice_ping();
test(false);
}
catch (Ice.LocalException)
{
}
registry.addObject(communicator.stringToProxy("test3@TestAdapter"));
try
{
communicator.stringToProxy("test3").ice_ping();
}
catch (Ice.LocalException)
{
test(false);
}
registry.addObject(communicator.stringToProxy("test4"));
try
{
communicator.stringToProxy("test4").ice_ping();
test(false);
}
catch (Ice.NoEndpointException)
{
}
output.WriteLine("ok");
output.Write("testing locator cache background updates... ");
output.Flush();
{
Ice.InitializationData initData = new Ice.InitializationData();
initData.properties = communicator.getProperties().ice_clone_();
initData.properties.setProperty("Ice.BackgroundLocatorCacheUpdates", "1");
Ice.Communicator ic = helper.initialize(initData);
registry.setAdapterDirectProxy("TestAdapter5", locator.findAdapterById("TestAdapter"));
registry.addObject(communicator.stringToProxy("test3@TestAdapter"));
count = locator.getRequestCount();
ic.stringToProxy("test@TestAdapter5").ice_locatorCacheTimeout(0).ice_ping(); // No locator cache.
ic.stringToProxy("test3").ice_locatorCacheTimeout(0).ice_ping(); // No locator cache.
count += 3;
test(count == locator.getRequestCount());
registry.setAdapterDirectProxy("TestAdapter5", null);
registry.addObject(communicator.stringToProxy("test3:tcp"));
ic.stringToProxy("test@TestAdapter5").ice_locatorCacheTimeout(10).ice_ping(); // 10s timeout.
ic.stringToProxy("test3").ice_locatorCacheTimeout(10).ice_ping(); // 10s timeout.
test(count == locator.getRequestCount());
System.Threading.Thread.Sleep(1200);
// The following request should trigger the background
// updates but still use the cached endpoints and
// therefore succeed.
ic.stringToProxy("test@TestAdapter5").ice_locatorCacheTimeout(1).ice_ping(); // 1s timeout.
ic.stringToProxy("test3").ice_locatorCacheTimeout(1).ice_ping(); // 1s timeout.
try
{
while (true)
{
ic.stringToProxy("test@TestAdapter5").ice_locatorCacheTimeout(1).ice_ping(); // 1s timeout.
System.Threading.Thread.Sleep(10);
}
}
catch (Ice.LocalException)
{
// Expected to fail once they endpoints have been updated in the background.
}
try
{
while (true)
{
ic.stringToProxy("test3").ice_locatorCacheTimeout(1).ice_ping(); // 1s timeout.
System.Threading.Thread.Sleep(10);
}
}
catch (Ice.LocalException)
{
// Expected to fail once they endpoints have been updated in the background.
}
ic.destroy();
}
output.WriteLine("ok");
output.Write("testing proxy from server after shutdown... ");
output.Flush();
hello = obj.getReplicatedHello();
obj.shutdown();
manager.startServer();
hello.sayHello();
output.WriteLine("ok");
output.Write("testing object migration... ");
output.Flush();
hello = Test.HelloPrxHelper.checkedCast(communicator.stringToProxy("hello"));
obj.migrateHello();
hello.ice_getConnection().close(Ice.ConnectionClose.GracefullyWithWait);
hello.sayHello();
obj.migrateHello();
hello.sayHello();
obj.migrateHello();
hello.sayHello();
output.WriteLine("ok");
output.Write("testing locator encoding resolution... ");
output.Flush();
hello = Test.HelloPrxHelper.checkedCast(communicator.stringToProxy("hello"));
count = locator.getRequestCount();
communicator.stringToProxy("test@TestAdapter").ice_encodingVersion(Ice.Util.Encoding_1_1).ice_ping();
test(count == locator.getRequestCount());
communicator.stringToProxy("test@TestAdapter10").ice_encodingVersion(Ice.Util.Encoding_1_0).ice_ping();
test(++count == locator.getRequestCount());
communicator.stringToProxy("test -e 1.0@TestAdapter10-2").ice_ping();
test(++count == locator.getRequestCount());
output.WriteLine("ok");
output.Write("shutdown server... ");
output.Flush();
obj.shutdown();
output.WriteLine("ok");
output.Write("testing whether server is gone... ");
output.Flush();
try
{
obj2.ice_ping();
test(false);
}
catch (Ice.LocalException)
{
}
try
{
obj3.ice_ping();
test(false);
}
catch (Ice.LocalException)
{
}
try
{
obj5.ice_ping();
test(false);
}
catch (Ice.LocalException)
{
}
output.WriteLine("ok");
output.Write("testing indirect proxies to collocated objects... ");
output.Flush();
//
// Set up test for calling a collocated object through an
// indirect, adapterless reference.
//
Ice.Properties properties = communicator.getProperties();
properties.setProperty("Ice.PrintAdapterReady", "0");
Ice.ObjectAdapter adapter = communicator.createObjectAdapterWithEndpoints("Hello", "tcp -h *");
adapter.setLocator(locator);
Ice.Identity id = new Ice.Identity();
id.name = Guid.NewGuid().ToString();
registry.addObject(adapter.add(new HelloI(), id));
adapter.activate();
var helloPrx = Test.HelloPrxHelper.checkedCast(
communicator.stringToProxy("\"" + communicator.identityToString(id) + "\""));
test(helloPrx.ice_getConnection() == null);
adapter.deactivate();
output.WriteLine("ok");
output.Write("shutdown server manager... ");
output.Flush();
manager.shutdown();
output.WriteLine("ok");
}
public static Test.ThrowerPrx allTests(global::Test.TestHelper helper)
{
Ice.Communicator communicator = helper.communicator();
var output = helper.getWriter();
{
output.Write("testing object adapter registration exceptions... ");
Ice.ObjectAdapter first;
try
{
first = communicator.createObjectAdapter("TestAdapter0");
}
catch (Ice.InitializationException)
{
// Expected
}
communicator.getProperties().setProperty("TestAdapter0.Endpoints", "tcp -h *");
first = communicator.createObjectAdapter("TestAdapter0");
try
{
communicator.createObjectAdapter("TestAdapter0");
test(false);
}
catch (Ice.AlreadyRegisteredException)
{
// Expected.
}
try
{
Ice.ObjectAdapter second =
communicator.createObjectAdapterWithEndpoints("TestAdapter0", "ssl -h foo -p 12011");
test(false);
//
// Quell mono error that variable second isn't used.
//
second.deactivate();
}
catch (Ice.AlreadyRegisteredException)
{
// Expected
}
first.deactivate();
output.WriteLine("ok");
}
{
output.Write("testing servant registration exceptions... ");
communicator.getProperties().setProperty("TestAdapter1.Endpoints", "tcp -h *");
Ice.ObjectAdapter adapter = communicator.createObjectAdapter("TestAdapter1");
Ice.Object obj = new EmptyI();
adapter.add(obj, Ice.Util.stringToIdentity("x"));
try
{
adapter.add(obj, Ice.Util.stringToIdentity("x"));
test(false);
}
catch (Ice.AlreadyRegisteredException)
{
}
try
{
adapter.add(obj, Ice.Util.stringToIdentity(""));
test(false);
}
catch (Ice.IllegalIdentityException e)
{
test(e.id.name.Equals(""));
}
try
{
adapter.add(null, Ice.Util.stringToIdentity("x"));
test(false);
}
catch (Ice.IllegalServantException)
{
}
adapter.remove(Ice.Util.stringToIdentity("x"));
try
{
adapter.remove(Ice.Util.stringToIdentity("x"));
test(false);
}
catch (Ice.NotRegisteredException)
{
}
adapter.deactivate();
output.WriteLine("ok");
}
{
output.Write("testing servant locator registration exceptions... ");
communicator.getProperties().setProperty("TestAdapter2.Endpoints", "tcp -h *");
Ice.ObjectAdapter adapter = communicator.createObjectAdapter("TestAdapter2");
Ice.ServantLocator loc = new ServantLocatorI();
adapter.addServantLocator(loc, "x");
try
{
adapter.addServantLocator(loc, "x");
test(false);
}
catch (Ice.AlreadyRegisteredException)
{
}
adapter.deactivate();
output.WriteLine("ok");
}
{
output.Write("testing object factory registration exception... ");
communicator.getValueFactoryManager().add(_ => { return(null); }, "::x");
try
{
communicator.getValueFactoryManager().add(_ => { return(null); }, "::x");
test(false);
}
catch (Ice.AlreadyRegisteredException)
{
}
output.WriteLine("ok");
}
output.Write("testing stringToProxy... ");
output.Flush();
String @ref = "thrower:" + helper.getTestEndpoint(0);
Ice.ObjectPrx @base = communicator.stringToProxy(@ref);
test(@base != null);
output.WriteLine("ok");
output.Write("testing checked cast... ");
output.Flush();
var thrower = Test.ThrowerPrxHelper.checkedCast(@base);
test(thrower != null);
test(thrower.Equals(@base));
output.WriteLine("ok");
output.Write("catching exact types... ");
output.Flush();
try
{
thrower.throwAasA(1);
test(false);
}
catch (Test.A ex)
{
test(ex.aMem == 1);
}
catch (Exception ex)
{
Console.WriteLine(ex);
test(false);
}
try
{
thrower.throwAorDasAorD(1);
test(false);
}
catch (Test.A ex)
{
test(ex.aMem == 1);
}
catch (Exception)
{
test(false);
}
try
{
thrower.throwAorDasAorD(-1);
test(false);
}
catch (Test.D ex)
{
test(ex.dMem == -1);
}
catch (Exception)
{
test(false);
}
try
{
thrower.throwBasB(1, 2);
test(false);
}
catch (Test.B ex)
{
test(ex.aMem == 1);
test(ex.bMem == 2);
}
catch (Exception)
{
test(false);
}
try
{
thrower.throwCasC(1, 2, 3);
test(false);
}
catch (Test.C ex)
{
test(ex.aMem == 1);
test(ex.bMem == 2);
test(ex.cMem == 3);
}
catch (Exception)
{
test(false);
}
output.WriteLine("ok");
output.Write("catching base types... ");
output.Flush();
try
{
thrower.throwBasB(1, 2);
test(false);
}
catch (Test.A ex)
{
test(ex.aMem == 1);
}
catch (Exception)
{
test(false);
}
try
{
thrower.throwCasC(1, 2, 3);
test(false);
}
catch (Test.B ex)
{
test(ex.aMem == 1);
test(ex.bMem == 2);
}
catch (Exception)
{
test(false);
}
output.WriteLine("ok");
output.Write("catching derived types... ");
output.Flush();
try
{
thrower.throwBasA(1, 2);
test(false);
}
catch (Test.B ex)
{
test(ex.aMem == 1);
test(ex.bMem == 2);
}
catch (Exception)
{
test(false);
}
try
{
thrower.throwCasA(1, 2, 3);
test(false);
}
catch (Test.C ex)
{
test(ex.aMem == 1);
test(ex.bMem == 2);
test(ex.cMem == 3);
}
catch (Exception)
{
test(false);
}
try
{
thrower.throwCasB(1, 2, 3);
test(false);
}
catch (Test.C ex)
{
test(ex.aMem == 1);
test(ex.bMem == 2);
test(ex.cMem == 3);
}
catch (Exception)
{
test(false);
}
output.WriteLine("ok");
if (thrower.supportsUndeclaredExceptions())
{
output.Write("catching unknown user exception... ");
output.Flush();
try
{
thrower.throwUndeclaredA(1);
test(false);
}
catch (Ice.UnknownUserException)
{
}
catch (Exception)
{
test(false);
}
try
{
thrower.throwUndeclaredB(1, 2);
test(false);
}
catch (Ice.UnknownUserException)
{
}
catch (Exception)
{
test(false);
}
try
{
thrower.throwUndeclaredC(1, 2, 3);
test(false);
}
catch (Ice.UnknownUserException)
{
}
catch (Exception)
{
test(false);
}
output.WriteLine("ok");
}
if (thrower.ice_getConnection() != null)
{
output.Write("testing memory limit marshal exception...");
output.Flush();
try
{
thrower.throwMemoryLimitException(null);
test(false);
}
catch (Ice.MemoryLimitException)
{
}
catch (Exception)
{
test(false);
}
try
{
thrower.throwMemoryLimitException(new byte[20 * 1024]); // 20KB
test(false);
}
catch (Ice.ConnectionLostException)
{
}
catch (Ice.UnknownLocalException)
{
// Expected with JS bidir server
}
catch (Exception)
{
test(false);
}
try
{
var thrower2 = Test.ThrowerPrxHelper.uncheckedCast(
communicator.stringToProxy("thrower:" + helper.getTestEndpoint(1)));
try
{
thrower2.throwMemoryLimitException(new byte[2 * 1024 * 1024]); // 2MB(no limits)
}
catch (Ice.MemoryLimitException)
{
}
var thrower3 = Test.ThrowerPrxHelper.uncheckedCast(
communicator.stringToProxy("thrower:" + helper.getTestEndpoint(2)));
try
{
thrower3.throwMemoryLimitException(new byte[1024]); // 1KB limit
test(false);
}
catch (Ice.ConnectionLostException)
{
}
}
catch (Ice.ConnectionRefusedException)
{
// Expected with JS bidir server
}
output.WriteLine("ok");
}
output.Write("catching object not exist exception... ");
output.Flush();
{
Ice.Identity id = Ice.Util.stringToIdentity("does not exist");
try
{
var thrower2 = Test.ThrowerPrxHelper.uncheckedCast(thrower.ice_identity(id));
thrower2.ice_ping();
test(false);
}
catch (Ice.ObjectNotExistException ex)
{
test(ex.id.Equals(id));
}
catch (Exception)
{
test(false);
}
}
output.WriteLine("ok");
output.Write("catching facet not exist exception... ");
output.Flush();
try
{
var thrower2 = Test.ThrowerPrxHelper.uncheckedCast(thrower, "no such facet");
try
{
thrower2.ice_ping();
test(false);
}
catch (Ice.FacetNotExistException ex)
{
test(ex.facet.Equals("no such facet"));
}
}
catch (Exception)
{
test(false);
}
output.WriteLine("ok");
output.Write("catching operation not exist exception... ");
output.Flush();
try
{
var thrower2 = Test.WrongOperationPrxHelper.uncheckedCast(thrower);
thrower2.noSuchOperation();
test(false);
}
catch (Ice.OperationNotExistException ex)
{
test(ex.operation.Equals("noSuchOperation"));
}
catch (Exception)
{
test(false);
}
output.WriteLine("ok");
output.Write("catching unknown local exception... ");
output.Flush();
try
{
thrower.throwLocalException();
test(false);
}
catch (Ice.UnknownLocalException)
{
}
catch (Exception)
{
test(false);
}
try
{
thrower.throwLocalExceptionIdempotent();
test(false);
}
catch (Ice.UnknownLocalException)
{
}
catch (Ice.OperationNotExistException)
{
}
catch (Exception)
{
test(false);
}
output.WriteLine("ok");
output.Write("catching unknown non-Ice exception... ");
output.Flush();
try
{
thrower.throwNonIceException();
test(false);
}
catch (Ice.UnknownException)
{
}
catch (Exception)
{
test(false);
}
output.WriteLine("ok");
output.Write("testing asynchronous exceptions... ");
output.Flush();
try
{
thrower.throwAfterResponse();
}
catch (Exception)
{
test(false);
}
try
{
thrower.throwAfterException();
test(false);
}
catch (Test.A)
{
}
catch (Exception)
{
test(false);
}
output.WriteLine("ok");
output.Write("catching exact types with AMI mapping... ");
output.Flush();
{
Callback cb = new Callback();
thrower.begin_throwAasA(1).whenCompleted(
() =>
{
test(false);
},
(Ice.Exception exc) =>
{
test(exc is Test.A);
var ex = exc as Test.A;
test(ex.aMem == 1);
cb.called();
});
cb.check();
}
{
Callback cb = new Callback();
thrower.begin_throwAorDasAorD(1).whenCompleted(
() =>
{
test(false);
},
(Ice.Exception exc) =>
{
try
{
throw exc;
}
catch (Test.A ex)
{
test(ex.aMem == 1);
}
catch (Test.D ex)
{
test(ex.dMem == -1);
}
catch (Exception)
{
test(false);
}
cb.called();
});
cb.check();
}
{
Callback cb = new Callback();
thrower.begin_throwAorDasAorD(-1).whenCompleted(
() =>
{
test(false);
},
(Ice.Exception exc) =>
{
try
{
throw exc;
}
catch (Test.A ex)
{
test(ex.aMem == 1);
}
catch (Test.D ex)
{
test(ex.dMem == -1);
}
catch (Exception)
{
test(false);
}
cb.called();
});
cb.check();
}
{
Callback cb = new Callback();
thrower.begin_throwBasB(1, 2).whenCompleted(
() =>
{
test(false);
},
(Ice.Exception exc) =>
{
try
{
throw exc;
}
catch (Test.B ex)
{
test(ex.aMem == 1);
test(ex.bMem == 2);
}
catch (Exception)
{
test(false);
}
cb.called();
});
cb.check();
}
{
Callback cb = new Callback();
thrower.begin_throwCasC(1, 2, 3).whenCompleted(
() =>
{
test(false);
},
(Ice.Exception exc) =>
{
try
{
throw exc;
}
catch (Test.C ex)
{
test(ex.aMem == 1);
test(ex.bMem == 2);
test(ex.cMem == 3);
}
catch (Exception)
{
test(false);
}
cb.called();
});
cb.check();
}
output.WriteLine("ok");
output.Write("catching derived types with new AMI mapping... ");
output.Flush();
{
Callback cb = new Callback();
thrower.begin_throwBasA(1, 2).whenCompleted(
() =>
{
test(false);
},
(Ice.Exception exc) =>
{
try
{
throw exc;
}
catch (Test.B ex)
{
test(ex.aMem == 1);
test(ex.bMem == 2);
}
catch (Exception)
{
test(false);
}
cb.called();
});
cb.check();
}
{
Callback cb = new Callback();
thrower.begin_throwCasA(1, 2, 3).whenCompleted(
() =>
{
test(false);
},
(Ice.Exception exc) =>
{
try
{
throw exc;
}
catch (Test.C ex)
{
test(ex.aMem == 1);
test(ex.bMem == 2);
test(ex.cMem == 3);
}
catch (Exception)
{
test(false);
}
cb.called();
});
cb.check();
}
{
Callback cb = new Callback();
thrower.begin_throwCasB(1, 2, 3).whenCompleted(
() =>
{
test(false);
},
(Ice.Exception exc) =>
{
try
{
throw exc;
}
catch (Test.C ex)
{
test(ex.aMem == 1);
test(ex.bMem == 2);
test(ex.cMem == 3);
}
catch (Exception)
{
test(false);
}
cb.called();
});
cb.check();
}
output.WriteLine("ok");
if (thrower.supportsUndeclaredExceptions())
{
output.Write("catching unknown user exception with new AMI mapping... ");
output.Flush();
{
Callback cb = new Callback();
thrower.begin_throwUndeclaredA(1).whenCompleted(
() =>
{
test(false);
},
(Ice.Exception exc) =>
{
try
{
throw exc;
}
catch (Ice.UnknownUserException)
{
}
catch (Exception)
{
test(false);
}
cb.called();
});
cb.check();
}
{
Callback cb = new Callback();
thrower.begin_throwUndeclaredB(1, 2).whenCompleted(
() =>
{
test(false);
},
(Ice.Exception exc) =>
{
try
{
throw exc;
}
catch (Ice.UnknownUserException)
{
}
catch (Exception)
{
test(false);
}
cb.called();
});
cb.check();
}
{
Callback cb = new Callback();
thrower.begin_throwUndeclaredC(1, 2, 3).whenCompleted(
() =>
{
test(false);
},
(Ice.Exception exc) =>
{
try
{
throw exc;
}
catch (Ice.UnknownUserException)
{
}
catch (Exception)
{
test(false);
}
cb.called();
});
cb.check();
}
output.WriteLine("ok");
}
output.Write("catching object not exist exception with new AMI mapping... ");
output.Flush();
{
Ice.Identity id = Ice.Util.stringToIdentity("does not exist");
var thrower2 = Test.ThrowerPrxHelper.uncheckedCast(thrower.ice_identity(id));
Callback cb = new Callback();
thrower2.begin_throwAasA(1).whenCompleted(
() =>
{
test(false);
},
(Ice.Exception exc) =>
{
try
{
throw exc;
}
catch (Ice.ObjectNotExistException ex)
{
test(ex.id.Equals(id));
}
catch (Exception)
{
test(false);
}
cb.called();
});
cb.check();
}
output.WriteLine("ok");
output.Write("catching facet not exist exception with new AMI mapping... ");
output.Flush();
{
var thrower2 = Test.ThrowerPrxHelper.uncheckedCast(thrower, "no such facet");
Callback cb = new Callback();
thrower2.begin_throwAasA(1).whenCompleted(
() =>
{
test(false);
},
(Ice.Exception exc) =>
{
try
{
throw exc;
}
catch (Ice.FacetNotExistException ex)
{
test(ex.facet.Equals("no such facet"));
}
catch (Exception)
{
test(false);
}
cb.called();
});
cb.check();
}
output.WriteLine("ok");
output.Write("catching operation not exist exception with new AMI mapping... ");
output.Flush();
{
Callback cb = new Callback();
var thrower4 = Test.WrongOperationPrxHelper.uncheckedCast(thrower);
thrower4.begin_noSuchOperation().whenCompleted(
() =>
{
test(false);
},
(Ice.Exception exc) =>
{
try
{
throw exc;
}
catch (Ice.OperationNotExistException ex)
{
test(ex.operation.Equals("noSuchOperation"));
}
catch (Exception)
{
test(false);
}
cb.called();
});
cb.check();
}
output.WriteLine("ok");
output.Write("catching unknown local exception with new AMI mapping... ");
output.Flush();
{
Callback cb = new Callback();
thrower.begin_throwLocalException().whenCompleted(
() =>
{
test(false);
},
(Ice.Exception exc) =>
{
try
{
throw exc;
}
catch (Ice.UnknownLocalException)
{
}
catch (Ice.OperationNotExistException)
{
}
catch (Exception)
{
test(false);
}
cb.called();
});
cb.check();
}
{
Callback cb = new Callback();
thrower.begin_throwLocalExceptionIdempotent().whenCompleted(
() =>
{
test(false);
},
(Ice.Exception exc) =>
{
try
{
throw exc;
}
catch (Ice.UnknownLocalException)
{
}
catch (Ice.OperationNotExistException)
{
}
catch (Exception)
{
test(false);
}
cb.called();
});
cb.check();
}
output.WriteLine("ok");
output.Write("catching unknown non-Ice exception with new AMI mapping... ");
output.Flush();
{
Callback cb = new Callback();
thrower.begin_throwNonIceException().whenCompleted(
() =>
{
test(false);
},
(Ice.Exception exc) =>
{
try
{
throw exc;
}
catch (Ice.UnknownException)
{
}
catch (Exception)
{
test(false);
}
cb.called();
});
cb.check();
}
output.WriteLine("ok");
if (thrower.supportsUndeclaredExceptions())
{
output.Write("catching unknown user exception with new AMI mapping... ");
output.Flush();
{
Callback cb = new Callback();
thrower.begin_throwUndeclaredA(1).whenCompleted(
() =>
{
test(false);
},
(Ice.Exception exc) =>
{
try
{
throw exc;
}
catch (Ice.UnknownUserException)
{
}
catch (Exception)
{
test(false);
}
cb.called();
});
cb.check();
}
{
Callback cb = new Callback();
thrower.begin_throwUndeclaredB(1, 2).whenCompleted(
() =>
{
test(false);
},
(Ice.Exception exc) =>
{
try
{
throw exc;
}
catch (Ice.UnknownUserException)
{
}
catch (Exception)
{
test(false);
}
cb.called();
});
cb.check();
}
{
Callback cb = new Callback();
thrower.begin_throwUndeclaredC(1, 2, 3).whenCompleted(
() =>
{
test(false);
},
(Ice.Exception exc) =>
{
try
{
throw exc;
}
catch (Ice.UnknownUserException)
{
}
catch (Exception)
{
test(false);
}
cb.called();
});
cb.check();
}
output.WriteLine("ok");
}
output.Write("catching object not exist exception with new AMI mapping... ");
output.Flush();
{
Ice.Identity id = Ice.Util.stringToIdentity("does not exist");
var thrower2 = Test.ThrowerPrxHelper.uncheckedCast(thrower.ice_identity(id));
Callback cb = new Callback();
thrower2.begin_throwAasA(1).whenCompleted(
() =>
{
test(false);
},
(Ice.Exception exc) =>
{
try
{
throw exc;
}
catch (Ice.ObjectNotExistException ex)
{
test(ex.id.Equals(id));
}
catch (Exception)
{
test(false);
}
cb.called();
});
cb.check();
}
output.WriteLine("ok");
output.Write("catching facet not exist exception with new AMI mapping... ");
output.Flush();
{
var thrower2 = Test.ThrowerPrxHelper.uncheckedCast(thrower, "no such facet");
Callback cb = new Callback();
thrower2.begin_throwAasA(1).whenCompleted(
() =>
{
test(false);
},
(Ice.Exception exc) =>
{
try
{
throw exc;
}
catch (Ice.FacetNotExistException ex)
{
test(ex.facet.Equals("no such facet"));
}
catch (Exception)
{
test(false);
}
cb.called();
});
cb.check();
}
output.WriteLine("ok");
output.Write("catching operation not exist exception with new AMI mapping... ");
output.Flush();
{
Callback cb = new Callback();
var thrower4 = Test.WrongOperationPrxHelper.uncheckedCast(thrower);
thrower4.begin_noSuchOperation().whenCompleted(
() =>
{
test(false);
},
(Ice.Exception exc) =>
{
try
{
throw exc;
}
catch (Ice.OperationNotExistException ex)
{
test(ex.operation.Equals("noSuchOperation"));
}
catch (Exception)
{
test(false);
}
cb.called();
});
cb.check();
}
output.WriteLine("ok");
output.Write("catching unknown local exception with new AMI mapping... ");
output.Flush();
{
Callback cb = new Callback();
thrower.begin_throwLocalException().whenCompleted(
() =>
{
test(false);
},
(Ice.Exception exc) =>
{
try
{
throw exc;
}
catch (Ice.UnknownLocalException)
{
}
catch (Ice.OperationNotExistException)
{
}
catch (Exception)
{
test(false);
}
cb.called();
});
cb.check();
}
{
Callback cb = new Callback();
thrower.begin_throwLocalExceptionIdempotent().whenCompleted(
() =>
{
test(false);
},
(Ice.Exception exc) =>
{
try
{
throw exc;
}
catch (Ice.UnknownLocalException)
{
}
catch (Ice.OperationNotExistException)
{
}
catch (Exception)
{
test(false);
}
cb.called();
});
cb.check();
}
output.WriteLine("ok");
output.Write("catching unknown non-Ice exception with new AMI mapping... ");
output.Flush();
{
Callback cb = new Callback();
thrower.begin_throwNonIceException().whenCompleted(
() =>
{
test(false);
},
(Ice.Exception exc) =>
{
try
{
throw exc;
}
catch (Ice.UnknownException)
{
}
catch (Exception)
{
test(false);
}
cb.called();
});
cb.check();
}
output.WriteLine("ok");
return(thrower);
}
public void Initialize(Scene scene)
{
try
{
if (!m_enabled)
{
return;
}
if (!m_started)
{
m_started = true;
scene.AddCommand(this, "mumble report", "mumble report",
"Returns mumble report", MumbleReport);
scene.AddCommand(this, "mumble unregister", "mumble unregister <userid>",
"Unregister User by userid", UnregisterUser);
scene.AddCommand(this, "mumble remove", "mumble remove <UUID>",
"Remove Agent by UUID", RemoveAgent);
Ice.Communicator comm = Ice.Util.initialize();
if (m_glacier_enabled)
{
m_router = RouterPrxHelper.uncheckedCast(comm.stringToProxy(m_glacier_ice));
comm.setDefaultRouter(m_router);
m_router.createSession(m_glacier_user, m_glacier_pass);
}
MetaPrx meta = MetaPrxHelper.checkedCast(comm.stringToProxy(m_murmurd_ice));
// Create the adapter
comm.getProperties().setProperty("Ice.PrintAdapterReady", "0");
if (m_glacier_enabled)
{
m_adapter = comm.createObjectAdapterWithRouter("Callback.Client", comm.getDefaultRouter());
}
else
{
m_adapter = comm.createObjectAdapterWithEndpoints("Callback.Client", m_murmur_ice_cb);
}
m_adapter.activate();
// Create identity and callback for Metaserver
Ice.Identity metaCallbackIdent = new Ice.Identity();
metaCallbackIdent.name = "metaCallback";
if (m_router != null)
{
metaCallbackIdent.category = m_router.getCategoryForClient();
}
MetaCallbackPrx meta_callback = MetaCallbackPrxHelper.checkedCast(m_adapter.add(new MetaCallbackImpl(), metaCallbackIdent));
meta.addCallback(meta_callback);
m_log.InfoFormat("[MurmurVoice] using murmur server ice '{0}'", m_murmurd_ice);
// create a server and figure out the port name
Dictionary <string, string> defaults = meta.getDefaultConf();
m_server = ServerPrxHelper.checkedCast(meta.getServer(m_server_id));
// start thread to ping glacier2 router and/or determine if con$
m_keepalive = new KeepAlive(m_server);
ThreadStart ka_d = new ThreadStart(m_keepalive.StartPinging);
m_keepalive_t = new Thread(ka_d);
m_keepalive_t.Start();
// first check the conf for a port, if not then use server id and default port to find the right one.
string conf_port = m_server.getConf("port");
if (!String.IsNullOrEmpty(conf_port))
{
m_murmurd_port = Convert.ToInt32(conf_port);
}
else
{
m_murmurd_port = Convert.ToInt32(defaults["port"]) + m_server_id - 1;
}
try
{
m_server.start();
}
catch
{
}
m_log.Info("[MurmurVoice] started");
}
// starts the server and gets a callback
ServerManager manager = new ServerManager(m_server, m_channel_name);
// Create identity and callback for this current server
AddServerCallback(scene, new ServerCallbackImpl(manager));
AddServerManager(scene, manager);
Ice.Identity serverCallbackIdent = new Ice.Identity();
serverCallbackIdent.name = "serverCallback_" + scene.RegionInfo.RegionName.Replace(" ", "_");
if (m_router != null)
{
serverCallbackIdent.category = m_router.getCategoryForClient();
}
m_server.addCallback(ServerCallbackPrxHelper.checkedCast(m_adapter.add(GetServerCallback(scene), serverCallbackIdent)));
// Show information on console for debugging purposes
m_log.InfoFormat("[MurmurVoice] using murmur server '{0}:{1}', sid '{2}'", m_murmurd_host, m_murmurd_port, m_server_id);
m_log.Info("[MurmurVoice] plugin enabled");
m_enabled = true;
}
catch (Exception e)
{
m_log.ErrorFormat("[MurmurVoice] plugin initialization failed: {0}", e.ToString());
return;
}
}
public static void allTests(global::Test.TestHelper helper)
{
Ice.Communicator communicator = helper.communicator();
var output = helper.getWriter();
output.Write("testing proxy endpoint information... ");
output.Flush();
{
var p1 = IObjectPrx.Parse(
"test -t:default -h tcphost -p 10000 -t 1200 -z --sourceAddress 10.10.10.10:" +
"udp -h udphost -p 10001 --interface eth0 --ttl 5 --sourceAddress 10.10.10.10:" +
"opaque -e 1.8 -t 100 -v ABCD", communicator);
Ice.Endpoint[] endps = p1.Endpoints;
Ice.EndpointInfo info = endps[0].getInfo();
Ice.TCPEndpointInfo tcpEndpoint = getTCPEndpointInfo(info);
test(tcpEndpoint.host.Equals("tcphost"));
test(tcpEndpoint.port == 10000);
test(tcpEndpoint.sourceAddress.Equals("10.10.10.10"));
test(tcpEndpoint.timeout == 1200);
test(tcpEndpoint.compress);
test(!tcpEndpoint.datagram());
test(tcpEndpoint.type() == Ice.TCPEndpointType.value && !tcpEndpoint.secure() ||
tcpEndpoint.type() == Ice.SSLEndpointType.value && tcpEndpoint.secure() ||
tcpEndpoint.type() == Ice.WSEndpointType.value && !tcpEndpoint.secure() ||
tcpEndpoint.type() == Ice.WSSEndpointType.value && tcpEndpoint.secure());
test(tcpEndpoint.type() == Ice.TCPEndpointType.value && info is Ice.TCPEndpointInfo ||
tcpEndpoint.type() == Ice.SSLEndpointType.value && info is IceSSL.EndpointInfo ||
tcpEndpoint.type() == Ice.WSEndpointType.value && info is Ice.WSEndpointInfo ||
tcpEndpoint.type() == Ice.WSSEndpointType.value && info is Ice.WSEndpointInfo);
Ice.UDPEndpointInfo udpEndpoint = (Ice.UDPEndpointInfo)endps[1].getInfo();
test(udpEndpoint.host.Equals("udphost"));
test(udpEndpoint.port == 10001);
test(udpEndpoint.mcastInterface.Equals("eth0"));
test(udpEndpoint.mcastTtl == 5);
test(udpEndpoint.sourceAddress.Equals("10.10.10.10"));
test(udpEndpoint.timeout == -1);
test(!udpEndpoint.compress);
test(!udpEndpoint.secure());
test(udpEndpoint.datagram());
test(udpEndpoint.type() == 3);
Ice.OpaqueEndpointInfo opaqueEndpoint = (Ice.OpaqueEndpointInfo)endps[2].getInfo();
test(opaqueEndpoint.rawBytes.Length > 0);
test(opaqueEndpoint.rawEncoding.Equals(new Ice.EncodingVersion(1, 8)));
}
output.WriteLine("ok");
Ice.ObjectAdapter adapter;
output.Write("test object adapter endpoint information... ");
output.Flush();
{
string host = communicator.getProperties().getPropertyAsInt("Ice.IPv6") != 0 ? "::1" : "127.0.0.1";
communicator.getProperties().setProperty("TestAdapter.Endpoints", "tcp -h \"" + host +
"\" -t 15000:udp -h \"" + host + "\"");
adapter = communicator.createObjectAdapter("TestAdapter");
Ice.Endpoint[] endpoints = adapter.GetEndpoints();
test(endpoints.Length == 2);
Ice.Endpoint[] publishedEndpoints = adapter.GetPublishedEndpoints();
test(IceUtilInternal.Arrays.Equals(endpoints, publishedEndpoints));
Ice.TCPEndpointInfo tcpEndpoint = getTCPEndpointInfo(endpoints[0].getInfo());
test(tcpEndpoint.type() == Ice.TCPEndpointType.value ||
tcpEndpoint.type() == Ice.SSLEndpointType.value ||
tcpEndpoint.type() == Ice.WSEndpointType.value ||
tcpEndpoint.type() == Ice.WSSEndpointType.value);
test(tcpEndpoint.host.Equals(host));
test(tcpEndpoint.port > 0);
test(tcpEndpoint.timeout == 15000);
Ice.UDPEndpointInfo udpEndpoint = (Ice.UDPEndpointInfo)endpoints[1].getInfo();
test(udpEndpoint.host.Equals(host));
test(udpEndpoint.datagram());
test(udpEndpoint.port > 0);
endpoints = new Ice.Endpoint[] { endpoints[0] };
test(endpoints.Length == 1);
adapter.SetPublishedEndpoints(endpoints);
publishedEndpoints = adapter.GetPublishedEndpoints();
test(IceUtilInternal.Arrays.Equals(endpoints, publishedEndpoints));
adapter.Destroy();
int port = helper.getTestPort(1);
communicator.getProperties().setProperty("TestAdapter.Endpoints", "default -h * -p " + port);
communicator.getProperties().setProperty("TestAdapter.PublishedEndpoints", helper.getTestEndpoint(1));
adapter = communicator.createObjectAdapter("TestAdapter");
endpoints = adapter.GetEndpoints();
test(endpoints.Length >= 1);
publishedEndpoints = adapter.GetPublishedEndpoints();
test(publishedEndpoints.Length == 1);
foreach (Ice.Endpoint endpoint in endpoints)
{
tcpEndpoint = getTCPEndpointInfo(endpoint.getInfo());
test(tcpEndpoint.port == port);
}
tcpEndpoint = getTCPEndpointInfo(publishedEndpoints[0].getInfo());
test(tcpEndpoint.host.Equals("127.0.0.1"));
test(tcpEndpoint.port == port);
adapter.Destroy();
}
output.WriteLine("ok");
int endpointPort = helper.getTestPort(0);
var @base = IObjectPrx.Parse("test:" +
helper.getTestEndpoint(0) + ":" +
helper.getTestEndpoint(0, "udp"), communicator);
var testIntf = Test.TestIntfPrx.CheckedCast(@base);
string defaultHost = communicator.getProperties().getProperty("Ice.Default.Host");
output.Write("test connection endpoint information... ");
output.Flush();
{
Ice.EndpointInfo info = @base.GetConnection().getEndpoint().getInfo();
Ice.TCPEndpointInfo tcpinfo = getTCPEndpointInfo(info);
test(tcpinfo.port == endpointPort);
test(!tcpinfo.compress);
test(tcpinfo.host.Equals(defaultHost));
Dictionary <string, string> ctx = testIntf.getEndpointInfoAsContext();
test(ctx["host"].Equals(tcpinfo.host));
test(ctx["compress"].Equals("false"));
int port = int.Parse(ctx["port"]);
test(port > 0);
info = @base.Clone(invocationMode: InvocationMode.Datagram).GetConnection().getEndpoint().getInfo();
Ice.UDPEndpointInfo udp = (Ice.UDPEndpointInfo)info;
test(udp.port == endpointPort);
test(udp.host.Equals(defaultHost));
}
output.WriteLine("ok");
output.Write("testing connection information... ");
output.Flush();
{
Ice.Connection connection = @base.GetConnection();
connection.setBufferSize(1024, 2048);
Ice.ConnectionInfo info = connection.getInfo();
Ice.TCPConnectionInfo ipInfo = getTCPConnectionInfo(info);
test(!info.incoming);
test(info.adapterName.Length == 0);
test(ipInfo.remotePort == endpointPort);
test(ipInfo.localPort > 0);
if (defaultHost.Equals("127.0.0.1"))
{
test(ipInfo.localAddress.Equals(defaultHost));
test(ipInfo.remoteAddress.Equals(defaultHost));
}
test(ipInfo.rcvSize >= 1024);
test(ipInfo.sndSize >= 2048);
Dictionary <string, string> ctx = testIntf.getConnectionInfoAsContext();
test(ctx["incoming"].Equals("true"));
test(ctx["adapterName"].Equals("TestAdapter"));
test(ctx["remoteAddress"].Equals(ipInfo.localAddress));
test(ctx["localAddress"].Equals(ipInfo.remoteAddress));
test(ctx["remotePort"].Equals(ipInfo.localPort.ToString()));
test(ctx["localPort"].Equals(ipInfo.remotePort.ToString()));
if (@base.GetConnection().type().Equals("ws") || @base.GetConnection().type().Equals("wss"))
{
Dictionary <string, string> headers = ((Ice.WSConnectionInfo)info).headers;
test(headers["Upgrade"].Equals("websocket"));
test(headers["Connection"].Equals("Upgrade"));
test(headers["Sec-WebSocket-Protocol"].Equals("ice.zeroc.com"));
test(headers["Sec-WebSocket-Accept"] != null);
test(ctx["ws.Upgrade"].Equals("websocket"));
test(ctx["ws.Connection"].Equals("Upgrade"));
test(ctx["ws.Sec-WebSocket-Protocol"].Equals("ice.zeroc.com"));
test(ctx["ws.Sec-WebSocket-Version"].Equals("13"));
test(ctx["ws.Sec-WebSocket-Key"] != null);
}
connection = @base.Clone(invocationMode: InvocationMode.Datagram).GetConnection();
connection.setBufferSize(2048, 1024);
Ice.UDPConnectionInfo udpInfo = (Ice.UDPConnectionInfo)connection.getInfo();
test(!udpInfo.incoming);
test(udpInfo.adapterName.Length == 0);
test(udpInfo.localPort > 0);
test(udpInfo.remotePort == endpointPort);
if (defaultHost.Equals("127.0.0.1"))
{
test(udpInfo.remoteAddress.Equals(defaultHost));
test(udpInfo.localAddress.Equals(defaultHost));
}
test(udpInfo.rcvSize >= 2048);
test(udpInfo.sndSize >= 1024);
}
output.WriteLine("ok");
testIntf.shutdown();
communicator.shutdown();
communicator.waitForShutdown();
}