ZEND_METHOD(Ice_ObjectPrx, ice_getEndpoints)
{
if(ZEND_NUM_ARGS() != 0)
{
WRONG_PARAM_COUNT;
}
ProxyPtr _this = Wrapper<ProxyPtr>::value(getThis() TSRMLS_CC);
assert(_this);
try
{
Ice::EndpointSeq endpoints = _this->proxy->ice_getEndpoints();
array_init(return_value);
uint idx = 0;
for(Ice::EndpointSeq::const_iterator p = endpoints.begin(); p != endpoints.end(); ++p, ++idx)
{
zval* elem;
MAKE_STD_ZVAL(elem);
if(!createEndpoint(elem, *p TSRMLS_CC))
{
zval_ptr_dtor(&elem);
RETURN_NULL();
}
add_index_zval(return_value, idx, elem);
}
}
catch(const IceUtil::Exception& ex)
{
throwException(ex TSRMLS_CC);
RETURN_NULL();
}
}
static PyObject*
adapterGetPublishedEndpoints(ObjectAdapterObject* self)
{
assert(self->adapter);
Ice::EndpointSeq endpoints;
try
{
endpoints = (*self->adapter)->getPublishedEndpoints();
}
catch(const Ice::Exception& ex)
{
setPythonException(ex);
return 0;
}
int count = static_cast<int>(endpoints.size());
PyObjectHandle result = PyTuple_New(count);
int i = 0;
for(Ice::EndpointSeq::const_iterator p = endpoints.begin(); p != endpoints.end(); ++p, ++i)
{
PyObjectHandle endp = createEndpoint(*p);
if(!endp.get())
{
return 0;
}
PyTuple_SET_ITEM(result.get(), i, endp.release()); // PyTuple_SET_ITEM steals a reference.
}
return result.release();
}
void
AdapterRequest::finished(const Ice::ObjectPrx& proxy)
{
if(proxy || _proxies.empty())
{
RequestT<std::string, Ice::AMD_Locator_findAdapterByIdPtr>::finished(proxy);
return;
}
else if(_proxies.size() == 1)
{
RequestT<std::string, Ice::AMD_Locator_findAdapterByIdPtr>::finished(_proxies[0]);
return;
}
Ice::EndpointSeq endpoints;
Ice::ObjectPrx prx;
for(vector<Ice::ObjectPrx>::const_iterator p = _proxies.begin(); p != _proxies.end(); ++p)
{
if(!prx)
{
prx = *p;
}
Ice::EndpointSeq endpts = (*p)->ice_getEndpoints();
copy(endpts.begin(), endpts.end(), back_inserter(endpoints));
}
RequestT<std::string, Ice::AMD_Locator_findAdapterByIdPtr>::finished(prx->ice_endpoints(endpoints));
}
Ice::ObjectPrx
WellKnownObjectsManager::getWellKnownObjectReplicatedProxy(const Ice::Identity& id, const string& endpt)
{
try
{
Ice::ObjectPrx proxy = _database->getObjectProxy(id);
Ice::EndpointSeq registryEndpoints = getEndpoints(endpt)->ice_getEndpoints();
//
// Re-order the endpoints to return first the endpoint for this
// registry replica.
//
Ice::EndpointSeq endpoints = proxy->ice_getEndpoints();
Ice::EndpointSeq newEndpoints = registryEndpoints;
for(Ice::EndpointSeq::const_iterator p = endpoints.begin(); p != endpoints.end(); ++p)
{
if(find(registryEndpoints.begin(), registryEndpoints.end(), *p) == registryEndpoints.end())
{
newEndpoints.push_back(*p);
}
}
return proxy->ice_endpoints(newEndpoints);
}
catch(const ObjectNotRegisteredException&)
{
//
// If for some reasons the object isn't registered, we compute
// the endpoints with the replica cache. For slaves, this will
// however only return the slave endpoints.
//
return _database->getReplicaCache().getEndpoints(endpt, getEndpoints(endpt))->ice_identity(id);
}
}
ZEND_METHOD(Ice_ObjectPrx, ice_endpoints)
{
ProxyPtr _this = Wrapper<ProxyPtr>::value(getThis() TSRMLS_CC);
assert(_this);
zval* zv;
if(zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, const_cast<char*>("a"), &zv) == FAILURE)
{
RETURN_NULL();
}
Ice::EndpointSeq seq;
HashTable* arr = Z_ARRVAL_P(zv);
HashPosition pos;
void* data;
zend_hash_internal_pointer_reset_ex(arr, &pos);
while(zend_hash_get_current_data_ex(arr, &data, &pos) != FAILURE)
{
zval** val = reinterpret_cast<zval**>(data);
if(Z_TYPE_PP(val) != IS_OBJECT)
{
runtimeError("expected an element of type Ice::Endpoint" TSRMLS_CC);
RETURN_NULL();
}
Ice::EndpointPtr endpoint;
if(!fetchEndpoint(*val, endpoint TSRMLS_CC))
{
RETURN_NULL();
}
seq.push_back(endpoint);
zend_hash_move_forward_ex(arr, &pos);
}
try
{
if(!_this->clone(return_value, _this->proxy->ice_endpoints(seq) TSRMLS_CC))
{
RETURN_NULL();
}
}
catch(const IceUtil::Exception& ex)
{
throwException(ex TSRMLS_CC);
RETURN_NULL();
}
}
int FleCSServer::run(int, char*[])
{
try
{
shutdownOnInterrupt();
Ice::ObjectAdapterPtr adapter = communicator()->createObjectAdapter("FleCS");
FleCS::C2SPtr c2s = new C2SI;
adapter->add(c2s, communicator()->stringToIdentity("c2s"));
FleCS::SM2SPtr sm2s = new SM2SI;
adapter->add(sm2s, communicator()->stringToIdentity("sm2s"));
adapter->activate();
// Notify master that a server is on.
//
// No deadlock as long as the master do not notify the originating server.
// server --(join)--> master --(notify)--> all other servers.
//
// Master needs to make sure that join service is serialized.
FleCS::MasterPrx& m_prx = GetMasterProxy();
// Ask to join the system. Give my endpoint and get the existing
// servers.
Ice::EndpointSeq eps = adapter->getEndpoints();
// Assume that this server has one endpoint.
if (eps.size() != 1)
{
_LOG("Unexpected");
exit(EXIT_FAILURE);
}
vector<string> existingServers;
m_prx->Join((*eps.begin())->toString(), existingServers);
AddServers(existingServers);
communicator()->waitForShutdown();
return EXIT_SUCCESS;
}
catch (const exception& e)
{
_LOG(e.what());
}
return EXIT_FAILURE;
}
void
NodeSessionManager::create(const NodeIPtr& node)
{
{
Lock sync(*this);
assert(!_node);
const_cast<NodeIPtr&>(_node) = node;
Ice::CommunicatorPtr communicator = _node->getCommunicator();
assert(communicator->getDefaultLocator());
Ice::Identity id = communicator->getDefaultLocator()->ice_getIdentity();
//
// Initialize the IceGrid::Query objects. The IceGrid::Query
// interface is used to lookup the registry proxy in case it
// becomes unavailable. Since replicas might not always have
// an up to date registry proxy, we need to query all the
// replicas.
//
Ice::EndpointSeq endpoints = communicator->getDefaultLocator()->ice_getEndpoints();
id.name = "Query";
QueryPrx query = QueryPrx::uncheckedCast(communicator->stringToProxy(communicator->identityToString(id)));
for(Ice::EndpointSeq::const_iterator p = endpoints.begin(); p != endpoints.end(); ++p)
{
Ice::EndpointSeq singleEndpoint;
singleEndpoint.push_back(*p);
_queryObjects.push_back(QueryPrx::uncheckedCast(query->ice_endpoints(singleEndpoint)));
}
id.name = "InternalRegistry-Master";
_master = InternalRegistryPrx::uncheckedCast(communicator->stringToProxy(communicator->identityToString(id)));
_thread = new Thread(*this);
_thread->start();
}
//
// Try to create the session. It's important that we wait for the
// creation of the session as this will also try to create sessions
// with replicas (see createdSession below) and this must be done
// before the node is activated.
//
_thread->tryCreateSession(true, IceUtil::Time::seconds(3));
}
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;
}
string
IceStormInternal::describeEndpoints(const Ice::ObjectPrx& proxy)
{
ostringstream os;
if(proxy)
{
Ice::EndpointSeq endpoints = proxy->ice_getEndpoints();
for(Ice::EndpointSeq::const_iterator i = endpoints.begin(); i != endpoints.end(); ++i)
{
if(i != endpoints.begin())
{
os << ", ";
}
os << "\"" << (*i)->toString() << "\"";
}
}
else
{
os << "subscriber proxy is null";
}
return os.str();
}
TestIntfPrxPtr
createTestIntfPrx(vector<RemoteObjectAdapterPrxPtr>& adapters)
{
Ice::EndpointSeq endpoints;
TestIntfPrxPtr test;
for(vector<RemoteObjectAdapterPrxPtr>::const_iterator p = adapters.begin(); p != adapters.end(); ++p)
{
test = (*p)->getTestIntf();
Ice::EndpointSeq edpts = test->ice_getEndpoints();
endpoints.insert(endpoints.end(), edpts.begin(), edpts.end());
}
return ICE_UNCHECKED_CAST(TestIntfPrx, test->ice_endpoints(endpoints));
}
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();
}
int
run(int argc, char* argv[], const CommunicatorPtr& communicator)
{
IceUtilInternal::Options opts;
opts.addOpt("", "cycle");
try
{
opts.parse(argc, (const char**)argv);
}
catch(const IceUtilInternal::BadOptException& e)
{
cerr << argv[0] << ": " << e.reason << endl;
return EXIT_FAILURE;
}
PropertiesPtr properties = communicator->getProperties();
const char* managerProxyProperty = "IceStormAdmin.TopicManager.Default";
string managerProxy = properties->getProperty(managerProxyProperty);
if(managerProxy.empty())
{
cerr << argv[0] << ": property `" << managerProxyProperty << "' is not set" << endl;
return EXIT_FAILURE;
}
IceStorm::TopicManagerPrx manager = IceStorm::TopicManagerPrx::checkedCast(
communicator->stringToProxy(managerProxy));
if(!manager)
{
cerr << argv[0] << ": `" << managerProxy << "' is not running" << endl;
return EXIT_FAILURE;
}
TopicPrx topic;
while(true)
{
try
{
topic = manager->retrieve("single");
break;
}
// This can happen if the replica group loses the majority
// during retrieve. In this case we retry.
catch(const Ice::UnknownException&)
{
continue;
}
catch(const IceStorm::NoSuchTopic& e)
{
cerr << argv[0] << ": NoSuchTopic: " << e.name << endl;
return EXIT_FAILURE;
}
}
assert(topic);
//
// Get a publisher object, create a twoway proxy and then cast to
// a Single object.
//
if(opts.isSet("cycle"))
{
Ice::ObjectPrx prx = topic->getPublisher()->ice_twoway();
vector<SinglePrx> single;
Ice::EndpointSeq endpoints = prx->ice_getEndpoints();
for(Ice::EndpointSeq::const_iterator p = endpoints.begin(); p != endpoints.end(); ++p)
{
if((*p)->toString().substr(0, 3) != "udp")
{
Ice::EndpointSeq e;
e.push_back(*p);
single.push_back(SinglePrx::uncheckedCast(prx->ice_endpoints(e)));
}
}
if(single.size() <= 1)
{
cerr << argv[0] << ": Not enough endpoints in publisher proxy" << endl;
return EXIT_FAILURE;
}
int which = 0;
for(int i = 0; i < 1000; ++i)
{
single[which]->event(i);
which = (which + 1) % static_cast<int>(single.size());
}
}
else
{
SinglePrx single = SinglePrx::uncheckedCast(topic->getPublisher()->ice_twoway());
for(int i = 0; i < 1000; ++i)
{
single->event(i);
}
}
return EXIT_SUCCESS;
}
Ice::ObjectPrx
ReplicaCache::getEndpoints(const string& name, const Ice::ObjectPrx& proxy) const
{
Ice::EndpointSeq endpoints;
if(proxy)
{
Ice::EndpointSeq endpts = proxy->ice_getEndpoints();
endpoints.insert(endpoints.end(), endpts.begin(), endpts.end());
}
Lock sync(*this);
for(map<string, ReplicaEntryPtr>::const_iterator p = _entries.begin(); p != _entries.end(); ++p)
{
Ice::ObjectPrx prx = p->second->getSession()->getEndpoint(name);
if(prx)
{
Ice::EndpointSeq endpts = prx->ice_getEndpoints();
endpoints.insert(endpoints.end(), endpts.begin(), endpts.end());
}
}
return _communicator->stringToProxy("dummy")->ice_endpoints(endpoints);
}
void
allTests(const Ice::CommunicatorPtr& comm)
{
IceGrid::RegistryPrx registry = IceGrid::RegistryPrx::checkedCast(
comm->stringToProxy(comm->getDefaultLocator()->ice_getIdentity().category + "/Registry"));
AdminSessionPrx session = registry->createAdminSession("foo", "bar");
session->ice_getConnection()->setACM(registry->getACMTimeout(), IceUtil::None, Ice::HeartbeatAlways);
AdminPrx admin = session->getAdmin();
test(admin);
map<string, string> params;
params.clear();
params["id"] = "Master";
params["replicaName"] = "";
params["port"] = "12050";
instantiateServer(admin, "IceGridRegistry", params);
params.clear();
params["id"] = "Slave1";
params["replicaName"] = "Slave1";
params["port"] = "12051";
instantiateServer(admin, "IceGridRegistry", params);
params.clear();
params["id"] = "Slave2";
params["replicaName"] = "Slave2";
params["port"] = "12052";
instantiateServer(admin, "IceGridRegistry", params);
Ice::LocatorPrx masterLocator =
Ice::LocatorPrx::uncheckedCast(comm->stringToProxy("RepTestIceGrid/Locator-Master:default -p 12050"));
Ice::LocatorPrx slave1Locator =
Ice::LocatorPrx::uncheckedCast(comm->stringToProxy("RepTestIceGrid/Locator-Slave1:default -p 12051"));
Ice::LocatorPrx slave2Locator =
Ice::LocatorPrx::uncheckedCast(comm->stringToProxy("RepTestIceGrid/Locator-Slave2:default -p 12052"));
Ice::LocatorPrx replicatedLocator =
Ice::LocatorPrx::uncheckedCast(comm->stringToProxy("RepTestIceGrid/Locator:default -p 12050:default -p 12051"));
AdminPrx masterAdmin, slave1Admin, slave2Admin;
admin->startServer("Master");
masterAdmin = createAdminSession(masterLocator, "");
admin->startServer("Slave1");
slave1Admin = createAdminSession(slave1Locator, "Slave1");
//
// Test replication and well-known objects:
//
// - Locator interface
// - Query interface
//
// - Registry object
// - RegistryUserAccountMapper
// - SessionManager/SSLSessionManager
// - AdminSessionManager/AdminSSLSessionManager
//
cout << "testing replicated locator and query interface... " << flush;
{
Ice::EndpointSeq endpoints;
ObjectInfo info;
info = masterAdmin->getObjectInfo(Ice::stringToIdentity("RepTestIceGrid/Locator"));
ObjectInfo info1 = slave1Admin->getObjectInfo(Ice::stringToIdentity("RepTestIceGrid/Locator"));
test(slave1Admin->getObjectInfo(Ice::stringToIdentity("RepTestIceGrid/Locator")) == info);
test(info.type == Ice::Locator::ice_staticId());
endpoints = info.proxy->ice_getEndpoints();
test(endpoints.size() == 2);
test(endpoints[0]->toString().find("-p 12050") != string::npos);
test(endpoints[1]->toString().find("-p 12051") != string::npos);
info = masterAdmin->getObjectInfo(Ice::stringToIdentity("RepTestIceGrid/Query"));
test(slave1Admin->getObjectInfo(Ice::stringToIdentity("RepTestIceGrid/Query")) == info);
test(info.type == IceGrid::Query::ice_staticId());
endpoints = info.proxy->ice_getEndpoints();
test(endpoints.size() == 2);
test(endpoints[0]->toString().find("-p 12050") != string::npos);
test(endpoints[1]->toString().find("-p 12051") != string::npos);
admin->startServer("Slave2");
slave2Admin = createAdminSession(slave2Locator, "Slave2");
info = masterAdmin->getObjectInfo(Ice::stringToIdentity("RepTestIceGrid/Locator"));
// We eventually need to wait here for the update of the replicated objects to propagate to the replica.
int nRetry = 0;
while(slave1Admin->getObjectInfo(Ice::stringToIdentity("RepTestIceGrid/Locator")) != info && nRetry < maxRetry)
{
IceUtil::ThreadControl::sleep(IceUtil::Time::milliSeconds(sleepTime));
++nRetry;
}
test(slave2Admin->getObjectInfo(Ice::stringToIdentity("RepTestIceGrid/Locator")) == info);
test(info.type == Ice::Locator::ice_staticId());
endpoints = info.proxy->ice_getEndpoints();
test(endpoints.size() == 3);
test(endpoints[0]->toString().find("-p 12050") != string::npos);
test(endpoints[1]->toString().find("-p 12051") != string::npos);
test(endpoints[2]->toString().find("-p 12052") != string::npos);
info = masterAdmin->getObjectInfo(Ice::stringToIdentity("RepTestIceGrid/Query"));
// We eventually need to wait here for the update of the replicated objects to propagate to the replica.
nRetry = 0;
while(slave1Admin->getObjectInfo(Ice::stringToIdentity("RepTestIceGrid/Query")) != info && nRetry < maxRetry)
{
IceUtil::ThreadControl::sleep(IceUtil::Time::milliSeconds(sleepTime));
++nRetry;
}
test(slave2Admin->getObjectInfo(Ice::stringToIdentity("RepTestIceGrid/Query")) == info);
test(info.type == IceGrid::Query::ice_staticId());
endpoints = info.proxy->ice_getEndpoints();
test(endpoints.size() == 3);
test(endpoints[0]->toString().find("-p 12050") != string::npos);
test(endpoints[1]->toString().find("-p 12051") != string::npos);
test(endpoints[2]->toString().find("-p 12052") != string::npos);
slave2Admin->shutdown();
waitForServerState(admin, "Slave2", false);
info = masterAdmin->getObjectInfo(Ice::stringToIdentity("RepTestIceGrid/Locator"));
// We eventually need to wait here for the update of the replicated objects to propagate to the replica.
nRetry = 0;
while(slave1Admin->getObjectInfo(Ice::stringToIdentity("RepTestIceGrid/Locator")) != info && nRetry < maxRetry)
{
IceUtil::ThreadControl::sleep(IceUtil::Time::milliSeconds(sleepTime));
++nRetry;
}
test(slave1Admin->getObjectInfo(Ice::stringToIdentity("RepTestIceGrid/Locator")) == info);
test(info.type == Ice::Locator::ice_staticId());
endpoints = info.proxy->ice_getEndpoints();
test(endpoints.size() == 2);
test(endpoints[0]->toString().find("-p 12050") != string::npos);
test(endpoints[1]->toString().find("-p 12051") != string::npos);
info = masterAdmin->getObjectInfo(Ice::stringToIdentity("RepTestIceGrid/Query"));
nRetry = 0;
while(slave1Admin->getObjectInfo(Ice::stringToIdentity("RepTestIceGrid/Query")) != info && nRetry < maxRetry)
{
IceUtil::ThreadControl::sleep(IceUtil::Time::milliSeconds(sleepTime));
++nRetry;
}
test(slave1Admin->getObjectInfo(Ice::stringToIdentity("RepTestIceGrid/Query")) == info);
test(info.type == IceGrid::Query::ice_staticId());
endpoints = info.proxy->ice_getEndpoints();
test(endpoints.size() == 2);
test(endpoints[0]->toString().find("-p 12050") != string::npos);
test(endpoints[1]->toString().find("-p 12051") != string::npos);
QueryPrx query;
query = QueryPrx::uncheckedCast(comm->stringToProxy("RepTestIceGrid/Query:" + endpoints[0]->toString()));
Ice::ObjectProxySeq objs = query->findAllObjectsByType("::IceGrid::Registry");
test(objs.size() == 2);
query = QueryPrx::uncheckedCast(comm->stringToProxy("RepTestIceGrid/Query:" + endpoints[1]->toString()));
test(objs == query->findAllObjectsByType("::IceGrid::Registry"));
}
cout << "ok" << endl;
cout << "testing well-known IceGrid objects... " << flush;
{
//
// Test Registry well-known object (we have already tested
// admin session creation for the creation of the admin
// session above!)
//
RegistryPrx masterRegistry = RegistryPrx::checkedCast(
comm->stringToProxy("RepTestIceGrid/Registry")->ice_locator(replicatedLocator));
RegistryPrx slave1Registry = RegistryPrx::checkedCast(
comm->stringToProxy("RepTestIceGrid/Registry-Slave1")->ice_locator(replicatedLocator));
SessionPrx session = masterRegistry->createSession("dummy", "dummy");
session->destroy();
if(comm->getProperties()->getProperty("Ice.Default.Protocol") == "ssl")
{
session = masterRegistry->createSessionFromSecureConnection();
session->destroy();
}
else
{
try
{
masterRegistry->createSessionFromSecureConnection();
}
catch(const PermissionDeniedException&)
{
}
}
try
{
slave1Registry->createSession("dummy", "");
}
catch(const PermissionDeniedException&)
{
}
try
{
slave1Registry->createSessionFromSecureConnection();
}
catch(const PermissionDeniedException&)
{
}
//
// Test registry user-account mapper.
//
UserAccountMapperPrx masterMapper = UserAccountMapperPrx::checkedCast(
comm->stringToProxy("RepTestIceGrid/RegistryUserAccountMapper")->ice_locator(replicatedLocator));
UserAccountMapperPrx slave1Mapper = UserAccountMapperPrx::checkedCast(
comm->stringToProxy("RepTestIceGrid/RegistryUserAccountMapper-Slave1")->ice_locator(replicatedLocator));
test(masterMapper->getUserAccount("Dummy User Account1") == "dummy1");
test(masterMapper->getUserAccount("Dummy User Account2") == "dummy2");
test(slave1Mapper->getUserAccount("Dummy User Account1") == "dummy1");
test(slave1Mapper->getUserAccount("Dummy User Account2") == "dummy2");
try
{
masterMapper->getUserAccount("unknown");
test(false);
}
catch(const UserAccountNotFoundException&)
{
}
try
{
slave1Mapper->getUserAccount("unknown");
test(false);
}
catch(const UserAccountNotFoundException&)
{
}
//
// Test SessionManager, SSLSessionManager,
// AdminSessionManager, AdminSSLSessionManager
//
comm->stringToProxy("RepTestIceGrid/SessionManager")->ice_locator(replicatedLocator)->ice_ping();
comm->stringToProxy("RepTestIceGrid/SSLSessionManager")->ice_locator(replicatedLocator)->ice_ping();
try
{
comm->stringToProxy("RepTestIceGrid/SessionManager-Slave1")->ice_locator(replicatedLocator)->ice_ping();
test(false);
}
catch(const Ice::NotRegisteredException&)
{
}
try
{
comm->stringToProxy("RepTestIceGrid/SSLSessionManager-Slave1")->ice_locator(replicatedLocator)->ice_ping();
test(false);
}
catch(const Ice::NotRegisteredException&)
{
}
comm->stringToProxy("RepTestIceGrid/AdminSessionManager")->ice_locator(replicatedLocator)->ice_ping();
comm->stringToProxy("RepTestIceGrid/AdminSSLSessionManager")->ice_locator(replicatedLocator)->ice_ping();
comm->stringToProxy("RepTestIceGrid/AdminSessionManager-Slave1")->ice_locator(replicatedLocator)->ice_ping();
comm->stringToProxy("RepTestIceGrid/AdminSSLSessionManager-Slave1")->ice_locator(replicatedLocator)->ice_ping();
}
cout << "ok" << endl;
//
// Registry update test:
//
// - start master
// - start slave1: keep slave1 up for each update
// - start slave2: shutdown slave2 for each update
// - ensure updates are correctly replicated
// - updates to test: application/adapter/object
//
cout << "testing registry updates... " << flush;
{
ApplicationDescriptor app;
app.name = "TestApp";
app.description = "added application";
AdapterInfo adpt;
adpt.id = "TestAdpt";
adpt.proxy = comm->stringToProxy("dummy:tcp -p 12345 -h 127.0.0.1");
ObjectInfo obj;
obj.proxy = comm->stringToProxy("dummy:tcp -p 12345 -h 127.0.0.1");
obj.type = "::Hello";
//
// We use the locator registry from Slave1 to ensure that the
// forwarding to the master work (the slave locator registry
// forwards everything to the master).
//
Ice::LocatorRegistryPrx locatorRegistry = slave1Locator->getRegistry();
//
// Test addition of application, adapter, object.
//
try
{
slave1Admin->addApplication(app);
test(false);
}
catch(const DeploymentException&)
{
// Slave can't modify the database.
}
masterAdmin->addApplication(app);
locatorRegistry->setAdapterDirectProxy(adpt.id, adpt.proxy);
try
{
slave1Admin->addObjectWithType(obj.proxy, obj.type);
test(false);
}
catch(const DeploymentException&)
{
// Slave can't modify the database
}
masterAdmin->addObjectWithType(obj.proxy, obj.type);
admin->startServer("Slave2");
slave2Admin = createAdminSession(slave2Locator, "Slave2");
test(masterAdmin->getApplicationInfo("TestApp").descriptor.description == "added application");
test(slave1Admin->getApplicationInfo("TestApp").descriptor.description == "added application");
test(slave2Admin->getApplicationInfo("TestApp").descriptor.description == "added application");
test(masterAdmin->getAdapterInfo("TestAdpt")[0] == adpt);
test(slave1Admin->getAdapterInfo("TestAdpt")[0] == adpt);
test(slave2Admin->getAdapterInfo("TestAdpt")[0] == adpt);
test(masterAdmin->getObjectInfo(obj.proxy->ice_getIdentity()) == obj);
test(slave1Admin->getObjectInfo(obj.proxy->ice_getIdentity()) == obj);
test(slave2Admin->getObjectInfo(obj.proxy->ice_getIdentity()) == obj);
slave2Admin->shutdown();
waitForServerState(admin, "Slave2", false);
//
// Test sync of application.
//
app.description = "updated1 application";
try
{
slave1Admin->syncApplication(app);
test(false);
}
catch(const DeploymentException&)
{
// Slave can't modify the database.
}
masterAdmin->syncApplication(app);
admin->startServer("Slave2");
slave2Admin = createAdminSession(slave2Locator, "Slave2");
test(masterAdmin->getApplicationInfo("TestApp").descriptor.description == "updated1 application");
test(slave1Admin->getApplicationInfo("TestApp").descriptor.description == "updated1 application");
test(slave2Admin->getApplicationInfo("TestApp").descriptor.description == "updated1 application");
slave2Admin->shutdown();
waitForServerState(admin, "Slave2", false);
//
// Test update of application, adapter, object.
//
ApplicationUpdateDescriptor appUpdate;
appUpdate.name = "TestApp";
appUpdate.description = new BoxedString("updated2 application");
try
{
slave1Admin->updateApplication(appUpdate);
test(false);
}
catch(const DeploymentException&)
{
// Slave can't modify the database.
}
masterAdmin->updateApplication(appUpdate);
adpt.replicaGroupId = "TestReplicaGroup";
locatorRegistry->setReplicatedAdapterDirectProxy(adpt.id, adpt.replicaGroupId, adpt.proxy);
obj.proxy = comm->stringToProxy("dummy:tcp -p 12346 -h 127.0.0.1");
try
{
slave1Admin->updateObject(obj.proxy);
test(false);
}
catch(const DeploymentException&)
{
// Slave can't modify the database
}
masterAdmin->updateObject(obj.proxy);
admin->startServer("Slave2");
slave2Admin = createAdminSession(slave2Locator, "Slave2");
test(masterAdmin->getApplicationInfo("TestApp").descriptor.description == "updated2 application");
test(slave1Admin->getApplicationInfo("TestApp").descriptor.description == "updated2 application");
test(slave2Admin->getApplicationInfo("TestApp").descriptor.description == "updated2 application");
test(masterAdmin->getAdapterInfo("TestAdpt")[0] == adpt);
test(slave1Admin->getAdapterInfo("TestAdpt")[0] == adpt);
test(slave2Admin->getAdapterInfo("TestAdpt")[0] == adpt);
test(masterAdmin->getObjectInfo(obj.proxy->ice_getIdentity()) == obj);
test(slave1Admin->getObjectInfo(obj.proxy->ice_getIdentity()) == obj);
test(slave2Admin->getObjectInfo(obj.proxy->ice_getIdentity()) == obj);
slave2Admin->shutdown();
waitForServerState(admin, "Slave2", false);
//
// Test removal of application, adapter and object.
try
{
slave1Admin->removeApplication("TestApp");
test(false);
}
catch(const DeploymentException&)
{
// Slave can't modify the database.
}
masterAdmin->removeApplication("TestApp");
try
{
slave1Admin->removeAdapter("TestAdpt");
test(false);
}
catch(const DeploymentException&)
{
// Slave can't modify the database.
}
masterAdmin->removeAdapter("TestAdpt");
try
{
slave1Admin->removeObject(obj.proxy->ice_getIdentity());
}
catch(const DeploymentException&)
{
// Slave can't modify the database.
}
masterAdmin->removeObject(obj.proxy->ice_getIdentity());
admin->startServer("Slave2");
slave2Admin = createAdminSession(slave2Locator, "Slave2");
try
{
masterAdmin->getApplicationInfo("TestApp");
test(false);
}
catch(const ApplicationNotExistException&)
{
}
try
{
slave1Admin->getApplicationInfo("TestApp");
test(false);
}
catch(const ApplicationNotExistException&)
{
}
try
{
slave2Admin->getApplicationInfo("TestApp");
test(false);
}
catch(const ApplicationNotExistException&)
{
}
try
{
masterAdmin->getAdapterInfo("TestAdpt");
test(false);
}
catch(const AdapterNotExistException&)
{
}
try
{
slave1Admin->getAdapterInfo("TestAdpt");
test(false);
}
catch(const AdapterNotExistException&)
{
}
try
{
slave2Admin->getAdapterInfo("TestAdpt");
test(false);
}
catch(const AdapterNotExistException&)
{
}
try
{
masterAdmin->getObjectInfo(obj.proxy->ice_getIdentity());
test(false);
}
catch(const ObjectNotRegisteredException&)
{
}
try
{
slave1Admin->getObjectInfo(obj.proxy->ice_getIdentity());
test(false);
}
catch(const ObjectNotRegisteredException&)
{
}
try
{
slave2Admin->getObjectInfo(obj.proxy->ice_getIdentity());
test(false);
}
catch(const ObjectNotRegisteredException&)
{
}
slave2Admin->shutdown();
waitForServerState(admin, "Slave2", false);
}
cout << "ok" << endl;
params.clear();
params["id"] = "Node1";
instantiateServer(admin, "IceGridNode", params);
//
// Add an application which is using Node1. Otherwise, when a
// registry restarts it would throw aways the proxy of the nodes
// because the node isn't used by any application.
//
ApplicationDescriptor app;
app.name = "DummyApp";
app.nodes["Node1"].description = "dummy node";
try
{
masterAdmin->addApplication(app);
}
catch(const Ice::Exception& ex)
{
cerr << ex << endl;
test(false);
}
//
// Test node session establishment.
//
// - start master, start slave1, start node, start slave2
// - shutdown slave1, start slave1 -> node should re-connect
// - shutdown master
// - shutdown slave2, start slave2 -> node should re-connect
// - shutdown slave1
// - start master -> node connects to master
// - start slave1 -> node connects to slave1
//
cout << "testing node session establishment... " << flush;
{
admin->startServer("Node1");
waitForNodeState(masterAdmin, "Node1", true);
waitForNodeState(slave1Admin, "Node1", true);
admin->startServer("Slave2");
slave2Admin = createAdminSession(slave2Locator, "Slave2");
waitForNodeState(slave2Admin, "Node1", true); // Node should connect.
slave1Admin->shutdown();
waitForServerState(admin, "Slave1", false);
admin->startServer("Slave1");
slave1Admin = createAdminSession(slave1Locator, "Slave1");
try
{
test(slave1Admin->pingNode("Node1")); // Node should be re-connected.
}
catch(const NodeNotExistException&)
{
test(false);
}
masterAdmin->shutdown();
waitForServerState(admin, "Master", false);
slave2Admin->shutdown();
waitForServerState(admin, "Slave2", false);
admin->startServer("Slave2");
slave2Admin = createAdminSession(slave2Locator, "Slave2");
try
{
//
// On slow environments, it can take a bit for the node to
// re-establish the connection so we ping it twice. The
// second should succeed.
//
slave2Admin->pingNode("Node1");
test(slave2Admin->pingNode("Node1")); // Node should be re-connected even if the master is down.
}
catch(const NodeNotExistException&)
{
test(false);
}
slave1Admin->shutdown();
waitForServerState(admin, "Slave1", false);
admin->startServer("Master");
masterAdmin = createAdminSession(masterLocator, "");
try
{
test(masterAdmin->pingNode("Node1")); // Node should be re-connected.
}
catch(const NodeNotExistException&)
{
test(false);
}
admin->startServer("Slave1");
slave1Admin = createAdminSession(slave1Locator, "Slave1");
try
{
test(slave1Admin->pingNode("Node1")); // Node should be re-connected.
}
catch(const NodeNotExistException&)
{
test(false);
}
try
{
test(masterAdmin->pingNode("Node1"));
}
catch(const NodeNotExistException&)
{
test(false);
}
try
{
test(slave2Admin->pingNode("Node1"));
}
catch(const NodeNotExistException&)
{
test(false);
}
slave2Admin->shutdown();
waitForServerState(admin, "Slave2", false);
admin->startServer("Slave2");
slave2Admin = createAdminSession(slave2Locator, "Slave2");
try
{
test(slave2Admin->pingNode("Node1"));
}
catch(const NodeNotExistException&)
{
test(false);
}
}
cout << "ok" << endl;
//
// Testing updates with out-of-date replicas.
//
cout << "testing out-of-date replicas... " << flush;
{
ApplicationDescriptor app;
app.name = "TestApp";
app.description = "added application";
ServerDescriptorPtr server = new ServerDescriptor();
server->id = "Server";
server->exe = comm->getProperties()->getProperty("ServerDir") + "/server";
server->pwd = ".";
server->applicationDistrib = false;
server->allocatable = false;
addProperty(server, "Ice.Admin.Endpoints", "tcp -h 127.0.0.1");
server->activation = "on-demand";
AdapterDescriptor adapter;
adapter.name = "TestAdapter";
adapter.id = "TestAdapter.Server";
adapter.registerProcess = false;
adapter.serverLifetime = true;
PropertyDescriptor property;
property.name = "TestAdapter.Endpoints";
property.value = "default";
server->propertySet.properties.push_back(property);
property.name = "Identity";
property.value = "test";
server->propertySet.properties.push_back(property);
ObjectDescriptor object;
object.id = Ice::stringToIdentity("test");
object.type = "::Test::TestIntf";
adapter.objects.push_back(object);
server->adapters.push_back(adapter);
app.nodes["Node1"].servers.push_back(server);
masterAdmin->addApplication(app);
try
{
comm->stringToProxy("test")->ice_locator(masterLocator)->ice_locatorCacheTimeout(0)->ice_ping();
comm->stringToProxy("test")->ice_locator(slave1Locator)->ice_locatorCacheTimeout(0)->ice_ping();
comm->stringToProxy("test")->ice_locator(slave2Locator)->ice_locatorCacheTimeout(0)->ice_ping();
}
catch(const Ice::LocalException& ex)
{
cerr << ex << endl;
test(false);
}
masterAdmin->stopServer("Server");
//
// Shutdown Slave2 and update application.
//
slave2Admin->shutdown();
waitForServerState(admin, "Slave2", false);
ApplicationUpdateDescriptor update;
update.name = "TestApp";
NodeUpdateDescriptor node;
node.name = "Node1";
node.servers.push_back(server);
update.nodes.push_back(node);
property.name = "Dummy";
property.value = "val";
server->propertySet.properties.push_back(property);
masterAdmin->updateApplication(update);
try
{
comm->stringToProxy("test")->ice_locator(masterLocator)->ice_locatorCacheTimeout(0)->ice_ping();
comm->stringToProxy("test")->ice_locator(slave1Locator)->ice_locatorCacheTimeout(0)->ice_ping();
}
catch(const Ice::LocalException& ex)
{
cerr << ex << endl;
test(false);
}
masterAdmin->shutdown();
waitForServerState(admin, "Master", false);
admin->startServer("Slave2");
slave2Admin = createAdminSession(slave2Locator, "Slave2");
waitForNodeState(slave2Admin, "Node1", true); // Node should connect.
try
{
slave2Admin->startServer("Server");
test(false);
}
catch(const DeploymentException&)
{
}
try
{
comm->stringToProxy("test")->ice_locator(slave2Locator)->ice_locatorCacheTimeout(0)->ice_ping();
test(false);
}
catch(const Ice::NoEndpointException&)
{
}
admin->startServer("Master");
masterAdmin = createAdminSession(masterLocator, "");
slave2Admin->shutdown();
waitForServerState(admin, "Slave2", false);
admin->startServer("Slave2");
slave2Admin = createAdminSession(slave2Locator, "Slave2");
try
{
comm->stringToProxy("test")->ice_locator(slave2Locator)->ice_locatorCacheTimeout(0)->ice_ping();
}
catch(const Ice::LocalException& ex)
{
cerr << ex << endl;
test(false);
}
//
// Shutdown Node1 and update the application, then, shutdown
// the master.
//
slave1Admin->shutdownNode("Node1");
waitForServerState(admin, "Node1", false);
slave2Admin->shutdown();
waitForServerState(admin, "Slave2", false);
property.name = "Dummy2";
property.value = "val";
server->propertySet.properties.push_back(property);
masterAdmin->updateApplication(update);
masterAdmin->shutdown();
waitForServerState(admin, "Master", false);
//
// Restart Node1 and Slave2, Slave2 still has the old version
// of the server so it should be able to load it. Slave1 has
// a more recent version, so it can't load it.
//
admin->startServer("Slave2");
slave2Admin = createAdminSession(slave2Locator, "Slave2");
admin->startServer("Node1");
waitForNodeState(slave2Admin, "Node1", true);
slave1Admin->shutdown();
waitForServerState(admin, "Slave1", false);
try
{
comm->stringToProxy("test")->ice_locator(slave2Locator)->ice_locatorCacheTimeout(0)->ice_ping();
}
catch(const Ice::LocalException& ex)
{
cerr << ex << endl;
test(false);
}
admin->startServer("Slave1");
slave1Admin = createAdminSession(slave1Locator, "Slave1");
try
{
comm->stringToProxy("test")->ice_locator(slave1Locator)->ice_locatorCacheTimeout(0)->ice_ping();
}
catch(const Ice::NoEndpointException&)
{
}
try
{
comm->stringToProxy("test")->ice_locator(slave2Locator)->ice_locatorCacheTimeout(0)->ice_ping();
}
catch(const Ice::LocalException& ex)
{
cerr << ex << endl;
test(false);
}
slave2Admin->stopServer("Server");
//
// Start the master. This will re-load the server on the node
// and update the out-of-date replicas.
//
admin->startServer("Master");
masterAdmin = createAdminSession(masterLocator, "");
slave1Admin->shutdown();
waitForServerState(admin, "Slave1", false);
admin->startServer("Slave1");
slave1Admin = createAdminSession(slave1Locator, "Slave1");
slave2Admin->shutdownNode("Node1");
waitForServerState(admin, "Node1", false);
admin->startServer("Node1");
slave2Admin->shutdown();
waitForServerState(admin, "Slave2", false);
admin->startServer("Slave2");
slave2Admin = createAdminSession(slave2Locator, "Slave2");
waitForNodeState(masterAdmin, "Node1", true);
waitForNodeState(slave1Admin, "Node1", true);
waitForNodeState(slave2Admin, "Node1", true);
try
{
comm->stringToProxy("test")->ice_locator(masterLocator)->ice_locatorCacheTimeout(0)->ice_ping();
comm->stringToProxy("test")->ice_locator(slave1Locator)->ice_locatorCacheTimeout(0)->ice_ping();
comm->stringToProxy("test")->ice_locator(slave2Locator)->ice_locatorCacheTimeout(0)->ice_ping();
}
catch(const Ice::LocalException& ex)
{
cerr << ex << endl;
test(false);
}
slave2Admin->stopServer("Server");
masterAdmin->removeApplication("TestApp");
}
cout << "ok" << endl;
cout << "testing master upgrade... " << flush;
{
ApplicationDescriptor app;
app.name = "TestApp";
app.description = "added application";
ServerDescriptorPtr server = new ServerDescriptor();
server->id = "Server";
server->exe = comm->getProperties()->getProperty("ServerDir") + "/server";
server->pwd = ".";
server->applicationDistrib = false;
server->allocatable = false;
addProperty(server, "Ice.Admin.Endpoints", "tcp -h 127.0.0.1");
server->activation = "on-demand";
AdapterDescriptor adapter;
adapter.name = "TestAdapter";
adapter.id = "TestAdapter.Server";
adapter.serverLifetime = true;
adapter.registerProcess = false;
PropertyDescriptor property;
property.name = "TestAdapter.Endpoints";
property.value = "default";
server->propertySet.properties.push_back(property);
property.name = "Identity";
property.value = "test";
server->propertySet.properties.push_back(property);
ObjectDescriptor object;
object.id = Ice::stringToIdentity("test");
object.type = "::Test::TestIntf";
adapter.objects.push_back(object);
server->adapters.push_back(adapter);
app.nodes["Node1"].servers.push_back(server);
masterAdmin->addApplication(app);
comm->stringToProxy("test")->ice_locator(masterLocator)->ice_locatorCacheTimeout(0)->ice_ping();
comm->stringToProxy("test")->ice_locator(slave1Locator)->ice_locatorCacheTimeout(0)->ice_ping();
comm->stringToProxy("test")->ice_locator(slave2Locator)->ice_locatorCacheTimeout(0)->ice_ping();
masterAdmin->stopServer("Server");
//
// Shutdown the Master, update Slave1 to be the Master.
//
masterAdmin->shutdown();
waitForServerState(admin, "Master", false);
slave1Admin->shutdown();
waitForServerState(admin, "Slave1", false);
params.clear();
params["id"] = "Slave1";
params["port"] = "12051";
params["replicaName"] = "Master";
instantiateServer(admin, "IceGridRegistry", params);
admin->startServer("Slave1");
slave1Locator =
Ice::LocatorPrx::uncheckedCast(comm->stringToProxy("RepTestIceGrid/Locator-Master:default -p 12051"));
slave1Admin = createAdminSession(slave1Locator, "");
waitForReplicaState(slave1Admin, "Slave2", true);
ApplicationUpdateDescriptor update;
update.name = "TestApp";
NodeUpdateDescriptor node;
node.name = "Node1";
node.servers.push_back(server);
update.nodes.push_back(node);
property.name = "Dummy";
property.value = "val";
server->propertySet.properties.push_back(property);
slave1Admin->updateApplication(update);
comm->stringToProxy("test")->ice_locator(slave1Locator)->ice_locatorCacheTimeout(0)->ice_ping();
comm->stringToProxy("test")->ice_locator(slave2Locator)->ice_locatorCacheTimeout(0)->ice_ping();
slave1Admin->shutdown();
waitForServerState(admin, "Slave1", false);
params.clear();
params["id"] = "Slave1";
params["replicaName"] = "Slave1";
params["port"] = "12051";
instantiateServer(admin, "IceGridRegistry", params);
params.clear();
params["id"] = "Master";
params["replicaName"] = "";
params["port"] = "12050";
params["arg"] = "--initdb-from-replica=Slave2";
instantiateServer(admin, "IceGridRegistry", params);
admin->startServer("Master");
masterAdmin = createAdminSession(masterLocator, "");
admin->startServer("Slave1");
slave1Locator =
Ice::LocatorPrx::uncheckedCast(comm->stringToProxy("RepTestIceGrid/Locator-Slave1:default -p 12051"));
slave1Admin = createAdminSession(slave1Locator, "Slave1");
comm->stringToProxy("test")->ice_locator(masterLocator)->ice_locatorCacheTimeout(0)->ice_ping();
comm->stringToProxy("test")->ice_locator(slave1Locator)->ice_locatorCacheTimeout(0)->ice_ping();
comm->stringToProxy("test")->ice_locator(slave2Locator)->ice_locatorCacheTimeout(0)->ice_ping();
masterAdmin->stopServer("Server");
waitForReplicaState(masterAdmin, "Slave1", true);
waitForReplicaState(masterAdmin, "Slave2", true);
ApplicationInfo info = masterAdmin->getApplicationInfo("TestApp");
test(info.revision == 2);
masterAdmin->removeApplication("TestApp");
}
cout << "ok" << endl;
cout << "testing interop with registry and node using the 1.0 encoding... " << flush;
{
params.clear();
params["id"] = "Slave3";
params["replicaName"] = "Slave3";
params["port"] = "12053";
params["encoding"] = "1.0";
instantiateServer(admin, "IceGridRegistry", params);
params.clear();
params["id"] = "Node2";
params["encoding"] = "1.0";
instantiateServer(admin, "IceGridNode", params);
admin->startServer("Slave3");
waitForServerState(admin, "Slave3", true);
waitForReplicaState(masterAdmin, "Slave3", true);
admin->startServer("Node2");
waitForNodeState(masterAdmin, "Node2", true);
Ice::LocatorPrx slave3Locator =
Ice::LocatorPrx::uncheckedCast(
comm->stringToProxy("RepTestIceGrid/Locator-Slave3 -e 1.0:default -p 12053"));
IceGrid::AdminPrx slave3Admin = createAdminSession(slave3Locator, "Slave3");
waitForNodeState(slave3Admin, "Node2", true);
ApplicationDescriptor app;
app.name = "TestApp";
app.description = "added application";
ServerDescriptorPtr server = new ServerDescriptor();
server->id = "Server";
server->exe = comm->getProperties()->getProperty("ServerDir") + "/server";
server->pwd = ".";
server->applicationDistrib = false;
server->allocatable = false;
addProperty(server, "Ice.Admin.Endpoints", "tcp -h 127.0.0.1");
server->activation = "on-demand";
AdapterDescriptor adapter;
adapter.name = "TestAdapter";
adapter.id = "TestAdapter.Server";
adapter.serverLifetime = true;
adapter.registerProcess = false;
PropertyDescriptor property;
property.name = "TestAdapter.Endpoints";
property.value = "default";
server->propertySet.properties.push_back(property);
property.name = "Identity";
property.value = "test";
server->propertySet.properties.push_back(property);
ObjectDescriptor object;
object.id = Ice::stringToIdentity("test");
object.type = "::Test::TestIntf";
adapter.objects.push_back(object);
server->adapters.push_back(adapter);
app.nodes["Node2"].servers.push_back(server);
masterAdmin->addApplication(app);
comm->stringToProxy("test -e 1.0")->ice_locator(
masterLocator->ice_encodingVersion(Ice::Encoding_1_0))->ice_locatorCacheTimeout(0)->ice_ping();
comm->stringToProxy("test -e 1.0")->ice_locator(
slave1Locator->ice_encodingVersion(Ice::Encoding_1_0))->ice_locatorCacheTimeout(0)->ice_ping();
comm->stringToProxy("test -e 1.0")->ice_locator(slave3Locator)->ice_locatorCacheTimeout(0)->ice_ping();
masterAdmin->stopServer("Server");
}
cout << "ok" << endl;
slave1Admin->shutdownNode("Node1");
removeServer(admin, "Node1");
removeServer(admin, "Slave2");
slave1Admin->shutdown();
removeServer(admin, "Slave1");
masterAdmin->shutdown();
removeServer(admin, "Master");
}
void
allTests(const Ice::CommunicatorPtr& communicator)
{
cout << "testing proxy endpoint information... " << flush;
{
Ice::ObjectPrx p1 =
communicator->stringToProxy("test -t:default -h tcphost -p 10000 -t 1200 -z --sourceAddress 10.10.10.10:"
"udp -h udphost -p 10001 --interface eth0 --ttl 5 --sourceAddress 10.10.10.10:"
"opaque -e 1.8 -t 100 -v ABCD");
Ice::EndpointSeq endps = p1->ice_getEndpoints();
Ice::IPEndpointInfoPtr ipEndpoint = Ice::IPEndpointInfoPtr::dynamicCast(endps[0]->getInfo());
test(ipEndpoint);
test(ipEndpoint->host == "tcphost");
test(ipEndpoint->port == 10000);
test(ipEndpoint->timeout == 1200);
#if !defined(ICE_OS_WINRT)
test(ipEndpoint->sourceAddress == "10.10.10.10");
#endif
test(ipEndpoint->compress);
test(!ipEndpoint->datagram());
test((ipEndpoint->type() == Ice::TCPEndpointType && !ipEndpoint->secure()) ||
(ipEndpoint->type() == IceSSL::EndpointType && ipEndpoint->secure()) ||
(ipEndpoint->type() == Ice::WSEndpointType && !ipEndpoint->secure()) ||
(ipEndpoint->type() == Ice::WSSEndpointType && ipEndpoint->secure()));
test((ipEndpoint->type() == Ice::TCPEndpointType && Ice::TCPEndpointInfoPtr::dynamicCast(ipEndpoint)) ||
(ipEndpoint->type() == IceSSL::EndpointType && IceSSL::EndpointInfoPtr::dynamicCast(ipEndpoint)) ||
(ipEndpoint->type() == Ice::WSEndpointType && Ice::EndpointInfoPtr::dynamicCast(ipEndpoint)) ||
(ipEndpoint->type() == Ice::WSSEndpointType && Ice::EndpointInfoPtr::dynamicCast(ipEndpoint)));
Ice::UDPEndpointInfoPtr udpEndpoint = Ice::UDPEndpointInfoPtr::dynamicCast(endps[1]->getInfo());
test(udpEndpoint);
test(udpEndpoint->host == "udphost");
test(udpEndpoint->port == 10001);
#if !defined(ICE_OS_WINRT)
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::OpaqueEndpointInfoPtr::dynamicCast(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");
cout << "test object adapter endpoint information... " << flush;
{
communicator->getProperties()->setProperty("TestAdapter.Endpoints", "default -t 15000:udp");
Ice::ObjectAdapterPtr adapter = communicator->createObjectAdapter("TestAdapter");
Ice::EndpointSeq endpoints = adapter->getEndpoints();
test(endpoints.size() == 2);
Ice::EndpointSeq publishedEndpoints = adapter->getPublishedEndpoints();
test(endpoints == publishedEndpoints);
Ice::IPEndpointInfoPtr ipEndpoint = Ice::IPEndpointInfoPtr::dynamicCast(endpoints[0]->getInfo());
test(ipEndpoint);
test(ipEndpoint->type() == Ice::TCPEndpointType || ipEndpoint->type() == IceSSL::EndpointType ||
ipEndpoint->type() == Ice::WSEndpointType || ipEndpoint->type() == Ice::WSSEndpointType);
test(ipEndpoint->host == defaultHost);
test(ipEndpoint->port > 0);
test(ipEndpoint->timeout == 15000);
Ice::UDPEndpointInfoPtr udpEndpoint = Ice::UDPEndpointInfoPtr::dynamicCast(endpoints[1]->getInfo());
test(udpEndpoint);
test(udpEndpoint->host == defaultHost);
test(udpEndpoint->datagram());
test(udpEndpoint->port > 0);
adapter->destroy();
communicator->getProperties()->setProperty("TestAdapter.Endpoints", "default -h * -p 12020");
communicator->getProperties()->setProperty("TestAdapter.PublishedEndpoints", "default -h 127.0.0.1 -p 12020");
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 = Ice::IPEndpointInfoPtr::dynamicCast((*p)->getInfo());
test(ipEndpoint->port == 12020);
}
ipEndpoint = Ice::IPEndpointInfoPtr::dynamicCast(publishedEndpoints[0]->getInfo());
test(ipEndpoint->host == "127.0.0.1");
test(ipEndpoint->port == 12020);
adapter->destroy();
}
cout << "ok" << endl;
Ice::ObjectPrx base = communicator->stringToProxy("test:default -p 12010:udp -p 12010 -c");
TestIntfPrx testIntf = TestIntfPrx::checkedCast(base);
cout << "test connection endpoint information... " << flush;
{
Ice::EndpointInfoPtr info = base->ice_getConnection()->getEndpoint()->getInfo();
Ice::IPEndpointInfoPtr ipinfo = Ice::IPEndpointInfoPtr::dynamicCast(info);
test(ipinfo->port == 12010);
test(!ipinfo->compress);
test(ipinfo->host == defaultHost);
ostringstream os;
Ice::Context ctx = testIntf->getEndpointInfoAsContext();
test(ctx["host"] == ipinfo->host);
test(ctx["compress"] == "false");
istringstream is(ctx["port"]);
int port;
is >> port;
test(port > 0);
info = base->ice_datagram()->ice_getConnection()->getEndpoint()->getInfo();
Ice::UDPEndpointInfoPtr udp = Ice::UDPEndpointInfoPtr::dynamicCast(info);
test(udp);
test(udp->port == 12010);
test(udp->host == defaultHost);
}
cout << "ok" << endl;
cout << "testing connection information... " << flush;
{
Ice::IPConnectionInfoPtr info = Ice::IPConnectionInfoPtr::dynamicCast(base->ice_getConnection()->getInfo());
test(info);
test(!info->incoming);
test(info->adapterName.empty());
test(info->localPort > 0);
test(info->remotePort == 12010);
if(defaultHost == "127.0.0.1")
{
test(info->remoteAddress == defaultHost);
test(info->localAddress == defaultHost);
}
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());
info = Ice::IPConnectionInfoPtr::dynamicCast(base->ice_datagram()->ice_getConnection()->getInfo());
test(!info->incoming);
test(info->adapterName.empty());
test(info->localPort > 0);
test(info->remotePort == 12010);
if(defaultHost == "127.0.0.1")
{
test(info->remoteAddress == defaultHost);
test(info->localAddress == defaultHost);
}
}
cout << "ok" << endl;
testIntf->shutdown();
communicator->shutdown();
communicator->waitForShutdown();
}
