void
Client::run(int argc, char** argv)
{
Ice::CommunicatorHolder communicator = initialize(argc, argv);
instance = this;
string protocol = getTestProtocol();
string host = getTestHost();
_initData.properties = Ice::createProperties(argc, argv, communicator->getProperties());
_initData.properties->setProperty("Ice.Default.Router", "Glacier2/router:" + getTestEndpoint(50));
DispatcherPtr dispatcher = new Dispatcher();
dispatcher->start();
#ifdef ICE_CPP11_MAPPING
_initData.dispatcher = [dispatcher](std::function<void()> call, const std::shared_ptr<Ice::Connection>& conn)
{
dispatcher->dispatch(call, conn);
};
#else
_initData.dispatcher = dispatcher;
#endif
_factory = ICE_MAKE_SHARED(Glacier2::SessionFactoryHelper, _initData, ICE_MAKE_SHARED(FailSessionCallback));
//
// Test to create a session with wrong userid/password
//
{
IceUtil::Monitor<IceUtil::Mutex>::Lock lock(_monitor);
cout << "testing SessionHelper connect with wrong userid/password... " << flush;
_session = _factory->connect("userid", "xxx");
//
// Wait for connectFailed callback
//
_monitor.timedWait(IceUtil::Time::seconds(30));
test(!_session->isConnected());
}
_factory->destroy();
//
// Test to interrupt connection establishment
//
_initData.properties->setProperty("Ice.Default.Router", "");
_factory = ICE_MAKE_SHARED(Glacier2::SessionFactoryHelper, _initData, ICE_MAKE_SHARED(InterruptConnectCallback));
{
IceUtil::Monitor<IceUtil::Mutex>::Lock lock(_monitor);
cout << "testing SessionHelper connect interrupt... " << flush;
_factory->setRouterHost(host);
_factory->setPort(getTestPort(_initData.properties, 1));
_factory->setProtocol(protocol);
_session = _factory->connect("userid", "abc123");
IceUtil::ThreadControl::sleep(IceUtil::Time::milliSeconds(100));
_session->destroy();
//
// Wait for connectFailed callback
//
_monitor.timedWait(IceUtil::Time::seconds(30));
test(!_session->isConnected());
}
_factory->destroy();
_factory = ICE_MAKE_SHARED(Glacier2::SessionFactoryHelper, _initData, ICE_MAKE_SHARED(SuccessSessionCallback));
{
IceUtil::Monitor<IceUtil::Mutex>::Lock lock(_monitor);
cout << "testing SessionHelper connect... " << flush;
_factory->setRouterHost(host);
_factory->setPort(getTestPort(_initData.properties, 50));
_factory->setProtocol(protocol);
_session = _factory->connect("userid", "abc123");
//
// Wait for connect callback
//
_monitor.timedWait(IceUtil::Time::seconds(30));
cout << "testing SessionHelper isConnected after connect... " << flush;
test(_session->isConnected());
cout << "ok" << endl;
cout << "testing SessionHelper categoryForClient after connect... " << flush;
try
{
test(!_session->categoryForClient().empty());
}
catch(const Glacier2::SessionNotExistException&)
{
test(false);
}
cout << "ok" << endl;
test(!_session->session());
cout << "testing stringToProxy for server object... " << flush;
Ice::ObjectPrxPtr base =
_session->communicator()->stringToProxy("callback:" + getTestEndpoint(_session->communicator()->getProperties()));
cout << "ok" << endl;
cout << "pinging server after session creation... " << flush;
base->ice_ping();
cout << "ok" << endl;
cout << "testing checked cast for server object... " << flush;
CallbackPrxPtr twoway = ICE_CHECKED_CAST(CallbackPrx, base);
test(twoway);
cout << "ok" << endl;
cout << "testing server shutdown... " << flush;
twoway->shutdown();
cout << "ok" << endl;
test(_session->communicator());
cout << "testing SessionHelper destroy... " << flush;
_session->destroy();
//
// Wait for disconnected callback
//
_monitor.wait();
cout << "testing SessionHelper isConnected after destroy... " << flush;
test(_session->isConnected() == false);
cout << "ok" << endl;
cout << "testing SessionHelper categoryForClient after destroy... " << flush;
try
{
test(!_session->categoryForClient().empty());
test(false);
}
catch(const Glacier2::SessionNotExistException&)
{
}
cout << "ok" << endl;
cout << "testing SessionHelper session after destroy... " << flush;
test(_session->session() == ICE_NULLPTR);
cout << "ok" << endl;
cout << "testing SessionHelper communicator after destroy... " << flush;
try
{
test(_session->communicator());
_session->communicator()->stringToProxy("dummy");
test(false);
}
catch(const Ice::CommunicatorDestroyedException&)
{
}
cout << "ok" << endl;
cout << "uninstalling router with communicator... " << flush;
communicator->setDefaultRouter(0);
cout << "ok" << endl;
Ice::ObjectPrxPtr processBase;
{
cout << "testing stringToProxy for process object... " << flush;
processBase = communicator->stringToProxy("Glacier2/admin -f Process:" + getTestEndpoint(51));
cout << "ok" << endl;
}
Ice::ProcessPrxPtr process;
{
cout << "testing checked cast for admin object... " << flush;
process = ICE_CHECKED_CAST(Ice::ProcessPrx, processBase);
test(process != 0);
cout << "ok" << endl;
}
cout << "testing Glacier2 shutdown... " << flush;
process->shutdown();
try
{
process->ice_ping();
test(false);
}
catch(const Ice::LocalException&)
{
cout << "ok" << endl;
}
}
_factory->destroy();
_factory = ICE_MAKE_SHARED(Glacier2::SessionFactoryHelper, _initData, ICE_MAKE_SHARED(AfterShutdownSessionCallback));
//
// Wait a bit to ensure glaci2router has been shutdown.
//
IceUtil::ThreadControl::sleep(IceUtil::Time::milliSeconds(100));
{
IceUtil::Monitor<IceUtil::Mutex>::Lock lock(_monitor);
cout << "testing SessionHelper connect after router shutdown... " << flush;
_factory->setRouterHost(host);
_factory->setPort(getTestPort(_initData.properties, 50));
_factory->setProtocol(protocol);
_session = _factory->connect("userid", "abc123");
//
// Wait for connectFailed callback
//
_monitor.wait();
cout << "testing SessionHelper isConnect after connect failure... " << flush;
test(_session->isConnected() == false);
cout << "ok" << endl;
cout << "testing SessionHelper communicator after connect failure... " << flush;
try
{
test(_session->communicator());
_session->communicator()->stringToProxy("dummy");
test(false);
}
catch(const Ice::CommunicatorDestroyedException&)
{
}
cout << "ok" << endl;
cout << "testing SessionHelper destroy after connect failure... " << flush;
_session->destroy();
cout << "ok" << endl;
}
_factory->destroy();
if(dispatcher)
{
dispatcher->destroy();
dispatcher->getThreadControl().join();
}
}
vector<EndpointIPtr>
IceInternal::RouterInfo::setClientEndpoints(const Ice::ObjectPrxPtr& proxy)
{
IceUtil::Mutex::Lock sync(*this);
if(_clientEndpoints.empty())
{
if(!proxy)
{
//
// If getClientProxy() return nil, use router endpoints.
//
_clientEndpoints = _router->__reference()->getEndpoints();
}
else
{
Ice::ObjectPrxPtr clientProxy = proxy->ice_router(0); // The client proxy cannot be routed.
//
// In order to avoid creating a new connection to the router,
// we must use the same timeout as the already existing
// connection.
//
if(_router->ice_getConnection())
{
clientProxy = clientProxy->ice_timeout(_router->ice_getConnection()->timeout());
}
_clientEndpoints = clientProxy->__reference()->getEndpoints();
}
}
return _clientEndpoints;
}
ProxyFlushBatch::ProxyFlushBatch(const Ice::ObjectPrxPtr& proxy, const string& operation) :
ProxyOutgoingBase(proxy, ICE_ENUM(OperationMode, Normal))
{
checkSupportedProtocol(getCompatibleProtocol(proxy->__reference()->getProtocol()));
_observer.attach(proxy, operation, ::Ice::noExplicitContext);
_batchRequestNum = proxy->__getBatchRequestQueue()->swap(&_os);
}
void
BatchRequestQueue::finishBatchRequest(OutputStream* os, const Ice::ObjectPrxPtr& proxy, const std::string& operation)
{
//
// No need for synchronization, no other threads are supposed
// to modify the queue since we set _batchStreamInUse to true.
//
assert(_batchStreamInUse);
_batchStream.swap(*os);
try
{
_batchStreamCanFlush = true; // Allow flush to proceed even if the stream is marked in use.
if(_maxSize > 0 && _batchStream.b.size() >= _maxSize)
{
#ifdef ICE_CPP11_MAPPING
proxy->ice_flushBatchRequests_async();
#else
proxy->begin_ice_flushBatchRequests();
#endif
}
assert(_batchMarker < _batchStream.b.size());
if(_interceptor)
{
BatchRequestI request(*this, proxy, operation, static_cast<int>(_batchStream.b.size() - _batchMarker));
#ifdef ICE_CPP11_MAPPING
_interceptor(request, _batchRequestNum, static_cast<int>(_batchMarker));
#else
_interceptor->enqueue(request, _batchRequestNum, static_cast<int>(_batchMarker));
#endif
}
else
{
_batchMarker = _batchStream.b.size();
++_batchRequestNum;
}
Lock sync(*this);
_batchStream.resize(_batchMarker);
_batchStreamInUse = false;
_batchStreamCanFlush = false;
notifyAll();
}
catch(const std::exception&)
{
Lock sync(*this);
_batchStream.resize(_batchMarker);
_batchStreamInUse = false;
_batchStreamCanFlush = false;
notifyAll();
throw;
}
}
Ice::ObjectPrxPtr
LocatorRegistryI::findObject(const Ice::Identity& id) const
{
Lock sync(*this);
if(id.name.empty())
{
return 0;
}
Ice::ObjectPrxPtr prx = _wellKnownProxy->ice_identity(id);
vector<string> adapterIds;
for(map<string, set<string> >::const_iterator p = _replicaGroups.begin(); p != _replicaGroups.end(); ++p)
{
try
{
prx->ice_adapterId(p->first)->ice_ping();
adapterIds.push_back(p->first);
}
catch(const Ice::Exception&)
{
// Ignore
}
}
if(adapterIds.empty())
{
for(map<string, Ice::ObjectPrxPtr>::const_iterator p = _adapters.begin(); p != _adapters.end(); ++p)
{
try
{
prx->ice_adapterId(p->first)->ice_ping();
adapterIds.push_back(p->first);
}
catch(const Ice::Exception&)
{
// Ignore
}
}
}
if(adapterIds.empty())
{
return 0;
}
random_shuffle(adapterIds.begin(), adapterIds.end());
return prx->ice_adapterId(adapterIds[0]);
}
int
run(int, char**, const Ice::CommunicatorPtr& communicator)
{
communicator->getProperties()->setProperty("TestAdapter.Endpoints", getTestEndpoint(communicator, 0));
communicator->getProperties()->setProperty("TestAdapter.AdapterId", "test");
Ice::ObjectAdapterPtr adapter = communicator->createObjectAdapter("TestAdapter");
Ice::ObjectPrxPtr prx = adapter->add(ICE_MAKE_SHARED(MyDerivedClassI), Ice::stringToIdentity("test"));
//adapter->activate(); // Don't activate OA to ensure collocation is used.
test(!prx->ice_getConnection());
Test::MyClassPrxPtr allTests(const Ice::CommunicatorPtr&);
allTests(communicator);
return EXIT_SUCCESS;
}
IceInternal::InvocationObserver::InvocationObserver(const Ice::ObjectPrxPtr& proxy, const string& op, const Context& ctx)
{
const CommunicatorObserverPtr& obsv = proxy->__reference()->getInstance()->initializationData().observer;
if(!obsv)
{
return;
}
attach(obsv->getInvocationObserver(proxy, op, ctx));
}
Ice::ObjectPrxPtr
LocatorRegistryI::findAdapter(const string& adapterId, bool& isReplicaGroup) const
{
Lock sync(*this);
map<string, Ice::ObjectPrxPtr>::const_iterator p = _adapters.find(adapterId);
if(p != _adapters.end())
{
isReplicaGroup = false;
return p->second;
}
map<string, set<string> >::const_iterator q = _replicaGroups.find(adapterId);
if(q != _replicaGroups.end())
{
Ice::EndpointSeq endpoints;
Ice::ObjectPrxPtr prx;
for(set<string>::const_iterator r = q->second.begin(); r != q->second.end(); ++r)
{
map<string, Ice::ObjectPrxPtr>::const_iterator s = _adapters.find(*r);
if(s == _adapters.end())
{
continue; // TODO: Inconsistency
}
if(!prx)
{
prx = s->second;
}
Ice::EndpointSeq endpts = s->second->ice_getEndpoints();
copy(endpts.begin(), endpts.end(), back_inserter(endpoints));
}
if(prx)
{
isReplicaGroup = true;
return prx->ice_endpoints(endpoints);
}
}
isReplicaGroup = false;
return 0;
}
ICE_DECLSPEC_EXPORT void
consume(const Ice::ObjectPtr& o, const Ice::ObjectPrxPtr& p)
{
cout << "testing dynamic cast across libraries... " << flush;
//
// Make sure dynamic cast works as expected
// and exception raised by a shared library can be caught by another
// shared library
//
Test::MyInterfacePtr servant = ICE_DYNAMIC_CAST(Test::MyInterface, o);
test(servant);
#ifdef ICE_CPP11_MAPPING
auto proxy = dynamic_pointer_cast<Test::MyInterfacePrx>(p);
#else
Test::MyInterfacePrx proxy = dynamic_cast<IceProxy::Test::MyInterface*>(p.get());
#endif
test(proxy);
proxy->op(false);
servant->op(false, Ice::emptyCurrent);
cout << "ok" << endl;
cout << "testing exceptions thrown across libraries... " << flush;
try
{
proxy->op(true);
}
catch(const Test::UserError&)
{
// expected
}
catch(...)
{
test(false);
}
try
{
servant->op(true, Ice::emptyCurrent);
}
catch(const Test::UserError&)
{
// expected
}
catch(...)
{
test(false);
}
cout << "ok" << endl;
}
ProxyOutgoingBase::ProxyOutgoingBase(const Ice::ObjectPrxPtr& proxy, OperationMode mode) :
OutgoingBase(proxy->__reference()->getInstance().get()),
_proxy(proxy),
_mode(mode),
_state(StateUnsent)
{
int invocationTimeout = _proxy->__reference()->getInvocationTimeout();
if(invocationTimeout > 0)
{
_invocationTimeoutDeadline = Time::now(Time::Monotonic) + Time::milliSeconds(invocationTimeout);
}
}
void
IceInternal::RouterInfo::addAndEvictProxies(const Ice::ObjectPrxPtr& proxy, const Ice::ObjectProxySeq& evictedProxies)
{
IceUtil::Mutex::Lock sync(*this);
//
// Check if the proxy hasn't already been evicted by a concurrent addProxies call.
// If it's the case, don't add it to our local map.
//
multiset<Identity>::iterator p = _evictedIdentities.find(proxy->ice_getIdentity());
if(p != _evictedIdentities.end())
{
_evictedIdentities.erase(p);
}
else
{
//
// If we successfully added the proxy to the router,
// we add it to our local map.
//
_identities.insert(proxy->ice_getIdentity());
}
//
// We also must remove whatever proxies the router evicted.
//
for(Ice::ObjectProxySeq::const_iterator q = evictedProxies.begin(); q != evictedProxies.end(); ++q)
{
if(_identities.erase((*q)->ice_getIdentity()) == 0)
{
//
// It's possible for the proxy to not have been
// added yet in the local map if two threads
// concurrently call addProxies.
//
_evictedIdentities.insert((*q)->ice_getIdentity());
}
}
}
bool
IceInternal::RouterInfo::addProxy(const Ice::ObjectPrxPtr& proxy, const AddProxyCallbackPtr& callback)
{
assert(proxy);
{
IceUtil::Mutex::Lock sync(*this);
if(_identities.find(proxy->ice_getIdentity()) != _identities.end())
{
//
// Only add the proxy to the router if it's not already in our local map.
//
return true;
}
}
Ice::ObjectProxySeq proxies;
proxies.push_back(proxy);
AddProxyCookiePtr cookie = new AddProxyCookie(callback, proxy);
#ifdef ICE_CPP11_MAPPING
RouterInfoPtr self = this;
_router->addProxies_async(proxies,
[self, cookie](const Ice::ObjectProxySeq& proxies)
{
self->addProxyResponse(proxies, cookie);
},
[self, cookie](exception_ptr e)
{
try
{
rethrow_exception(e);
}
catch(const Ice::Exception& ex)
{
self->addProxyException(ex, cookie);
}
});
#else
_router->begin_addProxies(proxies,
newCallback_Router_addProxies(this,
&RouterInfo::addProxyResponse,
&RouterInfo::addProxyException),
cookie);
#endif
return false;
}
void
allTests(Test::TestHelper* helper)
{
Ice::CommunicatorPtr communicator = helper->communicator();
cout << "testing proxy endpoint information... " << flush;
{
Ice::ObjectPrxPtr 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::EndpointSeq endps = p1->ice_getEndpoints();
Ice::EndpointInfoPtr info = endps[0]->getInfo();
Ice::TCPEndpointInfoPtr ipEndpoint = getTCPEndpointInfo(info);
test(ipEndpoint);
test(ipEndpoint->host == "tcphost");
test(ipEndpoint->port == 10000);
test(ipEndpoint->timeout == 1200);
#if !defined(ICE_OS_UWP)
test(ipEndpoint->sourceAddress == "10.10.10.10");
#endif
test(ipEndpoint->compress);
test(!ipEndpoint->datagram());
test((ipEndpoint->type() == Ice::TCPEndpointType && !ipEndpoint->secure()) ||
(ipEndpoint->type() == Ice::SSLEndpointType && ipEndpoint->secure()) ||
(ipEndpoint->type() == Ice::WSEndpointType && !ipEndpoint->secure()) ||
(ipEndpoint->type() == Ice::WSSEndpointType && ipEndpoint->secure()));
test((ipEndpoint->type() == Ice::TCPEndpointType && ICE_DYNAMIC_CAST(Ice::TCPEndpointInfo, info)) ||
(ipEndpoint->type() == Ice::SSLEndpointType && ICE_DYNAMIC_CAST(IceSSL::EndpointInfo, info)) ||
(ipEndpoint->type() == Ice::WSEndpointType && ICE_DYNAMIC_CAST(Ice::WSEndpointInfo, info)) ||
(ipEndpoint->type() == Ice::WSSEndpointType && ICE_DYNAMIC_CAST(Ice::WSEndpointInfo, info)));
Ice::UDPEndpointInfoPtr udpEndpoint = ICE_DYNAMIC_CAST(Ice::UDPEndpointInfo, endps[1]->getInfo());
test(udpEndpoint);
test(udpEndpoint->host == "udphost");
test(udpEndpoint->port == 10001);
#if !defined(ICE_OS_UWP)
test(udpEndpoint->sourceAddress == "10.10.10.10");
#endif
test(udpEndpoint->mcastInterface == "eth0");
test(udpEndpoint->mcastTtl == 5);
test(udpEndpoint->timeout == -1);
test(!udpEndpoint->compress);
test(!udpEndpoint->secure());
test(udpEndpoint->datagram());
test(udpEndpoint->type() == Ice::UDPEndpointType);
Ice::OpaqueEndpointInfoPtr opaqueEndpoint = ICE_DYNAMIC_CAST(Ice::OpaqueEndpointInfo, endps[2]->getInfo());
test(opaqueEndpoint);
Ice::EncodingVersion rev;
rev.major = 1;
rev.minor = 8;
test(opaqueEndpoint->rawEncoding == rev);
}
cout << "ok" << endl;
string defaultHost = communicator->getProperties()->getProperty("Ice.Default.Host");
#ifdef ICE_OS_UWP
bool uwp = true;
#else
bool uwp = false;
#endif
if(!uwp || (communicator->getProperties()->getProperty("Ice.Default.Protocol") != "ssl" &&
communicator->getProperties()->getProperty("Ice.Default.Protocol") != "wss"))
{
cout << "test object adapter endpoint information... " << flush;
{
communicator->getProperties()->setProperty("TestAdapter.Endpoints",
"default -h 127.0.0.1 -t 15000:udp -h 127.0.0.1");
Ice::ObjectAdapterPtr adapter = communicator->createObjectAdapter("TestAdapter");
Ice::EndpointSeq endpoints = adapter->getEndpoints();
test(endpoints.size() == 2);
Ice::EndpointSeq publishedEndpoints = adapter->getPublishedEndpoints();
test(endpoints == publishedEndpoints);
Ice::TCPEndpointInfoPtr ipEndpoint = getTCPEndpointInfo(endpoints[0]->getInfo());
test(ipEndpoint);
test(ipEndpoint->type() == Ice::TCPEndpointType || ipEndpoint->type() == Ice::SSLEndpointType ||
ipEndpoint->type() == Ice::WSEndpointType || ipEndpoint->type() == Ice::WSSEndpointType);
test(ipEndpoint->host == "127.0.0.1");
test(ipEndpoint->port > 0);
test(ipEndpoint->timeout == 15000);
Ice::UDPEndpointInfoPtr udpEndpoint = ICE_DYNAMIC_CAST(Ice::UDPEndpointInfo, endpoints[1]->getInfo());
test(udpEndpoint);
test(udpEndpoint->host == "127.0.0.1");
test(udpEndpoint->datagram());
test(udpEndpoint->port > 0);
endpoints.pop_back();
test(endpoints.size() == 1);
adapter->setPublishedEndpoints(endpoints);
publishedEndpoints = adapter->getPublishedEndpoints();
test(endpoints == publishedEndpoints);
adapter->destroy();
int port = helper->getTestPort(1);
ostringstream portStr;
portStr << port;
communicator->getProperties()->setProperty("TestAdapter.Endpoints", "default -h * -p " + portStr.str());
communicator->getProperties()->setProperty("TestAdapter.PublishedEndpoints", helper->getTestEndpoint(1));
adapter = communicator->createObjectAdapter("TestAdapter");
endpoints = adapter->getEndpoints();
test(endpoints.size() >= 1);
publishedEndpoints = adapter->getPublishedEndpoints();
test(publishedEndpoints.size() == 1);
for(Ice::EndpointSeq::const_iterator p = endpoints.begin(); p != endpoints.end(); ++p)
{
ipEndpoint = getTCPEndpointInfo((*p)->getInfo());
test(ipEndpoint->port == port);
}
ipEndpoint = getTCPEndpointInfo(publishedEndpoints[0]->getInfo());
test(ipEndpoint->host == helper->getTestHost());
test(ipEndpoint->port == port);
adapter->destroy();
}
cout << "ok" << endl;
}
string endpoints = helper->getTestEndpoint() + ":" + helper->getTestEndpoint("udp") + " -c";
int port = helper->getTestPort();
Ice::ObjectPrxPtr base = communicator->stringToProxy("test:" + endpoints);
TestIntfPrxPtr testIntf = ICE_CHECKED_CAST(TestIntfPrx, base);
cout << "test connection endpoint information... " << flush;
{
Ice::EndpointInfoPtr info = base->ice_getConnection()->getEndpoint()->getInfo();
Ice::TCPEndpointInfoPtr tcpinfo = getTCPEndpointInfo(info);
test(tcpinfo->port == port);
test(!tcpinfo->compress);
test(tcpinfo->host == defaultHost);
ostringstream os;
Ice::Context ctx = testIntf->getEndpointInfoAsContext();
test(ctx["host"] == tcpinfo->host);
test(ctx["compress"] == "false");
istringstream is(ctx["port"]);
int portCtx;
is >> portCtx;
test(portCtx > 0);
info = base->ice_datagram()->ice_getConnection()->getEndpoint()->getInfo();
Ice::UDPEndpointInfoPtr udp = ICE_DYNAMIC_CAST(Ice::UDPEndpointInfo, info);
test(udp);
test(udp->port == portCtx);
test(udp->host == defaultHost);
}
cout << "ok" << endl;
cout << "testing connection information... " << flush;
{
Ice::ConnectionPtr connection = base->ice_getConnection();
connection->setBufferSize(1024, 2048);
Ice::TCPConnectionInfoPtr info = getTCPConnectionInfo(connection->getInfo());
test(info);
test(!info->incoming);
test(info->adapterName.empty());
test(info->localPort > 0);
test(info->remotePort == port);
if(defaultHost == "127.0.0.1")
{
test(info->remoteAddress == defaultHost);
test(info->localAddress == defaultHost);
}
#if !defined(ICE_OS_UWP)
test(info->rcvSize >= 1024);
test(info->sndSize >= 2048);
#endif
ostringstream os;
Ice::Context ctx = testIntf->getConnectionInfoAsContext();
test(ctx["incoming"] == "true");
test(ctx["adapterName"] == "TestAdapter");
test(ctx["remoteAddress"] == info->localAddress);
test(ctx["localAddress"] == info->remoteAddress);
os.str("");
os << info->localPort;
test(ctx["remotePort"] == os.str());
os.str("");
os << info->remotePort;
test(ctx["localPort"] == os.str());
if(base->ice_getConnection()->type() == "ws" || base->ice_getConnection()->type() == "wss")
{
Ice::HeaderDict headers;
Ice::WSConnectionInfoPtr wsinfo = ICE_DYNAMIC_CAST(Ice::WSConnectionInfo, connection->getInfo());
test(wsinfo);
headers = wsinfo->headers;
if(base->ice_getConnection()->type() == "wss")
{
IceSSL::ConnectionInfoPtr wssinfo = ICE_DYNAMIC_CAST(IceSSL::ConnectionInfo, wsinfo->underlying);
test(wssinfo->verified);
#if !defined(ICE_OS_UWP) && TARGET_OS_IPHONE==0
test(!wssinfo->certs.empty());
#endif
}
test(headers["Upgrade"] == "websocket");
test(headers["Connection"] == "Upgrade");
test(headers["Sec-WebSocket-Protocol"] == "ice.zeroc.com");
test(headers.find("Sec-WebSocket-Accept") != headers.end());
test(ctx["ws.Upgrade"] == "websocket");
test(ctx["ws.Connection"] == "Upgrade");
test(ctx["ws.Sec-WebSocket-Protocol"] == "ice.zeroc.com");
test(ctx["ws.Sec-WebSocket-Version"] == "13");
test(ctx.find("ws.Sec-WebSocket-Key") != ctx.end());
}
connection = base->ice_datagram()->ice_getConnection();
connection->setBufferSize(2048, 1024);
Ice::UDPConnectionInfoPtr udpinfo = ICE_DYNAMIC_CAST(Ice::UDPConnectionInfo, connection->getInfo());
test(!udpinfo->incoming);
test(udpinfo->adapterName.empty());
test(udpinfo->localPort > 0);
test(udpinfo->remotePort == port);
if(defaultHost == "127.0.0.1")
{
test(udpinfo->remoteAddress == defaultHost);
test(udpinfo->localAddress == defaultHost);
}
#if !defined(ICE_OS_UWP)
test(udpinfo->rcvSize >= 2048);
test(udpinfo->sndSize >= 1024);
#endif
}
cout << "ok" << endl;
testIntf->shutdown();
communicator->shutdown();
communicator->waitForShutdown();
}
TimeoutPrxPtr
allTests(const Ice::CommunicatorPtr& communicator)
{
string sref = "timeout:" + getTestEndpoint(communicator, 0);
Ice::ObjectPrxPtr obj = communicator->stringToProxy(sref);
test(obj);
TimeoutPrxPtr timeout = ICE_CHECKED_CAST(TimeoutPrx, obj);
test(timeout);
cout << "testing connect timeout... " << flush;
{
//
// Expect ConnectTimeoutException.
//
TimeoutPrxPtr to = ICE_UNCHECKED_CAST(TimeoutPrx, 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.
TimeoutPrxPtr to = ICE_UNCHECKED_CAST(TimeoutPrx, 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.
//
TimeoutPrxPtr to = ICE_UNCHECKED_CAST(TimeoutPrx, 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.
TimeoutPrxPtr to = ICE_UNCHECKED_CAST(TimeoutPrx, 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();
TimeoutPrxPtr to = ICE_UNCHECKED_CAST(TimeoutPrx, obj->ice_invocationTimeout(100));
test(connection == to->ice_getConnection());
try
{
to->sleep(750);
test(false);
}
catch(const Ice::InvocationTimeoutException&)
{
}
obj->ice_ping();
to = ICE_CHECKED_CAST(TimeoutPrx, 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.
//
TimeoutPrxPtr to = ICE_UNCHECKED_CAST(TimeoutPrx, obj->ice_invocationTimeout(100));
#ifdef ICE_CPP11_MAPPING
auto f = to->sleep_async(750);
try
{
f.get();
test(false);
}
catch(const Ice::InvocationTimeoutException&)
{
}
catch(...)
{
test(false);
}
#else
CallbackPtr cb = new Callback();
to->begin_sleep(750, newCallback_Timeout_sleep(cb, &Callback::responseEx, &Callback::exceptionEx));
cb->check();
#endif
obj->ice_ping();
}
{
//
// Expect success.
//
TimeoutPrxPtr to = ICE_UNCHECKED_CAST(TimeoutPrx, obj->ice_invocationTimeout(500));
#ifdef ICE_CPP11_MAPPING
auto f = to->sleep_async(250);
try
{
f.get();
}
catch(...)
{
test(false);
}
#else
CallbackPtr cb = new Callback();
to->begin_sleep(250, newCallback_Timeout_sleep(cb, &Callback::response, &Callback::exception));
cb->check();
#endif
}
{
//
// Backward compatible connection timeouts
//
TimeoutPrxPtr to = ICE_UNCHECKED_CAST(TimeoutPrx, obj->ice_invocationTimeout(-2)->ice_timeout(250));
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();
#ifdef ICE_CPP11_MAPPING
to->sleep_async(750).get();
#else
to->end_sleep(to->begin_sleep(750));
#endif
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;
{
TimeoutPrxPtr to = ICE_CHECKED_CAST(TimeoutPrx, obj->ice_timeout(250));
Ice::ConnectionPtr connection = to->ice_getConnection();
timeout->holdAdapter(600);
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(650));
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", "250");
Ice::CommunicatorPtr comm = Ice::initialize(initData);
TimeoutPrxPtr to = ICE_CHECKED_CAST(TimeoutPrx, comm->stringToProxy(sref));
timeout->holdAdapter(700);
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 = ICE_CHECKED_CAST(TimeoutPrx, 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);
TimeoutPrxPtr to = ICE_UNCHECKED_CAST(TimeoutPrx, 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 = ICE_UNCHECKED_CAST(TimeoutPrx, 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 = ICE_UNCHECKED_CAST(TimeoutPrx, to->ice_timeout(250));
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", "250");
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();
TimeoutPrxPtr timeout = ICE_UNCHECKED_CAST(TimeoutPrx, adapter->addWithUUID(ICE_MAKE_SHARED(TimeoutI)));
timeout = timeout->ice_invocationTimeout(100);
try
{
timeout->sleep(300);
test(false);
}
catch(const Ice::InvocationTimeoutException&)
{
}
try
{
#ifdef ICE_CPP11_MAPPING
timeout->sleep_async(300).get();
#else
timeout->end_sleep(timeout->begin_sleep(300));
#endif
test(false);
}
catch(const Ice::InvocationTimeoutException&)
{
}
TimeoutPrxPtr batchTimeout = timeout->ice_batchOneway();
batchTimeout->ice_ping();
batchTimeout->ice_ping();
batchTimeout->ice_ping();
// Keep the server thread pool busy.
#ifdef ICE_CPP11_MAPPING
timeout->ice_invocationTimeout(-1)->sleep_async(300);
#else
timeout->ice_invocationTimeout(-1)->begin_sleep(300);
#endif
try
{
batchTimeout->ice_flushBatchRequests();
test(false);
}
catch(const Ice::InvocationTimeoutException&)
{
}
batchTimeout->ice_ping();
batchTimeout->ice_ping();
batchTimeout->ice_ping();
// Keep the server thread pool busy.
#ifdef ICE_CPP11_MAPPING
timeout->ice_invocationTimeout(-1)->sleep_async(300);
#else
timeout->ice_invocationTimeout(-1)->begin_sleep(300);
#endif
try
{
#ifdef ICE_CPP11_MAPPING
batchTimeout->ice_flushBatchRequests_async().get();
#else
batchTimeout->end_ice_flushBatchRequests(batchTimeout->begin_ice_flushBatchRequests());
#endif
test(false);
}
catch(const Ice::InvocationTimeoutException&)
{
}
adapter->destroy();
}
cout << "ok" << endl;
return timeout;
}
void
batchOneways(const Test::MyClassPrxPtr& p)
{
const Test::ByteS bs1(10 * 1024);
Test::MyClassPrxPtr batch = ICE_UNCHECKED_CAST(Test::MyClassPrx, p->ice_batchOneway());
batch->ice_flushBatchRequests(); // Empty flush
if(batch->ice_getConnection())
{
batch->ice_getConnection()->flushBatchRequests(Ice::ICE_SCOPED_ENUM(CompressBatch, BasedOnProxy));
}
batch->ice_getCommunicator()->flushBatchRequests(Ice::ICE_SCOPED_ENUM(CompressBatch, BasedOnProxy));
int i;
p->opByteSOnewayCallCount(); // Reset the call count
for(i = 0 ; i < 30 ; ++i)
{
try
{
batch->opByteSOneway(bs1);
}
catch(const Ice::LocalException& ex)
{
cerr << ex << endl;
test(false);
}
}
int count = 0;
while(count < 27) // 3 * 9 requests auto-flushed.
{
count += p->opByteSOnewayCallCount();
IceUtil::ThreadControl::sleep(IceUtil::Time::milliSeconds(10));
}
if(batch->ice_getConnection() &&
p->ice_getCommunicator()->getProperties()->getProperty("Ice.Default.Protocol") != "bt")
{
Test::MyClassPrxPtr batch1 = ICE_UNCHECKED_CAST(Test::MyClassPrx, p->ice_batchOneway());
Test::MyClassPrxPtr batch2 = ICE_UNCHECKED_CAST(Test::MyClassPrx, p->ice_batchOneway());
batch1->ice_ping();
batch2->ice_ping();
batch1->ice_flushBatchRequests();
batch1->ice_getConnection()->close(Ice::ICE_SCOPED_ENUM(ConnectionClose, GracefullyWithWait));
batch1->ice_ping();
batch2->ice_ping();
batch1->ice_getConnection();
batch2->ice_getConnection();
batch1->ice_ping();
batch1->ice_getConnection()->close(Ice::ICE_SCOPED_ENUM(ConnectionClose, GracefullyWithWait));
batch1->ice_ping();
batch2->ice_ping();
}
Ice::Identity identity;
identity.name = "invalid";
Ice::ObjectPrxPtr batch3 = batch->ice_identity(identity);
batch3->ice_ping();
batch3->ice_flushBatchRequests();
// Make sure that a bogus batch request doesn't cause troubles to other ones.
batch3->ice_ping();
batch->ice_ping();
batch->ice_flushBatchRequests();
batch->ice_ping();
if(batch->ice_getConnection() &&
p->ice_getCommunicator()->getProperties()->getProperty("Ice.Default.Protocol") != "bt")
{
Ice::InitializationData initData;
initData.properties = p->ice_getCommunicator()->getProperties()->clone();
BatchRequestInterceptorIPtr interceptor = ICE_MAKE_SHARED(BatchRequestInterceptorI);
#if defined(ICE_CPP11_MAPPING)
initData.batchRequestInterceptor = [=](const Ice::BatchRequest& request, int count, int size)
{
interceptor->enqueue(request, count, size);
};
#else
initData.batchRequestInterceptor = interceptor;
#endif
Ice::CommunicatorPtr ic = Ice::initialize(initData);
Test::MyClassPrxPtr batch =
ICE_UNCHECKED_CAST(Test::MyClassPrx, ic->stringToProxy(p->ice_toString()))->ice_batchOneway();
test(interceptor->count() == 0);
batch->ice_ping();
batch->ice_ping();
batch->ice_ping();
test(interceptor->count() == 0);
interceptor->enqueue(true);
batch->ice_ping();
batch->ice_ping();
batch->ice_ping();
test(interceptor->count() == 3);
batch->ice_flushBatchRequests();
batch->ice_ping();
test(interceptor->count() == 1);
batch->opByteSOneway(bs1);
test(interceptor->count() == 2);
batch->opByteSOneway(bs1);
test(interceptor->count() == 3);
batch->opByteSOneway(bs1); // This should trigger the flush
batch->ice_ping();
test(interceptor->count() == 2);
ic->destroy();
}
bool supportsCompress = true;
try
{
supportsCompress = p->supportsCompress();
}
catch(const Ice::OperationNotExistException&)
{
}
if(supportsCompress && batch->ice_getConnection() &&
p->ice_getCommunicator()->getProperties()->getProperty("Ice.Override.Compress") == "")
{
Ice::ObjectPrxPtr prx = batch->ice_getConnection()->createProxy(batch->ice_getIdentity())->ice_batchOneway();
Test::MyClassPrxPtr batch1 = ICE_UNCHECKED_CAST(Test::MyClassPrx, prx->ice_compress(false));
Test::MyClassPrxPtr batch2 = ICE_UNCHECKED_CAST(Test::MyClassPrx, prx->ice_compress(true));
Test::MyClassPrxPtr batch3 = ICE_UNCHECKED_CAST(Test::MyClassPrx, prx->ice_identity(identity));
batch1->opByteSOneway(bs1);
batch1->opByteSOneway(bs1);
batch1->opByteSOneway(bs1);
batch1->ice_getConnection()->flushBatchRequests(Ice::ICE_SCOPED_ENUM(CompressBatch, Yes));
batch2->opByteSOneway(bs1);
batch2->opByteSOneway(bs1);
batch2->opByteSOneway(bs1);
batch1->ice_getConnection()->flushBatchRequests(Ice::ICE_SCOPED_ENUM(CompressBatch, No));
batch1->opByteSOneway(bs1);
batch1->opByteSOneway(bs1);
batch1->opByteSOneway(bs1);
batch1->ice_getConnection()->flushBatchRequests(Ice::ICE_SCOPED_ENUM(CompressBatch, BasedOnProxy));
batch1->opByteSOneway(bs1);
batch2->opByteSOneway(bs1);
batch1->opByteSOneway(bs1);
batch1->ice_getConnection()->flushBatchRequests(Ice::ICE_SCOPED_ENUM(CompressBatch, BasedOnProxy));
batch1->opByteSOneway(bs1);
batch3->opByteSOneway(bs1);
batch1->opByteSOneway(bs1);
batch1->ice_getConnection()->flushBatchRequests(Ice::ICE_SCOPED_ENUM(CompressBatch, BasedOnProxy));
}
}
void
ObjectAdapterI::updateLocatorRegistry(const IceInternal::LocatorInfoPtr& locatorInfo, const Ice::ObjectPrxPtr& proxy)
{
if(_id.empty() || !locatorInfo)
{
return; // Nothing to update.
}
LocatorRegistryPrxPtr locatorRegistry = locatorInfo->getLocatorRegistry();
if(!locatorRegistry)
{
return;
}
try
{
if(_replicaGroupId.empty())
{
locatorRegistry->setAdapterDirectProxy(_id, proxy);
}
else
{
locatorRegistry->setReplicatedAdapterDirectProxy(_id, _replicaGroupId, proxy);
}
}
catch(const AdapterNotFoundException&)
{
if(_instance->traceLevels()->location >= 1)
{
Trace out(_instance->initializationData().logger, _instance->traceLevels()->locationCat);
out << "couldn't update object adapter `" + _id + "' endpoints with the locator registry:\n";
out << "the object adapter is not known to the locator registry";
}
throw NotRegisteredException(__FILE__, __LINE__, "object adapter", _id);
}
catch(const InvalidReplicaGroupIdException&)
{
if(_instance->traceLevels()->location >= 1)
{
Trace out(_instance->initializationData().logger, _instance->traceLevels()->locationCat);
out << "couldn't update object adapter `" + _id + "' endpoints with the locator registry:\n";
out << "the replica group `" << _replicaGroupId << "' is not known to the locator registry";
}
throw NotRegisteredException(__FILE__, __LINE__, "replica group", _replicaGroupId);
}
catch(const AdapterAlreadyActiveException&)
{
if(_instance->traceLevels()->location >= 1)
{
Trace out(_instance->initializationData().logger, _instance->traceLevels()->locationCat);
out << "couldn't update object adapter `" + _id + "' endpoints with the locator registry:\n";
out << "the object adapter endpoints are already set";
}
throw ObjectAdapterIdInUseException(__FILE__, __LINE__, _id);
}
catch(const ObjectAdapterDeactivatedException&)
{
// Expected if collocated call and OA is deactivated, ignore.
}
catch(const CommunicatorDestroyedException&)
{
// Ignore.
}
catch(const LocalException& ex)
{
if(_instance->traceLevels()->location >= 1)
{
Trace out(_instance->initializationData().logger, _instance->traceLevels()->locationCat);
out << "couldn't update object adapter `" + _id + "' endpoints with the locator registry:\n" << ex;
}
throw; // TODO: Shall we raise a special exception instead of a non obvious local exception?
}
if(_instance->traceLevels()->location >= 1)
{
Trace out(_instance->initializationData().logger, _instance->traceLevels()->locationCat);
out << "updated object adapter `" + _id + "' endpoints with the locator registry\n";
out << "endpoints = ";
if(proxy)
{
EndpointSeq endpts = proxy ? proxy->ice_getEndpoints() : EndpointSeq();
ostringstream o;
transform(endpts.begin(), endpts.end(), ostream_iterator<string>(o, endpts.size() > 1 ? ":" : ""),
Ice::constMemFun(&Endpoint::toString));
out << o.str();
}
}
}
Outgoing::Outgoing(const Ice::ObjectPrxPtr& proxy, const string& operation, OperationMode mode, const Context& context) :
ProxyOutgoingBase(proxy, mode),
_encoding(getCompatibleEncoding(proxy->__reference()->getEncoding())),
_is(proxy->__reference()->getInstance().get(), Ice::currentProtocolEncoding),
_operation(operation)
{
checkSupportedProtocol(getCompatibleProtocol(proxy->__reference()->getProtocol()));
_observer.attach(proxy, operation, context);
switch(_proxy->__reference()->getMode())
{
case Reference::ModeTwoway:
case Reference::ModeOneway:
case Reference::ModeDatagram:
{
_os.writeBlob(requestHdr, sizeof(requestHdr));
break;
}
case Reference::ModeBatchOneway:
case Reference::ModeBatchDatagram:
{
_proxy->__getBatchRequestQueue()->prepareBatchRequest(&_os);
break;
}
}
try
{
_os.write(_proxy->__reference()->getIdentity());
//
// For compatibility with the old FacetPath.
//
if(_proxy->__reference()->getFacet().empty())
{
_os.write(static_cast<string*>(0), static_cast<string*>(0));
}
else
{
string facet = _proxy->__reference()->getFacet();
_os.write(&facet, &facet + 1);
}
_os.write(operation, false);
_os.write(static_cast<Ice::Byte>(mode));
if(&context != &Ice::noExplicitContext)
{
//
// Explicit context
//
_os.write(context);
}
else
{
//
// Implicit context
//
const ImplicitContextIPtr& implicitContext = _proxy->__reference()->getInstance()->getImplicitContext();
const Context& prxContext = _proxy->__reference()->getContext()->getValue();
if(implicitContext == 0)
{
_os.write(prxContext);
}
else
{
implicitContext->write(prxContext, &_os);
}
}
}
catch(const LocalException& ex)
{
abort(ex);
}
}
void
allTests(const Ice::CommunicatorPtr& communicator, const string& ref)
{
ServerManagerPrxPtr manager = ICE_CHECKED_CAST(ServerManagerPrx, communicator->stringToProxy(ref));
TestLocatorPrxPtr locator = ICE_UNCHECKED_CAST(TestLocatorPrx, communicator->getDefaultLocator());
test(manager);
TestLocatorRegistryPrxPtr registry = ICE_CHECKED_CAST(TestLocatorRegistryPrx, locator->getRegistry());
test(registry);
cout << "testing stringToProxy... " << flush;
Ice::ObjectPrxPtr base = communicator->stringToProxy("test @ TestAdapter");
Ice::ObjectPrxPtr base2 = communicator->stringToProxy("test @ TestAdapter");
Ice::ObjectPrxPtr base3 = communicator->stringToProxy("test");
Ice::ObjectPrxPtr base4 = communicator->stringToProxy("ServerManager");
Ice::ObjectPrxPtr base5 = communicator->stringToProxy("test2");
Ice::ObjectPrxPtr base6 = communicator->stringToProxy("test @ ReplicatedAdapter");
cout << "ok" << endl;
cout << "testing ice_locator and ice_getLocator... " << flush;
test(Ice::proxyIdentityEqual(base->ice_getLocator(), communicator->getDefaultLocator()));
Ice::LocatorPrxPtr anotherLocator = ICE_UNCHECKED_CAST(Ice::LocatorPrx, communicator->stringToProxy("anotherLocator"));
base = base->ice_locator(anotherLocator);
test(Ice::proxyIdentityEqual(base->ice_getLocator(), anotherLocator));
communicator->setDefaultLocator(ICE_NULLPTR);
base = communicator->stringToProxy("test @ TestAdapter");
test(!base->ice_getLocator());
base = base->ice_locator(anotherLocator);
test(Ice::proxyIdentityEqual(base->ice_getLocator(), anotherLocator));
communicator->setDefaultLocator(locator);
base = communicator->stringToProxy("test @ TestAdapter");
test(Ice::proxyIdentityEqual(base->ice_getLocator(), communicator->getDefaultLocator()));
//
// We also test ice_router/ice_getRouter (perhaps we should add a
// test/Ice/router test?)
//
test(!base->ice_getRouter());
Ice::RouterPrxPtr anotherRouter = ICE_UNCHECKED_CAST(Ice::RouterPrx, communicator->stringToProxy("anotherRouter"));
base = base->ice_router(anotherRouter);
test(Ice::proxyIdentityEqual(base->ice_getRouter(), anotherRouter));
Ice::RouterPrxPtr router = ICE_UNCHECKED_CAST(Ice::RouterPrx, communicator->stringToProxy("dummyrouter"));
communicator->setDefaultRouter(router);
base = communicator->stringToProxy("test @ TestAdapter");
test(Ice::proxyIdentityEqual(base->ice_getRouter(), communicator->getDefaultRouter()));
communicator->setDefaultRouter(0);
base = communicator->stringToProxy("test @ TestAdapter");
test(!base->ice_getRouter());
cout << "ok" << endl;
cout << "starting server... " << flush;
manager->startServer();
cout << "ok" << endl;
cout << "testing checked cast... " << flush;
TestIntfPrxPtr obj = ICE_CHECKED_CAST(TestIntfPrx, base);
test(obj);
TestIntfPrxPtr obj2 = ICE_CHECKED_CAST(TestIntfPrx, base2);
test(obj2);
TestIntfPrxPtr obj3 = ICE_CHECKED_CAST(TestIntfPrx, base3);
test(obj3);
ServerManagerPrxPtr obj4 = ICE_CHECKED_CAST(ServerManagerPrx, base4);
test(obj4);
TestIntfPrxPtr obj5 = ICE_CHECKED_CAST(TestIntfPrx, base5);
test(obj5);
TestIntfPrxPtr obj6 = ICE_CHECKED_CAST(TestIntfPrx, base6);
test(obj6);
cout << "ok" << endl;
cout << "testing id@AdapterId indirect proxy... " << flush;
obj->shutdown();
manager->startServer();
try
{
obj2->ice_ping();
}
catch(const Ice::LocalException& ex)
{
cerr << ex << endl;
test(false);
}
cout << "ok" << endl;
cout << "testing id@ReplicaGroupId indirect proxy... " << flush;
obj->shutdown();
manager->startServer();
try
{
obj6->ice_ping();
}
catch(const Ice::LocalException& ex)
{
cerr << ex << endl;
test(false);
}
cout << "ok" << endl;
cout << "testing identity indirect proxy... " << flush;
obj->shutdown();
manager->startServer();
try
{
obj3->ice_ping();
}
catch(const Ice::LocalException& ex)
{
cerr << ex << endl;
test(false);
}
try
{
obj2->ice_ping();
}
catch(const Ice::LocalException& ex)
{
cerr << ex << endl;
test(false);
}
obj->shutdown();
manager->startServer();
try
{
obj2->ice_ping();
}
catch(const Ice::LocalException& ex)
{
cerr << ex << endl;
test(false);
}
try
{
obj3->ice_ping();
}
catch(const Ice::LocalException& ex)
{
cerr << ex << endl;
test(false);
}
obj->shutdown();
manager->startServer();
try
{
obj2->ice_ping();
}
catch(const Ice::LocalException& ex)
{
cerr << ex << endl;
test(false);
}
obj->shutdown();
manager->startServer();
try
{
obj3->ice_ping();
}
catch(const Ice::LocalException& ex)
{
cerr << ex << endl;
test(false);
}
obj->shutdown();
manager->startServer();
try
{
obj2->ice_ping();
}
catch(const Ice::LocalException& ex)
{
cerr << ex << endl;
test(false);
}
obj->shutdown();
manager->startServer();
try
{
obj5->ice_ping();
}
catch(const Ice::LocalException& ex)
{
cerr << ex << endl;
test(false);
}
cout << "ok" << endl;
cout << "testing proxy with unknown identity... " << flush;
try
{
base = communicator->stringToProxy("unknown/unknown");
base->ice_ping();
test(false);
}
catch (const Ice::NotRegisteredException& ex)
{
test(ex.kindOfObject == "object");
test(ex.id == "unknown/unknown");
}
cout << "ok" << endl;
cout << "testing proxy with unknown adapter... " << flush;
try
{
base = communicator->stringToProxy("test @ TestAdapterUnknown");
base->ice_ping();
test(false);
}
catch (const Ice::NotRegisteredException& ex)
{
test(ex.kindOfObject == "object adapter");
test(ex.id == "TestAdapterUnknown");
}
cout << "ok" << endl;
cout << "testing locator cache timeout... " << flush;
int count = locator->getRequestCount();
communicator->stringToProxy("test@TestAdapter")->ice_locatorCacheTimeout(0)->ice_ping(); // No locator cache.
test(++count == locator->getRequestCount());
communicator->stringToProxy("test@TestAdapter")->ice_locatorCacheTimeout(0)->ice_ping(); // No locator cache.
test(++count == locator->getRequestCount());
communicator->stringToProxy("test@TestAdapter")->ice_locatorCacheTimeout(1)->ice_ping(); // 1s timeout.
test(count == locator->getRequestCount());
IceUtil::ThreadControl::sleep(IceUtil::Time::milliSeconds(1300));
communicator->stringToProxy("test@TestAdapter")->ice_locatorCacheTimeout(1)->ice_ping(); // 1s timeout.
test(++count == locator->getRequestCount());
communicator->stringToProxy("test")->ice_locatorCacheTimeout(0)->ice_ping(); // No locator cache.
count += 2;
test(count == locator->getRequestCount());
communicator->stringToProxy("test")->ice_locatorCacheTimeout(1)->ice_ping(); // 1s timeout
test(count == locator->getRequestCount());
IceUtil::ThreadControl::sleep(IceUtil::Time::milliSeconds(1300));
communicator->stringToProxy("test")->ice_locatorCacheTimeout(1)->ice_ping(); // 1s timeout
count += 2;
test(count == locator->getRequestCount());
communicator->stringToProxy("test@TestAdapter")->ice_locatorCacheTimeout(-1)->ice_ping();
test(count == locator->getRequestCount());
communicator->stringToProxy("test")->ice_locatorCacheTimeout(-1)->ice_ping();
test(count == locator->getRequestCount());
communicator->stringToProxy("test@TestAdapter")->ice_ping();
test(count == locator->getRequestCount());
communicator->stringToProxy("test")->ice_ping();
test(count == locator->getRequestCount());
test(communicator->stringToProxy("test")->ice_locatorCacheTimeout(99)->ice_getLocatorCacheTimeout() == 99);
cout << "ok" << endl;
cout << "testing proxy from server... " << flush;
obj = ICE_CHECKED_CAST(TestIntfPrx, communicator->stringToProxy("test@TestAdapter"));
HelloPrxPtr hello = obj->getHello();
test(hello->ice_getAdapterId() == "TestAdapter");
hello->sayHello();
hello = obj->getReplicatedHello();
test(hello->ice_getAdapterId() == "ReplicatedAdapter");
hello->sayHello();
cout << "ok" << endl;
cout << "testing locator request queuing... " << flush;
hello = obj->getReplicatedHello()->ice_locatorCacheTimeout(0)->ice_connectionCached(false);
count = locator->getRequestCount();
hello->ice_ping();
test(++count == locator->getRequestCount());
int i;
#ifdef ICE_CPP11_MAPPING
list<future<void>> results;
for(i = 0; i < 1000; i++)
{
auto result = make_shared<promise<void>>();
hello->sayHello_async(
[result]()
{
result->set_value();
},
[result](exception_ptr)
{
test(false);
});
results.push_back(result->get_future());
}
for(auto& result : results)
{
result.get();
}
results.clear();
test(locator->getRequestCount() > count && locator->getRequestCount() < count + 999);
if(locator->getRequestCount() > count + 800)
{
cout << "queuing = " << locator->getRequestCount() - count;
}
count = locator->getRequestCount();
hello = hello->ice_adapterId("unknown");
for(i = 0; i < 1000; i++)
{
auto result = make_shared<promise<void>>();
hello->sayHello_async(
[result]()
{
test(false);
},
[result](exception_ptr ex)
{
try
{
rethrow_exception(ex);
}
catch(const Ice::NotRegisteredException&)
{
result->set_value();
}
catch(...)
{
test(false);
}
});
results.push_back(result->get_future());
}
for(auto& result : results)
{
result.get();
}
results.clear();
// Take into account the retries.
test(locator->getRequestCount() > count && locator->getRequestCount() < count + 1999);
if(locator->getRequestCount() > count + 800)
{
cout << "queuing = " << locator->getRequestCount() - count;
}
#else
list<Ice::AsyncResultPtr> results;
AMICallbackPtr cb = new AMICallback;
for(i = 0; i < 1000; i++)
{
Ice::AsyncResultPtr result = hello->begin_sayHello(
newCallback_Hello_sayHello(cb, &AMICallback::response1, &AMICallback::exception1));
results.push_back(result);
}
while(!results.empty())
{
Ice::AsyncResultPtr result = results.front();
results.pop_front();
result->waitForCompleted();
}
test(locator->getRequestCount() > count && locator->getRequestCount() < count + 999);
if(locator->getRequestCount() > count + 800)
{
cout << "queuing = " << locator->getRequestCount() - count;
}
count = locator->getRequestCount();
hello = hello->ice_adapterId("unknown");
for(i = 0; i < 1000; i++)
{
Ice::AsyncResultPtr result = hello->begin_sayHello(
newCallback_Hello_sayHello(cb, &AMICallback::response2, &AMICallback::exception2));
results.push_back(result);
}
while(!results.empty())
{
Ice::AsyncResultPtr result = results.front();
results.pop_front();
result->waitForCompleted();
}
// Take into account the retries.
test(locator->getRequestCount() > count && locator->getRequestCount() < count + 1999);
if(locator->getRequestCount() > count + 800)
{
cout << "queuing = " << locator->getRequestCount() - count;
}
#endif
cout << "ok" << endl;
cout << "testing adapter locator cache... " << flush;
try
{
communicator->stringToProxy("test@TestAdapter3")->ice_ping();
test(false);
}
catch(const Ice::NotRegisteredException& ex)
{
test(ex.kindOfObject == "object adapter");
test(ex.id == "TestAdapter3");
}
registry->setAdapterDirectProxy("TestAdapter3", locator->findAdapterById("TestAdapter"));
try
{
communicator->stringToProxy("test@TestAdapter3")->ice_ping();
registry->setAdapterDirectProxy("TestAdapter3", communicator->stringToProxy("dummy:tcp"));
communicator->stringToProxy("test@TestAdapter3")->ice_ping();
}
catch(const Ice::LocalException&)
{
test(false);
}
try
{
communicator->stringToProxy("test@TestAdapter3")->ice_locatorCacheTimeout(0)->ice_ping();
test(false);
}
catch(const Ice::LocalException&)
{
}
try
{
communicator->stringToProxy("test@TestAdapter3")->ice_ping();
test(false);
}
catch(const Ice::LocalException&)
{
}
registry->setAdapterDirectProxy("TestAdapter3", locator->findAdapterById("TestAdapter"));
try
{
communicator->stringToProxy("test@TestAdapter3")->ice_ping();
}
catch(const Ice::LocalException&)
{
test(false);
}
cout << "ok" <<endl;
cout << "testing well-known object locator cache... " << flush;
registry->addObject(communicator->stringToProxy("test3@TestUnknown"));
try
{
communicator->stringToProxy("test3")->ice_ping();
test(false);
}
catch(const Ice::NotRegisteredException& ex)
{
test(ex.kindOfObject == "object adapter");
test(ex.id == "TestUnknown");
}
registry->addObject(communicator->stringToProxy("test3@TestAdapter4")); // Update
registry->setAdapterDirectProxy("TestAdapter4", communicator->stringToProxy("dummy:tcp"));
try
{
communicator->stringToProxy("test3")->ice_ping();
test(false);
}
catch(const Ice::LocalException&)
{
}
registry->setAdapterDirectProxy("TestAdapter4", locator->findAdapterById("TestAdapter"));
try
{
communicator->stringToProxy("test3")->ice_ping();
}
catch(const Ice::LocalException&)
{
test(false);
}
registry->setAdapterDirectProxy("TestAdapter4", communicator->stringToProxy("dummy:tcp"));
try
{
communicator->stringToProxy("test3")->ice_ping();
}
catch(const Ice::LocalException&)
{
test(false);
}
try
{
communicator->stringToProxy("test@TestAdapter4")->ice_locatorCacheTimeout(0)->ice_ping();
test(false);
}
catch(const Ice::LocalException&)
{
}
try
{
communicator->stringToProxy("test@TestAdapter4")->ice_ping();
test(false);
}
catch(const Ice::LocalException&)
{
}
try
{
communicator->stringToProxy("test3")->ice_ping();
test(false);
}
catch(const Ice::LocalException&)
{
}
registry->addObject(communicator->stringToProxy("test3@TestAdapter"));
try
{
communicator->stringToProxy("test3")->ice_ping();
}
catch(const Ice::LocalException&)
{
test(false);
}
registry->addObject(communicator->stringToProxy("test4"));
try
{
communicator->stringToProxy("test4")->ice_ping();
test(false);
}
catch(const Ice::NoEndpointException&)
{
}
cout << "ok" << endl;
cout << "testing locator cache background updates... " << flush;
{
Ice::InitializationData initData;
initData.properties = communicator->getProperties()->clone();
initData.properties->setProperty("Ice.BackgroundLocatorCacheUpdates", "1");
Ice::CommunicatorPtr ic = Ice::initialize(initData);
registry->setAdapterDirectProxy("TestAdapter5", locator->findAdapterById("TestAdapter"));
registry->addObject(communicator->stringToProxy("test3@TestAdapter"));
int count = locator->getRequestCount();
ic->stringToProxy("test@TestAdapter5")->ice_locatorCacheTimeout(0)->ice_ping(); // No locator cache.
ic->stringToProxy("test3")->ice_locatorCacheTimeout(0)->ice_ping(); // No locator cache.
count += 3;
test(count == locator->getRequestCount());
registry->setAdapterDirectProxy("TestAdapter5", 0);
registry->addObject(communicator->stringToProxy("test3:tcp"));
ic->stringToProxy("test@TestAdapter5")->ice_locatorCacheTimeout(10)->ice_ping(); // 10s timeout.
ic->stringToProxy("test3")->ice_locatorCacheTimeout(10)->ice_ping(); // 10s timeout.
test(count == locator->getRequestCount());
IceUtil::ThreadControl::sleep(IceUtil::Time::milliSeconds(1200));
// The following request should trigger the background updates but still use the cached endpoints
// and therefore succeed.
ic->stringToProxy("test@TestAdapter5")->ice_locatorCacheTimeout(1)->ice_ping(); // 1s timeout.
ic->stringToProxy("test3")->ice_locatorCacheTimeout(1)->ice_ping(); // 1s timeout.
try
{
while(true)
{
ic->stringToProxy("test@TestAdapter5")->ice_locatorCacheTimeout(1)->ice_ping(); // 1s timeout.
IceUtil::ThreadControl::sleep(IceUtil::Time::milliSeconds(10));
}
}
catch(const Ice::LocalException&)
{
// Expected to fail once they endpoints have been updated in the background.
}
try
{
while(true)
{
ic->stringToProxy("test3")->ice_locatorCacheTimeout(1)->ice_ping(); // 1s timeout.
IceUtil::ThreadControl::sleep(IceUtil::Time::milliSeconds(10));
}
}
catch(const Ice::LocalException&)
{
// Expected to fail once they endpoints have been updated in the background.
}
ic->destroy();
}
cout << "ok" << endl;
cout << "testing proxy from server after shutdown... " << flush;
hello = obj->getReplicatedHello();
obj->shutdown();
manager->startServer();
hello->sayHello();
cout << "ok" << endl;
cout << "testing object migration... " << flush;
hello = ICE_CHECKED_CAST(HelloPrx, communicator->stringToProxy("hello"));
obj->migrateHello();
hello->ice_getConnection()->close(false);
hello->sayHello();
obj->migrateHello();
hello->sayHello();
obj->migrateHello();
hello->sayHello();
cout << "ok" << endl;
cout << "testing locator encoding resolution... " << flush;
hello = ICE_CHECKED_CAST(HelloPrx, communicator->stringToProxy("hello"));
count = locator->getRequestCount();
communicator->stringToProxy("test@TestAdapter")->ice_encodingVersion(Ice::Encoding_1_1)->ice_ping();
test(count == locator->getRequestCount());
communicator->stringToProxy("test@TestAdapter10")->ice_encodingVersion(Ice::Encoding_1_0)->ice_ping();
test(++count == locator->getRequestCount());
communicator->stringToProxy("test -e 1.0@TestAdapter10-2")->ice_ping();
test(++count == locator->getRequestCount());
cout << "ok" << endl;
cout << "shutdown server... " << flush;
obj->shutdown();
cout << "ok" << endl;
cout << "testing whether server is gone... " << flush;
try
{
obj2->ice_ping();
test(false);
}
catch(const Ice::LocalException&)
{
}
try
{
obj3->ice_ping();
test(false);
}
catch(const Ice::LocalException&)
{
}
try
{
obj5->ice_ping();
test(false);
}
catch(const Ice::LocalException&)
{
}
cout << "ok" << endl;
string host = communicator->getProperties()->getPropertyAsIntWithDefault("Ice.IPv6", 0) == 0 ?
"127.0.0.1" : "\"0:0:0:0:0:0:0:1\"";
if(communicator->getProperties()->getProperty("Ice.Default.Host") == host)
{
cout << "testing indirect proxies to collocated objects... " << flush;
//
// Set up test for calling a collocated object through an indirect, adapterless reference.
//
Ice::PropertiesPtr properties = communicator->getProperties();
properties->setProperty("Ice.PrintAdapterReady", "0");
Ice::ObjectAdapterPtr adapter = communicator->createObjectAdapterWithEndpoints("Hello", "default");
adapter->setLocator(locator);
Ice::Identity id;
id.name = IceUtil::generateUUID();
registry->addObject(adapter->add(ICE_MAKE_SHARED(HelloI), id));
adapter->activate();
HelloPrxPtr helloPrx = ICE_CHECKED_CAST(HelloPrx, communicator->stringToProxy(communicator->identityToString(id)));
test(!helloPrx->ice_getConnection());
adapter->deactivate();
cout << "ok" << endl;
}
cout << "shutdown server manager... " << flush;
manager->shutdown();
cout << "ok" << endl;
}
void
allTests(const Ice::CommunicatorPtr& communicator)
{
string ref = "communicator:" + getTestEndpoint(communicator, 0);
RemoteCommunicatorPrxPtr com = ICE_UNCHECKED_CAST(RemoteCommunicatorPrx, communicator->stringToProxy(ref));
RandomNumberGenerator rng;
cout << "testing binding with single endpoint... " << flush;
{
RemoteObjectAdapterPrxPtr adapter = com->createObjectAdapter("Adapter", "default");
TestIntfPrxPtr test1 = adapter->getTestIntf();
TestIntfPrxPtr test2 = adapter->getTestIntf();
test(test1->ice_getConnection() == test2->ice_getConnection());
test1->ice_ping();
test2->ice_ping();
com->deactivateObjectAdapter(adapter);
TestIntfPrxPtr test3 = ICE_UNCHECKED_CAST(TestIntfPrx, test1);
test(test3->ice_getConnection() == test1->ice_getConnection());
test(test3->ice_getConnection() == test2->ice_getConnection());
try
{
test3->ice_ping();
test(false);
}
catch(const Ice::ConnectFailedException&)
{
}
}
cout << "ok" << endl;
cout << "testing binding with multiple endpoints... " << flush;
{
vector<RemoteObjectAdapterPrxPtr> adapters;
adapters.push_back(com->createObjectAdapter("Adapter11", "default"));
adapters.push_back(com->createObjectAdapter("Adapter12", "default"));
adapters.push_back(com->createObjectAdapter("Adapter13", "default"));
//
// Ensure that when a connection is opened it's reused for new
// proxies and that all endpoints are eventually tried.
//
set<string> names;
names.insert("Adapter11");
names.insert("Adapter12");
names.insert("Adapter13");
while(!names.empty())
{
vector<RemoteObjectAdapterPrxPtr> adpts = adapters;
TestIntfPrxPtr test1 = createTestIntfPrx(adpts);
random_shuffle(adpts.begin(), adpts.end(), rng);
TestIntfPrxPtr test2 = createTestIntfPrx(adpts);
random_shuffle(adpts.begin(), adpts.end(), rng);
TestIntfPrxPtr test3 = createTestIntfPrx(adpts);
test(test1->ice_getConnection() == test2->ice_getConnection());
test(test2->ice_getConnection() == test3->ice_getConnection());
names.erase(test1->getAdapterName());
test1->ice_getConnection()->close(false);
}
//
// Ensure that the proxy correctly caches the connection (we
// always send the request over the same connection.)
//
{
for(vector<RemoteObjectAdapterPrxPtr>::const_iterator p = adapters.begin(); p != adapters.end(); ++p)
{
(*p)->getTestIntf()->ice_ping();
}
TestIntfPrxPtr test = createTestIntfPrx(adapters);
string name = test->getAdapterName();
const int nRetry = 10;
int i;
for(i = 0; i < nRetry && test->getAdapterName() == name; i++);
test(i == nRetry);
for(vector<RemoteObjectAdapterPrxPtr>::const_iterator q = adapters.begin(); q != adapters.end(); ++q)
{
(*q)->getTestIntf()->ice_getConnection()->close(false);
}
}
//
// Deactivate an adapter and ensure that we can still
// establish the connection to the remaining adapters.
//
com->deactivateObjectAdapter(adapters[0]);
names.insert("Adapter12");
names.insert("Adapter13");
while(!names.empty())
{
vector<RemoteObjectAdapterPrxPtr> adpts = adapters;
TestIntfPrxPtr test1 = createTestIntfPrx(adpts);
random_shuffle(adpts.begin(), adpts.end(), rng);
TestIntfPrxPtr test2 = createTestIntfPrx(adpts);
random_shuffle(adpts.begin(), adpts.end(), rng);
TestIntfPrxPtr test3 = createTestIntfPrx(adpts);
test(test1->ice_getConnection() == test2->ice_getConnection());
test(test2->ice_getConnection() == test3->ice_getConnection());
names.erase(test1->getAdapterName());
test1->ice_getConnection()->close(false);
}
//
// Deactivate an adapter and ensure that we can still
// establish the connection to the remaining adapter.
//
com->deactivateObjectAdapter(adapters[2]);
TestIntfPrxPtr test = createTestIntfPrx(adapters);
test(test->getAdapterName() == "Adapter12");
deactivate(com, adapters);
}
cout << "ok" << endl;
cout << "testing binding with multiple random endpoints... " << flush;
{
vector<RemoteObjectAdapterPrxPtr> adapters;
adapters.push_back(com->createObjectAdapter("AdapterRandom11", "default"));
adapters.push_back(com->createObjectAdapter("AdapterRandom12", "default"));
adapters.push_back(com->createObjectAdapter("AdapterRandom13", "default"));
adapters.push_back(com->createObjectAdapter("AdapterRandom14", "default"));
adapters.push_back(com->createObjectAdapter("AdapterRandom15", "default"));
#ifdef _WIN32
int count = 60;
#else
int count = 20;
#endif
int adapterCount = static_cast<int>(adapters.size());
while(--count > 0)
{
#ifdef _WIN32
if(count == 10)
{
com->deactivateObjectAdapter(adapters[4]);
--adapterCount;
}
vector<TestIntfPrxPtr> proxies;
proxies.resize(10);
#else
if(count < 60 && count % 10 == 0)
{
com->deactivateObjectAdapter(adapters[count / 10 - 1]);
--adapterCount;
}
vector<TestIntfPrxPtr> proxies;
proxies.resize(40);
#endif
unsigned int i;
for(i = 0; i < proxies.size(); ++i)
{
vector<RemoteObjectAdapterPrxPtr> adpts;
adpts.resize(IceUtilInternal::random(static_cast<int>(adapters.size())));
if(adpts.empty())
{
adpts.resize(1);
}
for(vector<RemoteObjectAdapterPrxPtr>::iterator p = adpts.begin(); p != adpts.end(); ++p)
{
*p = adapters[IceUtilInternal::random(static_cast<int>(adapters.size()))];
}
proxies[i] = createTestIntfPrx(adpts);
}
for(i = 0; i < proxies.size(); i++)
{
#ifdef ICE_CPP11_MAPPING
proxies[i]->getAdapterName_async();
#else
proxies[i]->begin_getAdapterName();
#endif
}
for(i = 0; i < proxies.size(); i++)
{
try
{
proxies[i]->ice_ping();
}
catch(const Ice::LocalException&)
{
}
}
set<Ice::ConnectionPtr> connections;
for(i = 0; i < proxies.size(); i++)
{
if(proxies[i]->ice_getCachedConnection())
{
connections.insert(proxies[i]->ice_getCachedConnection());
}
}
test(static_cast<int>(connections.size()) <= adapterCount);
for(vector<RemoteObjectAdapterPrxPtr>::const_iterator q = adapters.begin(); q != adapters.end(); ++q)
{
try
{
(*q)->getTestIntf()->ice_getConnection()->close(false);
}
catch(const Ice::LocalException&)
{
// Expected if adapter is down.
}
}
}
}
cout << "ok" << endl;
cout << "testing binding with multiple endpoints and AMI... " << flush;
{
vector<RemoteObjectAdapterPrxPtr> adapters;
adapters.push_back(com->createObjectAdapter("AdapterAMI11", "default"));
adapters.push_back(com->createObjectAdapter("AdapterAMI12", "default"));
adapters.push_back(com->createObjectAdapter("AdapterAMI13", "default"));
//
// Ensure that when a connection is opened it's reused for new
// proxies and that all endpoints are eventually tried.
//
set<string> names;
names.insert("AdapterAMI11");
names.insert("AdapterAMI12");
names.insert("AdapterAMI13");
while(!names.empty())
{
vector<RemoteObjectAdapterPrxPtr> adpts = adapters;
TestIntfPrxPtr test1 = createTestIntfPrx(adpts);
random_shuffle(adpts.begin(), adpts.end(), rng);
TestIntfPrxPtr test2 = createTestIntfPrx(adpts);
random_shuffle(adpts.begin(), adpts.end(), rng);
TestIntfPrxPtr test3 = createTestIntfPrx(adpts);
test(test1->ice_getConnection() == test2->ice_getConnection());
test(test2->ice_getConnection() == test3->ice_getConnection());
names.erase(getAdapterNameWithAMI(test1));
test1->ice_getConnection()->close(false);
}
//
// Ensure that the proxy correctly caches the connection (we
// always send the request over the same connection.)
//
{
for(vector<RemoteObjectAdapterPrxPtr>::const_iterator p = adapters.begin(); p != adapters.end(); ++p)
{
(*p)->getTestIntf()->ice_ping();
}
TestIntfPrxPtr test = createTestIntfPrx(adapters);
string name = getAdapterNameWithAMI(test);
const int nRetry = 10;
int i;
for(i = 0; i < nRetry && getAdapterNameWithAMI(test) == name; i++);
test(i == nRetry);
for(vector<RemoteObjectAdapterPrxPtr>::const_iterator q = adapters.begin(); q != adapters.end(); ++q)
{
(*q)->getTestIntf()->ice_getConnection()->close(false);
}
}
//
// Deactivate an adapter and ensure that we can still
// establish the connection to the remaining adapters.
//
com->deactivateObjectAdapter(adapters[0]);
names.insert("AdapterAMI12");
names.insert("AdapterAMI13");
while(!names.empty())
{
vector<RemoteObjectAdapterPrxPtr> adpts = adapters;
TestIntfPrxPtr test1 = createTestIntfPrx(adpts);
random_shuffle(adpts.begin(), adpts.end(), rng);
TestIntfPrxPtr test2 = createTestIntfPrx(adpts);
random_shuffle(adpts.begin(), adpts.end(), rng);
TestIntfPrxPtr test3 = createTestIntfPrx(adpts);
test(test1->ice_getConnection() == test2->ice_getConnection());
test(test2->ice_getConnection() == test3->ice_getConnection());
names.erase(test1->getAdapterName());
test1->ice_getConnection()->close(false);
}
//
// Deactivate an adapter and ensure that we can still
// establish the connection to the remaining adapter.
//
com->deactivateObjectAdapter(adapters[2]);
TestIntfPrxPtr test = createTestIntfPrx(adapters);
test(test->getAdapterName() == "AdapterAMI12");
deactivate(com, adapters);
}
cout << "ok" << endl;
cout << "testing random endpoint selection... " << flush;
{
vector<RemoteObjectAdapterPrxPtr> adapters;
adapters.push_back(com->createObjectAdapter("Adapter21", "default"));
adapters.push_back(com->createObjectAdapter("Adapter22", "default"));
adapters.push_back(com->createObjectAdapter("Adapter23", "default"));
TestIntfPrxPtr test = createTestIntfPrx(adapters);
test(test->ice_getEndpointSelection() == Ice::Random);
set<string> names;
names.insert("Adapter21");
names.insert("Adapter22");
names.insert("Adapter23");
while(!names.empty())
{
names.erase(test->getAdapterName());
test->ice_getConnection()->close(false);
}
test = ICE_UNCHECKED_CAST(TestIntfPrx, test->ice_endpointSelection(Ice::Random));
test(test->ice_getEndpointSelection() == Ice::Random);
names.insert("Adapter21");
names.insert("Adapter22");
names.insert("Adapter23");
while(!names.empty())
{
names.erase(test->getAdapterName());
test->ice_getConnection()->close(false);
}
deactivate(com, adapters);
}
cout << "ok" << endl;
cout << "testing ordered endpoint selection... " << flush;
{
vector<RemoteObjectAdapterPrxPtr> adapters;
adapters.push_back(com->createObjectAdapter("Adapter31", "default"));
adapters.push_back(com->createObjectAdapter("Adapter32", "default"));
adapters.push_back(com->createObjectAdapter("Adapter33", "default"));
TestIntfPrxPtr test = createTestIntfPrx(adapters);
test = ICE_UNCHECKED_CAST(TestIntfPrx, test->ice_endpointSelection(Ice::Ordered));
test(test->ice_getEndpointSelection() == Ice::Ordered);
const int nRetry = 5;
int i;
//
// Ensure that endpoints are tried in order by deactiving the adapters
// one after the other.
//
for(i = 0; i < nRetry && test->getAdapterName() == "Adapter31"; i++);
#if TARGET_OS_IPHONE > 0
if(i != nRetry)
{
test->ice_getConnection()->close(false);
for(i = 0; i < nRetry && test->getAdapterName() == "Adapter31"; i++);
}
#endif
test(i == nRetry);
com->deactivateObjectAdapter(adapters[0]);
for(i = 0; i < nRetry && test->getAdapterName() == "Adapter32"; i++);
#if TARGET_OS_IPHONE > 0
if(i != nRetry)
{
test->ice_getConnection()->close(false);
for(i = 0; i < nRetry && test->getAdapterName() == "Adapter32"; i++);
}
#endif
test(i == nRetry);
com->deactivateObjectAdapter(adapters[1]);
for(i = 0; i < nRetry && test->getAdapterName() == "Adapter33"; i++);
#if TARGET_OS_IPHONE > 0
if(i != nRetry)
{
test->ice_getConnection()->close(false);
for(i = 0; i < nRetry && test->getAdapterName() == "Adapter33"; i++);
}
#endif
test(i == nRetry);
com->deactivateObjectAdapter(adapters[2]);
try
{
test->getAdapterName();
}
catch(const Ice::ConnectFailedException&)
{
}
Ice::EndpointSeq endpoints = test->ice_getEndpoints();
adapters.clear();
//
// Now, re-activate the adapters with the same endpoints in the opposite
// order.
//
adapters.push_back(com->createObjectAdapter("Adapter36", endpoints[2]->toString()));
for(i = 0; i < nRetry && test->getAdapterName() == "Adapter36"; i++);
#if TARGET_OS_IPHONE > 0
if(i != nRetry)
{
test->ice_getConnection()->close(false);
for(i = 0; i < nRetry && test->getAdapterName() == "Adapter36"; i++);
}
#endif
test(i == nRetry);
test->ice_getConnection()->close(false);
adapters.push_back(com->createObjectAdapter("Adapter35", endpoints[1]->toString()));
for(i = 0; i < nRetry && test->getAdapterName() == "Adapter35"; i++);
#if TARGET_OS_IPHONE > 0
if(i != nRetry)
{
test->ice_getConnection()->close(false);
for(i = 0; i < nRetry && test->getAdapterName() == "Adapter35"; i++);
}
#endif
test(i == nRetry);
test->ice_getConnection()->close(false);
adapters.push_back(com->createObjectAdapter("Adapter34", endpoints[0]->toString()));
for(i = 0; i < nRetry && test->getAdapterName() == "Adapter34"; i++);
#if TARGET_OS_IPHONE > 0
if(i != nRetry)
{
test->ice_getConnection()->close(false);
for(i = 0; i < nRetry && test->getAdapterName() == "Adapter34"; i++);
}
#endif
test(i == nRetry);
deactivate(com, adapters);
}
cout << "ok" << endl;
cout << "testing per request binding with single endpoint... " << flush;
{
RemoteObjectAdapterPrxPtr adapter = com->createObjectAdapter("Adapter41", "default");
TestIntfPrxPtr test1 = ICE_UNCHECKED_CAST(TestIntfPrx, adapter->getTestIntf()->ice_connectionCached(false));
TestIntfPrxPtr test2 = ICE_UNCHECKED_CAST(TestIntfPrx, adapter->getTestIntf()->ice_connectionCached(false));
test(!test1->ice_isConnectionCached());
test(!test2->ice_isConnectionCached());
test(test1->ice_getConnection() == test2->ice_getConnection());
test1->ice_ping();
com->deactivateObjectAdapter(adapter);
TestIntfPrxPtr test3 = ICE_UNCHECKED_CAST(TestIntfPrx, test1);
try
{
test(test3->ice_getConnection() == test1->ice_getConnection());
test(false);
}
catch(const Ice::ConnectFailedException&)
{
}
}
cout << "ok" << endl;
cout << "testing per request binding with multiple endpoints... " << flush;
{
vector<RemoteObjectAdapterPrxPtr> adapters;
adapters.push_back(com->createObjectAdapter("Adapter51", "default"));
adapters.push_back(com->createObjectAdapter("Adapter52", "default"));
adapters.push_back(com->createObjectAdapter("Adapter53", "default"));
TestIntfPrxPtr test = ICE_UNCHECKED_CAST(TestIntfPrx, createTestIntfPrx(adapters)->ice_connectionCached(false));
test(!test->ice_isConnectionCached());
set<string> names;
names.insert("Adapter51");
names.insert("Adapter52");
names.insert("Adapter53");
while(!names.empty())
{
names.erase(test->getAdapterName());
}
com->deactivateObjectAdapter(adapters[0]);
names.insert("Adapter52");
names.insert("Adapter53");
while(!names.empty())
{
names.erase(test->getAdapterName());
}
com->deactivateObjectAdapter(adapters[2]);
test(test->getAdapterName() == "Adapter52");
deactivate(com, adapters);
}
cout << "ok" << endl;
cout << "testing per request binding with multiple endpoints and AMI... " << flush;
{
vector<RemoteObjectAdapterPrxPtr> adapters;
adapters.push_back(com->createObjectAdapter("AdapterAMI51", "default"));
adapters.push_back(com->createObjectAdapter("AdapterAMI52", "default"));
adapters.push_back(com->createObjectAdapter("AdapterAMI53", "default"));
TestIntfPrxPtr test = ICE_UNCHECKED_CAST(TestIntfPrx, createTestIntfPrx(adapters)->ice_connectionCached(false));
test(!test->ice_isConnectionCached());
set<string> names;
names.insert("AdapterAMI51");
names.insert("AdapterAMI52");
names.insert("AdapterAMI53");
while(!names.empty())
{
names.erase(getAdapterNameWithAMI(test));
}
com->deactivateObjectAdapter(adapters[0]);
names.insert("AdapterAMI52");
names.insert("AdapterAMI53");
while(!names.empty())
{
names.erase(getAdapterNameWithAMI(test));
}
com->deactivateObjectAdapter(adapters[2]);
test(test->getAdapterName() == "AdapterAMI52");
deactivate(com, adapters);
}
cout << "ok" << endl;
cout << "testing per request binding and ordered endpoint selection... " << flush;
{
vector<RemoteObjectAdapterPrxPtr> adapters;
adapters.push_back(com->createObjectAdapter("Adapter61", "default"));
adapters.push_back(com->createObjectAdapter("Adapter62", "default"));
adapters.push_back(com->createObjectAdapter("Adapter63", "default"));
TestIntfPrxPtr test = createTestIntfPrx(adapters);
test = ICE_UNCHECKED_CAST(TestIntfPrx, test->ice_endpointSelection(Ice::Ordered));
test(test->ice_getEndpointSelection() == Ice::Ordered);
test = ICE_UNCHECKED_CAST(TestIntfPrx, test->ice_connectionCached(false));
test(!test->ice_isConnectionCached());
const int nRetry = 5;
int i;
//
// Ensure that endpoints are tried in order by deactiving the adapters
// one after the other.
//
for(i = 0; i < nRetry && test->getAdapterName() == "Adapter61"; i++);
#if TARGET_OS_IPHONE > 0
test(i >= nRetry - 1); // WORKAROUND: for connection establishment hang.
#else
test(i == nRetry);
#endif
com->deactivateObjectAdapter(adapters[0]);
for(i = 0; i < nRetry && test->getAdapterName() == "Adapter62"; i++);
#if TARGET_OS_IPHONE > 0
test(i >= nRetry - 1); // WORKAROUND: for connection establishment hang.
#else
test(i == nRetry);
#endif
com->deactivateObjectAdapter(adapters[1]);
for(i = 0; i < nRetry && test->getAdapterName() == "Adapter63"; i++);
#if TARGET_OS_IPHONE > 0
test(i >= nRetry - 1); // WORKAROUND: for connection establishment hang.
#else
test(i == nRetry);
#endif
com->deactivateObjectAdapter(adapters[2]);
try
{
test->getAdapterName();
}
catch(const Ice::ConnectFailedException&)
{
}
Ice::EndpointSeq endpoints = test->ice_getEndpoints();
adapters.clear();
//
// Now, re-activate the adapters with the same endpoints in the opposite
// order.
//
adapters.push_back(com->createObjectAdapter("Adapter66", endpoints[2]->toString()));
for(i = 0; i < nRetry && test->getAdapterName() == "Adapter66"; i++);
#if TARGET_OS_IPHONE > 0
test(i >= nRetry - 1); // WORKAROUND: for connection establishment hang.
#else
test(i == nRetry);
#endif
adapters.push_back(com->createObjectAdapter("Adapter65", endpoints[1]->toString()));
for(i = 0; i < nRetry && test->getAdapterName() == "Adapter65"; i++);
#if TARGET_OS_IPHONE > 0
test(i >= nRetry - 1); // WORKAROUND: for connection establishment hang.
#else
test(i == nRetry);
#endif
adapters.push_back(com->createObjectAdapter("Adapter64", endpoints[0]->toString()));
for(i = 0; i < nRetry && test->getAdapterName() == "Adapter64"; i++);
#if TARGET_OS_IPHONE > 0
test(i >= nRetry - 1); // WORKAROUND: for connection establishment hang.
#else
test(i == nRetry);
#endif
deactivate(com, adapters);
}
cout << "ok" << endl;
cout << "testing per request binding and ordered endpoint selection and AMI... " << flush;
{
vector<RemoteObjectAdapterPrxPtr> adapters;
adapters.push_back(com->createObjectAdapter("AdapterAMI61", "default"));
adapters.push_back(com->createObjectAdapter("AdapterAMI62", "default"));
adapters.push_back(com->createObjectAdapter("AdapterAMI63", "default"));
TestIntfPrxPtr test = createTestIntfPrx(adapters);
test = ICE_UNCHECKED_CAST(TestIntfPrx, test->ice_endpointSelection(Ice::Ordered));
test(test->ice_getEndpointSelection() == Ice::Ordered);
test = ICE_UNCHECKED_CAST(TestIntfPrx, test->ice_connectionCached(false));
test(!test->ice_isConnectionCached());
const int nRetry = 5;
int i;
//
// Ensure that endpoints are tried in order by deactiving the adapters
// one after the other.
//
for(i = 0; i < nRetry && getAdapterNameWithAMI(test) == "AdapterAMI61"; i++);
#if TARGET_OS_IPHONE > 0
test(i >= nRetry - 1); // WORKAROUND: for connection establishment hang.
#else
test(i == nRetry);
#endif
com->deactivateObjectAdapter(adapters[0]);
for(i = 0; i < nRetry && getAdapterNameWithAMI(test) == "AdapterAMI62"; i++);
#if TARGET_OS_IPHONE > 0
test(i >= nRetry - 1); // WORKAROUND: for connection establishment hang.
#else
test(i == nRetry);
#endif
com->deactivateObjectAdapter(adapters[1]);
for(i = 0; i < nRetry && getAdapterNameWithAMI(test) == "AdapterAMI63"; i++);
#if TARGET_OS_IPHONE > 0
test(i >= nRetry - 1); // WORKAROUND: for connection establishment hang.
#else
test(i == nRetry);
#endif
com->deactivateObjectAdapter(adapters[2]);
try
{
test->getAdapterName();
}
catch(const Ice::ConnectFailedException&)
{
}
Ice::EndpointSeq endpoints = test->ice_getEndpoints();
adapters.clear();
//
// Now, re-activate the adapters with the same endpoints in the opposite
// order.
//
adapters.push_back(com->createObjectAdapter("AdapterAMI66", endpoints[2]->toString()));
for(i = 0; i < nRetry && getAdapterNameWithAMI(test) == "AdapterAMI66"; i++);
#if TARGET_OS_IPHONE > 0
test(i >= nRetry - 1); // WORKAROUND: for connection establishment hang.
#else
test(i == nRetry);
#endif
adapters.push_back(com->createObjectAdapter("AdapterAMI65", endpoints[1]->toString()));
for(i = 0; i < nRetry && getAdapterNameWithAMI(test) == "AdapterAMI65"; i++);
test(i == nRetry);
adapters.push_back(com->createObjectAdapter("AdapterAMI64", endpoints[0]->toString()));
for(i = 0; i < nRetry && getAdapterNameWithAMI(test) == "AdapterAMI64"; i++);
test(i == nRetry);
deactivate(com, adapters);
}
cout << "ok" << endl;
cout << "testing endpoint mode filtering... " << flush;
{
vector<RemoteObjectAdapterPrxPtr> adapters;
adapters.push_back(com->createObjectAdapter("Adapter71", "default"));
adapters.push_back(com->createObjectAdapter("Adapter72", "udp"));
TestIntfPrxPtr test = createTestIntfPrx(adapters);
test(test->getAdapterName() == "Adapter71");
TestIntfPrxPtr testUDP = ICE_UNCHECKED_CAST(TestIntfPrx, test->ice_datagram());
test(test->ice_getConnection() != testUDP->ice_getConnection());
try
{
testUDP->getAdapterName();
}
catch(const Ice::TwowayOnlyException&)
{
}
catch(const IceUtil::IllegalArgumentException&)
{
}
}
cout << "ok" << endl;
if(!communicator->getProperties()->getProperty("Ice.Plugin.IceSSL").empty() &&
communicator->getProperties()->getProperty("Ice.Default.Protocol") == "ssl")
{
cout << "testing unsecure vs. secure endpoints... " << flush;
{
vector<RemoteObjectAdapterPrxPtr> adapters;
adapters.push_back(com->createObjectAdapter("Adapter81", "ssl"));
adapters.push_back(com->createObjectAdapter("Adapter82", "tcp"));
TestIntfPrxPtr test = createTestIntfPrx(adapters);
int i;
for(i = 0; i < 5; i++)
{
test(test->getAdapterName() == "Adapter82");
test->ice_getConnection()->close(false);
}
TestIntfPrxPtr testSecure = ICE_UNCHECKED_CAST(TestIntfPrx, test->ice_secure(true));
test(testSecure->ice_isSecure());
testSecure = ICE_UNCHECKED_CAST(TestIntfPrx, test->ice_secure(false));
test(!testSecure->ice_isSecure());
testSecure = ICE_UNCHECKED_CAST(TestIntfPrx, test->ice_secure(true));
test(testSecure->ice_isSecure());
test(test->ice_getConnection() != testSecure->ice_getConnection());
com->deactivateObjectAdapter(adapters[1]);
for(i = 0; i < 5; i++)
{
test(test->getAdapterName() == "Adapter81");
test->ice_getConnection()->close(false);
}
com->createObjectAdapter("Adapter83", (test->ice_getEndpoints()[1])->toString()); // Reactive tcp OA.
for(i = 0; i < 5; i++)
{
test(test->getAdapterName() == "Adapter83");
test->ice_getConnection()->close(false);
}
com->deactivateObjectAdapter(adapters[0]);
try
{
testSecure->ice_ping();
test(false);
}
catch(const Ice::ConnectFailedException&)
{
}
deactivate(com, adapters);
}
cout << "ok" << endl;
}
{
cout << "testing ipv4 & ipv6 connections... " << flush;
Ice::PropertiesPtr ipv4 = Ice::createProperties();
ipv4->setProperty("Ice.IPv4", "1");
ipv4->setProperty("Ice.IPv6", "0");
ipv4->setProperty("Adapter.Endpoints", "tcp -h localhost");
Ice::PropertiesPtr ipv6 = Ice::createProperties();
ipv6->setProperty("Ice.IPv4", "0");
ipv6->setProperty("Ice.IPv6", "1");
ipv6->setProperty("Adapter.Endpoints", "tcp -h localhost");
Ice::PropertiesPtr bothPreferIPv4 = Ice::createProperties();
bothPreferIPv4->setProperty("Ice.IPv4", "1");
bothPreferIPv4->setProperty("Ice.IPv6", "1");
bothPreferIPv4->setProperty("Ice.PreferIPv6Address", "0");
bothPreferIPv4->setProperty("Adapter.Endpoints", "tcp -h localhost");
Ice::PropertiesPtr bothPreferIPv6 = Ice::createProperties();
bothPreferIPv6->setProperty("Ice.IPv4", "1");
bothPreferIPv6->setProperty("Ice.IPv6", "1");
bothPreferIPv6->setProperty("Ice.PreferIPv6Address", "1");
bothPreferIPv6->setProperty("Adapter.Endpoints", "tcp -h localhost");
vector<Ice::PropertiesPtr> clientProps;
clientProps.push_back(ipv4);
clientProps.push_back(ipv6);
clientProps.push_back(bothPreferIPv4);
clientProps.push_back(bothPreferIPv6);
Ice::PropertiesPtr anyipv4 = ipv4->clone();
anyipv4->setProperty("Adapter.Endpoints", "tcp -p 12012");
anyipv4->setProperty("Adapter.PublishedEndpoints", "tcp -h 127.0.0.1 -p 12012");
Ice::PropertiesPtr anyipv6 = ipv6->clone();
anyipv6->setProperty("Adapter.Endpoints", "tcp -p 12012");
anyipv6->setProperty("Adapter.PublishedEndpoints", "tcp -h \"::1\" -p 12012");
Ice::PropertiesPtr anyboth = Ice::createProperties();
anyboth->setProperty("Ice.IPv4", "1");
anyboth->setProperty("Ice.IPv6", "1");
anyboth->setProperty("Adapter.Endpoints", "tcp -p 12012");
anyboth->setProperty("Adapter.PublishedEndpoints", "tcp -h \"::1\" -p 12012:tcp -h 127.0.0.1 -p 12012");
Ice::PropertiesPtr localipv4 = ipv4->clone();
localipv4->setProperty("Adapter.Endpoints", "tcp -h 127.0.0.1");
Ice::PropertiesPtr localipv6 = ipv6->clone();
localipv6->setProperty("Adapter.Endpoints", "tcp -h \"::1\"");
vector<Ice::PropertiesPtr> serverProps = clientProps;
serverProps.push_back(anyipv4);
serverProps.push_back(anyipv6);
serverProps.push_back(anyboth);
serverProps.push_back(localipv4);
serverProps.push_back(localipv6);
#if defined(_WIN32) && !defined(ICE_OS_WINRT)
OSVERSIONINFO ver;
ver.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
# if defined(_MSC_VER) && _MSC_VER >= 1800
# pragma warning (disable : 4996)
# endif
GetVersionEx(&ver);
# if defined(_MSC_VER) && _MSC_VER >= 1800
# pragma warning (default : 4996)
# endif
const bool dualStack = ver.dwMajorVersion >= 6; // Windows XP IPv6 doesn't support dual-stack
#else
const bool dualStack = true;
#endif
bool ipv6NotSupported = false;
for(vector<Ice::PropertiesPtr>::const_iterator p = serverProps.begin(); p != serverProps.end(); ++p)
{
Ice::InitializationData serverInitData;
serverInitData.properties = *p;
Ice::CommunicatorPtr serverCommunicator = Ice::initialize(serverInitData);
Ice::ObjectAdapterPtr oa;
try
{
oa = serverCommunicator->createObjectAdapter("Adapter");
oa->activate();
}
catch(const Ice::DNSException&)
{
serverCommunicator->destroy();
continue; // IP version not supported.
}
catch(const Ice::SocketException&)
{
if(*p == ipv6)
{
ipv6NotSupported = true;
}
serverCommunicator->destroy();
continue; // IP version not supported.
}
// Ensure the published endpoints are actually valid. On
// Fedora, binding to "localhost" with IPv6 only works but
// resolving localhost don't return the IPv6 adress.
Ice::ObjectPrxPtr prx = oa->createProxy(serverCommunicator->stringToIdentity("dummy"));
try
{
prx->ice_collocationOptimized(false)->ice_ping();
}
catch(const Ice::LocalException&)
{
serverCommunicator->destroy();
continue; // IP version not supported.
}
string strPrx = prx->ice_toString();
for(vector<Ice::PropertiesPtr>::const_iterator q = clientProps.begin(); q != clientProps.end(); ++q)
{
Ice::InitializationData clientInitData;
clientInitData.properties = *q;
Ice::CommunicatorHolder clientCommunicator = Ice::initialize(clientInitData);
Ice::ObjectPrxPtr prx = clientCommunicator->stringToProxy(strPrx);
try
{
prx->ice_ping();
test(false);
}
catch(const Ice::ObjectNotExistException&)
{
// Expected, no object registered.
}
catch(const Ice::DNSException&)
{
// Expected if no IPv4 or IPv6 address is
// associated to localhost or if trying to connect
// to an any endpoint with the wrong IP version,
// e.g.: resolving an IPv4 address when only IPv6
// is enabled fails with a DNS exception.
}
catch(const Ice::SocketException&)
{
test((*p == ipv4 && *q == ipv6) || (*p == ipv6 && *q == ipv4) ||
(*p == bothPreferIPv4 && *q == ipv6) || (*p == bothPreferIPv6 && *q == ipv4) ||
(*p == bothPreferIPv6 && *q == ipv6 && ipv6NotSupported) ||
(*p == anyipv4 && *q == ipv6) || (*p == anyipv6 && *q == ipv4) ||
(*p == anyboth && *q == ipv4 && !dualStack) ||
(*p == localipv4 && *q == ipv6) || (*p == localipv6 && *q == ipv4) ||
(*p == ipv6 && *q == bothPreferIPv4) || (*p == ipv6 && *q == bothPreferIPv6) ||
(*p == bothPreferIPv6 && *q == ipv6));
}
}
serverCommunicator->destroy();
}
cout << "ok" << endl;
}
com->shutdown();
}
GPrxPtr
allTests(const Ice::CommunicatorPtr& communicator)
{
#ifdef ICE_OS_UWP
bool uwp = true;
#else
bool uwp = false;
#endif
cout << "testing Ice.Admin.Facets property... " << flush;
test(communicator->getProperties()->getPropertyAsList("Ice.Admin.Facets").empty());
communicator->getProperties()->setProperty("Ice.Admin.Facets", "foobar");
Ice::StringSeq facetFilter = communicator->getProperties()->getPropertyAsList("Ice.Admin.Facets");
test(facetFilter.size() == 1 && facetFilter[0] == "foobar");
communicator->getProperties()->setProperty("Ice.Admin.Facets", "foo\\'bar");
facetFilter = communicator->getProperties()->getPropertyAsList("Ice.Admin.Facets");
test(facetFilter.size() == 1 && facetFilter[0] == "foo'bar");
communicator->getProperties()->setProperty("Ice.Admin.Facets", "'foo bar' toto 'titi'");
facetFilter = communicator->getProperties()->getPropertyAsList("Ice.Admin.Facets");
test(facetFilter.size() == 3 && facetFilter[0] == "foo bar" && facetFilter[1] == "toto" &&
facetFilter[2] == "titi");
communicator->getProperties()->setProperty("Ice.Admin.Facets", "'foo bar\\' toto' 'titi'");
facetFilter = communicator->getProperties()->getPropertyAsList("Ice.Admin.Facets");
test(facetFilter.size() == 2 && facetFilter[0] == "foo bar' toto" && facetFilter[1] == "titi");
// communicator->getProperties()->setProperty("Ice.Admin.Facets", "'foo bar' 'toto titi");
// facetFilter = communicator->getProperties()->getPropertyAsList("Ice.Admin.Facets");
// test(facetFilter.size() == 0);
communicator->getProperties()->setProperty("Ice.Admin.Facets", "");
cout << "ok" << endl;
cout << "testing facet registration exceptions... " << flush;
string localOAEndpoint;
{
ostringstream ostr;
if(communicator->getProperties()->getProperty("Ice.Default.Protocol") == "bt")
{
ostr << "default -a *";
}
else
{
ostr << "default -h *";
}
localOAEndpoint = ostr.str();
}
communicator->getProperties()->setProperty("FacetExceptionTestAdapter.Endpoints", localOAEndpoint);
if(uwp || (communicator->getProperties()->getProperty("Ice.Default.Protocol") != "ssl" &&
communicator->getProperties()->getProperty("Ice.Default.Protocol") != "wss"))
{
Ice::ObjectAdapterPtr adapter = communicator->createObjectAdapter("FacetExceptionTestAdapter");
Ice::ObjectPtr obj = ICE_MAKE_SHARED(EmptyI);
adapter->add(obj, Ice::stringToIdentity("d"));
adapter->addFacet(obj, Ice::stringToIdentity("d"), "facetABCD");
try
{
adapter->addFacet(obj, Ice::stringToIdentity("d"), "facetABCD");
test(false);
}
catch(const Ice::AlreadyRegisteredException&)
{
}
adapter->removeFacet(Ice::stringToIdentity("d"), "facetABCD");
try
{
adapter->removeFacet(Ice::stringToIdentity("d"), "facetABCD");
test(false);
}
catch(const Ice::NotRegisteredException&)
{
}
cout << "ok" << endl;
cout << "testing removeAllFacets... " << flush;
Ice::ObjectPtr obj1 = ICE_MAKE_SHARED(EmptyI);
Ice::ObjectPtr obj2 = ICE_MAKE_SHARED(EmptyI);
adapter->addFacet(obj1, Ice::stringToIdentity("id1"), "f1");
adapter->addFacet(obj2, Ice::stringToIdentity("id1"), "f2");
Ice::ObjectPtr obj3 = ICE_MAKE_SHARED(EmptyI);
adapter->addFacet(obj1, Ice::stringToIdentity("id2"), "f1");
adapter->addFacet(obj2, Ice::stringToIdentity("id2"), "f2");
adapter->addFacet(obj3, Ice::stringToIdentity("id2"), "");
Ice::FacetMap fm = adapter->removeAllFacets(Ice::stringToIdentity("id1"));
test(fm.size() == 2);
test(fm["f1"] == obj1);
test(fm["f2"] == obj2);
try
{
adapter->removeAllFacets(Ice::stringToIdentity("id1"));
test(false);
}
catch(const Ice::NotRegisteredException&)
{
}
fm = adapter->removeAllFacets(Ice::stringToIdentity("id2"));
test(fm.size() == 3);
test(fm["f1"] == obj1);
test(fm["f2"] == obj2);
test(fm[""] == obj3);
cout << "ok" << endl;
adapter->deactivate();
}
cout << "testing stringToProxy... " << flush;
string ref = "d:" + getTestEndpoint(communicator, 0);
Ice::ObjectPrxPtr db = communicator->stringToProxy(ref);
test(db);
cout << "ok" << endl;
cout << "testing unchecked cast... " << flush;
Ice::ObjectPrxPtr prx = ICE_UNCHECKED_CAST(Ice::ObjectPrx, db);
test(prx->ice_getFacet().empty());
#ifdef ICE_CPP11_MAPPING
prx = Ice::uncheckedCast<Ice::ObjectPrx>(db, "facetABCD");
#else
prx = Ice::ObjectPrx::uncheckedCast(db, "facetABCD");
#endif
test(prx->ice_getFacet() == "facetABCD");
Ice::ObjectPrxPtr prx2 = ICE_UNCHECKED_CAST(Ice::ObjectPrx, prx);
test(prx2->ice_getFacet() == "facetABCD");
#ifdef ICE_CPP11_MAPPING
shared_ptr<Ice::ObjectPrx> prx3 = Ice::uncheckedCast<Ice::ObjectPrx>(prx, "");
#else
Ice::ObjectPrx prx3 = Ice::ObjectPrx::uncheckedCast(prx, "");
#endif
test(prx3->ice_getFacet().empty());
DPrxPtr d = ICE_UNCHECKED_CAST(Test::DPrx, db);
test(d->ice_getFacet().empty());
#ifdef ICE_CPP11_MAPPING
shared_ptr<DPrx> df = Ice::uncheckedCast<Test::DPrx>(db, "facetABCD");
#else
DPrx df = Test::DPrx::uncheckedCast(db, "facetABCD");
#endif
test(df->ice_getFacet() == "facetABCD");
DPrxPtr df2 = ICE_UNCHECKED_CAST(Test::DPrx, df);
test(df2->ice_getFacet() == "facetABCD");
#ifdef ICE_CPP11_MAPPING
shared_ptr<DPrx> df3 = Ice::uncheckedCast<Test::DPrx>(df, "");
#else
DPrx df3 = Test::DPrx::uncheckedCast(df, "");
#endif
test(df3->ice_getFacet().empty());
cout << "ok" << endl;
cout << "testing checked cast... " << flush;
prx = ICE_CHECKED_CAST(Ice::ObjectPrx, db);
test(prx->ice_getFacet().empty());
#ifdef ICE_CPP11_MAPPING
prx = Ice::checkedCast<Ice::ObjectPrx>(db, "facetABCD");
#else
prx = Ice::ObjectPrx::checkedCast(db, "facetABCD");
#endif
test(prx->ice_getFacet() == "facetABCD");
prx2 = ICE_CHECKED_CAST(Ice::ObjectPrx, prx);
test(prx2->ice_getFacet() == "facetABCD");
#ifdef ICE_CPP11_MAPPING
prx3 = Ice::checkedCast<Ice::ObjectPrx>(prx, "");
#else
prx3 = Ice::ObjectPrx::checkedCast(prx, "");
#endif
test(prx3->ice_getFacet().empty());
d = ICE_CHECKED_CAST(Test::DPrx, db);
test(d->ice_getFacet().empty());
#ifdef ICE_CPP11_MAPPING
df = Ice::checkedCast<Test::DPrx>(db, "facetABCD");
#else
df = Test::DPrx::checkedCast(db, "facetABCD");
#endif
test(df->ice_getFacet() == "facetABCD");
df2 = ICE_CHECKED_CAST(Test::DPrx, df);
test(df2->ice_getFacet() == "facetABCD");
#ifdef ICE_CPP11_MAPPING
df3 = Ice::checkedCast<Test::DPrx>(df, "");
#else
df3 = Test::DPrx::checkedCast(df, "");
#endif
test(df3->ice_getFacet().empty());
cout << "ok" << endl;
cout << "testing non-facets A, B, C, and D... " << flush;
d = ICE_CHECKED_CAST(DPrx, db);
test(d);
#ifdef ICE_CPP11_MAPPING
test(Ice::targetEqualTo(d, db));
#else
test(d == db);
#endif
test(d->callA() == "A");
test(d->callB() == "B");
test(d->callC() == "C");
test(d->callD() == "D");
cout << "ok" << endl;
cout << "testing facets A, B, C, and D... " << flush;
#ifdef ICE_CPP11_MAPPING
df = Ice::checkedCast<DPrx>(d, "facetABCD");
#else
df = DPrx::checkedCast(d, "facetABCD");
#endif
test(df);
test(df->callA() == "A");
test(df->callB() == "B");
test(df->callC() == "C");
test(df->callD() == "D");
cout << "ok" << endl;
cout << "testing facets E and F... " << flush;
#ifdef ICE_CPP11_MAPPING
auto ff = Ice::checkedCast<FPrx>(d, "facetEF");
#else
FPrx ff = FPrx::checkedCast(d, "facetEF");
#endif
test(ff);
test(ff->callE() == "E");
test(ff->callF() == "F");
cout << "ok" << endl;
cout << "testing facet G... " << flush;
#ifdef ICE_CPP11_MAPPING
auto gf = Ice::checkedCast<GPrx>(ff, "facetGH");
#else
GPrx gf = GPrx::checkedCast(ff, "facetGH");
#endif
test(gf);
test(gf->callG() == "G");
cout << "ok" << endl;
cout << "testing whether casting preserves the facet... " << flush;
HPrxPtr hf = ICE_CHECKED_CAST(HPrx, gf);
test(hf);
test(hf->callG() == "G");
test(hf->callH() == "H");
cout << "ok" << endl;
return gf;
}
void
ServerLocatorRegistry::addObject(const Ice::ObjectPrxPtr& object)
{
_objects[object->ice_getIdentity()] = object;
}
