diff options
Diffstat (limited to 'cpp/test/IceGrid/allocation/AllTests.cpp')
| -rw-r--r-- | cpp/test/IceGrid/allocation/AllTests.cpp | 1868 |
1 files changed, 934 insertions, 934 deletions
diff --git a/cpp/test/IceGrid/allocation/AllTests.cpp b/cpp/test/IceGrid/allocation/AllTests.cpp index 7079f31c4ed..dfc515d904f 100644 --- a/cpp/test/IceGrid/allocation/AllTests.cpp +++ b/cpp/test/IceGrid/allocation/AllTests.cpp @@ -32,47 +32,47 @@ public: void response(const Ice::ObjectPrx& obj) { - Lock sync(*this); - _response = true; - _obj = obj; - notify(); + Lock sync(*this); + _response = true; + _obj = obj; + notify(); } void exception() { - Lock sync(*this); - _exception = true; - notify(); + Lock sync(*this); + _exception = true; + notify(); } void waitResponse(const char* file, int line) { - Lock sync(*this); - while(!_response && !_exception) - { - if(!timedWait(IceUtil::Time::seconds(3))) - { - cerr << "timeout: " << file << ":" << line << endl; - test(false); // Timeout - } - } + Lock sync(*this); + while(!_response && !_exception) + { + if(!timedWait(IceUtil::Time::seconds(3))) + { + cerr << "timeout: " << file << ":" << line << endl; + test(false); // Timeout + } + } } bool hasResponse(Ice::ObjectPrx& obj) { - Lock sync(*this); - obj = _obj; - return _response; + Lock sync(*this); + obj = _obj; + return _response; } bool hasException() { - Lock sync(*this); - return _exception; + Lock sync(*this); + return _exception; } private: @@ -106,171 +106,171 @@ public: StressClient(int id, const RegistryPrx& registry, bool destroySession) : _communicator(registry->ice_getCommunicator()), - _id(id), - _registry(registry), - _notified(false), - _terminated(false), - _destroySession(destroySession) + _id(id), + _registry(registry), + _notified(false), + _terminated(false), + _destroySession(destroySession) { } StressClient(int id, const SessionPrx& session) : _communicator(session->ice_getCommunicator()), - _id(id), - _session(session), - _notified(false), - _terminated(false), - _destroySession(false) + _id(id), + _session(session), + _notified(false), + _terminated(false), + _destroySession(false) { } virtual void run() { - { - Lock sync(*this); - while(!_notified) - { - wait(); - } - } - - SessionPrx session; - while(true) - { - { - Lock sync(*this); - if(_terminated) - { - if(!_session && session) - { - session->destroy(); - } - return; - } - } - - if(!session) - { - ostringstream os; - os << "Client-" << _id; - if(_session) - { - session = _session; - } - else - { - session = _registry->createSession(os.str(), ""); - session->setAllocationTimeout(IceUtil::random(200)); // 200ms timeout - } - } - - assert(session); - session->keepAlive(); - - Ice::ObjectPrx object; - switch(IceUtil::random(_destroySession ? 4 : 2)) - { - case 0: - object = allocate(session); - break; - case 1: - object = allocateByType(session); - break; - case 2: - assert(!_session); - allocateAndDestroy(session); - session = 0; - break; - case 3: - assert(!_session); - allocateByTypeAndDestroy(session); - session = 0; - break; - } - - if(object) - { - IceUtil::ThreadControl::sleep(IceUtil::Time::milliSeconds(IceUtil::random(20))); - switch(IceUtil::random(_destroySession ? 2 : 1)) - { - case 0: - session->releaseObject(object->ice_getIdentity()); - break; - case 1: - assert(!_session); - session->destroy(); - session = 0; - break; - } - } - } + { + Lock sync(*this); + while(!_notified) + { + wait(); + } + } + + SessionPrx session; + while(true) + { + { + Lock sync(*this); + if(_terminated) + { + if(!_session && session) + { + session->destroy(); + } + return; + } + } + + if(!session) + { + ostringstream os; + os << "Client-" << _id; + if(_session) + { + session = _session; + } + else + { + session = _registry->createSession(os.str(), ""); + session->setAllocationTimeout(IceUtil::random(200)); // 200ms timeout + } + } + + assert(session); + session->keepAlive(); + + Ice::ObjectPrx object; + switch(IceUtil::random(_destroySession ? 4 : 2)) + { + case 0: + object = allocate(session); + break; + case 1: + object = allocateByType(session); + break; + case 2: + assert(!_session); + allocateAndDestroy(session); + session = 0; + break; + case 3: + assert(!_session); + allocateByTypeAndDestroy(session); + session = 0; + break; + } + + if(object) + { + IceUtil::ThreadControl::sleep(IceUtil::Time::milliSeconds(IceUtil::random(20))); + switch(IceUtil::random(_destroySession ? 2 : 1)) + { + case 0: + session->releaseObject(object->ice_getIdentity()); + break; + case 1: + assert(!_session); + session->destroy(); + session = 0; + break; + } + } + } } Ice::ObjectPrx allocate(const SessionPrx& session) { - ostringstream os; - os << "stress-" << IceUtil::random(6) + 1; - try - { - return session->allocateObjectById(_communicator->stringToIdentity(os.str())); - } - catch(const AllocationTimeoutException&) - { - } - catch(const AllocationException&) - { - // This can only happen if we are using the common session - // and the object is already allocated. - test(_session); - } - return 0; + ostringstream os; + os << "stress-" << IceUtil::random(6) + 1; + try + { + return session->allocateObjectById(_communicator->stringToIdentity(os.str())); + } + catch(const AllocationTimeoutException&) + { + } + catch(const AllocationException&) + { + // This can only happen if we are using the common session + // and the object is already allocated. + test(_session); + } + return 0; } Ice::ObjectPrx allocateByType(const SessionPrx& session) { - try - { - return session->allocateObjectByType("::StressTest"); - } - catch(const AllocationTimeoutException&) - { - } - return 0; + try + { + return session->allocateObjectByType("::StressTest"); + } + catch(const AllocationTimeoutException&) + { + } + return 0; } void allocateAndDestroy(const SessionPrx& session) { - ostringstream os; - os << "stress-" << IceUtil::random(3); - session->allocateObjectById_async(new AllocateObjectByIdCallback(), _communicator->stringToIdentity(os.str())); - session->destroy(); + ostringstream os; + os << "stress-" << IceUtil::random(3); + session->allocateObjectById_async(new AllocateObjectByIdCallback(), _communicator->stringToIdentity(os.str())); + session->destroy(); } void allocateByTypeAndDestroy(const SessionPrx& session) { - session->allocateObjectByType_async(new AllocateObjectByTypeCallback(), "::StressTest"); - session->destroy(); + session->allocateObjectByType_async(new AllocateObjectByTypeCallback(), "::StressTest"); + session->destroy(); } void notifyThread() { - Lock sync(*this); - _notified = true; - notify(); + Lock sync(*this); + _notified = true; + notify(); } void terminate() { - Lock sync(*this); - _terminated = true; - notify(); + Lock sync(*this); + _terminated = true; + notify(); } protected: @@ -290,72 +290,72 @@ class SessionKeepAliveThread : public IceUtil::Thread, public IceUtil::Monitor<I public: SessionKeepAliveThread(const Ice::LoggerPtr& logger, const IceUtil::Time& timeout) : - _logger(logger), - _timeout(timeout), - _terminated(false) + _logger(logger), + _timeout(timeout), + _terminated(false) { } virtual void run() { - Lock sync(*this); - while(!_terminated) - { - timedWait(_timeout); - if(!_terminated) - { - vector<SessionPrx>::iterator p = _sessions.begin(); - while(p != _sessions.end()) - { - try - { - (*p)->keepAlive(); - ++p; - } - catch(const Ice::Exception&) - { - p = _sessions.erase(p); - } - } - - vector<AdminSessionPrx>::iterator q = _adminSessions.begin(); - while(q != _adminSessions.end()) - { - try - { - (*q)->keepAlive(); - ++q; - } - catch(const Ice::Exception&) - { - q = _adminSessions.erase(q); - } - } - } - } + Lock sync(*this); + while(!_terminated) + { + timedWait(_timeout); + if(!_terminated) + { + vector<SessionPrx>::iterator p = _sessions.begin(); + while(p != _sessions.end()) + { + try + { + (*p)->keepAlive(); + ++p; + } + catch(const Ice::Exception&) + { + p = _sessions.erase(p); + } + } + + vector<AdminSessionPrx>::iterator q = _adminSessions.begin(); + while(q != _adminSessions.end()) + { + try + { + (*q)->keepAlive(); + ++q; + } + catch(const Ice::Exception&) + { + q = _adminSessions.erase(q); + } + } + } + } } void add(const SessionPrx& session) { - Lock sync(*this); - _sessions.push_back(session); + Lock sync(*this); + _sessions.push_back(session); } void add(const AdminSessionPrx& session) { - Lock sync(*this); - _adminSessions.push_back(session); + Lock sync(*this); + _adminSessions.push_back(session); } void terminate() { - Lock sync(*this); - _terminated = true; - notify(); + Lock sync(*this); + _terminated = true; + notify(); } private: @@ -372,7 +372,7 @@ void allTests(const Ice::CommunicatorPtr& communicator) { SessionKeepAliveThreadPtr keepAlive = new SessionKeepAliveThread( - communicator->getLogger(), IceUtil::Time::seconds(5)); + communicator->getLogger(), IceUtil::Time::seconds(5)); keepAlive->start(); RegistryPrx registry = IceGrid::RegistryPrx::checkedCast(communicator->stringToProxy("IceGrid/Registry")); @@ -387,12 +387,12 @@ allTests(const Ice::CommunicatorPtr& communicator) cout << "starting router... " << flush; try { - admin->startServer("Glacier2"); + admin->startServer("Glacier2"); } catch(const ServerStartException& ex) { - cerr << ex.reason << endl; - test(false); + cerr << ex.reason << endl; + test(false); } cout << "ok" << endl; @@ -403,756 +403,756 @@ allTests(const Ice::CommunicatorPtr& communicator) try { - cout << "testing create session... " << flush; - SessionPrx session1 = registry->createSession("Client1", ""); - SessionPrx session2 = registry->createSession("Client2", ""); - - keepAlive->add(session1); - keepAlive->add(session2); + cout << "testing create session... " << flush; + SessionPrx session1 = registry->createSession("Client1", ""); + SessionPrx session2 = registry->createSession("Client2", ""); + + keepAlive->add(session1); + keepAlive->add(session2); - cout << "ok" << endl; - - cout << "testing allocate object by identity... " << flush; - - Ice::Identity allocatable = communicator->stringToIdentity("allocatable"); - Ice::Identity allocatablebis = communicator->stringToIdentity("allocatablebis"); - - try - { - session1->allocateObjectById(communicator->stringToIdentity("dummy")); - } - catch(const ObjectNotRegisteredException&) - { - } - try - { - session1->releaseObject(communicator->stringToIdentity("dummy")); - } - catch(const ObjectNotRegisteredException&) - { - } - - try - { - session1->allocateObjectById(communicator->stringToIdentity("nonallocatable")); - test(false); - } - catch(const AllocationException&) - { - test(false); - } - catch(const ObjectNotRegisteredException&) - { - } - - try - { - session2->allocateObjectById(communicator->stringToIdentity("nonallocatable")); - test(false); - } - catch(const AllocationException&) - { - test(false); - } - catch(const ObjectNotRegisteredException&) - { - } - - try - { - session1->releaseObject(communicator->stringToIdentity("nonallocatable")); - test(false); - } - catch(const AllocationException&) - { - test(false); - } - catch(const ObjectNotRegisteredException&) - { - } - - try - { - session2->releaseObject(communicator->stringToIdentity("nonallocatable")); - test(false); - } - catch(const AllocationException&) - { - test(false); - } - catch(const ObjectNotRegisteredException&) - { - } - - session1->allocateObjectById(allocatable); - try - { - session1->allocateObjectById(allocatable); - test(false); - } - catch(const AllocationException&) - { - } - - session1->setAllocationTimeout(0); - session2->setAllocationTimeout(0); - - try - { - session2->allocateObjectById(allocatable); - test(false); - } - catch(const AllocationTimeoutException&) - { - } - try - { - session2->releaseObject(allocatable); - test(false); - } - catch(const AllocationException&) - { - } - - session1->allocateObjectById(allocatablebis); - try - { - session2->allocateObjectById(allocatablebis); - test(false); - } - catch(const AllocationTimeoutException&) - { - } - session1->releaseObject(allocatablebis); - session2->allocateObjectById(allocatablebis); - try - { - session1->allocateObjectById(allocatablebis); - test(false); - } - catch(const AllocationTimeoutException&) - { - } - session2->releaseObject(allocatablebis); + cout << "ok" << endl; + + cout << "testing allocate object by identity... " << flush; + + Ice::Identity allocatable = communicator->stringToIdentity("allocatable"); + Ice::Identity allocatablebis = communicator->stringToIdentity("allocatablebis"); + + try + { + session1->allocateObjectById(communicator->stringToIdentity("dummy")); + } + catch(const ObjectNotRegisteredException&) + { + } + try + { + session1->releaseObject(communicator->stringToIdentity("dummy")); + } + catch(const ObjectNotRegisteredException&) + { + } + + try + { + session1->allocateObjectById(communicator->stringToIdentity("nonallocatable")); + test(false); + } + catch(const AllocationException&) + { + test(false); + } + catch(const ObjectNotRegisteredException&) + { + } + + try + { + session2->allocateObjectById(communicator->stringToIdentity("nonallocatable")); + test(false); + } + catch(const AllocationException&) + { + test(false); + } + catch(const ObjectNotRegisteredException&) + { + } + + try + { + session1->releaseObject(communicator->stringToIdentity("nonallocatable")); + test(false); + } + catch(const AllocationException&) + { + test(false); + } + catch(const ObjectNotRegisteredException&) + { + } + + try + { + session2->releaseObject(communicator->stringToIdentity("nonallocatable")); + test(false); + } + catch(const AllocationException&) + { + test(false); + } + catch(const ObjectNotRegisteredException&) + { + } + + session1->allocateObjectById(allocatable); + try + { + session1->allocateObjectById(allocatable); + test(false); + } + catch(const AllocationException&) + { + } + + session1->setAllocationTimeout(0); + session2->setAllocationTimeout(0); + + try + { + session2->allocateObjectById(allocatable); + test(false); + } + catch(const AllocationTimeoutException&) + { + } + try + { + session2->releaseObject(allocatable); + test(false); + } + catch(const AllocationException&) + { + } + + session1->allocateObjectById(allocatablebis); + try + { + session2->allocateObjectById(allocatablebis); + test(false); + } + catch(const AllocationTimeoutException&) + { + } + session1->releaseObject(allocatablebis); + session2->allocateObjectById(allocatablebis); + try + { + session1->allocateObjectById(allocatablebis); + test(false); + } + catch(const AllocationTimeoutException&) + { + } + session2->releaseObject(allocatablebis); - session2->setAllocationTimeout(allocationTimeout); - AllocateObjectByIdCallbackPtr cb1 = new AllocateObjectByIdCallback(); - session2->allocateObjectById_async(cb1, allocatable); - IceUtil::ThreadControl::sleep(IceUtil::Time::milliSeconds(500)); - test(!cb1->hasResponse(dummy)); - session1->releaseObject(allocatable); - cb1->waitResponse(__FILE__, __LINE__); - test(cb1->hasResponse(dummy)); - - session1->setAllocationTimeout(0); - try - { - session1->allocateObjectById(allocatable); - test(false); - } - catch(const AllocationTimeoutException&) - { - } - try - { - session1->releaseObject(allocatable); - test(false); - } - catch(const AllocationException&) - { - } - session1->setAllocationTimeout(allocationTimeout); - cb1 = new AllocateObjectByIdCallback(); - session1->allocateObjectById_async(cb1, allocatable); - IceUtil::ThreadControl::sleep(IceUtil::Time::milliSeconds(500)); - test(!cb1->hasResponse(dummy)); - session2->releaseObject(allocatable); - cb1->waitResponse(__FILE__, __LINE__); - test(cb1->hasResponse(dummy)); - - session1->releaseObject(allocatable); - - cout << "ok" << endl; - - cout << "testing allocate object by type... " << flush; + session2->setAllocationTimeout(allocationTimeout); + AllocateObjectByIdCallbackPtr cb1 = new AllocateObjectByIdCallback(); + session2->allocateObjectById_async(cb1, allocatable); + IceUtil::ThreadControl::sleep(IceUtil::Time::milliSeconds(500)); + test(!cb1->hasResponse(dummy)); + session1->releaseObject(allocatable); + cb1->waitResponse(__FILE__, __LINE__); + test(cb1->hasResponse(dummy)); + + session1->setAllocationTimeout(0); + try + { + session1->allocateObjectById(allocatable); + test(false); + } + catch(const AllocationTimeoutException&) + { + } + try + { + session1->releaseObject(allocatable); + test(false); + } + catch(const AllocationException&) + { + } + session1->setAllocationTimeout(allocationTimeout); + cb1 = new AllocateObjectByIdCallback(); + session1->allocateObjectById_async(cb1, allocatable); + IceUtil::ThreadControl::sleep(IceUtil::Time::milliSeconds(500)); + test(!cb1->hasResponse(dummy)); + session2->releaseObject(allocatable); + cb1->waitResponse(__FILE__, __LINE__); + test(cb1->hasResponse(dummy)); + + session1->releaseObject(allocatable); + + cout << "ok" << endl; + + cout << "testing allocate object by type... " << flush; - session1->setAllocationTimeout(0); - session2->setAllocationTimeout(0); - - - try - { - obj = session1->allocateObjectByType("::Unknown"); - test(false); - } - catch(const AllocationTimeoutException&) - { - test(false); - } - catch(const AllocationException&) - { - } - - try - { - obj = session1->allocateObjectByType("::NotAllocatable"); - test(false); - } - catch(const AllocationTimeoutException&) - { - test(false); - } - catch(const AllocationException&) - { - } - - obj = session1->allocateObjectByType("::Test"); - test(obj && obj->ice_getIdentity().name == "allocatable"); - try - { - session1->allocateObjectByType("::Test"); - test(false); - } - catch(const AllocationException&) - { - } - try - { - session2->allocateObjectByType("::Test"); - test(false); - } - catch(const AllocationTimeoutException&) - { - } - try - { - session2->releaseObject(obj->ice_getIdentity()); - } - catch(const AllocationException&) - { - } - - session1->releaseObject(obj->ice_getIdentity()); - try - { - session1->releaseObject(obj->ice_getIdentity()); - } - catch(const AllocationException&) - { - } - - obj = session2->allocateObjectByType("::Test"); // Allocate the object - test(obj && obj->ice_getIdentity().name == "allocatable"); - try - { - session2->allocateObjectByType("::Test"); - test(false); - } - catch(const AllocationException&) - { - } - try - { - session1->allocateObjectByType("::Test"); - test(false); - } - catch(const AllocationTimeoutException&) - { - } - session1->allocateObjectByType("::TestBis"); - try - { - session2->allocateObjectByType("::TestBis"); - test(false); - } - catch(const AllocationTimeoutException&) - { - } - session1->releaseObject(allocatablebis); - session2->allocateObjectByType("::TestBis"); - try - { - session1->allocateObjectByType("::TestBis"); - test(false); - } - catch(const AllocationTimeoutException&) - { - } - session2->releaseObject(allocatablebis); - - session1->setAllocationTimeout(allocationTimeout); - AllocateObjectByTypeCallbackPtr cb3 = new AllocateObjectByTypeCallback(); - session1->allocateObjectByType_async(cb3, "::Test"); - IceUtil::ThreadControl::sleep(IceUtil::Time::milliSeconds(500)); - test(!cb3->hasResponse(dummy)); - session2->releaseObject(obj->ice_getIdentity()); - cb3->waitResponse(__FILE__, __LINE__); - test(cb3->hasResponse(obj)); - - session1->releaseObject(obj->ice_getIdentity()); + session1->setAllocationTimeout(0); + session2->setAllocationTimeout(0); + + + try + { + obj = session1->allocateObjectByType("::Unknown"); + test(false); + } + catch(const AllocationTimeoutException&) + { + test(false); + } + catch(const AllocationException&) + { + } + + try + { + obj = session1->allocateObjectByType("::NotAllocatable"); + test(false); + } + catch(const AllocationTimeoutException&) + { + test(false); + } + catch(const AllocationException&) + { + } + + obj = session1->allocateObjectByType("::Test"); + test(obj && obj->ice_getIdentity().name == "allocatable"); + try + { + session1->allocateObjectByType("::Test"); + test(false); + } + catch(const AllocationException&) + { + } + try + { + session2->allocateObjectByType("::Test"); + test(false); + } + catch(const AllocationTimeoutException&) + { + } + try + { + session2->releaseObject(obj->ice_getIdentity()); + } + catch(const AllocationException&) + { + } + + session1->releaseObject(obj->ice_getIdentity()); + try + { + session1->releaseObject(obj->ice_getIdentity()); + } + catch(const AllocationException&) + { + } + + obj = session2->allocateObjectByType("::Test"); // Allocate the object + test(obj && obj->ice_getIdentity().name == "allocatable"); + try + { + session2->allocateObjectByType("::Test"); + test(false); + } + catch(const AllocationException&) + { + } + try + { + session1->allocateObjectByType("::Test"); + test(false); + } + catch(const AllocationTimeoutException&) + { + } + session1->allocateObjectByType("::TestBis"); + try + { + session2->allocateObjectByType("::TestBis"); + test(false); + } + catch(const AllocationTimeoutException&) + { + } + session1->releaseObject(allocatablebis); + session2->allocateObjectByType("::TestBis"); + try + { + session1->allocateObjectByType("::TestBis"); + test(false); + } + catch(const AllocationTimeoutException&) + { + } + session2->releaseObject(allocatablebis); + + session1->setAllocationTimeout(allocationTimeout); + AllocateObjectByTypeCallbackPtr cb3 = new AllocateObjectByTypeCallback(); + session1->allocateObjectByType_async(cb3, "::Test"); + IceUtil::ThreadControl::sleep(IceUtil::Time::milliSeconds(500)); + test(!cb3->hasResponse(dummy)); + session2->releaseObject(obj->ice_getIdentity()); + cb3->waitResponse(__FILE__, __LINE__); + test(cb3->hasResponse(obj)); + + session1->releaseObject(obj->ice_getIdentity()); - cout << "ok" << endl; - - cout << "testing object allocation timeout... " << flush; - - session1->allocateObjectById(allocatable); - IceUtil::Time time = IceUtil::Time::now(); - session2->setAllocationTimeout(500); - try - { - session2->allocateObjectById(allocatable); - test(false); - } - catch(const AllocationTimeoutException&) - { - test(time + IceUtil::Time::milliSeconds(100) < IceUtil::Time::now()); - } - time = IceUtil::Time::now(); - try - { - session2->allocateObjectById(allocatable); - test(false); - } - catch(const AllocationTimeoutException&) - { - } - test(time + IceUtil::Time::milliSeconds(100) < IceUtil::Time::now()); - time = IceUtil::Time::now(); - try - { - session2->allocateObjectByType("::Test"); - test(false); - } - catch(const AllocationTimeoutException&) - { - } - test(time + IceUtil::Time::milliSeconds(100) < IceUtil::Time::now()); - - session1->releaseObject(allocatable); - session2->setAllocationTimeout(0); - - cout << "ok" << endl; - - cout << "testing server allocation... " << flush; - - session1->setAllocationTimeout(0); - session2->setAllocationTimeout(0); - - Ice::Identity allocatable3 = communicator->stringToIdentity("allocatable3"); - Ice::Identity allocatable4 = communicator->stringToIdentity("allocatable4"); - - session1->allocateObjectById(allocatable3); - try - { - session2->allocateObjectById(allocatable3); - test(false); - } - catch(const AllocationTimeoutException&) - { - } - try - { - session2->allocateObjectById(allocatable4); - test(false); - } - catch(const AllocationTimeoutException&) - { - } - - session1->allocateObjectById(allocatable4); - session1->releaseObject(allocatable3); - try - { - session2->allocateObjectById(allocatable3); - test(false); - } - catch(const AllocationTimeoutException&) - { - } - session1->releaseObject(allocatable4); - session2->allocateObjectById(allocatable3); - try - { - session1->allocateObjectById(allocatable3); - test(false); - } - catch(const AllocationTimeoutException&) - { - } - try - { - session1->allocateObjectById(allocatable4); - test(false); - } - catch(const AllocationTimeoutException&) - { - } - session2->allocateObjectById(allocatable4); - session2->releaseObject(allocatable3); - try - { - session1->allocateObjectById(allocatable3); - test(false); - } - catch(const AllocationTimeoutException&) - { - } - try - { - session1->allocateObjectByType("::TestServer1"); - test(false); - } - catch(AllocationException&) - { - } - try - { - session1->allocateObjectByType("::TestServer2"); - test(false); - } - catch(AllocationException&) - { - } - test(session2->allocateObjectByType("::TestServer1")); - try - { - session2->allocateObjectByType("::TestServer1"); - test(false); - } - catch(AllocationException&) - { - } - try - { - session2->allocateObjectByType("::TestServer2"); - test(false); - } - catch(AllocationException&) - { - } - session2->releaseObject(allocatable3); - session2->releaseObject(allocatable4); - - session1->allocateObjectById(allocatable3); - session1->allocateObjectById(allocatable4); - - session2->setAllocationTimeout(allocationTimeout); - cb1 = new AllocateObjectByIdCallback(); - session2->allocateObjectById_async(cb1, allocatable3); - IceUtil::ThreadControl::sleep(IceUtil::Time::milliSeconds(500)); - test(!cb1->hasResponse(dummy)); - session1->releaseObject(allocatable3); - test(!cb1->hasResponse(dummy)); - session1->releaseObject(allocatable4); - cb1->waitResponse(__FILE__, __LINE__); - test(cb1->hasResponse(dummy)); - session2->releaseObject(allocatable3); - - session1->setAllocationTimeout(allocationTimeout); - test(session2->allocateObjectByType("::TestServer1")); - cb3 = new AllocateObjectByTypeCallback(); - session1->allocateObjectByType_async(cb3, "::TestServer2"); - IceUtil::ThreadControl::sleep(IceUtil::Time::milliSeconds(500)); - test(!cb3->hasResponse(dummy)); - session2->releaseObject(allocatable3); - cb3->waitResponse(__FILE__, __LINE__); - test(cb3->hasResponse(dummy)); - session1->releaseObject(allocatable4); - - session1->setAllocationTimeout(0); - session2->setAllocationTimeout(0); - test(session1->allocateObjectByType("::TestMultipleByServer")); - try - { - session2->allocateObjectByType("::TestMultipleByServer"); - test(false); - } - catch(AllocationException&) - { - } - test(session1->allocateObjectByType("::TestMultipleByServer")); - session1->releaseObject(communicator->stringToIdentity("allocatable31")); - session1->releaseObject(communicator->stringToIdentity("allocatable41")); - test(session2->allocateObjectByType("::TestMultipleByServer")); - try - { - session1->allocateObjectByType("::TestMultipleByServer"); - test(false); - } - catch(AllocationException&) - { - } - test(session2->allocateObjectByType("::TestMultipleByServer")); - session2->releaseObject(communicator->stringToIdentity("allocatable31")); - session2->releaseObject(communicator->stringToIdentity("allocatable41")); - - Ice::ObjectPrx obj1 = session1->allocateObjectByType("::TestMultipleServer"); - test(obj1); - Ice::ObjectPrx obj2 = session2->allocateObjectByType("::TestMultipleServer"); - test(obj2); - try - { - session1->allocateObjectByType("::TestMultipleServer"); - test(false); - } - catch(AllocationTimeoutException&) - { - } - try - { - session2->allocateObjectByType("::TestMultipleServer"); - test(false); - } - catch(AllocationTimeoutException&) - { - } - session1->releaseObject(obj1->ice_getIdentity()); - obj1 = session2->allocateObjectByType("::TestMultipleServer"); - session2->releaseObject(obj1->ice_getIdentity()); - session2->releaseObject(obj2->ice_getIdentity()); - - cout << "ok" << endl; - - cout << "testing concurrent allocations... " << flush; - - session1->setAllocationTimeout(allocationTimeout); - session2->setAllocationTimeout(allocationTimeout); - - session2->allocateObjectById(allocatable); - AllocateObjectByIdCallbackPtr cb11 = new AllocateObjectByIdCallback(); - AllocateObjectByIdCallbackPtr cb12 = new AllocateObjectByIdCallback(); - session1->allocateObjectById_async(cb11, allocatable); - session1->allocateObjectById_async(cb12, allocatable); - IceUtil::ThreadControl::sleep(IceUtil::Time::milliSeconds(500)); - test(!cb11->hasResponse(dummy)); - test(!cb12->hasResponse(dummy)); - session2->releaseObject(allocatable); - cb11->waitResponse(__FILE__, __LINE__); - cb12->waitResponse(__FILE__, __LINE__); - test(cb11->hasResponse(dummy) ? cb12->hasException() : cb12->hasResponse(dummy)); - test(cb12->hasResponse(dummy) ? cb11->hasException() : cb11->hasResponse(dummy)); - session1->releaseObject(allocatable); - - session2->allocateObjectById(allocatable); - AllocateObjectByTypeCallbackPtr cb31 = new AllocateObjectByTypeCallback(); - AllocateObjectByTypeCallbackPtr cb32 = new AllocateObjectByTypeCallback(); - session1->allocateObjectByType_async(cb31, "::Test"); - session1->allocateObjectByType_async(cb32, "::Test"); - IceUtil::ThreadControl::sleep(IceUtil::Time::milliSeconds(500)); - test(!cb31->hasResponse(dummy)); - test(!cb32->hasResponse(dummy)); - session2->releaseObject(allocatable); - IceUtil::ThreadControl::sleep(IceUtil::Time::milliSeconds(300)); - do - { - IceUtil::ThreadControl::sleep(IceUtil::Time::milliSeconds(200)); - } - while(!cb31->hasResponse(dummy) && !cb32->hasResponse(dummy)); - test(cb31->hasResponse(dummy) && dummy && !cb32->hasResponse(dummy) || - cb32->hasResponse(dummy) && dummy && !cb31->hasResponse(dummy)); - session1->releaseObject(allocatable); - IceUtil::ThreadControl::sleep(IceUtil::Time::milliSeconds(300)); - AllocateObjectByTypeCallbackPtr cb33 = cb31->hasResponse(dummy) ? cb32 : cb31; - cb33->waitResponse(__FILE__, __LINE__); - test(cb33->hasResponse(dummy) && dummy); - session1->releaseObject(allocatable); - - session2->allocateObjectById(allocatable3); - cb11 = new AllocateObjectByIdCallback(); - cb12 = new AllocateObjectByIdCallback(); - session1->allocateObjectById_async(cb11, allocatable3); - session1->allocateObjectById_async(cb12, allocatable3); - IceUtil::ThreadControl::sleep(IceUtil::Time::milliSeconds(500)); - test(!cb11->hasResponse(dummy)); - test(!cb12->hasResponse(dummy)); - session2->releaseObject(allocatable3); - cb11->waitResponse(__FILE__, __LINE__); - cb12->waitResponse(__FILE__, __LINE__); - test(cb11->hasResponse(dummy) ? cb12->hasException() : cb12->hasResponse(dummy)); - test(cb12->hasResponse(dummy) ? cb11->hasException() : cb11->hasResponse(dummy)); - session1->releaseObject(allocatable3); - - session2->allocateObjectById(allocatable3); - cb31 = new AllocateObjectByTypeCallback(); - cb32 = new AllocateObjectByTypeCallback(); - session1->allocateObjectByType_async(cb31, "::TestServer1"); - session1->allocateObjectByType_async(cb32, "::TestServer1"); - IceUtil::ThreadControl::sleep(IceUtil::Time::milliSeconds(500)); - test(!cb31->hasResponse(dummy)); - test(!cb32->hasResponse(dummy)); - session2->releaseObject(allocatable3); - IceUtil::ThreadControl::sleep(IceUtil::Time::milliSeconds(300)); - do - { - IceUtil::ThreadControl::sleep(IceUtil::Time::milliSeconds(200)); - } - while(!cb31->hasResponse(dummy) && !cb32->hasResponse(dummy)); - test(cb31->hasResponse(dummy) && dummy && !cb32->hasResponse(dummy) || - cb32->hasResponse(dummy) && dummy && !cb31->hasResponse(dummy)); - session1->releaseObject(allocatable3); - IceUtil::ThreadControl::sleep(IceUtil::Time::milliSeconds(300)); - cb33 = cb31->hasResponse(dummy) ? cb32 : cb31; - cb33->waitResponse(__FILE__, __LINE__); - test(cb33->hasResponse(dummy) && dummy); - session1->releaseObject(allocatable3); - - session1->allocateObjectById(allocatable3); - cb31 = new AllocateObjectByTypeCallback(); - cb32 = new AllocateObjectByTypeCallback(); - session1->allocateObjectByType_async(cb31, "::TestServer1"); - session1->allocateObjectByType_async(cb32, "::TestServer1"); - IceUtil::ThreadControl::sleep(IceUtil::Time::milliSeconds(500)); - test(!cb31->hasResponse(dummy)); - test(!cb32->hasResponse(dummy)); - session1->releaseObject(allocatable3); - IceUtil::ThreadControl::sleep(IceUtil::Time::milliSeconds(300)); - do - { - IceUtil::ThreadControl::sleep(IceUtil::Time::milliSeconds(200)); - } - while(!cb31->hasResponse(dummy) && !cb32->hasResponse(dummy)); - test(cb31->hasResponse(dummy) && dummy && !cb32->hasResponse(dummy) || - cb32->hasResponse(dummy) && dummy && !cb31->hasResponse(dummy)); - session1->releaseObject(allocatable3); - IceUtil::ThreadControl::sleep(IceUtil::Time::milliSeconds(300)); - cb33 = cb31->hasResponse(dummy) ? cb32 : cb31; - cb33->waitResponse(__FILE__, __LINE__); - test(cb33->hasResponse(dummy) && dummy); - session1->releaseObject(allocatable3); - - cout << "ok" << endl; - - cout << "testing session destroy... " << flush; - - obj = session2->allocateObjectByType("::Test"); // Allocate the object - test(obj && obj->ice_getIdentity().name == "allocatable"); - - session1->setAllocationTimeout(allocationTimeout); - cb3 = new AllocateObjectByTypeCallback(); - session1->allocateObjectByType_async(cb3, "::Test"); - IceUtil::ThreadControl::sleep(IceUtil::Time::milliSeconds(500)); - test(!cb3->hasResponse(dummy)); - session2->destroy(); - cb3->waitResponse(__FILE__, __LINE__); - test(cb3->hasResponse(obj)); - session1->destroy(); - - session2 = SessionPrx::uncheckedCast(registry->createSession("Client2", "")); - session2->setAllocationTimeout(0); - session2->allocateObjectById(allocatable); - session2->destroy(); - - cout << "ok" << endl; - - cout << "testing allocation with Glacier2 session... " << flush; - Ice::ObjectPrx routerBase = communicator->stringToProxy("Glacier2/router:default -p 12347"); - Glacier2::RouterPrx router1 = Glacier2::RouterPrx::checkedCast(routerBase->ice_connectionId("client1")); - test(router1); - - Glacier2::SessionPrx sessionBase = router1->createSession("test1", "abc123"); - try - { - session1 = IceGrid::SessionPrx::checkedCast(sessionBase->ice_connectionId("client1")->ice_router(router1)); - test(session1); - session1->ice_ping(); - - Ice::ObjectPrx obj; - obj = session1->allocateObjectById(allocatable)->ice_connectionId("client1")->ice_router(router1); - obj->ice_ping(); - session1->releaseObject(allocatable); - try - { - obj->ice_ping(); - } - catch(const Ice::ObjectNotExistException&) - { - } - - obj = session1->allocateObjectById(allocatable3)->ice_connectionId("client1")->ice_router(router1); - obj->ice_ping(); - obj2 = communicator->stringToProxy("allocatable4")->ice_connectionId("client1")->ice_router(router1); - obj2->ice_ping(); - session1->releaseObject(allocatable3); - try - { - obj->ice_ping(); - } - catch(const Ice::ObjectNotExistException&) - { - } - try - { - obj2->ice_ping(); - } - catch(const Ice::ObjectNotExistException&) - { - } - session1->destroy(); - } - catch(const Ice::LocalException& ex) - { - cerr << ex << endl; - test(false); - } - cout << "ok" << endl; - - cout << "stress test... " << flush; - - SessionPrx stressSession = registry->createSession("StressSession", ""); - keepAlive->add(stressSession); - - const int nClients = 10; - int i; - vector<StressClientPtr> clients; - for(i = 0; i < nClients - 2; ++i) - { - if(IceUtil::random(2) == 1) - { - clients.push_back(new StressClient(i, registry, false)); - } - else - { - clients.push_back(new StressClient(i, stressSession)); - } - clients.back()->start(); - } - clients.push_back(new StressClient(i++, registry, true)); - clients.back()->start(); - clients.push_back(new StressClient(i++, registry, true)); - clients.back()->start(); - - for(vector<StressClientPtr>::const_iterator p = clients.begin(); p != clients.end(); ++p) - { - (*p)->notifyThread(); - } - - // - // Let the stress client run for a bit. - // - IceUtil::ThreadControl::sleep(IceUtil::Time::seconds(8)); - - // - // Terminate the stress clients. - // - for(vector<StressClientPtr>::const_iterator q = clients.begin(); q != clients.end(); ++q) - { - (*q)->terminate(); - (*q)->getThreadControl().join(); - } - - stressSession->destroy(); - - cout << "ok" << endl; + cout << "ok" << endl; + + cout << "testing object allocation timeout... " << flush; + + session1->allocateObjectById(allocatable); + IceUtil::Time time = IceUtil::Time::now(); + session2->setAllocationTimeout(500); + try + { + session2->allocateObjectById(allocatable); + test(false); + } + catch(const AllocationTimeoutException&) + { + test(time + IceUtil::Time::milliSeconds(100) < IceUtil::Time::now()); + } + time = IceUtil::Time::now(); + try + { + session2->allocateObjectById(allocatable); + test(false); + } + catch(const AllocationTimeoutException&) + { + } + test(time + IceUtil::Time::milliSeconds(100) < IceUtil::Time::now()); + time = IceUtil::Time::now(); + try + { + session2->allocateObjectByType("::Test"); + test(false); + } + catch(const AllocationTimeoutException&) + { + } + test(time + IceUtil::Time::milliSeconds(100) < IceUtil::Time::now()); + + session1->releaseObject(allocatable); + session2->setAllocationTimeout(0); + + cout << "ok" << endl; + + cout << "testing server allocation... " << flush; + + session1->setAllocationTimeout(0); + session2->setAllocationTimeout(0); + + Ice::Identity allocatable3 = communicator->stringToIdentity("allocatable3"); + Ice::Identity allocatable4 = communicator->stringToIdentity("allocatable4"); + + session1->allocateObjectById(allocatable3); + try + { + session2->allocateObjectById(allocatable3); + test(false); + } + catch(const AllocationTimeoutException&) + { + } + try + { + session2->allocateObjectById(allocatable4); + test(false); + } + catch(const AllocationTimeoutException&) + { + } + + session1->allocateObjectById(allocatable4); + session1->releaseObject(allocatable3); + try + { + session2->allocateObjectById(allocatable3); + test(false); + } + catch(const AllocationTimeoutException&) + { + } + session1->releaseObject(allocatable4); + session2->allocateObjectById(allocatable3); + try + { + session1->allocateObjectById(allocatable3); + test(false); + } + catch(const AllocationTimeoutException&) + { + } + try + { + session1->allocateObjectById(allocatable4); + test(false); + } + catch(const AllocationTimeoutException&) + { + } + session2->allocateObjectById(allocatable4); + session2->releaseObject(allocatable3); + try + { + session1->allocateObjectById(allocatable3); + test(false); + } + catch(const AllocationTimeoutException&) + { + } + try + { + session1->allocateObjectByType("::TestServer1"); + test(false); + } + catch(AllocationException&) + { + } + try + { + session1->allocateObjectByType("::TestServer2"); + test(false); + } + catch(AllocationException&) + { + } + test(session2->allocateObjectByType("::TestServer1")); + try + { + session2->allocateObjectByType("::TestServer1"); + test(false); + } + catch(AllocationException&) + { + } + try + { + session2->allocateObjectByType("::TestServer2"); + test(false); + } + catch(AllocationException&) + { + } + session2->releaseObject(allocatable3); + session2->releaseObject(allocatable4); + + session1->allocateObjectById(allocatable3); + session1->allocateObjectById(allocatable4); + + session2->setAllocationTimeout(allocationTimeout); + cb1 = new AllocateObjectByIdCallback(); + session2->allocateObjectById_async(cb1, allocatable3); + IceUtil::ThreadControl::sleep(IceUtil::Time::milliSeconds(500)); + test(!cb1->hasResponse(dummy)); + session1->releaseObject(allocatable3); + test(!cb1->hasResponse(dummy)); + session1->releaseObject(allocatable4); + cb1->waitResponse(__FILE__, __LINE__); + test(cb1->hasResponse(dummy)); + session2->releaseObject(allocatable3); + + session1->setAllocationTimeout(allocationTimeout); + test(session2->allocateObjectByType("::TestServer1")); + cb3 = new AllocateObjectByTypeCallback(); + session1->allocateObjectByType_async(cb3, "::TestServer2"); + IceUtil::ThreadControl::sleep(IceUtil::Time::milliSeconds(500)); + test(!cb3->hasResponse(dummy)); + session2->releaseObject(allocatable3); + cb3->waitResponse(__FILE__, __LINE__); + test(cb3->hasResponse(dummy)); + session1->releaseObject(allocatable4); + + session1->setAllocationTimeout(0); + session2->setAllocationTimeout(0); + test(session1->allocateObjectByType("::TestMultipleByServer")); + try + { + session2->allocateObjectByType("::TestMultipleByServer"); + test(false); + } + catch(AllocationException&) + { + } + test(session1->allocateObjectByType("::TestMultipleByServer")); + session1->releaseObject(communicator->stringToIdentity("allocatable31")); + session1->releaseObject(communicator->stringToIdentity("allocatable41")); + test(session2->allocateObjectByType("::TestMultipleByServer")); + try + { + session1->allocateObjectByType("::TestMultipleByServer"); + test(false); + } + catch(AllocationException&) + { + } + test(session2->allocateObjectByType("::TestMultipleByServer")); + session2->releaseObject(communicator->stringToIdentity("allocatable31")); + session2->releaseObject(communicator->stringToIdentity("allocatable41")); + + Ice::ObjectPrx obj1 = session1->allocateObjectByType("::TestMultipleServer"); + test(obj1); + Ice::ObjectPrx obj2 = session2->allocateObjectByType("::TestMultipleServer"); + test(obj2); + try + { + session1->allocateObjectByType("::TestMultipleServer"); + test(false); + } + catch(AllocationTimeoutException&) + { + } + try + { + session2->allocateObjectByType("::TestMultipleServer"); + test(false); + } + catch(AllocationTimeoutException&) + { + } + session1->releaseObject(obj1->ice_getIdentity()); + obj1 = session2->allocateObjectByType("::TestMultipleServer"); + session2->releaseObject(obj1->ice_getIdentity()); + session2->releaseObject(obj2->ice_getIdentity()); + + cout << "ok" << endl; + + cout << "testing concurrent allocations... " << flush; + + session1->setAllocationTimeout(allocationTimeout); + session2->setAllocationTimeout(allocationTimeout); + + session2->allocateObjectById(allocatable); + AllocateObjectByIdCallbackPtr cb11 = new AllocateObjectByIdCallback(); + AllocateObjectByIdCallbackPtr cb12 = new AllocateObjectByIdCallback(); + session1->allocateObjectById_async(cb11, allocatable); + session1->allocateObjectById_async(cb12, allocatable); + IceUtil::ThreadControl::sleep(IceUtil::Time::milliSeconds(500)); + test(!cb11->hasResponse(dummy)); + test(!cb12->hasResponse(dummy)); + session2->releaseObject(allocatable); + cb11->waitResponse(__FILE__, __LINE__); + cb12->waitResponse(__FILE__, __LINE__); + test(cb11->hasResponse(dummy) ? cb12->hasException() : cb12->hasResponse(dummy)); + test(cb12->hasResponse(dummy) ? cb11->hasException() : cb11->hasResponse(dummy)); + session1->releaseObject(allocatable); + + session2->allocateObjectById(allocatable); + AllocateObjectByTypeCallbackPtr cb31 = new AllocateObjectByTypeCallback(); + AllocateObjectByTypeCallbackPtr cb32 = new AllocateObjectByTypeCallback(); + session1->allocateObjectByType_async(cb31, "::Test"); + session1->allocateObjectByType_async(cb32, "::Test"); + IceUtil::ThreadControl::sleep(IceUtil::Time::milliSeconds(500)); + test(!cb31->hasResponse(dummy)); + test(!cb32->hasResponse(dummy)); + session2->releaseObject(allocatable); + IceUtil::ThreadControl::sleep(IceUtil::Time::milliSeconds(300)); + do + { + IceUtil::ThreadControl::sleep(IceUtil::Time::milliSeconds(200)); + } + while(!cb31->hasResponse(dummy) && !cb32->hasResponse(dummy)); + test(cb31->hasResponse(dummy) && dummy && !cb32->hasResponse(dummy) || + cb32->hasResponse(dummy) && dummy && !cb31->hasResponse(dummy)); + session1->releaseObject(allocatable); + IceUtil::ThreadControl::sleep(IceUtil::Time::milliSeconds(300)); + AllocateObjectByTypeCallbackPtr cb33 = cb31->hasResponse(dummy) ? cb32 : cb31; + cb33->waitResponse(__FILE__, __LINE__); + test(cb33->hasResponse(dummy) && dummy); + session1->releaseObject(allocatable); + + session2->allocateObjectById(allocatable3); + cb11 = new AllocateObjectByIdCallback(); + cb12 = new AllocateObjectByIdCallback(); + session1->allocateObjectById_async(cb11, allocatable3); + session1->allocateObjectById_async(cb12, allocatable3); + IceUtil::ThreadControl::sleep(IceUtil::Time::milliSeconds(500)); + test(!cb11->hasResponse(dummy)); + test(!cb12->hasResponse(dummy)); + session2->releaseObject(allocatable3); + cb11->waitResponse(__FILE__, __LINE__); + cb12->waitResponse(__FILE__, __LINE__); + test(cb11->hasResponse(dummy) ? cb12->hasException() : cb12->hasResponse(dummy)); + test(cb12->hasResponse(dummy) ? cb11->hasException() : cb11->hasResponse(dummy)); + session1->releaseObject(allocatable3); + + session2->allocateObjectById(allocatable3); + cb31 = new AllocateObjectByTypeCallback(); + cb32 = new AllocateObjectByTypeCallback(); + session1->allocateObjectByType_async(cb31, "::TestServer1"); + session1->allocateObjectByType_async(cb32, "::TestServer1"); + IceUtil::ThreadControl::sleep(IceUtil::Time::milliSeconds(500)); + test(!cb31->hasResponse(dummy)); + test(!cb32->hasResponse(dummy)); + session2->releaseObject(allocatable3); + IceUtil::ThreadControl::sleep(IceUtil::Time::milliSeconds(300)); + do + { + IceUtil::ThreadControl::sleep(IceUtil::Time::milliSeconds(200)); + } + while(!cb31->hasResponse(dummy) && !cb32->hasResponse(dummy)); + test(cb31->hasResponse(dummy) && dummy && !cb32->hasResponse(dummy) || + cb32->hasResponse(dummy) && dummy && !cb31->hasResponse(dummy)); + session1->releaseObject(allocatable3); + IceUtil::ThreadControl::sleep(IceUtil::Time::milliSeconds(300)); + cb33 = cb31->hasResponse(dummy) ? cb32 : cb31; + cb33->waitResponse(__FILE__, __LINE__); + test(cb33->hasResponse(dummy) && dummy); + session1->releaseObject(allocatable3); + + session1->allocateObjectById(allocatable3); + cb31 = new AllocateObjectByTypeCallback(); + cb32 = new AllocateObjectByTypeCallback(); + session1->allocateObjectByType_async(cb31, "::TestServer1"); + session1->allocateObjectByType_async(cb32, "::TestServer1"); + IceUtil::ThreadControl::sleep(IceUtil::Time::milliSeconds(500)); + test(!cb31->hasResponse(dummy)); + test(!cb32->hasResponse(dummy)); + session1->releaseObject(allocatable3); + IceUtil::ThreadControl::sleep(IceUtil::Time::milliSeconds(300)); + do + { + IceUtil::ThreadControl::sleep(IceUtil::Time::milliSeconds(200)); + } + while(!cb31->hasResponse(dummy) && !cb32->hasResponse(dummy)); + test(cb31->hasResponse(dummy) && dummy && !cb32->hasResponse(dummy) || + cb32->hasResponse(dummy) && dummy && !cb31->hasResponse(dummy)); + session1->releaseObject(allocatable3); + IceUtil::ThreadControl::sleep(IceUtil::Time::milliSeconds(300)); + cb33 = cb31->hasResponse(dummy) ? cb32 : cb31; + cb33->waitResponse(__FILE__, __LINE__); + test(cb33->hasResponse(dummy) && dummy); + session1->releaseObject(allocatable3); + + cout << "ok" << endl; + + cout << "testing session destroy... " << flush; + + obj = session2->allocateObjectByType("::Test"); // Allocate the object + test(obj && obj->ice_getIdentity().name == "allocatable"); + + session1->setAllocationTimeout(allocationTimeout); + cb3 = new AllocateObjectByTypeCallback(); + session1->allocateObjectByType_async(cb3, "::Test"); + IceUtil::ThreadControl::sleep(IceUtil::Time::milliSeconds(500)); + test(!cb3->hasResponse(dummy)); + session2->destroy(); + cb3->waitResponse(__FILE__, __LINE__); + test(cb3->hasResponse(obj)); + session1->destroy(); + + session2 = SessionPrx::uncheckedCast(registry->createSession("Client2", "")); + session2->setAllocationTimeout(0); + session2->allocateObjectById(allocatable); + session2->destroy(); + + cout << "ok" << endl; + + cout << "testing allocation with Glacier2 session... " << flush; + Ice::ObjectPrx routerBase = communicator->stringToProxy("Glacier2/router:default -p 12347"); + Glacier2::RouterPrx router1 = Glacier2::RouterPrx::checkedCast(routerBase->ice_connectionId("client1")); + test(router1); + + Glacier2::SessionPrx sessionBase = router1->createSession("test1", "abc123"); + try + { + session1 = IceGrid::SessionPrx::checkedCast(sessionBase->ice_connectionId("client1")->ice_router(router1)); + test(session1); + session1->ice_ping(); + + Ice::ObjectPrx obj; + obj = session1->allocateObjectById(allocatable)->ice_connectionId("client1")->ice_router(router1); + obj->ice_ping(); + session1->releaseObject(allocatable); + try + { + obj->ice_ping(); + } + catch(const Ice::ObjectNotExistException&) + { + } + + obj = session1->allocateObjectById(allocatable3)->ice_connectionId("client1")->ice_router(router1); + obj->ice_ping(); + obj2 = communicator->stringToProxy("allocatable4")->ice_connectionId("client1")->ice_router(router1); + obj2->ice_ping(); + session1->releaseObject(allocatable3); + try + { + obj->ice_ping(); + } + catch(const Ice::ObjectNotExistException&) + { + } + try + { + obj2->ice_ping(); + } + catch(const Ice::ObjectNotExistException&) + { + } + session1->destroy(); + } + catch(const Ice::LocalException& ex) + { + cerr << ex << endl; + test(false); + } + cout << "ok" << endl; + + cout << "stress test... " << flush; + + SessionPrx stressSession = registry->createSession("StressSession", ""); + keepAlive->add(stressSession); + + const int nClients = 10; + int i; + vector<StressClientPtr> clients; + for(i = 0; i < nClients - 2; ++i) + { + if(IceUtil::random(2) == 1) + { + clients.push_back(new StressClient(i, registry, false)); + } + else + { + clients.push_back(new StressClient(i, stressSession)); + } + clients.back()->start(); + } + clients.push_back(new StressClient(i++, registry, true)); + clients.back()->start(); + clients.push_back(new StressClient(i++, registry, true)); + clients.back()->start(); + + for(vector<StressClientPtr>::const_iterator p = clients.begin(); p != clients.end(); ++p) + { + (*p)->notifyThread(); + } + + // + // Let the stress client run for a bit. + // + IceUtil::ThreadControl::sleep(IceUtil::Time::seconds(8)); + + // + // Terminate the stress clients. + // + for(vector<StressClientPtr>::const_iterator q = clients.begin(); q != clients.end(); ++q) + { + (*q)->terminate(); + (*q)->getThreadControl().join(); + } + + stressSession->destroy(); + + cout << "ok" << endl; } catch(const AllocationTimeoutException& ex) { - cerr << ex << endl; - test(false); + cerr << ex << endl; + test(false); } catch(const AllocationException& ex) { - cerr << ex.reason << endl; - test(false); + cerr << ex.reason << endl; + test(false); } cout << "shutting down router... " << flush; |