int
AdapterObserverTopic::adapterInit(Ice::Long dbSerial, const AdapterInfoSeq& adpts)
{
Lock sync(*this);
if(_topics.empty())
{
return -1;
}
updateSerial(dbSerial);
_adapters.clear();
for(AdapterInfoSeq::const_iterator q = adpts.begin(); q != adpts.end(); ++q)
{
_adapters.insert(make_pair(q->id, *q));
}
try
{
for(vector<AdapterObserverPrx>::const_iterator p = _publishers.begin(); p != _publishers.end(); ++p)
{
(*p)->adapterInit(adpts, getContext(_serial, dbSerial));
}
}
catch(const Ice::LocalException& ex)
{
Ice::Warning out(_logger);
out << "unexpected exception while publishing `adapterInit' update:\n" << ex;
}
addExpectedUpdate(_serial);
return _serial;
}
void
AdapterObserverTopic::initObserver(const Ice::ObjectPrx& obsv)
{
AdapterObserverPrx observer = AdapterObserverPrx::uncheckedCast(obsv);
AdapterInfoSeq adapters;
for(map<string, AdapterInfo>::const_iterator p = _adapters.begin(); p != _adapters.end(); ++p)
{
adapters.push_back(p->second);
}
observer->adapterInit(adapters, getContext(_serial, _dbSerial));
}
Ice::ObjectProxySeq
QueryI::findAllReplicas(const Ice::ObjectPrx& proxy, const Ice::Current&) const
{
if(!proxy)
{
return Ice::ObjectProxySeq();
}
//
// If the given proxy has an empty adapter id, we check if it's a
// well-known object. If it's a well-known object we use the
// registered proxy instead.
//
Ice::ObjectPrx prx = proxy;
if(prx->ice_getAdapterId().empty())
{
try
{
ObjectInfo info = _database->getObjectInfo(prx->ice_getIdentity());
prx = info.proxy;
}
catch(const ObjectNotRegisteredException&)
{
return Ice::ObjectProxySeq();
}
}
try
{
AdapterInfoSeq infos = _database->getAdapterInfo(prx->ice_getAdapterId());
if(infos.empty() || infos[0].replicaGroupId != prx->ice_getAdapterId())
{
// The adapter id doesn't refer to a replica group or the replica group is empty.
return Ice::ObjectProxySeq();
}
Ice::ObjectProxySeq proxies;
for(AdapterInfoSeq::const_iterator p = infos.begin(); p != infos.end(); ++p)
{
assert(!p->id.empty());
proxies.push_back(prx->ice_adapterId(p->id));
}
return proxies;
}
catch(const AdapterNotExistException&)
{
return Ice::ObjectProxySeq();
}
}
AdapterInfoSeq
ServerAdapterEntry::getAdapterInfo() const
{
AdapterInfo info;
info.id = _id;
info.replicaGroupId = _replicaGroupId;
try
{
info.proxy = _server->getAdapter(_id, true)->getDirectProxy();
}
catch(const SynchronizationException&)
{
}
catch(const Ice::Exception&)
{
}
AdapterInfoSeq infos;
infos.push_back(info);
return infos;
}
AdapterInfoSeq
ReplicaGroupEntry::getAdapterInfo() const
{
//
// This method is called with the database locked so we're sure
// that no new adapters will be added or removed concurrently.
//
vector<ServerAdapterEntryPtr> replicas;
{
Lock sync(*this);
replicas = _replicas;
}
AdapterInfoSeq infos;
for(vector<ServerAdapterEntryPtr>::const_iterator p = replicas.begin(); p != replicas.end(); ++p)
{
AdapterInfoSeq infs = (*p)->getAdapterInfo();
assert(infs.size() == 1);
infos.push_back(infs[0]);
}
return infos;
}
