public ConnectionRequestHandler(Reference @ref, Ice.Connection connection, bool compress) { _reference = @ref; _response = _reference.GetMode() == Ice.InvocationMode.Twoway; _connection = connection; _compress = compress; }
public void heartbeat(Ice.Connection con) { lock (this) { ++_heartbeat; } }
public void Reap(Ice.Connection connection) { lock (this) { _reapedConnections.Add(connection); } }
public override void runTestCase(RemoteObjectAdapterPrx adapter, TestIntfPrx proxy) { Ice.Connection con = proxy.ice_getCachedConnection(); try { con.setACM(-19, Ice.Util.None, Ice.Util.None); test(false); } catch (ArgumentException) { } Ice.ACM acm; acm = con.getACM(); test(acm.timeout == 15); test(acm.close == Ice.ACMClose.CloseOnIdleForceful); test(acm.heartbeat == Ice.ACMHeartbeat.HeartbeatOff); con.setACM(Ice.Util.None, Ice.Util.None, Ice.Util.None); acm = con.getACM(); test(acm.timeout == 15); test(acm.close == Ice.ACMClose.CloseOnIdleForceful); test(acm.heartbeat == Ice.ACMHeartbeat.HeartbeatOff); con.setACM(1, Ice.ACMClose.CloseOnInvocationAndIdle, Ice.ACMHeartbeat.HeartbeatAlways); acm = con.getACM(); test(acm.timeout == 1); test(acm.close == Ice.ACMClose.CloseOnInvocationAndIdle); test(acm.heartbeat == Ice.ACMHeartbeat.HeartbeatAlways); proxy.startHeartbeatCount(); proxy.waitForHeartbeatCount(2); var t1 = new TaskCompletionSource <object>(); con.setCloseCallback(_ => { t1.SetResult(null); }); con.close(Ice.ConnectionClose.Gracefully); test(t1.Task.Result == null); try { con.throwException(); test(false); } catch (Ice.ConnectionManuallyClosedException) { } var t2 = new TaskCompletionSource <object>(); con.setCloseCallback(_ => { t2.SetResult(null); }); test(t2.Task.Result == null); con.setHeartbeatCallback(_ => { test(false); }); }
public void closed(Ice.Connection con) { lock (this) { _closed = true; Monitor.Pulse(this); } }
public void heartbeat(Ice.Connection c) { lock (this) { --_count; System.Threading.Monitor.PulseAll(this); } }
public void dispatch(System.Action call, Ice.Connection con) #endif { lock (this) { if (_destroyed) { throw new Ice.CommunicatorDestroyedException(); } _workItems.Enqueue(() => { dispatchFromThisThread(call, con); }); System.Threading.Monitor.Pulse(this); // // If this is a dynamic thread pool which can still grow and if all threads are // currently busy dispatching or about to dispatch, we spawn a new thread to // execute this new work item right away. // if (_threads.Count < _sizeMax && (_inUse + _workItems.Count) > _threads.Count && !_destroyed) { if (_instance.traceLevels().threadPool >= 1) { string s = "growing " + _prefix + ": Size = " + (_threads.Count + 1); _instance.initializationData().logger.trace(_instance.traceLevels().threadPoolCat, s); } try { WorkerThread t = new WorkerThread(this, _threadPrefix + "-" + _threadIndex++); #if !SILVERLIGHT if (_hasPriority) { t.start(_priority); } else { t.start(ThreadPriority.Normal); } #else t.start(); #endif _threads.Add(t); } catch (System.Exception ex) { string s = "cannot create thread for `" + _prefix + "':\n" + ex; _instance.initializationData().logger.error(s); } } } }
public static ConnectionFlushBatch check(Ice.AsyncResult r, Ice.Connection con, string operation) { if (r != null && r.getConnection() != con) { throw new System.ArgumentException("Connection for call to end_" + operation + " does not match connection that was used to call " + "corresponding begin_" + operation + " method"); } return(AsyncResultI.check <ConnectionFlushBatch>(r, operation)); }
public void dispatch(System.Action call, Ice.Connection con) { lock (_m) { _calls.Enqueue(call); if (_calls.Count == 1) { Monitor.Pulse(_m); } } }
dispatchCallback(Action callback, Ice.Connection conn) { if (_initData.dispatcher != null) { _initData.dispatcher(callback, conn); } else { callback(); } }
public override void runTestCase(RemoteObjectAdapterPrx adapter, TestIntfPrx proxy) { proxy.startHeartbeatCount(); Ice.Connection con = proxy.ice_getConnection(); con.heartbeat(); con.heartbeat(); con.heartbeat(); con.heartbeat(); con.heartbeat(); proxy.waitForHeartbeatCount(5); }
public void Remove(Ice.Connection connection) { lock (this) { Debug.Assert(_connection == connection); _connection = null; if (_config.Timeout > 0) { _timer.Cancel(this); } } }
public void Add(Ice.Connection connection) { lock (this) { Debug.Assert(_connection == null); _connection = connection; if (_config.Timeout > 0) { _timer.ScheduleRepeated(this, _config.Timeout / 2); } } }
connected(RouterPrx router, SessionPrx session) { string category = router.getCategoryForClient(); long timeout = router.getSessionTimeout(); Ice.Connection conn = router.ice_getCachedConnection(); lock (this) { _router = router; if (_destroy) { // // Run the destroyInternal in a thread. This is because it // destroyInternal makes remote invocations. // Thread t = new Thread(new ThreadStart(destroyInternal)); t.Start(); return; } // // Cache the category. // _category = category; // // Assign the session after _destroy is checked. // _session = session; _connected = true; Debug.Assert(_sessionRefresh == null); if (timeout > 0) { _sessionRefresh = new SessionRefreshThread(this, _router, (int)(timeout * 1000) / 2); _refreshThread = new Thread(new ThreadStart(_sessionRefresh.run)); _refreshThread.Start(); } } dispatchCallback(delegate() { try { _callback.connected(this); } catch (Glacier2.SessionNotExistException) { destroy(); } }, conn); }
dispatchCallback(System.Action callback, Ice.Connection conn) #endif { if (_initData.dispatcher != null) { _initData.dispatcher(callback, conn); } else { callback(); } }
public void Remove(Ice.Connection connection) { if (_config.Timeout == 0) { return; } lock (this) { Debug.Assert(_communicator != null); _changes.Add(new Change(connection, true)); } }
public void dispatch(System.Action call, Ice.Connection con) #endif { _m.Lock(); try { _calls.Enqueue(call); if (_calls.Count == 1) { _m.Notify(); } } finally { _m.Unlock(); } }
// // These functions allow this object to be reused, rather than reallocated. // public void Reset(Ice.Communicator communicator, IResponseHandler handler, Ice.Connection connection, Ice.ObjectAdapter adapter, bool response, byte compress, int requestId) { _communicator = communicator; _responseHandler = handler; _response = response; _compress = compress; // // Don't recycle the Current object, because servants may keep a reference to it. // _current = null; _adapter = adapter; _connection = connection; _requestId = requestId; _inParamPos = -1; }
public void Add(Ice.Connection connection) { if (_config.Timeout == 0) { return; } lock (this) { if (_connections.Count == 0) { Debug.Assert(_communicator != null); _connections.Add(connection); _communicator.Timer().ScheduleRepeated(this, _config.Timeout / 2); } else { _changes.Add(new Change(connection, false)); } } }
public void dispatchFromThisThread(System.Action call, Ice.Connection con) { if (_dispatcher != null) { try { _dispatcher(call, con); } catch (System.Exception ex) { if (_instance.initializationData().properties.getPropertyAsIntWithDefault( "Ice.Warn.Dispatch", 1) > 1) { _instance.initializationData().logger.warning("dispatch exception:\n" + ex); } } } else { call(); } }
public override int InvokeRemote(Ice.Connection connection, bool compress, bool response) { CachedConnection = connection; return(connection.SendAsyncRequest(this, compress, response)); }
public abstract int InvokeRemote(Ice.Connection connection, bool compress, bool response);
public void closed(Ice.Connection c) { }
public ConnectionFlushBatchCompletionCallback(Ice.Connection connection, Ice.Communicator communicator, Instance instance, string op, object cookie, Ice.AsyncCallback callback) : base(communicator, instance, op, cookie, callback) { _connection = connection; }
connected(RouterPrx router, SessionPrx session) { // // Remote invocation should be done without acquiring a mutex lock. // Debug.Assert(router != null); Ice.Connection conn = router.ice_getCachedConnection(); string category = router.getCategoryForClient(); int acmTimeout = 0; try { acmTimeout = router.getACMTimeout(); } catch (Ice.OperationNotExistException) { } if (acmTimeout <= 0) { acmTimeout = (int)router.getSessionTimeout(); } // // We create the callback object adapter here because createObjectAdapter internally // makes synchronous RPCs to the router. We can't create the OA on-demand when the // client calls objectAdapter() or addWithUUID() because they can be called from the // GUI thread. // if (_useCallbacks) { Debug.Assert(_adapter == null); _adapter = _communicator.createObjectAdapterWithRouter("", router); _adapter.activate(); } lock (_mutex) { _router = router; if (_destroy) { // // Run destroyInternal in a thread because it makes remote invocations. // Thread t = new Thread(new ThreadStart(destroyInternal)); t.Start(); return; } // // Cache the category. // _category = category; // // Assign the session after _destroy is checked. // _session = session; _connected = true; if (acmTimeout > 0) { Ice.Connection connection = _router.ice_getCachedConnection(); Debug.Assert(connection != null); connection.setACM(acmTimeout, Ice.Util.None, Ice.ACMHeartbeat.HeartbeatAlways); connection.setCloseCallback(_ => destroy()); } } dispatchCallback(() => { try { _callback.connected(this); } catch (SessionNotExistException) { destroy(); } }, conn); }
public void closed(Ice.Connection con) { called(); }
public static void allTests(TestCommon.Application app) { Ice.Communicator communicator = app.communicator(); Write("testing proxy endpoint information... "); Flush(); { Ice.ObjectPrx p1 = communicator.stringToProxy( "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"); Ice.Endpoint[] endps = p1.ice_getEndpoints(); 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))); } WriteLine("ok"); Ice.ObjectAdapter adapter; Write("test object adapter endpoint information... "); 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 = app.getTestPort(1); communicator.getProperties().setProperty("TestAdapter.Endpoints", "default -h * -p " + port); communicator.getProperties().setProperty("TestAdapter.PublishedEndpoints", app.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(); } WriteLine("ok"); int endpointPort = app.getTestPort(0); Ice.ObjectPrx @base = communicator.stringToProxy("test:" + app.getTestEndpoint(0) + ":" + app.getTestEndpoint(0, "udp")); TestIntfPrx testIntf = TestIntfPrxHelper.checkedCast(@base); string defaultHost = communicator.getProperties().getProperty("Ice.Default.Host"); Write("test connection endpoint information... "); Flush(); { Ice.EndpointInfo info = @base.ice_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 = System.Int32.Parse(ctx["port"]); test(port > 0); info = @base.ice_datagram().ice_getConnection().getEndpoint().getInfo(); Ice.UDPEndpointInfo udp = (Ice.UDPEndpointInfo)info; test(udp.port == endpointPort); test(udp.host.Equals(defaultHost)); } WriteLine("ok"); Write("testing connection information... "); Flush(); { Ice.Connection connection = @base.ice_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.ice_getConnection().type().Equals("ws") || @base.ice_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.ice_datagram().ice_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); } WriteLine("ok"); testIntf.shutdown(); communicator.shutdown(); communicator.waitForShutdown(); }
public static Test.TimeoutPrx allTests(Ice.Communicator communicator) #endif { string sref = "timeout:default -p 12010"; Ice.ObjectPrx obj = communicator.stringToProxy(sref); test(obj != null); Test.TimeoutPrx timeout = Test.TimeoutPrxHelper.checkedCast(obj); test(timeout != null); Write("testing connect timeout... "); Flush(); { // // Expect ConnectTimeoutException. // Test.TimeoutPrx to = Test.TimeoutPrxHelper.uncheckedCast(obj.ice_timeout(100)); timeout.holdAdapter(500); try { to.op(); test(false); } catch (Ice.ConnectTimeoutException) { // Expected. } } { // // Expect success. // timeout.op(); // Ensure adapter is active. Test.TimeoutPrx to = Test.TimeoutPrxHelper.uncheckedCast(obj.ice_timeout(1000)); timeout.holdAdapter(500); 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(100)); timeout.holdAdapter(500); try { to.sendData(seq); test(false); } catch (Ice.TimeoutException) { // Expected. } } { // // Expect success. // timeout.op(); // Ensure adapter is active. Test.TimeoutPrx to = Test.TimeoutPrxHelper.uncheckedCast(obj.ice_timeout(1000)); timeout.holdAdapter(500); 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(750); test(false); } catch (Ice.InvocationTimeoutException) { } obj.ice_ping(); to = Test.TimeoutPrxHelper.checkedCast(obj.ice_invocationTimeout(500)); test(connection == to.ice_getConnection()); try { to.sleep(250); } 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(750).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(500)); Callback cb = new Callback(); to.begin_sleep(250).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(100)); Ice.Connection con = null; try { con = to.ice_getConnection(); 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 = to.ice_getConnection(); 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.checkedCast(obj.ice_timeout(100)); Ice.Connection connection = to.ice_getConnection(); timeout.holdAdapter(500); connection.close(false); try { connection.getInfo(); // getInfo() doesn't throw in the closing state. } catch (Ice.LocalException) { test(false); } Thread.Sleep(500); try { connection.getInfo(); test(false); } catch (Ice.CloseConnectionException) { // Expected. } 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.Timeout", "100"); Ice.Communicator comm = Ice.Util.initialize(ref args, initData); Test.TimeoutPrx to = Test.TimeoutPrxHelper.checkedCast(comm.stringToProxy(sref)); timeout.holdAdapter(500); try { to.sendData(seq); test(false); } catch (Ice.TimeoutException) { // Expected. } // // Calling ice_timeout() should have no effect. // timeout.op(); // Ensure adapter is active. to = Test.TimeoutPrxHelper.checkedCast(to.ice_timeout(1000)); timeout.holdAdapter(500); try { to.sendData(seq); test(false); } catch (Ice.TimeoutException) { // Expected. } 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); timeout.holdAdapter(750); Test.TimeoutPrx to = Test.TimeoutPrxHelper.uncheckedCast(comm.stringToProxy(sref)); try { to.op(); test(false); } catch (Ice.ConnectTimeoutException) { // Expected. } // // Calling ice_timeout() should have no effect on the connect timeout. // timeout.op(); // Ensure adapter is active. timeout.holdAdapter(750); to = Test.TimeoutPrxHelper.uncheckedCast(to.ice_timeout(1000)); try { to.op(); test(false); } catch (Ice.ConnectTimeoutException) { // Expected. } // // Verify that timeout set via ice_timeout() is still used for requests. // timeout.op(); // Ensure adapter is active. to = Test.TimeoutPrxHelper.uncheckedCast(to.ice_timeout(100)); to.ice_getConnection(); // Establish connection. timeout.holdAdapter(750); try { to.sendData(seq); test(false); } catch (Ice.TimeoutException) { // Expected. } 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(); timeout.holdAdapter(500); long begin = System.DateTime.Now.Ticks; comm.destroy(); test(((long)new System.TimeSpan(System.DateTime.Now.Ticks - begin).TotalMilliseconds - begin) < 400); } 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(300); test(false); } catch (Ice.InvocationTimeoutException) { } try { proxy.end_sleep(proxy.begin_sleep(300)); test(false); } catch (Ice.InvocationTimeoutException) { } 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"); #if SILVERLIGHT timeout.shutdown(); #else return(timeout); #endif }
public void heartbeat(Ice.Connection con) { }
dispatchCallback(Ice.VoidAction callback, Ice.Connection conn)
private static int run(Ice.Communicator communicator) { var router = Glacier2.RouterPrxHelper.checkedCast(communicator.getDefaultRouter()); Glacier2.SessionPrx session; while (true) { Console.WriteLine("This demo accepts any user-id / password combination."); string id; string pw; try { Console.Write("user id: "); Console.Out.Flush(); id = Console.In.ReadLine(); if (id == null) { throw new Ice.CommunicatorDestroyedException(); } id = id.Trim(); Console.Write("password: "******"permission denied:\n" + ex.reason); } catch (Glacier2.CannotCreateSessionException ex) { Console.WriteLine("cannot create session:\n" + ex.reason); } } int acmTimeout = router.getACMTimeout(); Ice.Connection connection = router.ice_getCachedConnection(); Debug.Assert(connection != null); connection.setACM(acmTimeout, Ice.Util.None, Ice.ACMHeartbeat.HeartbeatAlways); connection.setCloseCallback(_ => Console.WriteLine("The Glacier2 session has been destroyed.")); Ice.Identity callbackReceiverIdent = new Ice.Identity("callbackReceiver", router.getCategoryForClient()); Ice.Identity callbackReceiverFakeIdent = new Ice.Identity("fake", "callbackReceiver"); Ice.ObjectPrx @base = communicator.propertyToProxy("Callback.Proxy"); CallbackPrx twoway = CallbackPrxHelper.checkedCast(@base); CallbackPrx oneway = CallbackPrxHelper.uncheckedCast(twoway.ice_oneway()); CallbackPrx batchOneway = CallbackPrxHelper.uncheckedCast(twoway.ice_batchOneway()); var adapter = communicator.createObjectAdapterWithRouter("", router); adapter.add(new CallbackReceiverI(), callbackReceiverFakeIdent); CallbackReceiverPrx twowayR = CallbackReceiverPrxHelper.uncheckedCast( adapter.add(new CallbackReceiverI(), callbackReceiverIdent)); adapter.activate(); CallbackReceiverPrx onewayR = CallbackReceiverPrxHelper.uncheckedCast(twowayR.ice_oneway()); menu(); string line = null; string @override = null; bool fake = false; do { Console.Write("==> "); Console.Out.Flush(); line = Console.In.ReadLine(); if (line == null) { break; } if (line.Equals("t")) { Dictionary <string, string> context = new Dictionary <string, string>(); context["_fwd"] = "t"; if (@override != null) { context["_ovrd"] = @override; } twoway.initiateCallback(twowayR, context); } else if (line.Equals("o")) { Dictionary <string, string> context = new Dictionary <string, string>(); context["_fwd"] = "o"; if (@override != null) { context["_ovrd"] = @override; } oneway.initiateCallback(onewayR, context); } else if (line.Equals("O")) { Dictionary <string, string> context = new Dictionary <string, string>(); context["_fwd"] = "O"; if (@override != null) { context["_ovrd"] = @override; } batchOneway.initiateCallback(onewayR, context); } else if (line.Equals("f")) { batchOneway.ice_flushBatchRequests(); } else if (line.Equals("v")) { if (@override == null) { @override = "some_value"; Console.WriteLine("override context field is now `" + @override + "'"); } else { @override = null; Console.WriteLine("override context field is empty"); } } else if (line.Equals("F")) { fake = !fake; if (fake) { twowayR = CallbackReceiverPrxHelper.uncheckedCast( twowayR.ice_identity(callbackReceiverFakeIdent)); onewayR = CallbackReceiverPrxHelper.uncheckedCast( onewayR.ice_identity(callbackReceiverFakeIdent)); } else { twowayR = CallbackReceiverPrxHelper.uncheckedCast( twowayR.ice_identity(callbackReceiverIdent)); onewayR = CallbackReceiverPrxHelper.uncheckedCast( onewayR.ice_identity(callbackReceiverIdent)); } Console.WriteLine("callback receiver identity: " + Ice.Util.identityToString(twowayR.ice_getIdentity())); } else if (line.Equals("s")) { twoway.shutdown(); } else if (line.Equals("x")) { // Nothing to do } else if (line.Equals("?")) { menu(); } else { Console.WriteLine("unknown command `" + line + "'"); menu(); } }while(!line.Equals("x")); return(0); }