public RemoteObjectAdapterI(Ice.ObjectAdapter adapter) { _adapter = adapter; _testIntf = TestIntfPrxHelper.uncheckedCast(_adapter.add(new TestI(), Ice.Util.stringToIdentity("test"))); _adapter.activate(); }
static minie_backend_client() { string[] parray = new string[] {"--Ice.Plugin.IceSSL=IceSSL.dll:IceSSL.PluginFactory", "--IceSSL.DefaultDir=.", "--IceSSL.CAs=root.pem", "--IceSSL.CertFile=client.p12", "--IceSSL.VerifyPeer=2", "--Ice.ThreadPool.Server.SizeMax=8", "--Ice.ThreadPool.Client.SizeMax=16", "--Ice.MessageSizeMax=10485760", "--Ice.Override.ConnectTimeout=5000", "--Ice.Override.Timeout=5000"}; //Ice.InitializationData inid = new Ice.InitializationData(); //inid.properties = Ice.Util.createProperties(); //inid.properties.setProperty("Ice.Plugin.IceSSL", "IceSSL.dll:IceSSL.PluginFactory"); //inid.properties.setProperty("IceSSL.DefaultDir", "."); //inid.properties.setProperty("IceSSL.CAs", "root.pem"); //inid.properties.setProperty("IceSSL.CertFile", "client.p12"); //inid.properties.setProperty("IceSSL.VerifyPeer", "2"); //inid.properties.setProperty("Ice.ThreadPool.Server.SizeMax", "8"); //inid.properties.setProperty("Ice.ThreadPool.Client.SizeMax", "16"); //inid.properties.setProperty("Ice.MessageSizeMax", "10485760"); //inid.properties.setProperty("Ice.Override.ConnectTimeout", "5000"); //inid.properties.setProperty("Ice.Override.Timeout", "5000"); s_ic = Ice.Util.initialize(ref parray); s_adapter = s_ic.createObjectAdapter(""); s_adapter.activate(); }
public void start(string name, Ice.Communicator communicator, string[] args) { _adapter = communicator.createObjectAdapter("Hello-" + name); string helloIdentity = communicator.getProperties().getProperty("Hello.Identity"); _adapter.add(new HelloI(name), Ice.Util.stringToIdentity(helloIdentity)); _adapter.activate(); }
public static Ice.ObjectAdapter createAdapter( Ice.Communicator ic, string adapterName, uint port) { instance = ic.createObjectAdapterWithEndpoints( adapterName, "default -p " + port); instance.activate(); return instance; }
/// <summary> /// Service execution method /// </summary> /// <param name="name">Name of service</param> /// <param name="communicator">Ice communicator</param> /// <param name="args">Arguments from command line</param> public void start(string name, Ice.Communicator communicator, string[] args) { Debug.Listeners.Clear(); Debug.Listeners.Add(new TextWriterTraceListener(name + ".log")); Debug.AutoFlush = true; Debug.WriteLine("Starting service..."); _adapter = communicator.createObjectAdapter(name); ObjectFactoryForPropertyTypes factory = new ObjectFactoryForPropertyTypes(); ObjectFactoryForPropertyTypes.addFactoryToCommunicator( communicator, factory); Debug.WriteLine("Activating adapter..."); _adapter.activate(); reaper = new ReapThread(); reaperThread = new Thread(new ThreadStart(reaper.Run)); reaperThread.Start(); Debug.WriteLine("Registering boxes..."); registerBoxes(); if (havePropertyBoxes) { propertyReaper = new PropertyReapThread(); propertyReaperThread = new Thread(new ThreadStart(propertyReaper.Run)); propertyReaperThread.Start(); Debug.WriteLine("Registering property boxes..."); registerPropertyBoxes(); } }
public void initialize() { Ice.Properties properties = _communicator.getProperties(); bool ipv4 = properties.getPropertyAsIntWithDefault("Ice.IPv4", 1) > 0; bool preferIPv6 = properties.getPropertyAsInt("Ice.PreferIPv6Address") > 0; string address; if(ipv4 && !preferIPv6) { address = properties.getPropertyWithDefault("IceDiscovery.Address", "239.255.0.1"); } else { address = properties.getPropertyWithDefault("IceDiscovery.Address", "ff15::1"); } int port = properties.getPropertyAsIntWithDefault("IceDiscovery.Port", 4061); string intf = properties.getProperty("IceDiscovery.Interface"); if(properties.getProperty("IceDiscovery.Multicast.Endpoints").Length == 0) { StringBuilder s = new StringBuilder(); s.Append("udp -h \"").Append(address).Append("\" -p ").Append(port); if(intf.Length != 0) { s.Append(" --interface \"").Append(intf).Append("\""); } properties.setProperty("IceDiscovery.Multicast.Endpoints", s.ToString()); } if(properties.getProperty("IceDiscovery.Reply.Endpoints").Length == 0) { StringBuilder s = new StringBuilder(); s.Append("udp"); if(intf.Length != 0) { s.Append(" -h \"").Append(intf).Append("\""); } properties.setProperty("IceDiscovery.Reply.Endpoints", s.ToString()); } if(properties.getProperty("IceDiscovery.Locator.Endpoints").Length == 0) { properties.setProperty("IceDiscovery.Locator.AdapterId", Guid.NewGuid().ToString()); } _multicastAdapter = _communicator.createObjectAdapter("IceDiscovery.Multicast"); _replyAdapter = _communicator.createObjectAdapter("IceDiscovery.Reply"); _locatorAdapter = _communicator.createObjectAdapter("IceDiscovery.Locator"); // // Setup locatory registry. // LocatorRegistryI locatorRegistry = new LocatorRegistryI(_communicator); Ice.LocatorRegistryPrx locatorRegistryPrx = Ice.LocatorRegistryPrxHelper.uncheckedCast( _locatorAdapter.addWithUUID(locatorRegistry)); string lookupEndpoints = properties.getProperty("IceDiscovery.Lookup"); if(lookupEndpoints.Length == 0) { lookupEndpoints = "udp -h \"" + address + "\" -p " + port; if(intf.Length > 0) { lookupEndpoints += " --interface \"" + intf + "\""; } } Ice.ObjectPrx lookupPrx = _communicator.stringToProxy("IceDiscovery/Lookup -d:" + lookupEndpoints); lookupPrx = lookupPrx.ice_collocationOptimized(false); try { lookupPrx.ice_getConnection(); } catch(Ice.LocalException ex) { StringBuilder b = new StringBuilder(); b.Append("IceDiscovery is unable to establish a multicast connection:\n"); b.Append("proxy = "); b.Append(lookupPrx.ToString()); b.Append('\n'); b.Append(ex.ToString()); throw new Ice.PluginInitializationException(b.ToString()); } // // Add lookup and lookup reply Ice objects // LookupI lookup = new LookupI(locatorRegistry, LookupPrxHelper.uncheckedCast(lookupPrx), properties); _multicastAdapter.add(lookup, Ice.Util.stringToIdentity("IceDiscovery/Lookup")); Ice.ObjectPrx lookupReply = _replyAdapter.addWithUUID(new LookupReplyI(lookup)).ice_datagram(); lookup.setLookupReply(LookupReplyPrxHelper.uncheckedCast(lookupReply)); // // Setup locator on the communicator. // Ice.ObjectPrx loc; loc = _locatorAdapter.addWithUUID( new LocatorI(lookup, Ice.LocatorRegistryPrxHelper.uncheckedCast(locatorRegistryPrx))); _communicator.setDefaultLocator(Ice.LocatorPrxHelper.uncheckedCast(loc)); _multicastAdapter.activate(); _replyAdapter.activate(); _locatorAdapter.activate(); }
/// <summary> /// Returns an object adapter for callback objects, creating it if necessary. /// </summary> /// <returns>The object adapter.</returns> public Ice.ObjectAdapter objectAdapter() { if(_router == null) { throw new SessionNotExistException(); } lock(mutex__) { if(_adapter == null) { _adapter = communicator().createObjectAdapterWithRouter("", _router); _adapter.activate(); } } return _adapter; }
public static void allTests(TestCommon.Application app) { Ice.Communicator communicator = app.communicator(); Console.Out.Write("testing stringToProxy... "); Console.Out.Flush(); String rf = "test @ TestAdapter"; Ice.ObjectPrx @base = communicator.stringToProxy(rf); test(@base != null); Console.Out.WriteLine("ok"); Console.Out.Write("testing IceGrid.Locator is present... "); IceGrid.LocatorPrx locator = IceGrid.LocatorPrxHelper.uncheckedCast(@base); test(locator != null); Console.Out.WriteLine("ok"); Console.Out.Write("testing checked cast... "); Console.Out.Flush(); TestIntfPrx obj = TestIntfPrxHelper.checkedCast(@base); test(obj != null); test(obj.Equals(@base)); Console.Out.WriteLine("ok"); Console.Out.Write("pinging server... "); Console.Out.Flush(); obj.ice_ping(); Console.Out.WriteLine("ok"); Console.Out.Write("testing locator finder... "); Ice.Identity finderId = new Ice.Identity(); finderId.category = "Ice"; finderId.name = "LocatorFinder"; Ice.LocatorFinderPrx finder = Ice.LocatorFinderPrxHelper.checkedCast( communicator.getDefaultLocator().ice_identity(finderId)); test(finder.getLocator() != null); Console.Out.WriteLine("ok"); Console.Out.Write("testing discovery... "); { // Add test well-known object IceGrid.RegistryPrx registry = IceGrid.RegistryPrxHelper.checkedCast( communicator.stringToProxy(communicator.getDefaultLocator().ice_getIdentity().category + "/Registry")); test(registry != null); try { IceGrid.AdminSessionPrx session = registry.createAdminSession("foo", "bar"); session.getAdmin().addObjectWithType(@base, "::Test"); session.destroy(); } catch (Ice.UserException) { test(false); } // // Ensure the IceGrid discovery locator can discover the // registries and make sure locator requests are forwarded. // Ice.InitializationData initData = new Ice.InitializationData(); initData.properties = communicator.getProperties().ice_clone_(); initData.properties.setProperty("Ice.Default.Locator", ""); initData.properties.setProperty("Ice.Plugin.IceLocatorDiscovery", "IceLocatorDiscovery:IceLocatorDiscovery.PluginFactory"); if (IceInternal.AssemblyUtil.osx_ && initData.properties.getPropertyAsInt("Ice.PreferIPv6Address") > 0) { initData.properties.setProperty("IceLocatorDiscovery.Interface", "::1"); } initData.properties.setProperty("IceLocatorDiscovery.Port", app.getTestPort(99).ToString()); initData.properties.setProperty("AdapterForDiscoveryTest.AdapterId", "discoveryAdapter"); initData.properties.setProperty("AdapterForDiscoveryTest.Endpoints", "default"); Ice.Communicator com = Ice.Util.initialize(initData); test(com.getDefaultLocator() != null); com.stringToProxy("test @ TestAdapter").ice_ping(); com.stringToProxy("test").ice_ping(); test(com.getDefaultLocator().getRegistry() != null); test(IceGrid.LocatorPrxHelper.uncheckedCast(com.getDefaultLocator()).getLocalRegistry() != null); test(IceGrid.LocatorPrxHelper.uncheckedCast(com.getDefaultLocator()).getLocalQuery() != null); Ice.ObjectAdapter adapter = com.createObjectAdapter("AdapterForDiscoveryTest"); adapter.activate(); adapter.deactivate(); com.destroy(); // // Now, ensure that the IceGrid discovery locator correctly // handles failure to find a locator. // initData.properties.setProperty("IceLocatorDiscovery.InstanceName", "unknown"); initData.properties.setProperty("IceLocatorDiscovery.RetryCount", "1"); initData.properties.setProperty("IceLocatorDiscovery.Timeout", "100"); com = Ice.Util.initialize(initData); test(com.getDefaultLocator() != null); try { com.stringToProxy("test @ TestAdapter").ice_ping(); } catch (Ice.NoEndpointException) { } try { com.stringToProxy("test").ice_ping(); } catch (Ice.NoEndpointException) { } test(com.getDefaultLocator().getRegistry() == null); test(IceGrid.LocatorPrxHelper.checkedCast(com.getDefaultLocator()) == null); try { IceGrid.LocatorPrxHelper.uncheckedCast(com.getDefaultLocator()).getLocalRegistry(); } catch (Ice.OperationNotExistException) { } adapter = com.createObjectAdapter("AdapterForDiscoveryTest"); adapter.activate(); adapter.deactivate(); com.destroy(); } Console.Out.WriteLine("ok"); Console.Out.Write("shutting down server... "); Console.Out.Flush(); obj.shutdown(); Console.Out.WriteLine("ok"); }
public static void allTests(TestCommon.Application app) { Ice.Communicator communicator = app.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:" + app.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(); string endpoint; if (communicator.getProperties().getProperty("Ice.IPv6").Equals("1")) { endpoint = "udp -h \"ff15::1:1\" -p 12020"; } else { endpoint = "udp -h 239.255.1.1 -p 12020"; } @base = communicator.stringToProxy("test -d:" + endpoint); TestIntfPrx objMcast = Test.TestIntfPrxHelper.uncheckedCast(@base); nRetry = 5; while (nRetry-- > 0) { replyI.reset(); objMcast.ping(reply); 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); objMcast.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 = (PingReplyPrx)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 OS X 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 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"); adapter = config.GlacierEnabled ? comm.createObjectAdapterWithRouter("Callback.Client", comm.getDefaultRouter()) : comm.createObjectAdapterWithEndpoints("Callback.Client", config.IceCB); adapter.activate(); // Create identity and callback for Metaserver Ice.Identity metaCallbackIdent = new Ice.Identity {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 {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); return; } }
public int run() { try { Ice.Properties properties = _communicator.getProperties(); // // Create an object adapter. Services probably should NOT share // this object adapter, as the endpoint(s) for this object adapter // will most likely need to be firewalled for security reasons. // Ice.ObjectAdapter adapter = null; if (properties.getProperty("IceBox.ServiceManager.Endpoints").Length != 0) { adapter = _communicator.createObjectAdapter("IceBox.ServiceManager"); Ice.Identity identity = new Ice.Identity(); identity.category = properties.getPropertyWithDefault("IceBox.InstanceName", "IceBox"); identity.name = "ServiceManager"; adapter.add(this, identity); } // // Parse the property set with the prefix "IceBox.Service.". These // properties should have the following format: // // IceBox.Service.Foo=<assembly>:Package.Foo [args] // // We parse the service properties specified in IceBox.LoadOrder // first, then the ones from remaining services. // string prefix = "IceBox.Service."; Dictionary <string, string> services = properties.getPropertiesForPrefix(prefix); string[] loadOrder = properties.getPropertyAsList("IceBox.LoadOrder"); List <StartServiceInfo> servicesInfo = new List <StartServiceInfo>(); for (int i = 0; i < loadOrder.Length; ++i) { if (loadOrder[i].Length > 0) { string key = prefix + loadOrder[i]; string value = services[key]; if (value == null) { FailureException ex = new FailureException(); ex.reason = "ServiceManager: no service definition for `" + loadOrder[i] + "'"; throw ex; } servicesInfo.Add(new StartServiceInfo(loadOrder[i], value, _argv)); services.Remove(key); } } foreach (KeyValuePair <string, string> entry in services) { string name = entry.Key.Substring(prefix.Length); string value = entry.Value; servicesInfo.Add(new StartServiceInfo(name, value, _argv)); } // // Check if some services are using the shared communicator in which // case we create the shared communicator now with a property set that // is the union of all the service properties (from services that use // the shared communicator). // if (properties.getPropertiesForPrefix("IceBox.UseSharedCommunicator.").Count > 0) { Ice.InitializationData initData = new Ice.InitializationData(); initData.properties = createServiceProperties("SharedCommunicator"); foreach (StartServiceInfo service in servicesInfo) { if (properties.getPropertyAsInt("IceBox.UseSharedCommunicator." + service.name) <= 0) { continue; } // // Load the service properties using the shared communicator properties as // the default properties. // Ice.Properties svcProperties = Ice.Util.createProperties(ref service.args, initData.properties); // // Remove properties from the shared property set that a service explicitly clears. // Dictionary <string, string> allProps = initData.properties.getPropertiesForPrefix(""); foreach (string key in allProps.Keys) { if (svcProperties.getProperty(key).Length == 0) { initData.properties.setProperty(key, ""); } } // // Add the service properties to the shared communicator properties. // foreach (KeyValuePair <string, string> entry in svcProperties.getPropertiesForPrefix("")) { initData.properties.setProperty(entry.Key, entry.Value); } // // Parse <service>.* command line options (the Ice command line options // were parsed by the call to createProperties above). // service.args = initData.properties.parseCommandLineOptions(service.name, service.args); } string facetNamePrefix = "IceBox.SharedCommunicator."; bool addFacets = configureAdmin(initData.properties, facetNamePrefix); _sharedCommunicator = Ice.Util.initialize(initData); if (addFacets) { // Add all facets created on shared communicator to the IceBox communicator // but renamed <prefix>.<facet-name>, except for the Process facet which is // never added. foreach (KeyValuePair <string, Ice.Object> p in _sharedCommunicator.findAllAdminFacets()) { if (!p.Key.Equals("Process")) { _communicator.addAdminFacet(p.Value, facetNamePrefix + p.Key); } } } } foreach (StartServiceInfo s in servicesInfo) { startService(s.name, s.entryPoint, s.args); } // // We may want to notify external scripts that the services // have started. This is done by defining the property: // // PrintServicesReady=bundleName // // Where bundleName is whatever you choose to call this set of // services. It will be echoed back as "bundleName ready". // // This must be done after start() has been invoked on the // services. // string bundleName = properties.getProperty("IceBox.PrintServicesReady"); if (bundleName.Length > 0) { Console.Out.WriteLine(bundleName + " ready"); } // // Don't move after the adapter activation. This allows // applications to wait for the service manager to be // reachable before sending a signal to shutdown the // // Ice.Application.shutdownOnInterrupt(); // // Register "this" as a facet to the Admin object and create Admin object // try { _communicator.addAdminFacet(this, "IceBox.ServiceManager"); _communicator.getAdmin(); } catch (Ice.ObjectAdapterDeactivatedException) { // // Expected if the communicator has been shutdown. // } // // Start request dispatching after we've started the services. // if (adapter != null) { try { adapter.activate(); } catch (Ice.ObjectAdapterDeactivatedException) { // // Expected if the communicator has been shutdown. // } } _communicator.waitForShutdown(); } catch (FailureException ex) { _logger.error(ex.ToString()); return(1); } catch (Exception ex) { _logger.error("ServiceManager: caught exception:\n" + ex.ToString()); return(1); } finally { // // Invoke stop() on the services. // stopAll(); } return(0); }
public static void allTests(TestCommon.Application app) { Ice.Communicator communicator = app.communicator(); string sref = "timeout:" + app.getTestEndpoint(0); Ice.ObjectPrx obj = communicator.stringToProxy(sref); test(obj != null); Test.TimeoutPrx timeout = Test.TimeoutPrxHelper.checkedCast(obj); test(timeout != null); Test.ControllerPrx controller = Test.ControllerPrxHelper.checkedCast( communicator.stringToProxy("controller:" + app.getTestEndpoint(1))); test(controller != null); Write("testing connect timeout... "); Flush(); { // // Expect ConnectTimeoutException. // Test.TimeoutPrx to = Test.TimeoutPrxHelper.uncheckedCast(obj.ice_timeout(100)); controller.holdAdapter(-1); try { to.op(); test(false); } catch (Ice.ConnectTimeoutException) { // Expected. } controller.resumeAdapter(); timeout.op(); // Ensure adapter is active. } { // // Expect success. // Test.TimeoutPrx to = Test.TimeoutPrxHelper.uncheckedCast(obj.ice_timeout(2000)); controller.holdAdapter(100); try { to.op(); } catch (Ice.ConnectTimeoutException) { test(false); } } WriteLine("ok"); // The sequence needs to be large enough to fill the write/recv buffers byte[] seq = new byte[2000000]; Write("testing connection timeout... "); Flush(); { // // Expect TimeoutException. // Test.TimeoutPrx to = Test.TimeoutPrxHelper.uncheckedCast(obj.ice_timeout(250)); connect(to); controller.holdAdapter(-1); try { to.sendData(seq); test(false); } catch (Ice.TimeoutException) { // Expected. } controller.resumeAdapter(); timeout.op(); // Ensure adapter is active. } { // // Expect success. // Test.TimeoutPrx to = Test.TimeoutPrxHelper.uncheckedCast(obj.ice_timeout(2000)); controller.holdAdapter(100); try { to.sendData(new byte[1000000]); } catch (Ice.TimeoutException) { test(false); } } WriteLine("ok"); Write("testing invocation timeout... "); Flush(); { Ice.Connection connection = obj.ice_getConnection(); Test.TimeoutPrx to = Test.TimeoutPrxHelper.uncheckedCast(obj.ice_invocationTimeout(100)); test(connection == to.ice_getConnection()); try { to.sleep(500); test(false); } catch (Ice.InvocationTimeoutException) { } obj.ice_ping(); to = Test.TimeoutPrxHelper.checkedCast(obj.ice_invocationTimeout(1000)); test(connection == to.ice_getConnection()); try { to.sleep(100); } catch (Ice.InvocationTimeoutException) { test(false); } test(connection == to.ice_getConnection()); } { // // Expect InvocationTimeoutException. // Test.TimeoutPrx to = Test.TimeoutPrxHelper.uncheckedCast(obj.ice_invocationTimeout(100)); Callback cb = new Callback(); to.begin_sleep(500).whenCompleted( () => { test(false); }, (Ice.Exception ex) => { test(ex is Ice.InvocationTimeoutException); cb.called(); }); cb.check(); obj.ice_ping(); } { // // Expect success. // Test.TimeoutPrx to = Test.TimeoutPrxHelper.uncheckedCast(obj.ice_invocationTimeout(1000)); Callback cb = new Callback(); to.begin_sleep(100).whenCompleted( () => { cb.called(); }, (Ice.Exception ex) => { test(false); }); cb.check(); } { // // Backward compatible connection timeouts // Test.TimeoutPrx to = Test.TimeoutPrxHelper.uncheckedCast(obj.ice_invocationTimeout(-2).ice_timeout(250)); Ice.Connection con = connect(to); try { to.sleep(750); test(false); } catch (Ice.TimeoutException) { try { con.getInfo(); test(false); } catch (Ice.TimeoutException) { // Connection got closed as well. } } obj.ice_ping(); try { con = connect(to); to.end_sleep(to.begin_sleep(750)); test(false); } catch (Ice.TimeoutException) { try { con.getInfo(); test(false); } catch (Ice.TimeoutException) { // Connection got closed as well. } } obj.ice_ping(); } WriteLine("ok"); Write("testing close timeout... "); Flush(); { Test.TimeoutPrx to = Test.TimeoutPrxHelper.uncheckedCast(obj.ice_timeout(250)); Ice.Connection connection = connect(to); controller.holdAdapter(-1); connection.close(Ice.ConnectionClose.GracefullyWithWait); try { connection.getInfo(); // getInfo() doesn't throw in the closing state. } catch (Ice.LocalException) { test(false); } while (true) { try { connection.getInfo(); Thread.Sleep(10); } catch (Ice.ConnectionManuallyClosedException ex) { // Expected. test(ex.graceful); break; } } controller.resumeAdapter(); timeout.op(); // Ensure adapter is active. } WriteLine("ok"); Write("testing timeout overrides... "); Flush(); { // // Test Ice.Override.Timeout. This property overrides all // endpoint timeouts. // string[] args = new string[0]; Ice.InitializationData initData = new Ice.InitializationData(); initData.properties = communicator.getProperties().ice_clone_(); initData.properties.setProperty("Ice.Override.ConnectTimeout", "250"); initData.properties.setProperty("Ice.Override.Timeout", "100"); Ice.Communicator comm = Ice.Util.initialize(ref args, initData); Test.TimeoutPrx to = Test.TimeoutPrxHelper.uncheckedCast(comm.stringToProxy(sref)); connect(to); controller.holdAdapter(-1); try { to.sendData(seq); test(false); } catch (Ice.TimeoutException) { // Expected. } controller.resumeAdapter(); timeout.op(); // Ensure adapter is active. // // Calling ice_timeout() should have no effect. // to = Test.TimeoutPrxHelper.uncheckedCast(to.ice_timeout(1000)); connect(to); controller.holdAdapter(-1); try { to.sendData(seq); test(false); } catch (Ice.TimeoutException) { // Expected. } controller.resumeAdapter(); timeout.op(); // Ensure adapter is active. comm.destroy(); } { // // Test Ice.Override.ConnectTimeout. // string[] args = new string[0]; Ice.InitializationData initData = new Ice.InitializationData(); initData.properties = communicator.getProperties().ice_clone_(); initData.properties.setProperty("Ice.Override.ConnectTimeout", "250"); Ice.Communicator comm = Ice.Util.initialize(ref args, initData); controller.holdAdapter(-1); Test.TimeoutPrx to = Test.TimeoutPrxHelper.uncheckedCast(comm.stringToProxy(sref)); try { to.op(); test(false); } catch (Ice.ConnectTimeoutException) { // Expected. } controller.resumeAdapter(); timeout.op(); // Ensure adapter is active. // // Calling ice_timeout() should have no effect on the connect timeout. // controller.holdAdapter(-1); to = Test.TimeoutPrxHelper.uncheckedCast(to.ice_timeout(1000)); try { to.op(); test(false); } catch (Ice.ConnectTimeoutException) { // Expected. } controller.resumeAdapter(); timeout.op(); // Ensure adapter is active. // // Verify that timeout set via ice_timeout() is still used for requests. // to = Test.TimeoutPrxHelper.uncheckedCast(to.ice_timeout(250)); connect(to); controller.holdAdapter(-1); try { to.sendData(seq); test(false); } catch (Ice.TimeoutException) { // Expected. } controller.resumeAdapter(); timeout.op(); // Ensure adapter is active. comm.destroy(); } { // // Test Ice.Override.CloseTimeout. // Ice.InitializationData initData = new Ice.InitializationData(); initData.properties = communicator.getProperties().ice_clone_(); initData.properties.setProperty("Ice.Override.CloseTimeout", "100"); Ice.Communicator comm = Ice.Util.initialize(initData); comm.stringToProxy(sref).ice_getConnection(); controller.holdAdapter(-1); long begin = System.DateTime.Now.Ticks; comm.destroy(); test(((long)new System.TimeSpan(System.DateTime.Now.Ticks - begin).TotalMilliseconds - begin) < 700); controller.resumeAdapter(); } WriteLine("ok"); Write("testing invocation timeouts with collocated calls... "); Flush(); { communicator.getProperties().setProperty("TimeoutCollocated.AdapterId", "timeoutAdapter"); Ice.ObjectAdapter adapter = communicator.createObjectAdapter("TimeoutCollocated"); adapter.activate(); Test.TimeoutPrx proxy = Test.TimeoutPrxHelper.uncheckedCast(adapter.addWithUUID(new TimeoutI())); proxy = (Test.TimeoutPrx)proxy.ice_invocationTimeout(100); try { proxy.sleep(500); test(false); } catch (Ice.InvocationTimeoutException) { } try { proxy.end_sleep(proxy.begin_sleep(500)); test(false); } catch (Ice.InvocationTimeoutException) { } try { ((Test.TimeoutPrx)proxy.ice_invocationTimeout(-2)).ice_ping(); ((Test.TimeoutPrx)proxy.ice_invocationTimeout(-2)).begin_ice_ping().waitForCompleted(); } catch (Ice.Exception) { test(false); } Test.TimeoutPrx batchTimeout = (Test.TimeoutPrx)proxy.ice_batchOneway(); batchTimeout.ice_ping(); batchTimeout.ice_ping(); batchTimeout.ice_ping(); ((Test.TimeoutPrx)proxy.ice_invocationTimeout(-1)).begin_sleep(300); // Keep the server thread pool busy. try { batchTimeout.ice_flushBatchRequests(); test(false); } catch (Ice.InvocationTimeoutException) { } batchTimeout.ice_ping(); batchTimeout.ice_ping(); batchTimeout.ice_ping(); ((Test.TimeoutPrx)proxy.ice_invocationTimeout(-1)).begin_sleep(300); // Keep the server thread pool busy. try { batchTimeout.end_ice_flushBatchRequests(batchTimeout.begin_ice_flushBatchRequests()); test(false); } catch (Ice.InvocationTimeoutException) { } adapter.destroy(); } WriteLine("ok"); controller.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.Communicator serverCommunicator = Ice.Util.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", _app.getTestEndpoint(_nextPort++)); serverCommunicator.getProperties().setProperty("TestAdapter2.Endpoints", _app.getTestEndpoint(_nextPort++)); adapter = serverCommunicator.createObjectAdapter("TestAdapter"); adapter2 = serverCommunicator.createObjectAdapter("TestAdapter2"); Ice.ObjectPrx locator = serverCommunicator.stringToProxy("locator:" + _app.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 void initialize() { Ice.Properties properties = _communicator.getProperties(); bool ipv4 = properties.getPropertyAsIntWithDefault("Ice.IPv4", 1) > 0; bool preferIPv6 = properties.getPropertyAsInt("Ice.PreferIPv6Address") > 0; string address; if(ipv4 && !preferIPv6) { address = properties.getPropertyWithDefault("IceLocatorDiscovery.Address", "239.255.0.1"); } else { address = properties.getPropertyWithDefault("IceLocatorDiscovery.Address", "ff15::1"); } int port = properties.getPropertyAsIntWithDefault("IceLocatorDiscovery.Port", 4061); string intf = properties.getProperty("IceLocatorDiscovery.Interface"); if(properties.getProperty("IceLocatorDiscovery.Reply.Endpoints").Length == 0) { System.Text.StringBuilder s = new System.Text.StringBuilder(); s.Append("udp"); if(intf.Length > 0) { s.Append(" -h \""); s.Append(intf); s.Append("\""); } properties.setProperty("IceLocatorDiscovery.Reply.Endpoints", s.ToString()); } if(properties.getProperty("IceLocatorDiscovery.Locator.Endpoints").Length == 0) { properties.setProperty("IceLocatorDiscovery.Locator.AdapterId", Guid.NewGuid().ToString()); } _replyAdapter = _communicator.createObjectAdapter("IceLocatorDiscovery.Reply"); _locatorAdapter = _communicator.createObjectAdapter("IceLocatorDiscovery.Locator"); // We don't want those adapters to be registered with the locator so clear their locator. _replyAdapter.setLocator(null); _locatorAdapter.setLocator(null); string lookupEndpoints = properties.getProperty("IceLocatorDiscovery.Lookup"); if(lookupEndpoints.Length == 0) { System.Text.StringBuilder s = new System.Text.StringBuilder(); s.Append("udp -h \""); s.Append(address); s.Append("\" -p "); s.Append(port); if(intf.Length > 0) { s.Append(" --interface \""); s.Append(intf); s.Append("\""); } lookupEndpoints = s.ToString(); } Ice.ObjectPrx lookupPrx = _communicator.stringToProxy("IceLocatorDiscovery/Lookup -d:" + lookupEndpoints); lookupPrx = lookupPrx.ice_collocationOptimized(false); // No colloc optimization for the multicast proxy! try { lookupPrx.ice_getConnection(); // Ensure we can establish a connection to the multicast proxy } catch (Ice.LocalException ex) { System.Text.StringBuilder s = new System.Text.StringBuilder(); s.Append("IceLocatorDiscovery is unable to establish a multicast connection:\n"); s.Append("proxy = "); s.Append(lookupPrx.ToString()); s.Append("\n"); s.Append(ex); throw new Ice.PluginInitializationException(s.ToString()); } Ice.LocatorPrx voidLo = Ice.LocatorPrxHelper.uncheckedCast(_locatorAdapter.addWithUUID(new VoidLocatorI())); string instanceName = properties.getProperty("IceLocatorDiscovery.InstanceName"); Ice.Identity id = new Ice.Identity(); id.name = "Locator"; id.category = instanceName.Length > 0 ? instanceName : Guid.NewGuid().ToString(); LocatorI locator = new LocatorI(LookupPrxHelper.uncheckedCast(lookupPrx), properties, instanceName, voidLo); _communicator.setDefaultLocator(Ice.LocatorPrxHelper.uncheckedCast(_locatorAdapter.addWithUUID(locator))); Ice.ObjectPrx lookupReply = _replyAdapter.addWithUUID(new LookupReplyI(locator)).ice_datagram(); locator.setLookupReply(LookupReplyPrxHelper.uncheckedCast(lookupReply)); _replyAdapter.activate(); _locatorAdapter.activate(); }
public IceManager(string adapterName, string host, int port, bool catchSignals = true) { IceGridHost = host; IceGridPort = port; Name = adapterName; logger = log4net.LogManager.GetLogger(this.GetType().Name + "::" + Name); _ServantIds = new List<Ice.Identity>(); //keep track of servants for emergency cleanup string myIP = findLocalIPAddress(); logger.Info("My IPAddress is: " + myIP); //initialize Ice Ice.Properties prop = Ice.Util.createProperties(); prop.setProperty("hms.AdapterId", adapterName); prop.setProperty("hms.Endpoints", "tcp -h " + myIP + ":udp -h " + myIP); prop.setProperty("Ice.Default.Locator", "IceGrid/Locator:tcp -p " + IceGridPort + " -h " + IceGridHost); prop.setProperty("Ice.ThreadPool.Server.Size", "5"); prop.setProperty("Ice.ThreadPool.Server.SizeMax", "100000"); prop.setProperty("Ice.ThreadPool.Client.Size", "5"); prop.setProperty("Ice.ThreadPool.Client.SizeMax", "100000"); Ice.InitializationData iceidata = new Ice.InitializationData(); iceidata.properties = prop; Communicator = Ice.Util.initialize(iceidata); // could add sys.argv try { _Adapter = Communicator.createObjectAdapter("hms"); _Adapter.activate(); } catch (Exception ex) { logger.Fatal("Network error, check configuration: " + ex.Message); logger.Fatal("Endpoint(should be local machine): " + prop.getProperty("hms.Endpoints")); logger.Fatal("Locator (should be IceGrid Server): " + prop.getProperty("Ice.Default.Locator")); throw (ex); // we are dead anyway } //Now are we ready to communicate with others //getting usefull proxies try { // proxy to icegrid to register our vc devices Query = IceGrid.QueryPrxHelper.checkedCast(Communicator.stringToProxy("IceGrid/Query")); if (Query == null) { logger.Error("invalid ICeGrid proxy"); } // proxy to icestorm to publish events EventMgr = IceStorm.TopicManagerPrxHelper.checkedCast(Communicator.stringToProxy("EventServer/TopicManager")); if (EventMgr == null) { logger.Error("invalid IceStorm proxy"); } //these 2 objects are only needed to get the IceGrid admin object in order to register _Registry = IceGrid.RegistryPrxHelper.uncheckedCast(Communicator.stringToProxy("IceGrid/Registry")); updateIceGridAdmin(); } catch (Ice.NotRegisteredException e) { logger.Fatal("If we fail here it is probably because the Icebox objects are not registered: " + e.Message); } catch (Exception e) { logger.Fatal("IceGrid Server not found!!!!!: " + e.Message); throw (e);//without yellow page system, there is no need to start } if (catchSignals) { setupSignals(); } }
public void start(string name, Ice.Communicator communicator, string[] args) { _adapter = communicator.createObjectAdapter(name); _adapter.add(new HelloI(), Ice.Util.stringToIdentity("hello")); _adapter.activate(); }
public static TestIntfPrx allTests(Test.TestHelper helper, bool collocated) { Ice.Communicator communicator = helper.communicator(); var output = helper.getWriter(); output.Write("testing stringToProxy... "); output.Flush(); String @ref = "Test:" + helper.getTestEndpoint(0) + " -t 2000"; Ice.ObjectPrx @base = communicator.stringToProxy(@ref); test(@base != null); output.WriteLine("ok"); output.Write("testing checked cast... "); output.Flush(); TestIntfPrx testPrx = TestIntfPrxHelper.checkedCast(@base); test(testPrx != null); test(testPrx.Equals(@base)); output.WriteLine("ok"); output.Write("base... "); output.Flush(); { try { testPrx.baseAsBase(); test(false); } catch (Base b) { test(b.b.Equals("Base.b")); test(b.GetType().FullName.Equals("Test.Base")); } catch (Exception) { test(false); } } output.WriteLine("ok"); output.Write("base (AMI)... "); output.Flush(); { Callback cb = new Callback(); testPrx.begin_baseAsBase().whenCompleted( () => { test(false); }, (Ice.Exception ex) => { try { throw ex; } catch (Base b) { test(b.b.Equals("Base.b")); test(b.GetType().Name.Equals("Base")); } catch (Exception) { test(false); } cb.called(); }); cb.check(); try { testPrx.baseAsBaseAsync().Wait(); test(false); } catch (AggregateException ae) { try { throw ae.InnerException; } catch (Base b) { test(b.b.Equals("Base.b")); test(b.GetType().Name.Equals("Base")); } catch (Exception) { test(false); } } } output.WriteLine("ok"); output.Write("slicing of unknown derived... "); output.Flush(); { try { testPrx.unknownDerivedAsBase(); test(false); } catch (Base b) { test(b.b.Equals("UnknownDerived.b")); test(b.GetType().FullName.Equals("Test.Base")); } catch (Exception) { test(false); } } output.WriteLine("ok"); output.Write("slicing of unknown derived (AMI)... "); output.Flush(); { Callback cb = new Callback(); testPrx.begin_unknownDerivedAsBase().whenCompleted( () => { test(false); }, (Ice.Exception ex) => { try { throw ex; } catch (Base b) { test(b.b.Equals("UnknownDerived.b")); test(b.GetType().Name.Equals("Base")); } catch (Exception) { test(false); } cb.called(); }); cb.check(); try { testPrx.unknownDerivedAsBaseAsync().Wait(); test(false); } catch (AggregateException ae) { try { throw ae.InnerException; } catch (Base b) { test(b.b.Equals("UnknownDerived.b")); test(b.GetType().Name.Equals("Base")); } catch (Exception) { test(false); } } } output.WriteLine("ok"); output.Write("non-slicing of known derived as base... "); output.Flush(); { try { testPrx.knownDerivedAsBase(); test(false); } catch (KnownDerived k) { test(k.b.Equals("KnownDerived.b")); test(k.kd.Equals("KnownDerived.kd")); test(k.GetType().FullName.Equals("Test.KnownDerived")); } catch (Exception) { test(false); } } output.WriteLine("ok"); output.Write("non-slicing of known derived as base (AMI)... "); output.Flush(); { Callback cb = new Callback(); testPrx.begin_knownDerivedAsBase().whenCompleted( () => { test(false); }, (Ice.Exception ex) => { try { throw ex; } catch (KnownDerived k) { test(k.b.Equals("KnownDerived.b")); test(k.kd.Equals("KnownDerived.kd")); test(k.GetType().Name.Equals("KnownDerived")); } catch (Exception) { test(false); } cb.called(); }); cb.check(); try { testPrx.knownDerivedAsBaseAsync().Wait(); test(false); } catch (AggregateException ae) { try { throw ae.InnerException; } catch (KnownDerived k) { test(k.b.Equals("KnownDerived.b")); test(k.kd.Equals("KnownDerived.kd")); test(k.GetType().Name.Equals("KnownDerived")); } catch (Exception) { test(false); } } } output.WriteLine("ok"); output.Write("non-slicing of known derived as derived... "); output.Flush(); { try { testPrx.knownDerivedAsKnownDerived(); test(false); } catch (KnownDerived k) { test(k.b.Equals("KnownDerived.b")); test(k.kd.Equals("KnownDerived.kd")); test(k.GetType().FullName.Equals("Test.KnownDerived")); } catch (Exception) { test(false); } } output.WriteLine("ok"); output.Write("non-slicing of known derived as derived (AMI)... "); output.Flush(); { Callback cb = new Callback(); testPrx.begin_knownDerivedAsKnownDerived().whenCompleted( () => { test(false); }, (Ice.Exception ex) => { try { throw ex; } catch (KnownDerived k) { test(k.b.Equals("KnownDerived.b")); test(k.kd.Equals("KnownDerived.kd")); test(k.GetType().Name.Equals("KnownDerived")); } catch (Exception) { test(false); } cb.called(); }); cb.check(); try { testPrx.knownDerivedAsKnownDerivedAsync().Wait(); test(false); } catch (AggregateException ae) { try { throw ae.InnerException; } catch (KnownDerived k) { test(k.b.Equals("KnownDerived.b")); test(k.kd.Equals("KnownDerived.kd")); test(k.GetType().Name.Equals("KnownDerived")); } catch (Exception) { test(false); } } } output.WriteLine("ok"); output.Write("slicing of unknown intermediate as base... "); output.Flush(); { try { testPrx.unknownIntermediateAsBase(); test(false); } catch (Base b) { test(b.b.Equals("UnknownIntermediate.b")); test(b.GetType().FullName.Equals("Test.Base")); } catch (Exception) { test(false); } } output.WriteLine("ok"); output.Write("slicing of unknown intermediate as base (AMI)... "); output.Flush(); { Callback cb = new Callback(); testPrx.begin_unknownIntermediateAsBase().whenCompleted( () => { test(false); }, (Ice.Exception ex) => { try { throw ex; } catch (Base b) { test(b.b.Equals("UnknownIntermediate.b")); test(b.GetType().Name.Equals("Base")); } catch (Exception) { test(false); } cb.called(); }); cb.check(); try { testPrx.unknownIntermediateAsBaseAsync().Wait(); test(false); } catch (AggregateException ae) { try { throw ae.InnerException; } catch (Base b) { test(b.b.Equals("UnknownIntermediate.b")); test(b.GetType().Name.Equals("Base")); } catch (Exception) { test(false); } } } output.WriteLine("ok"); output.Write("slicing of known intermediate as base... "); output.Flush(); { try { testPrx.knownIntermediateAsBase(); test(false); } catch (KnownIntermediate ki) { test(ki.b.Equals("KnownIntermediate.b")); test(ki.ki.Equals("KnownIntermediate.ki")); test(ki.GetType().FullName.Equals("Test.KnownIntermediate")); } catch (Exception) { test(false); } } output.WriteLine("ok"); output.Write("slicing of known intermediate as base (AMI)... "); output.Flush(); { Callback cb = new Callback(); testPrx.begin_knownIntermediateAsBase().whenCompleted( () => { test(false); }, (Ice.Exception ex) => { try { throw ex; } catch (KnownIntermediate ki) { test(ki.b.Equals("KnownIntermediate.b")); test(ki.ki.Equals("KnownIntermediate.ki")); test(ki.GetType().Name.Equals("KnownIntermediate")); } catch (Exception) { test(false); } cb.called(); }); cb.check(); try { testPrx.knownIntermediateAsBaseAsync().Wait(); test(false); } catch (AggregateException ae) { try { throw ae.InnerException; } catch (KnownIntermediate ki) { test(ki.b.Equals("KnownIntermediate.b")); test(ki.ki.Equals("KnownIntermediate.ki")); test(ki.GetType().Name.Equals("KnownIntermediate")); } catch (Exception) { test(false); } } } output.WriteLine("ok"); output.Write("slicing of known most derived as base... "); output.Flush(); { try { testPrx.knownMostDerivedAsBase(); test(false); } catch (KnownMostDerived kmd) { test(kmd.b.Equals("KnownMostDerived.b")); test(kmd.ki.Equals("KnownMostDerived.ki")); test(kmd.kmd.Equals("KnownMostDerived.kmd")); test(kmd.GetType().FullName.Equals("Test.KnownMostDerived")); } catch (Exception) { test(false); } } output.WriteLine("ok"); output.Write("slicing of known most derived as base (AMI)... "); output.Flush(); { Callback cb = new Callback(); testPrx.begin_knownMostDerivedAsBase().whenCompleted( () => { test(false); }, (Ice.Exception ex) => { try { throw ex; } catch (KnownMostDerived kmd) { test(kmd.b.Equals("KnownMostDerived.b")); test(kmd.ki.Equals("KnownMostDerived.ki")); test(kmd.kmd.Equals("KnownMostDerived.kmd")); test(kmd.GetType().Name.Equals("KnownMostDerived")); } catch (Exception) { test(false); } cb.called(); }); cb.check(); try { testPrx.knownMostDerivedAsBaseAsync().Wait(); test(false); } catch (AggregateException ae) { try { throw ae.InnerException; } catch (KnownMostDerived kmd) { test(kmd.b.Equals("KnownMostDerived.b")); test(kmd.ki.Equals("KnownMostDerived.ki")); test(kmd.kmd.Equals("KnownMostDerived.kmd")); test(kmd.GetType().Name.Equals("KnownMostDerived")); } catch (Exception) { test(false); } } } output.WriteLine("ok"); output.Write("non-slicing of known intermediate as intermediate... "); output.Flush(); { try { testPrx.knownIntermediateAsKnownIntermediate(); test(false); } catch (KnownIntermediate ki) { test(ki.b.Equals("KnownIntermediate.b")); test(ki.ki.Equals("KnownIntermediate.ki")); test(ki.GetType().FullName.Equals("Test.KnownIntermediate")); } catch (Exception) { test(false); } } output.WriteLine("ok"); output.Write("non-slicing of known intermediate as intermediate (AMI)... "); output.Flush(); { Callback cb = new Callback(); testPrx.begin_knownIntermediateAsKnownIntermediate().whenCompleted( () => { test(false); }, (Ice.Exception ex) => { try { throw ex; } catch (KnownIntermediate ki) { test(ki.b.Equals("KnownIntermediate.b")); test(ki.ki.Equals("KnownIntermediate.ki")); test(ki.GetType().Name.Equals("KnownIntermediate")); } catch (Exception) { test(false); } cb.called(); }); cb.check(); try { testPrx.knownIntermediateAsKnownIntermediateAsync().Wait(); test(false); } catch (AggregateException ae) { try { throw ae.InnerException; } catch (KnownIntermediate ki) { test(ki.b.Equals("KnownIntermediate.b")); test(ki.ki.Equals("KnownIntermediate.ki")); test(ki.GetType().Name.Equals("KnownIntermediate")); } catch (Exception) { test(false); } } } output.WriteLine("ok"); output.Write("non-slicing of known most derived as intermediate... "); output.Flush(); { try { testPrx.knownMostDerivedAsKnownIntermediate(); test(false); } catch (KnownMostDerived kmd) { test(kmd.b.Equals("KnownMostDerived.b")); test(kmd.ki.Equals("KnownMostDerived.ki")); test(kmd.kmd.Equals("KnownMostDerived.kmd")); test(kmd.GetType().FullName.Equals("Test.KnownMostDerived")); } catch (Exception) { test(false); } } output.WriteLine("ok"); output.Write("non-slicing of known most derived as intermediate (AMI)... "); output.Flush(); { Callback cb = new Callback(); testPrx.begin_knownMostDerivedAsKnownIntermediate().whenCompleted( () => { test(false); }, (Ice.Exception ex) => { try { throw ex; } catch (KnownMostDerived kmd) { test(kmd.b.Equals("KnownMostDerived.b")); test(kmd.ki.Equals("KnownMostDerived.ki")); test(kmd.kmd.Equals("KnownMostDerived.kmd")); test(kmd.GetType().Name.Equals("KnownMostDerived")); } catch (Exception) { test(false); } cb.called(); }); cb.check(); try { testPrx.knownMostDerivedAsKnownIntermediateAsync().Wait(); test(false); } catch (AggregateException ae) { try { throw ae.InnerException; } catch (KnownMostDerived kmd) { test(kmd.b.Equals("KnownMostDerived.b")); test(kmd.ki.Equals("KnownMostDerived.ki")); test(kmd.kmd.Equals("KnownMostDerived.kmd")); test(kmd.GetType().Name.Equals("KnownMostDerived")); } catch (Exception) { test(false); } } } output.WriteLine("ok"); output.Write("non-slicing of known most derived as most derived... "); output.Flush(); { try { testPrx.knownMostDerivedAsKnownMostDerived(); test(false); } catch (KnownMostDerived kmd) { test(kmd.b.Equals("KnownMostDerived.b")); test(kmd.ki.Equals("KnownMostDerived.ki")); test(kmd.kmd.Equals("KnownMostDerived.kmd")); test(kmd.GetType().FullName.Equals("Test.KnownMostDerived")); } catch (Exception) { test(false); } } output.WriteLine("ok"); output.Write("non-slicing of known most derived as most derived (AMI)... "); output.Flush(); { Callback cb = new Callback(); testPrx.begin_knownMostDerivedAsKnownMostDerived().whenCompleted( () => { test(false); }, (Ice.Exception ex) => { try { throw ex; } catch (KnownMostDerived kmd) { test(kmd.b.Equals("KnownMostDerived.b")); test(kmd.ki.Equals("KnownMostDerived.ki")); test(kmd.kmd.Equals("KnownMostDerived.kmd")); test(kmd.GetType().Name.Equals("KnownMostDerived")); } catch (Exception) { test(false); } cb.called(); }); cb.check(); try { testPrx.knownMostDerivedAsKnownMostDerivedAsync().Wait(); test(false); } catch (AggregateException ae) { try { throw ae.InnerException; } catch (KnownMostDerived kmd) { test(kmd.b.Equals("KnownMostDerived.b")); test(kmd.ki.Equals("KnownMostDerived.ki")); test(kmd.kmd.Equals("KnownMostDerived.kmd")); test(kmd.GetType().Name.Equals("KnownMostDerived")); } catch (Exception) { test(false); } } } output.WriteLine("ok"); output.Write("slicing of unknown most derived, known intermediate as base... "); output.Flush(); { try { testPrx.unknownMostDerived1AsBase(); test(false); } catch (KnownIntermediate ki) { test(ki.b.Equals("UnknownMostDerived1.b")); test(ki.ki.Equals("UnknownMostDerived1.ki")); test(ki.GetType().FullName.Equals("Test.KnownIntermediate")); } catch (Exception) { test(false); } } output.WriteLine("ok"); output.Write("slicing of unknown most derived, known intermediate as base (AMI)... "); output.Flush(); { Callback cb = new Callback(); testPrx.begin_unknownMostDerived1AsBase().whenCompleted( () => { test(false); }, (Ice.Exception ex) => { try { throw ex; } catch (KnownIntermediate ki) { test(ki.b.Equals("UnknownMostDerived1.b")); test(ki.ki.Equals("UnknownMostDerived1.ki")); test(ki.GetType().Name.Equals("KnownIntermediate")); } catch (Exception) { test(false); } cb.called(); }); cb.check(); try { testPrx.unknownMostDerived1AsBaseAsync().Wait(); test(false); } catch (AggregateException ae) { try { throw ae.InnerException; } catch (KnownIntermediate ki) { test(ki.b.Equals("UnknownMostDerived1.b")); test(ki.ki.Equals("UnknownMostDerived1.ki")); test(ki.GetType().Name.Equals("KnownIntermediate")); } catch (Exception) { test(false); } } } output.WriteLine("ok"); output.Write("slicing of unknown most derived, known intermediate as intermediate... "); output.Flush(); { try { testPrx.unknownMostDerived1AsKnownIntermediate(); test(false); } catch (KnownIntermediate ki) { test(ki.b.Equals("UnknownMostDerived1.b")); test(ki.ki.Equals("UnknownMostDerived1.ki")); test(ki.GetType().FullName.Equals("Test.KnownIntermediate")); } catch (Exception) { test(false); } } output.WriteLine("ok"); output.Write("slicing of unknown most derived, known intermediate as intermediate (AMI)... "); output.Flush(); { Callback cb = new Callback(); testPrx.begin_unknownMostDerived1AsKnownIntermediate().whenCompleted( () => { test(false); }, (Ice.Exception ex) => { try { throw ex; } catch (KnownIntermediate ki) { test(ki.b.Equals("UnknownMostDerived1.b")); test(ki.ki.Equals("UnknownMostDerived1.ki")); test(ki.GetType().Name.Equals("KnownIntermediate")); } catch (Exception) { test(false); } cb.called(); }); cb.check(); try { testPrx.unknownMostDerived1AsKnownIntermediateAsync().Wait(); test(false); } catch (AggregateException ae) { try { throw ae.InnerException; } catch (KnownIntermediate ki) { test(ki.b.Equals("UnknownMostDerived1.b")); test(ki.ki.Equals("UnknownMostDerived1.ki")); test(ki.GetType().Name.Equals("KnownIntermediate")); } catch (Exception) { test(false); } } } output.WriteLine("ok"); output.Write("slicing of unknown most derived, unknown intermediate thrown as base... "); output.Flush(); { try { testPrx.unknownMostDerived2AsBase(); test(false); } catch (Base b) { test(b.b.Equals("UnknownMostDerived2.b")); test(b.GetType().FullName.Equals("Test.Base")); } catch (Exception) { test(false); } } output.WriteLine("ok"); output.Write("slicing of unknown most derived, unknown intermediate thrown as base (AMI)... "); output.Flush(); { Callback cb = new Callback(); testPrx.begin_unknownMostDerived2AsBase().whenCompleted( () => { test(false); }, (Ice.Exception ex) => { try { throw ex; } catch (Base b) { test(b.b.Equals("UnknownMostDerived2.b")); test(b.GetType().Name.Equals("Base")); } catch (Exception) { test(false); } cb.called(); }); cb.check(); try { testPrx.unknownMostDerived2AsBaseAsync().Wait(); test(false); } catch (AggregateException ae) { try { throw ae.InnerException; } catch (Base b) { test(b.b.Equals("UnknownMostDerived2.b")); test(b.GetType().Name.Equals("Base")); } catch (Exception) { test(false); } } } output.WriteLine("ok"); output.Write("unknown most derived in compact format... "); output.Flush(); { try { testPrx.unknownMostDerived2AsBaseCompact(); test(false); } catch (Base) { // // For the 1.0 encoding, the unknown exception is sliced to Base. // test(testPrx.ice_getEncodingVersion().Equals(Ice.Util.Encoding_1_0)); } catch (Ice.UnknownUserException) { // // A MarshalException is raised for the compact format because the // most-derived type is unknown and the exception cannot be sliced. // test(!testPrx.ice_getEncodingVersion().Equals(Ice.Util.Encoding_1_0)); } catch (Ice.OperationNotExistException) { } catch (Exception) { test(false); } } output.WriteLine("ok"); output.Write("preserved exceptions... "); output.Flush(); { try { testPrx.unknownPreservedAsBase(); test(false); } catch (Base ex) { if (testPrx.ice_getEncodingVersion().Equals(Ice.Util.Encoding_1_0)) { test(ex.ice_getSlicedData() == null); } else { Ice.SlicedData slicedData = ex.ice_getSlicedData(); test(slicedData != null); test(slicedData.slices.Length == 2); test(slicedData.slices[1].typeId.Equals("::Test::SPreserved1")); test(slicedData.slices[0].typeId.Equals("::Test::SPreserved2")); } } try { testPrx.unknownPreservedAsKnownPreserved(); test(false); } catch (KnownPreserved ex) { test(ex.kp.Equals("preserved")); if (testPrx.ice_getEncodingVersion().Equals(Ice.Util.Encoding_1_0)) { test(ex.ice_getSlicedData() == null); } else { Ice.SlicedData slicedData = ex.ice_getSlicedData(); test(slicedData != null); test(slicedData.slices.Length == 2); test(slicedData.slices[1].typeId.Equals("::Test::SPreserved1")); test(slicedData.slices[0].typeId.Equals("::Test::SPreserved2")); } } Ice.ObjectAdapter adapter = communicator.createObjectAdapter(""); RelayPrx relay = RelayPrxHelper.uncheckedCast(adapter.addWithUUID(new RelayI())); adapter.activate(); testPrx.ice_getConnection().setAdapter(adapter); try { testPrx.relayKnownPreservedAsBase(relay); test(false); } catch (KnownPreservedDerived ex) { test(ex.b.Equals("base")); test(ex.kp.Equals("preserved")); test(ex.kpd.Equals("derived")); } catch (Ice.OperationNotExistException) { } catch (Exception) { test(false); } try { testPrx.relayKnownPreservedAsKnownPreserved(relay); test(false); } catch (KnownPreservedDerived ex) { test(ex.b.Equals("base")); test(ex.kp.Equals("preserved")); test(ex.kpd.Equals("derived")); } catch (Ice.OperationNotExistException) { } catch (Exception) { test(false); } try { testPrx.relayUnknownPreservedAsBase(relay); test(false); } catch (Preserved2 ex) { test(ex.b.Equals("base")); test(ex.kp.Equals("preserved")); test(ex.kpd.Equals("derived")); test(ex.p1.ice_id().Equals(PreservedClass.ice_staticId())); PreservedClass pc = ex.p1 as PreservedClass; test(pc.bc.Equals("bc")); test(pc.pc.Equals("pc")); test(ex.p2 == ex.p1); } catch (KnownPreservedDerived ex) { // // For the 1.0 encoding, the unknown exception is sliced to KnownPreserved. // test(testPrx.ice_getEncodingVersion().Equals(Ice.Util.Encoding_1_0)); test(ex.b.Equals("base")); test(ex.kp.Equals("preserved")); test(ex.kpd.Equals("derived")); } catch (Ice.OperationNotExistException) { } catch (Exception) { test(false); } try { testPrx.relayUnknownPreservedAsKnownPreserved(relay); test(false); } catch (Preserved2 ex) { test(ex.b.Equals("base")); test(ex.kp.Equals("preserved")); test(ex.kpd.Equals("derived")); test(ex.p1.ice_id().Equals(PreservedClass.ice_staticId())); PreservedClass pc = ex.p1 as PreservedClass; test(pc.bc.Equals("bc")); test(pc.pc.Equals("pc")); test(ex.p2 == ex.p1); } catch (KnownPreservedDerived ex) { // // For the 1.0 encoding, the unknown exception is sliced to KnownPreserved. // test(testPrx.ice_getEncodingVersion().Equals(Ice.Util.Encoding_1_0)); test(ex.b.Equals("base")); test(ex.kp.Equals("preserved")); test(ex.kpd.Equals("derived")); } catch (Ice.OperationNotExistException) { } catch (Exception) { test(false); } adapter.destroy(); } output.WriteLine("ok"); return(testPrx); }