int
run(int argc, char* argv[])
{
Ice::InitializationData initData;
initData.properties = Ice::createProperties();
loadConfig(initData.properties);
//
// Now parse argc/argv into initData.properties
//
initData.properties = Ice::createProperties(argc, argv, initData.properties);
//
// For this test, we want to disable retries.
//
initData.properties->setProperty("Ice.RetryIntervals", "-1");
//
// This test kills connections, so we don't want warnings.
//
initData.properties->setProperty("Ice.Warn.Connections", "0");
initData.logger = getLogger();
setCommunicator(Ice::initialize(argc, argv, initData));
TimeoutPrx allTests(const Ice::CommunicatorPtr&);
TimeoutPrx timeout = allTests(communicator());
timeout->shutdown();
return EXIT_SUCCESS;
}
int
run(int, char**, const Ice::CommunicatorPtr& communicator)
{
TimeoutPrx allTests(const Ice::CommunicatorPtr&);
TimeoutPrx timeout = allTests(communicator);
timeout->shutdown();
return EXIT_SUCCESS;
}
TimeoutPrx
allTests(const Ice::CommunicatorPtr& communicator)
{
string sref = "timeout:default -p 12010";
Ice::ObjectPrx obj = communicator->stringToProxy(sref);
test(obj);
TimeoutPrx timeout = TimeoutPrx::checkedCast(obj);
test(timeout);
cout << "testing connect timeout... " << flush;
{
//
// Expect ConnectTimeoutException.
//
TimeoutPrx to = TimeoutPrx::uncheckedCast(obj->ice_timeout(250));
to->holdAdapter(750);
to->ice_getConnection()->close(true); // Force a reconnect.
try
{
to->op();
test(false);
}
catch(const Ice::ConnectTimeoutException&)
{
// Expected.
}
}
{
//
// Expect success.
//
timeout->op(); // Ensure adapter is active.
TimeoutPrx to = TimeoutPrx::uncheckedCast(obj->ice_timeout(1000));
to->holdAdapter(500);
to->ice_getConnection()->close(true); // Force a reconnect.
try
{
to->op();
}
catch(const Ice::ConnectTimeoutException&)
{
test(false);
}
}
cout << "ok" << endl;
cout << "testing read timeout... " << flush;
{
//
// Expect TimeoutException.
//
TimeoutPrx to = TimeoutPrx::uncheckedCast(obj->ice_timeout(500));
try
{
to->sleep(750);
test(false);
}
catch(const Ice::TimeoutException&)
{
// Expected.
}
}
{
//
// Expect success.
//
timeout->op(); // Ensure adapter is active.
TimeoutPrx to = TimeoutPrx::uncheckedCast(obj->ice_timeout(2000));
try
{
to->sleep(500);
}
catch(const Ice::TimeoutException&)
{
test(false);
}
}
cout << "ok" << endl;
cout << "testing write timeout... " << flush;
{
//
// Expect TimeoutException.
//
TimeoutPrx to = TimeoutPrx::uncheckedCast(obj->ice_timeout(500));
to->holdAdapter(2000);
try
{
ByteSeq seq(100000);
to->sendData(seq);
test(false);
}
catch(const Ice::TimeoutException&)
{
// Expected.
}
}
{
//
// Expect success.
//
timeout->op(); // Ensure adapter is active.
TimeoutPrx to = TimeoutPrx::uncheckedCast(obj->ice_timeout(1000));
to->holdAdapter(500);
try
{
ByteSeq seq(100000);
to->sendData(seq);
}
catch(const Ice::TimeoutException&)
{
test(false);
}
}
cout << "ok" << endl;
cout << "testing AMI read timeout... " << flush;
{
//
// Expect TimeoutException.
//
TimeoutPrx to = TimeoutPrx::uncheckedCast(obj->ice_timeout(500));
CallbackPtr cb = new Callback();
to->begin_sleep(2000, newCallback_Timeout_sleep(cb, &Callback::responseEx, &Callback::exceptionEx));
cb->check();
}
{
//
// Expect success.
//
timeout->op(); // Ensure adapter is active.
TimeoutPrx to = TimeoutPrx::uncheckedCast(obj->ice_timeout(1000));
CallbackPtr cb = new Callback();
to->begin_sleep(500, newCallback_Timeout_sleep(cb, &Callback::response, &Callback::exception));
cb->check();
}
cout << "ok" << endl;
cout << "testing AMI write timeout... " << flush;
{
//
// Expect TimeoutException.
//
TimeoutPrx to = TimeoutPrx::uncheckedCast(obj->ice_timeout(500));
to->holdAdapter(2000);
ByteSeq seq(100000);
CallbackPtr cb = new Callback();
to->begin_sendData(seq, newCallback_Timeout_sendData(cb, &Callback::responseEx, &Callback::exceptionEx));
cb->check();
}
{
//
// Expect success.
//
timeout->op(); // Ensure adapter is active.
TimeoutPrx to = TimeoutPrx::uncheckedCast(obj->ice_timeout(1000));
to->holdAdapter(500);
ByteSeq seq(100000);
CallbackPtr cb = new Callback();
to->begin_sendData(seq, newCallback_Timeout_sendData(cb, &Callback::response, &Callback::exception));
cb->check();
}
cout << "ok" << endl;
cout << "testing close timeout... " << flush;
{
TimeoutPrx to = TimeoutPrx::checkedCast(obj->ice_timeout(250));
Ice::ConnectionPtr connection = to->ice_getConnection();
timeout->holdAdapter(750);
connection->close(false);
try
{
connection->getInfo(); // getInfo() doesn't throw in the closing state.
}
catch(const Ice::LocalException&)
{
test(false);
}
IceUtil::ThreadControl::sleep(IceUtil::Time::milliSeconds(500));
try
{
connection->getInfo();
test(false);
}
catch(const Ice::CloseConnectionException&)
{
// Expected.
}
timeout->op(); // Ensure adapter is active.
}
cout << "ok" << endl;
cout << "testing timeout overrides... " << flush;
{
//
// Test Ice.Override.Timeout. This property overrides all
// endpoint timeouts.
//
Ice::InitializationData initData;
initData.properties = communicator->getProperties()->clone();
initData.properties->setProperty("Ice.Override.Timeout", "500");
Ice::CommunicatorPtr comm = Ice::initialize(initData);
TimeoutPrx to = TimeoutPrx::checkedCast(comm->stringToProxy(sref));
try
{
to->sleep(750);
test(false);
}
catch(const Ice::TimeoutException&)
{
// Expected.
}
//
// Calling ice_timeout() should have no effect.
//
timeout->op(); // Ensure adapter is active.
to = TimeoutPrx::checkedCast(to->ice_timeout(1000));
try
{
to->sleep(750);
test(false);
}
catch(const Ice::TimeoutException&)
{
// Expected.
}
comm->destroy();
}
{
//
// Test Ice.Override.ConnectTimeout.
//
Ice::InitializationData initData;
initData.properties = communicator->getProperties()->clone();
initData.properties->setProperty("Ice.Override.ConnectTimeout", "750");
Ice::CommunicatorPtr comm = Ice::initialize(initData);
timeout->holdAdapter(1000);
TimeoutPrx to = TimeoutPrx::uncheckedCast(comm->stringToProxy(sref));
try
{
to->op();
test(false);
}
catch(const Ice::ConnectTimeoutException&)
{
// Expected.
}
//
// Calling ice_timeout() should have no effect on the connect timeout.
//
timeout->op(); // Ensure adapter is active.
timeout->holdAdapter(1000);
to = TimeoutPrx::uncheckedCast(to->ice_timeout(1250));
try
{
to->op();
test(false);
}
catch(const Ice::ConnectTimeoutException&)
{
// Expected.
}
//
// Verify that timeout set via ice_timeout() is still used for requests.
//
to->op(); // Force connection.
try
{
to->sleep(2000);
test(false);
}
catch(const Ice::TimeoutException&)
{
// Expected.
}
comm->destroy();
}
{
//
// Test Ice.Override.CloseTimeout.
//
Ice::InitializationData initData;
initData.properties = communicator->getProperties()->clone();
initData.properties->setProperty("Ice.Override.CloseTimeout", "200");
Ice::CommunicatorPtr comm = Ice::initialize(initData);
Ice::ConnectionPtr connection = comm->stringToProxy(sref)->ice_getConnection();
timeout->holdAdapter(750);
IceUtil::Time now = IceUtil::Time::now();
comm->destroy();
test(IceUtil::Time::now() - now < IceUtil::Time::milliSeconds(500));
}
cout << "ok" << endl;
return timeout;
}
TimeoutPrx
allTests(const Ice::CommunicatorPtr& communicator)
{
string sref = "timeout:default -p 12010";
Ice::ObjectPrx obj = communicator->stringToProxy(sref);
test(obj);
TimeoutPrx timeout = TimeoutPrx::checkedCast(obj);
test(timeout);
cout << "testing connect timeout... " << flush;
{
//
// Expect ConnectTimeoutException.
//
TimeoutPrx to = TimeoutPrx::uncheckedCast(obj->ice_timeout(100));
timeout->holdAdapter(500);
try
{
to->op();
test(false);
}
catch(const Ice::ConnectTimeoutException&)
{
// Expected.
}
}
{
//
// Expect success.
//
timeout->op(); // Ensure adapter is active.
TimeoutPrx to = TimeoutPrx::uncheckedCast(obj->ice_timeout(1000));
timeout->holdAdapter(500);
try
{
to->op();
}
catch(const Ice::ConnectTimeoutException&)
{
test(false);
}
}
cout << "ok" << endl;
// The sequence needs to be large enough to fill the write/recv buffers
ByteSeq seq(2000000);
cout << "testing connection timeout... " << flush;
{
//
// Expect TimeoutException.
//
TimeoutPrx to = TimeoutPrx::uncheckedCast(obj->ice_timeout(100));
timeout->holdAdapter(500);
try
{
to->sendData(seq);
test(false);
}
catch(const Ice::TimeoutException&)
{
// Expected.
}
}
{
//
// Expect success.
//
timeout->op(); // Ensure adapter is active.
TimeoutPrx to = TimeoutPrx::uncheckedCast(obj->ice_timeout(1000));
timeout->holdAdapter(500);
try
{
ByteSeq seq(1000000);
to->sendData(seq);
}
catch(const Ice::TimeoutException&)
{
test(false);
}
}
cout << "ok" << endl;
cout << "testing invocation timeout... " << flush;
{
Ice::ConnectionPtr connection = obj->ice_getConnection();
TimeoutPrx to = TimeoutPrx::uncheckedCast(obj->ice_invocationTimeout(100));
test(connection == to->ice_getConnection());
try
{
to->sleep(750);
test(false);
}
catch(const Ice::InvocationTimeoutException&)
{
}
obj->ice_ping();
to = TimeoutPrx::checkedCast(obj->ice_invocationTimeout(500));
test(connection == to->ice_getConnection());
try
{
to->sleep(250);
}
catch(const Ice::InvocationTimeoutException&)
{
test(false);
}
test(connection == to->ice_getConnection());
}
{
//
// Expect InvocationTimeoutException.
//
TimeoutPrx to = TimeoutPrx::uncheckedCast(obj->ice_invocationTimeout(100));
CallbackPtr cb = new Callback();
to->begin_sleep(750, newCallback_Timeout_sleep(cb, &Callback::responseEx, &Callback::exceptionEx));
cb->check();
obj->ice_ping();
}
{
//
// Expect success.
//
TimeoutPrx to = TimeoutPrx::uncheckedCast(obj->ice_invocationTimeout(500));
CallbackPtr cb = new Callback();
to->begin_sleep(250, newCallback_Timeout_sleep(cb, &Callback::response, &Callback::exception));
cb->check();
}
{
//
// Backward compatible connection timeouts
//
TimeoutPrx to = TimeoutPrx::uncheckedCast(obj->ice_invocationTimeout(-2)->ice_timeout(100));
Ice::ConnectionPtr con;
try
{
con = to->ice_getConnection();
to->sleep(750);
test(false);
}
catch(const Ice::TimeoutException&)
{
try
{
con->getInfo();
test(false);
}
catch(const 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(const Ice::TimeoutException&)
{
try
{
con->getInfo();
test(false);
}
catch(const Ice::TimeoutException&)
{
// Connection got closed as well.
}
}
obj->ice_ping();
}
cout << "ok" << endl;
cout << "testing close timeout... " << flush;
{
TimeoutPrx to = TimeoutPrx::checkedCast(obj->ice_timeout(100));
Ice::ConnectionPtr connection = to->ice_getConnection();
timeout->holdAdapter(500);
connection->close(false);
try
{
connection->getInfo(); // getInfo() doesn't throw in the closing state.
}
catch(const Ice::LocalException&)
{
test(false);
}
IceUtil::ThreadControl::sleep(IceUtil::Time::milliSeconds(500));
try
{
connection->getInfo();
test(false);
}
catch(const Ice::CloseConnectionException&)
{
// Expected.
}
timeout->op(); // Ensure adapter is active.
}
cout << "ok" << endl;
cout << "testing timeout overrides... " << flush;
{
//
// Test Ice.Override.Timeout. This property overrides all
// endpoint timeouts.
//
Ice::InitializationData initData;
initData.properties = communicator->getProperties()->clone();
initData.properties->setProperty("Ice.Override.Timeout", "100");
Ice::CommunicatorPtr comm = Ice::initialize(initData);
TimeoutPrx to = TimeoutPrx::checkedCast(comm->stringToProxy(sref));
timeout->holdAdapter(500);
try
{
to->sendData(seq);
test(false);
}
catch(const Ice::TimeoutException&)
{
// Expected.
}
//
// Calling ice_timeout() should have no effect.
//
timeout->op(); // Ensure adapter is active.
to = TimeoutPrx::checkedCast(to->ice_timeout(1000));
timeout->holdAdapter(500);
try
{
to->sendData(seq);
test(false);
}
catch(const Ice::TimeoutException&)
{
// Expected.
}
comm->destroy();
}
{
//
// Test Ice.Override.ConnectTimeout.
//
Ice::InitializationData initData;
initData.properties = communicator->getProperties()->clone();
initData.properties->setProperty("Ice.Override.ConnectTimeout", "250");
Ice::CommunicatorPtr comm = Ice::initialize(initData);
timeout->holdAdapter(750);
TimeoutPrx to = TimeoutPrx::uncheckedCast(comm->stringToProxy(sref));
try
{
to->op();
test(false);
}
catch(const Ice::ConnectTimeoutException&)
{
// Expected.
}
//
// Calling ice_timeout() should have no effect on the connect timeout.
//
timeout->op(); // Ensure adapter is active.
timeout->holdAdapter(750);
to = TimeoutPrx::uncheckedCast(to->ice_timeout(1000));
try
{
to->op();
test(false);
}
catch(const Ice::ConnectTimeoutException&)
{
// Expected.
}
//
// Verify that timeout set via ice_timeout() is still used for requests.
//
timeout->op(); // Ensure adapter is active.
to = TimeoutPrx::uncheckedCast(to->ice_timeout(100));
to->ice_getConnection(); // Establish connection
timeout->holdAdapter(750);
try
{
to->sendData(seq);
test(false);
}
catch(const Ice::TimeoutException&)
{
// Expected.
}
comm->destroy();
}
{
//
// Test Ice.Override.CloseTimeout.
//
Ice::InitializationData initData;
initData.properties = communicator->getProperties()->clone();
initData.properties->setProperty("Ice.Override.CloseTimeout", "100");
Ice::CommunicatorPtr comm = Ice::initialize(initData);
Ice::ConnectionPtr connection = comm->stringToProxy(sref)->ice_getConnection();
timeout->holdAdapter(500);
IceUtil::Time now = IceUtil::Time::now();
comm->destroy();
test(IceUtil::Time::now() - now < IceUtil::Time::milliSeconds(400));
}
cout << "ok" << endl;
cout << "testing invocation timeouts with collocated calls... " << flush;
{
communicator->getProperties()->setProperty("TimeoutCollocated.AdapterId", "timeoutAdapter");
Ice::ObjectAdapterPtr adapter = communicator->createObjectAdapter("TimeoutCollocated");
adapter->activate();
TimeoutPrx timeout = TimeoutPrx::uncheckedCast(adapter->addWithUUID(new TimeoutI()));
timeout = timeout->ice_invocationTimeout(100);
try
{
timeout->sleep(300);
test(false);
}
catch(const Ice::InvocationTimeoutException&)
{
}
try
{
timeout->end_sleep(timeout->begin_sleep(300));
test(false);
}
catch(const Ice::InvocationTimeoutException&)
{
}
TimeoutPrx batchTimeout = timeout->ice_batchOneway();
batchTimeout->ice_ping();
batchTimeout->ice_ping();
batchTimeout->ice_ping();
timeout->ice_invocationTimeout(-1)->begin_sleep(300); // Keep the server thread pool busy.
try
{
batchTimeout->ice_flushBatchRequests();
test(false);
}
catch(const Ice::InvocationTimeoutException&)
{
}
batchTimeout->ice_ping();
batchTimeout->ice_ping();
batchTimeout->ice_ping();
timeout->ice_invocationTimeout(-1)->begin_sleep(300); // Keep the server thread pool busy.
try
{
batchTimeout->end_ice_flushBatchRequests(batchTimeout->begin_ice_flushBatchRequests());
test(false);
}
catch(const Ice::InvocationTimeoutException&)
{
}
adapter->destroy();
}
cout << "ok" << endl;
return timeout;
}
