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);
}