Ice::ObjectAdapterPtr
RegistryI::setupAdminSessionFactory(const Ice::ObjectAdapterPtr& registryAdapter,
const Ice::ObjectPtr& router,
const IceGrid::LocatorPrx& locator)
{
Ice::PropertiesPtr properties = _communicator->getProperties();
Ice::ObjectAdapterPtr adapter;
SessionServantManagerPtr servantManager;
if(!properties->getProperty("IceGrid.Registry.AdminSessionManager.Endpoints").empty())
{
adapter = _communicator->createObjectAdapter("IceGrid.Registry.AdminSessionManager");
servantManager = new SessionServantManager(adapter, _instanceName, false, getServerAdminCategory(), router, 0);
adapter->addServantLocator(servantManager, "");
}
assert(_reaper);
_adminSessionFactory = new AdminSessionFactory(servantManager, _database, _reaper, this);
if(servantManager)
{
Identity sessionMgrId;
sessionMgrId.category = _instanceName;
sessionMgrId.name = "AdminSessionManager";
Identity sslSessionMgrId;
sslSessionMgrId.category = _instanceName;
sslSessionMgrId.name = "AdminSSLSessionManager";
if(!_master)
{
sessionMgrId.name += "-" + _replicaName;
sslSessionMgrId.name += "-" + _replicaName;
}
adapter->add(new AdminSessionManagerI(_adminSessionFactory), sessionMgrId);
adapter->add(new AdminSSLSessionManagerI(_adminSessionFactory), sslSessionMgrId);
_wellKnownObjects->add(adapter->createProxy(sessionMgrId), Glacier2::SessionManager::ice_staticId());
_wellKnownObjects->add(adapter->createProxy(sslSessionMgrId), Glacier2::SSLSessionManager::ice_staticId());
}
if(adapter)
{
Ice::Identity dummy;
dummy.name = "dummy";
_wellKnownObjects->addEndpoint("AdminSessionManager", adapter->createDirectProxy(dummy));
}
_adminVerifier = getPermissionsVerifier(registryAdapter,
locator,
"IceGrid.Registry.AdminPermissionsVerifier",
properties->getProperty("IceGrid.Registry.AdminCryptPasswords"));
_sslAdminVerifier = getSSLPermissionsVerifier(locator, "IceGrid.Registry.AdminSSLPermissionsVerifier");
return adapter;
}
Ice::ObjectAdapterPtr
RegistryI::setupClientSessionFactory(const Ice::ObjectAdapterPtr& registryAdapter, const IceGrid::LocatorPrx& locator)
{
Ice::PropertiesPtr properties = _communicator->getProperties();
Ice::ObjectAdapterPtr adapter;
SessionServantManagerPtr servantManager;
if(!properties->getProperty("IceGrid.Registry.SessionManager.Endpoints").empty())
{
adapter = _communicator->createObjectAdapter("IceGrid.Registry.SessionManager");
servantManager = new SessionServantManager(adapter, _instanceName, false, "", 0, 0);
adapter->addServantLocator(servantManager, "");
}
assert(_reaper);
_timer = new IceUtil::Timer(); // Used for for session allocation timeout.
_clientSessionFactory = new ClientSessionFactory(servantManager, _database, _timer, _reaper);
if(servantManager && _master) // Slaves don't support client session manager objects.
{
Identity sessionMgrId;
sessionMgrId.category = _instanceName;
sessionMgrId.name = "SessionManager";
Identity sslSessionMgrId;
sslSessionMgrId.category = _instanceName;
sslSessionMgrId.name = "SSLSessionManager";
adapter->add(new ClientSessionManagerI(_clientSessionFactory), sessionMgrId);
adapter->add(new ClientSSLSessionManagerI(_clientSessionFactory), sslSessionMgrId);
_wellKnownObjects->add(adapter->createProxy(sessionMgrId), Glacier2::SessionManager::ice_staticId());
_wellKnownObjects->add(adapter->createProxy(sslSessionMgrId), Glacier2::SSLSessionManager::ice_staticId());
}
if(adapter)
{
Ice::Identity dummy;
dummy.name = "dummy";
_wellKnownObjects->addEndpoint("SessionManager", adapter->createDirectProxy(dummy));
}
_clientVerifier = getPermissionsVerifier(registryAdapter,
locator,
"IceGrid.Registry.PermissionsVerifier",
properties->getProperty("IceGrid.Registry.CryptPasswords"));
_sslClientVerifier = getSSLPermissionsVerifier(locator, "IceGrid.Registry.SSLPermissionsVerifier");
return adapter;
}
bool
RegistryI::setupUserAccountMapper(const Ice::ObjectAdapterPtr& registryAdapter)
{
Ice::PropertiesPtr properties = _communicator->getProperties();
//
// Setup file user account mapper object if the property is set.
//
string userAccountFileProperty = properties->getProperty("IceGrid.Registry.UserAccounts");
if(!userAccountFileProperty.empty())
{
try
{
Identity mapperId;
mapperId.category = _instanceName;
mapperId.name = "RegistryUserAccountMapper";
if(!_master)
{
mapperId.name += "-" + _replicaName;
}
registryAdapter->add(new FileUserAccountMapperI(userAccountFileProperty), mapperId);
_wellKnownObjects->add(registryAdapter->createProxy(mapperId), UserAccountMapper::ice_staticId());
}
catch(const std::string& msg)
{
Error out(_communicator->getLogger());
out << msg;
return false;
}
}
return true;
}
static ServerPrx idToProxy(int id, const Ice::ObjectAdapterPtr &adapter) {
Ice::Identity ident;
ident.category = "s";
ident.name = u8(QString::number(id));
return ServerPrx::uncheckedCast(adapter->createProxy(ident));
}
void
RegistryI::setupAdminSessionFactory(const Ice::ObjectAdapterPtr& registryAdapter,
const Ice::ObjectAdapterPtr& sessionManagerAdapter,
const IceGrid::LocatorPrx& locator,
bool nowarn)
{
assert(_reaper);
_adminSessionFactory = new AdminSessionFactory(sessionManagerAdapter, _database, _reaper, this);
if(sessionManagerAdapter)
{
Identity adminSessionMgrId;
adminSessionMgrId.category = _instanceName;
adminSessionMgrId.name = "AdminSessionManager";
Identity sslAdmSessionMgrId;
sslAdmSessionMgrId.category = _instanceName;
sslAdmSessionMgrId.name = "AdminSSLSessionManager";
if(!_master)
{
adminSessionMgrId.name += "-" + _replicaName;
sslAdmSessionMgrId.name += "-" + _replicaName;
}
sessionManagerAdapter->add(new AdminSessionManagerI(_adminSessionFactory), adminSessionMgrId);
sessionManagerAdapter->add(new AdminSSLSessionManagerI(_adminSessionFactory), sslAdmSessionMgrId);
_wellKnownObjects->add(sessionManagerAdapter->createProxy(adminSessionMgrId),
Glacier2::SessionManager::ice_staticId());
_wellKnownObjects->add(sessionManagerAdapter->createProxy(sslAdmSessionMgrId),
Glacier2::SSLSessionManager::ice_staticId());
}
Ice::PropertiesPtr properties = _communicator->getProperties();
_adminVerifier = getPermissionsVerifier(registryAdapter,
locator,
"IceGrid.Registry.AdminPermissionsVerifier",
properties->getProperty("IceGrid.Registry.AdminCryptPasswords"),
nowarn);
_sslAdminVerifier =
getSSLPermissionsVerifier(locator,
"IceGrid.Registry.AdminSSLPermissionsVerifier",
nowarn);
}
int
NestedClient::run(int argc, char*[])
{
if(argc > 1)
{
cerr << appName() << ": too many arguments" << endl;
return EXIT_FAILURE;
}
NestedPrx nested = NestedPrx::checkedCast(communicator()->propertyToProxy("Nested.Proxy"));
if(!nested)
{
cerr << appName() << ": invalid proxy" << endl;
return EXIT_FAILURE;
}
//
// Ensure the invocation times out if the nesting level is too
// high and there are no more threads in the thread pool to
// dispatch the call.
//
nested = nested->ice_invocationTimeout(5000);
Ice::ObjectAdapterPtr adapter = communicator()->createObjectAdapter("Nested.Client");
NestedPrx self = NestedPrx::uncheckedCast(adapter->createProxy(communicator()->stringToIdentity("nestedClient")));
NestedPtr servant = new NestedI(self);
adapter->add(servant, communicator()->stringToIdentity("nestedClient"));
adapter->activate();
cout << "Note: The maximum nesting level is sz * 2, with sz being\n"
<< "the maximum number of threads in the server thread pool. if\n"
<< "you specify a value higher than that, the application will\n"
<< "block or timeout.\n"
<< endl;
string s;
do
{
try
{
cout << "enter nesting level or 'x' for exit: ";
cin >> s;
int level = atoi(s.c_str());
if(level > 0)
{
nested->nestedCall(level, self);
}
}
catch(const Ice::Exception& ex)
{
cerr << ex << endl;
}
}
while(cin.good() && s != "x");
return EXIT_SUCCESS;
}
virtual void
initialize(const Ice::ObjectAdapterPtr& adptr, const Ice::Identity& identity, const string& /*facet*/,
const Ice::ObjectPtr& servant)
{
CasinoStore::PersistentPlayerPrx prx =
CasinoStore::PersistentPlayerPrx::uncheckedCast(adptr->createProxy(identity));
PlayerI* player = dynamic_cast<PlayerI*>(servant.get());
player->init(prx, _server._playerEvictor, _server._bankPrx);
}
void
RegistryI::setupClientSessionFactory(const Ice::ObjectAdapterPtr& registryAdapter,
const Ice::ObjectAdapterPtr& sessionManagerAdapter,
const IceGrid::LocatorPrx& locator,
bool nowarn)
{
_waitQueue = new WaitQueue(); // Used for for session allocation timeout.
_waitQueue->start();
assert(_reaper);
_clientSessionFactory = new ClientSessionFactory(sessionManagerAdapter, _database, _waitQueue, _reaper);
if(sessionManagerAdapter && _master) // Slaves don't support client session manager objects.
{
Identity clientSessionMgrId;
clientSessionMgrId.category = _instanceName;
clientSessionMgrId.name = "SessionManager";
Identity sslClientSessionMgrId;
sslClientSessionMgrId.category = _instanceName;
sslClientSessionMgrId.name = "SSLSessionManager";
sessionManagerAdapter->add(new ClientSessionManagerI(_clientSessionFactory), clientSessionMgrId);
sessionManagerAdapter->add(new ClientSSLSessionManagerI(_clientSessionFactory), sslClientSessionMgrId);
_wellKnownObjects->add(sessionManagerAdapter->createProxy(clientSessionMgrId),
Glacier2::SessionManager::ice_staticId());
_wellKnownObjects->add(sessionManagerAdapter->createProxy(sslClientSessionMgrId),
Glacier2::SSLSessionManager::ice_staticId());
}
Ice::PropertiesPtr properties = _communicator->getProperties();
_clientVerifier = getPermissionsVerifier(registryAdapter,
locator,
"IceGrid.Registry.PermissionsVerifier",
properties->getProperty("IceGrid.Registry.CryptPasswords"),
nowarn);
_sslClientVerifier = getSSLPermissionsVerifier(locator,
"IceGrid.Registry.SSLPermissionsVerifier",
nowarn);
}
vector<CasinoStore::PersistentBetPrx>
BankI::getBets(const Ice::ObjectAdapterPtr& adapter) const
{
vector<CasinoStore::PersistentBetPrx> result;
Freeze::EvictorIteratorPtr p = _betEvictor->getIterator("", 100);
while(p->hasNext())
{
Ice::Identity ident = p->next();
result.push_back(CasinoStore::PersistentBetPrx::uncheckedCast(adapter->createProxy(ident)));
}
return result;
}
int
NestedServer::run(int argc, char*[])
{
if(argc > 1)
{
cerr << appName() << ": too many arguments" << endl;
return EXIT_FAILURE;
}
Ice::ObjectAdapterPtr adapter = communicator()->createObjectAdapter("Nested.Server");
NestedPrx self = NestedPrx::uncheckedCast(adapter->createProxy(communicator()->stringToIdentity("nestedServer")));
NestedPtr servant = new NestedI(self);
adapter->add(servant, communicator()->stringToIdentity("nestedServer"));
adapter->activate();
communicator()->waitForShutdown();
return EXIT_SUCCESS;
}
int
run(int, char**, const Ice::CommunicatorPtr& communicator,
const Ice::InitializationData& initData)
{
//
// Register the server manager. The server manager creates a new
// 'server' (a server isn't a different process, it's just a new
// communicator and object adapter).
//
Ice::PropertiesPtr properties = communicator->getProperties();
properties->setProperty("Ice.ThreadPool.Server.Size", "2");
properties->setProperty("ServerManager.Endpoints", getTestEndpoint(communicator, 0) + ":udp");
Ice::ObjectAdapterPtr adapter = communicator->createObjectAdapter("ServerManager");
//
// We also register a sample server locator which implements the
// locator interface, this locator is used by the clients and the
// 'servers' created with the server manager interface.
//
ServerLocatorRegistryPtr registry = ICE_MAKE_SHARED(ServerLocatorRegistry);
registry->addObject(adapter->createProxy(Ice::stringToIdentity("ServerManager")));
Ice::ObjectPtr object = ICE_MAKE_SHARED(ServerManagerI, registry, initData);
adapter->add(object, Ice::stringToIdentity("ServerManager"));
Ice::LocatorRegistryPrxPtr registryPrx =
ICE_UNCHECKED_CAST(Ice::LocatorRegistryPrx,
adapter->add(registry, Ice::stringToIdentity("registry")));
Ice::LocatorPtr locator = ICE_MAKE_SHARED(ServerLocator, registry, registryPrx);
adapter->add(locator, Ice::stringToIdentity("locator"));
adapter->activate();
TEST_READY
communicator->waitForShutdown();
return EXIT_SUCCESS;
}
int
run(int argc, char* argv[], const Ice::CommunicatorPtr& communicator,
const Ice::InitializationData& initData)
{
//
// Register the server manager. The server manager creates a new
// 'server' (a server isn't a different process, it's just a new
// communicator and object adapter).
//
Ice::PropertiesPtr properties = communicator->getProperties();
properties->setProperty("Ice.ThreadPool.Server.Size", "2");
properties->setProperty("ServerManager.Endpoints", "default -p 12010:udp");
Ice::ObjectAdapterPtr adapter = communicator->createObjectAdapter("ServerManager");
//
// We also register a sample server locator which implements the
// locator interface, this locator is used by the clients and the
// 'servers' created with the server manager interface.
//
ServerLocatorRegistryPtr registry = new ServerLocatorRegistry();
registry->addObject(adapter->createProxy(communicator->stringToIdentity("ServerManager")));
Ice::ObjectPtr object = new ServerManagerI(adapter, registry, initData);
adapter->add(object, communicator->stringToIdentity("ServerManager"));
Ice::LocatorRegistryPrx registryPrx =
Ice::LocatorRegistryPrx::uncheckedCast(adapter->add(registry, communicator->stringToIdentity("registry")));
Ice::LocatorPtr locator = new ServerLocator(registry, registryPrx);
adapter->add(locator, communicator->stringToIdentity("locator"));
adapter->activate();
communicator->waitForShutdown();
return EXIT_SUCCESS;
}
void
ServiceI::start(
const string& name,
const CommunicatorPtr& communicator,
const StringSeq& /*args*/)
{
PropertiesPtr properties = communicator->getProperties();
validateProperties(name, properties, communicator->getLogger());
int id = properties->getPropertyAsIntWithDefault(name + ".NodeId", -1);
// If we are using a replicated deployment and if the topic
// manager thread pool max size is not set then ensure it is set
// to some suitably high number. This ensures no deadlocks in the
// replicated case due to call forwarding from replicas to
// coordinators.
if(id != -1 && properties->getProperty(name + ".TopicManager.ThreadPool.SizeMax").empty())
{
properties->setProperty(name + ".TopicManager.ThreadPool.SizeMax", "100");
}
Ice::ObjectAdapterPtr topicAdapter = communicator->createObjectAdapter(name + ".TopicManager");
Ice::ObjectAdapterPtr publishAdapter = communicator->createObjectAdapter(name + ".Publish");
//
// We use the name of the service for the name of the database environment.
//
string instanceName = properties->getPropertyWithDefault(name + ".InstanceName", "IceStorm");
Identity topicManagerId;
topicManagerId.category = instanceName;
topicManagerId.name = "TopicManager";
if(properties->getPropertyAsIntWithDefault(name+ ".Transient", 0) > 0)
{
_instance = new Instance(instanceName, name, communicator, publishAdapter, topicAdapter, 0);
try
{
TransientTopicManagerImplPtr manager = new TransientTopicManagerImpl(_instance);
_managerProxy = TopicManagerPrx::uncheckedCast(topicAdapter->add(manager, topicManagerId));
}
catch(const Ice::Exception& ex)
{
_instance = 0;
LoggerOutputBase s;
s << "exception while starting IceStorm service " << name << ":\n";
s << ex;
IceBox::FailureException e(__FILE__, __LINE__);
e.reason = s.str();
throw e;
}
topicAdapter->activate();
publishAdapter->activate();
return;
}
if(id == -1) // No replication.
{
_instance = new Instance(instanceName, name, communicator, publishAdapter, topicAdapter);
try
{
_manager = new TopicManagerImpl(_instance);
_managerProxy = TopicManagerPrx::uncheckedCast(topicAdapter->add(_manager->getServant(), topicManagerId));
}
catch(const Ice::Exception& ex)
{
_instance = 0;
LoggerOutputBase s;
s << "exception while starting IceStorm service " << name << ":\n";
s << ex;
IceBox::FailureException e(__FILE__, __LINE__);
e.reason = s.str();
throw e;
}
}
else
{
// Here we want to create a map of id -> election node
// proxies.
map<int, NodePrx> nodes;
string topicManagerAdapterId = properties->getProperty(name + ".TopicManager.AdapterId");
// We support two possible deployments. The first is a manual
// deployment, the second is IceGrid.
//
// Here we check for the manual deployment
const string prefix = name + ".Nodes.";
Ice::PropertyDict props = properties->getPropertiesForPrefix(prefix);
if(!props.empty())
{
for(Ice::PropertyDict::const_iterator p = props.begin(); p != props.end(); ++p)
{
int nodeid = atoi(p->first.substr(prefix.size()).c_str());
nodes[nodeid] = NodePrx::uncheckedCast(communicator->propertyToProxy(p->first));
}
}
else
{
// If adapter id's are defined for the topic manager or
// node adapters then we consider this an IceGrid based
// deployment.
string nodeAdapterId = properties->getProperty(name + ".Node.AdapterId");
// Validate first that the adapter ids match for the node
// and the topic manager otherwise some other deployment
// is being used.
const string suffix = ".TopicManager";
if(topicManagerAdapterId.empty() || nodeAdapterId.empty() ||
topicManagerAdapterId.replace(
topicManagerAdapterId.find(suffix), suffix.size(), ".Node") != nodeAdapterId)
{
Ice::Error error(communicator->getLogger());
error << "deployment error: `" << topicManagerAdapterId << "' prefix does not match `"
<< nodeAdapterId << "'";
throw IceBox::FailureException(__FILE__, __LINE__, "IceGrid deployment is incorrect");
}
// Determine the set of node id and node proxies.
//
// This is determined by locating all topic manager
// replicas, and then working out the node for that
// replica.
//
// We work out the node id by removing the instance
// name. The node id must follow.
//
IceGrid::LocatorPrx locator = IceGrid::LocatorPrx::checkedCast(communicator->getDefaultLocator());
assert(locator);
IceGrid::QueryPrx query = locator->getLocalQuery();
Ice::ObjectProxySeq replicas = query->findAllReplicas(
communicator->stringToProxy(instanceName + "/TopicManager"));
for(Ice::ObjectProxySeq::const_iterator p = replicas.begin(); p != replicas.end(); ++p)
{
string adapterid = (*p)->ice_getAdapterId();
// Replace TopicManager with the node endpoint.
adapterid = adapterid.replace(adapterid.find(suffix), suffix.size(), ".Node");
// The adapter id must start with the instance name.
if(adapterid.find(instanceName) != 0)
{
Ice::Error error(communicator->getLogger());
error << "deployment error: `" << adapterid << "' does not start with `" << instanceName << "'";
throw IceBox::FailureException(__FILE__, __LINE__, "IceGrid deployment is incorrect");
}
// The node id follows. We find the first digit (the
// start of the node id, and then the end of the
// digits).
string::size_type start = instanceName.size();
while(start < adapterid.size() && !IceUtilInternal::isDigit(adapterid[start]))
{
++start;
}
string::size_type end = start;
while(end < adapterid.size() && IceUtilInternal::isDigit(adapterid[end]))
{
++end;
}
if(start == end)
{
// We must have at least one digit, otherwise there is
// some sort of deployment error.
Ice::Error error(communicator->getLogger());
error << "deployment error: node id does not follow instance name. instance name:"
<< instanceName << " adapter id: " << adapterid;
throw IceBox::FailureException(__FILE__, __LINE__, "IceGrid deployment is incorrect");
}
int nodeid = atoi(adapterid.substr(start, end-start).c_str());
ostringstream os;
os << "node" << nodeid;
Ice::Identity id;
id.category = instanceName;
id.name = os.str();
nodes[nodeid] = NodePrx::uncheckedCast((*p)->ice_adapterId(adapterid)->ice_identity(id));
}
}
if(nodes.size() < 3)
{
Ice::Error error(communicator->getLogger());
error << "Replication requires at least 3 Nodes";
throw IceBox::FailureException(__FILE__, __LINE__, "Replication requires at least 3 Nodes");
}
try
{
// If the node thread pool size is not set then initialize
// to the number of nodes + 1 and disable thread pool size
// warnings.
if(properties->getProperty(name + ".Node.ThreadPool.Size").empty())
{
ostringstream os;
os << nodes.size() + 1;
properties->setProperty(name + ".Node.ThreadPool.Size", os.str());
properties->setProperty(name + ".Node.ThreadPool.SizeWarn", "0");
}
if(properties->getProperty(name + ".Node.MessageSizeMax").empty())
{
properties->setProperty(name + ".Node.MessageSizeMax", "0"); // No limit on data exchanged internally
}
Ice::ObjectAdapterPtr nodeAdapter = communicator->createObjectAdapter(name + ".Node");
_instance = new Instance(instanceName, name, communicator, publishAdapter, topicAdapter,
nodeAdapter, nodes[id]);
_instance->observers()->setMajority(static_cast<unsigned int>(nodes.size())/2);
// Trace replication information.
TraceLevelsPtr traceLevels = _instance->traceLevels();
if(traceLevels->election > 0)
{
Ice::Trace out(traceLevels->logger, traceLevels->electionCat);
out << "I am node " << id << "\n";
for(map<int, NodePrx>::const_iterator p = nodes.begin(); p != nodes.end(); ++p)
{
out << "\tnode: " << p->first << " proxy: " << p->second->ice_toString() << "\n";
}
}
if(topicManagerAdapterId.empty())
{
// We're not using an IceGrid deployment. Here we need
// a proxy which is used to create proxies to the
// replicas later.
_managerProxy = TopicManagerPrx::uncheckedCast(topicAdapter->createProxy(topicManagerId));
}
else
{
// If we're using IceGrid deployment we need to create
// indirect proxies.
_managerProxy = TopicManagerPrx::uncheckedCast(topicAdapter->createIndirectProxy(topicManagerId));
}
_manager = new TopicManagerImpl(_instance);
topicAdapter->add(_manager->getServant(), topicManagerId);
ostringstream os; // The node object identity.
os << "node" << id;
Ice::Identity nodeid;
nodeid.category = instanceName;
nodeid.name = os.str();
NodeIPtr node = new NodeI(_instance, _manager, _managerProxy, id, nodes);
_instance->setNode(node);
nodeAdapter->add(node, nodeid);
nodeAdapter->activate();
node->start();
}
catch(const Ice::Exception& ex)
{
_instance = 0;
LoggerOutputBase s;
s << "exception while starting IceStorm service " << name << ":\n";
s << ex;
IceBox::FailureException e(__FILE__, __LINE__);
e.reason = s.str();
throw e;
}
}
topicAdapter->add(new FinderI(TopicManagerPrx::uncheckedCast(topicAdapter->createProxy(topicManagerId))),
communicator->stringToIdentity("IceStorm/Finder"));
topicAdapter->activate();
publishAdapter->activate();
}
int
CallbackClient::run(int argc, char* argv[])
{
//
// Since this is an interactive demo we want the custom interrupt
// callback to be called when the process is interrupted.
//
callbackOnInterrupt();
CallbackSenderPrx twoway = CallbackSenderPrx::checkedCast(
communicator()->propertyToProxy("Callback.CallbackServer")->
ice_twoway()->ice_timeout(-1)->ice_secure(false));
if(!twoway)
{
cerr << appName() << ": invalid proxy" << endl;
return EXIT_FAILURE;
}
CallbackSenderPrx oneway = CallbackSenderPrx::uncheckedCast(twoway->ice_oneway());
CallbackSenderPrx batchOneway = CallbackSenderPrx::uncheckedCast(twoway->ice_batchOneway());
CallbackSenderPrx datagram = CallbackSenderPrx::uncheckedCast(twoway->ice_datagram());
CallbackSenderPrx batchDatagram = CallbackSenderPrx::uncheckedCast(twoway->ice_batchDatagram());
Ice::ObjectAdapterPtr adapter = communicator()->createObjectAdapter("Callback.Client");
adapter->add(new CallbackReceiverI, communicator()->stringToIdentity("callbackReceiver"));
adapter->activate();
CallbackReceiverPrx twowayR = CallbackReceiverPrx::uncheckedCast(
adapter->createProxy(communicator()->stringToIdentity("callbackReceiver")));
CallbackReceiverPrx onewayR = CallbackReceiverPrx::uncheckedCast(twowayR->ice_oneway());
CallbackReceiverPrx datagramR = CallbackReceiverPrx::uncheckedCast(twowayR->ice_datagram());
bool secure = false;
string secureStr = "";
menu();
char c;
do
{
try
{
cout << "==> ";
cin >> c;
if(c == 't')
{
twoway->initiateCallback(twowayR);
}
else if(c == 'o')
{
oneway->initiateCallback(onewayR);
}
else if(c == 'O')
{
batchOneway->initiateCallback(onewayR);
}
else if(c == 'd')
{
if(secure)
{
cout << "secure datagrams are not supported" << endl;
}
else
{
datagram->initiateCallback(datagramR);
}
}
else if(c == 'D')
{
if(secure)
{
cout << "secure datagrams are not supported" << endl;
}
else
{
batchDatagram->initiateCallback(datagramR);
}
}
else if(c == 'f')
{
communicator()->flushBatchRequests();
}
else if(c == 'S')
{
secure = !secure;
secureStr = secure ? "s" : "";
twoway = CallbackSenderPrx::uncheckedCast(twoway->ice_secure(secure));
oneway = CallbackSenderPrx::uncheckedCast(oneway->ice_secure(secure));
batchOneway = CallbackSenderPrx::uncheckedCast(batchOneway->ice_secure(secure));
datagram = CallbackSenderPrx::uncheckedCast(datagram->ice_secure(secure));
batchDatagram = CallbackSenderPrx::uncheckedCast(batchDatagram->ice_secure(secure));
twowayR = CallbackReceiverPrx::uncheckedCast(twowayR->ice_secure(secure));
onewayR = CallbackReceiverPrx::uncheckedCast(onewayR->ice_secure(secure));
datagramR = CallbackReceiverPrx::uncheckedCast(datagramR->ice_secure(secure));
if(secure)
{
cout << "secure mode is now on" << endl;
}
else
{
cout << "secure mode is now off" << endl;
}
}
else if(c == 's')
{
twoway->shutdown();
}
else if(c == 'x')
{
// Nothing to do
}
else if(c == '?')
{
menu();
}
else
{
cout << "unknown command `" << c << "'" << endl;
menu();
}
}
catch(const Ice::Exception& ex)
{
cerr << ex << endl;
}
}
while(cin.good() && c != 'x');
return EXIT_SUCCESS;
}
int
run(int argc, char* argv[], const Ice::CommunicatorPtr& communicator)
{
if(argc > 1)
{
fprintf(stderr, "%s: too many arguments\n", argv[0]);
return EXIT_FAILURE;
}
Ice::PropertiesPtr properties = communicator->getProperties();
const char* proxyProperty = "CallbackSender.Proxy";
string proxy = properties->getProperty(proxyProperty);
if(proxy.empty())
{
fprintf(stderr, "%s: property `%s' not set\n", argv[0], proxyProperty);
return EXIT_FAILURE;
}
Ice::ObjectPrx base = communicator->stringToProxy(proxy);
CallbackSenderPrx twoway = CallbackSenderPrx::checkedCast(base->ice_twoway()->ice_timeout(-1));
if(!twoway)
{
fprintf(stderr, "%s: invalid proxy\n", argv[0]);
return EXIT_FAILURE;
}
CallbackSenderPrx oneway = twoway->ice_oneway();
#ifdef ICEE_HAS_BATCH
CallbackSenderPrx batchOneway = twoway->ice_batchOneway();
#endif
Ice::ObjectAdapterPtr adapter = communicator->createObjectAdapter("Callback.Client");
CallbackReceiverPtr cr = new CallbackReceiverI;
adapter->add(cr, communicator->stringToIdentity("callbackReceiver"));
adapter->activate();
CallbackReceiverPrx twowayR = CallbackReceiverPrx::uncheckedCast(
adapter->createProxy(communicator->stringToIdentity("callbackReceiver")));
CallbackReceiverPrx onewayR = twowayR->ice_oneway();
menu();
char c = EOF;
do
{
try
{
printf("==> "); fflush(stdout);
do
{
c = getchar();
}
while(c != EOF && c == '\n');
if(c == 't')
{
twoway->initiateCallback(twowayR);
}
else if(c == 'o')
{
oneway->initiateCallback(onewayR);
}
#ifdef ICEE_HAS_BATCH
else if(c == 'O')
{
batchOneway->initiateCallback(onewayR);
}
else if(c == 'f')
{
batchOneway->ice_flushBatchRequests();
}
#endif
else if(c == 's')
{
twoway->shutdown();
}
else if(c == 'x')
{
// Nothing to do
}
else if(c == '?')
{
menu();
}
else
{
printf("unknown command `%c'\n", c);
menu();
}
}
catch(const Ice::Exception& ex)
{
fprintf(stderr, "%s\n", ex.toString().c_str());
}
}
while(c != EOF && c != 'x');
return EXIT_SUCCESS;
}
int
CallbackClient::run(int argc, char*[])
{
if(argc > 1)
{
cerr << appName() << ": too many arguments" << endl;
return EXIT_FAILURE;
}
CallbackSenderPrx sender = CallbackSenderPrx::checkedCast(
communicator()->propertyToProxy("CallbackSender.Proxy")->ice_twoway()->ice_timeout(-1)->ice_secure(false));
if(!sender)
{
cerr << appName() << ": invalid proxy" << endl;
return EXIT_FAILURE;
}
Ice::ObjectAdapterPtr adapter = communicator()->createObjectAdapter("Callback.Client");
CallbackReceiverPtr cr = new CallbackReceiverI;
adapter->add(cr, communicator()->stringToIdentity("callbackReceiver"));
adapter->activate();
CallbackReceiverPrx receiver = CallbackReceiverPrx::uncheckedCast(
adapter->createProxy(communicator()->stringToIdentity("callbackReceiver")));
menu();
char c = 'x';
do
{
try
{
cout << "==> ";
cin >> c;
if(c == 't')
{
sender->initiateCallback(receiver);
}
else if(c == 's')
{
sender->shutdown();
}
else if(c == 'x')
{
// Nothing to do
}
else if(c == '?')
{
menu();
}
else
{
cout << "unknown command `" << c << "'" << endl;
menu();
}
}
catch(const Ice::Exception& ex)
{
cerr << ex << endl;
}
}
while(cin.good() && c != 'x');
return EXIT_SUCCESS;
}
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();
}
void
allTests(const Ice::CommunicatorPtr& communicator)
{
Ice::ObjectAdapterPtr oa = communicator->createObjectAdapterWithEndpoints("MyOA", "tcp -h localhost");
oa->activate();
Ice::ObjectPtr servant = ICE_MAKE_SHARED(MyObjectI);
//
// Register default servant with category "foo"
//
oa->addDefaultServant(servant, "foo");
//
// Start test
//
cout << "testing single category... " << flush;
Ice::ObjectPtr r = oa->findDefaultServant("foo");
test(r == servant);
r = oa->findDefaultServant("bar");
test(r == 0);
Ice::Identity identity;
identity.category = "foo";
string names[] = { "foo", "bar", "x", "y", "abcdefg" };
int idx;
for(idx = 0; idx < 5; ++idx)
{
identity.name = names[idx];
MyObjectPrxPtr prx = ICE_UNCHECKED_CAST(MyObjectPrx, oa->createProxy(identity));
prx->ice_ping();
test(prx->getName() == names[idx]);
}
identity.name = "ObjectNotExist";
MyObjectPrxPtr prx = ICE_UNCHECKED_CAST(MyObjectPrx, oa->createProxy(identity));
try
{
prx->ice_ping();
test(false);
}
catch(const Ice::ObjectNotExistException&)
{
// Expected
}
try
{
prx->getName();
test(false);
}
catch(const Ice::ObjectNotExistException&)
{
// Expected
}
identity.name = "FacetNotExist";
prx = ICE_UNCHECKED_CAST(MyObjectPrx, oa->createProxy(identity));
try
{
prx->ice_ping();
test(false);
}
catch(const Ice::FacetNotExistException&)
{
// Expected
}
try
{
prx->getName();
test(false);
}
catch(const Ice::FacetNotExistException&)
{
// Expected
}
identity.category = "bar";
for(idx = 0; idx < 5; idx++)
{
identity.name = names[idx];
prx = ICE_UNCHECKED_CAST(MyObjectPrx, oa->createProxy(identity));
try
{
prx->ice_ping();
test(false);
}
catch(const Ice::ObjectNotExistException&)
{
// Expected
}
try
{
prx->getName();
test(false);
}
catch(const Ice::ObjectNotExistException&)
{
// Expected
}
}
oa->removeDefaultServant("foo");
identity.category = "foo";
prx = ICE_UNCHECKED_CAST(MyObjectPrx, oa->createProxy(identity));
try
{
prx->ice_ping();
}
catch(const Ice::ObjectNotExistException&)
{
// Expected
}
cout << "ok" << endl;
cout << "testing default category... " << flush;
oa->addDefaultServant(servant, "");
r = oa->findDefaultServant("bar");
test(r == 0);
r = oa->findDefaultServant("");
test(r == servant);
for(idx = 0; idx < 5; ++idx)
{
identity.name = names[idx];
prx = ICE_UNCHECKED_CAST(MyObjectPrx, oa->createProxy(identity));
prx->ice_ping();
test(prx->getName() == names[idx]);
}
cout << "ok" << endl;
}
