void
IceInternal::LocatorInfo::clearCache(const ReferencePtr& ref)
{
assert(ref->isIndirect());
if(!ref->isWellKnown())
{
vector<EndpointIPtr> endpoints = _table->removeAdapterEndpoints(ref->getAdapterId());
if(!endpoints.empty() && ref->getInstance()->traceLevels()->location >= 2)
{
trace("removed endpoints from locator table", ref, endpoints);
}
}
else
{
ReferencePtr r = _table->removeObjectReference(ref->getIdentity());
if(r)
{
if(!r->isIndirect())
{
if(ref->getInstance()->traceLevels()->location >= 2)
{
trace("removed endpoints from locator table", ref, r->getEndpoints());
}
}
else if(!r->isWellKnown())
{
clearCache(r);
}
}
}
}
void
IceInternal::LocatorInfo::getEndpoints(const ReferencePtr& ref,
const ReferencePtr& wellKnownRef,
int ttl,
const GetEndpointsCallbackPtr& callback)
{
assert(ref->isIndirect());
vector<EndpointIPtr> endpoints;
if(!ref->isWellKnown())
{
if(!_table->getAdapterEndpoints(ref->getAdapterId(), ttl, endpoints))
{
if(_background && !endpoints.empty())
{
getAdapterRequest(ref)->addCallback(ref, wellKnownRef, ttl, 0);
}
else
{
getAdapterRequest(ref)->addCallback(ref, wellKnownRef, ttl, callback);
return;
}
}
}
else
{
ReferencePtr r;
if(!_table->getObjectReference(ref->getIdentity(), ttl, r))
{
if(_background && r)
{
getObjectRequest(ref)->addCallback(ref, 0, ttl, 0);
}
else
{
getObjectRequest(ref)->addCallback(ref, 0, ttl, callback);
return;
}
}
if(!r->isIndirect())
{
endpoints = r->getEndpoints();
}
else if(!r->isWellKnown())
{
getEndpoints(r, ref, ttl, callback);
return;
}
}
assert(!endpoints.empty());
if(ref->getInstance()->traceLevels()->location >= 1)
{
getEndpointsTrace(ref, endpoints, true);
}
if(callback)
{
callback->setEndpoints(endpoints, true);
}
}
vector<EndpointIPtr>
IceInternal::LocatorInfo::Request::getEndpoints(const ReferencePtr& ref,
const ReferencePtr& wellKnownRef,
int ttl,
bool& cached)
{
IceUtil::Monitor<IceUtil::Mutex>::Lock sync(_monitor);
if(!_response || _exception.get())
{
if(wellKnownRef) // This request is to resolve the endpoints of a cached well-known object reference
{
_wellKnownRefs.push_back(wellKnownRef);
}
if(!_sent)
{
_sent = true;
sync.release();
send(); // send() might call exception() from this thread so we need to release the mutex.
sync.acquire();
}
while(!_response && !_exception.get())
{
_monitor.wait();
}
}
if(_exception.get())
{
_locatorInfo->getEndpointsException(ref, *_exception.get()); // This throws.
}
assert(_response);
vector<EndpointIPtr> endpoints;
if(_proxy)
{
ReferencePtr r = _proxy->__reference();
if(!r->isIndirect())
{
endpoints = r->getEndpoints();
}
else if(ref->isWellKnown() && !r->isWellKnown())
{
//
// We're resolving the endpoints of a well-known object and the proxy returned
// by the locator is an indirect proxy. We now need to resolve the endpoints
// of this indirect proxy.
//
return _locatorInfo->getEndpoints(r, ref, ttl, cached);
}
}
cached = false;
if(_ref->getInstance()->traceLevels()->location >= 1)
{
_locatorInfo->getEndpointsTrace(ref, endpoints, false);
}
return endpoints;
}
void
IceInternal::LocatorInfo::RequestCallback::response(const LocatorInfoPtr& locatorInfo, const Ice::ObjectPrx& proxy)
{
vector<EndpointIPtr> endpoints;
if(proxy)
{
ReferencePtr r = proxy->__reference();
if(_ref->isWellKnown() && !isSupported(_ref->getEncoding(), r->getEncoding()))
{
//
// If a well-known proxy and the returned proxy encoding
// isn't supported, we're done: there's no compatible
// endpoint we can use.
//
}
else if(!r->isIndirect())
{
endpoints = r->getEndpoints();
}
else if(_ref->isWellKnown() && !r->isWellKnown())
{
//
// We're resolving the endpoints of a well-known object and the proxy returned
// by the locator is an indirect proxy. We now need to resolve the endpoints
// of this indirect proxy.
//
locatorInfo->getEndpoints(r, _ref, _ttl, _callback);
return;
}
}
if(_ref->getInstance()->traceLevels()->location >= 1)
{
locatorInfo->getEndpointsTrace(_ref, endpoints, false);
}
if(_callback)
{
_callback->setEndpoints(endpoints, false);
}
}
bool
Ice::ObjectAdapterI::isLocal(const ObjectPrx& proxy) const
{
//
// NOTE: it's important that isLocal() doesn't perform any blocking operations as
// it can be called for AMI invocations if the proxy has no delegate set yet.
//
ReferencePtr ref = proxy->__reference();
if(ref->isWellKnown())
{
//
// Check the active servant map to see if the well-known
// proxy is for a local object.
//
return _servantManager->hasServant(ref->getIdentity());
}
else if(ref->isIndirect())
{
//
// Proxy is local if the reference adapter id matches this
// adapter id or replica group id.
//
return ref->getAdapterId() == _id || ref->getAdapterId() == _replicaGroupId;
}
else
{
vector<EndpointIPtr> endpoints = ref->getEndpoints();
IceUtil::Monitor<IceUtil::RecMutex>::Lock sync(*this);
checkForDeactivation();
//
// Proxies which have at least one endpoint in common with the
// endpoints used by this object adapter are considered local.
//
for(vector<EndpointIPtr>::const_iterator p = endpoints.begin(); p != endpoints.end(); ++p)
{
for(vector<IncomingConnectionFactoryPtr>::const_iterator q = _incomingConnectionFactories.begin();
q != _incomingConnectionFactories.end(); ++q)
{
if((*p)->equivalent((*q)->endpoint()))
{
return true;
}
}
for(vector<EndpointIPtr>::const_iterator r = _publishedEndpoints.begin();
r != _publishedEndpoints.end(); ++r)
{
if((*p)->equivalent(*r))
{
return true;
}
}
}
//
// Proxies which have at least one endpoint in common with the
// router's server proxy endpoints (if any), are also considered
// local.
//
if(_routerInfo && _routerInfo->getRouter() == proxy->ice_getRouter())
{
for(vector<EndpointIPtr>::const_iterator p = endpoints.begin(); p != endpoints.end(); ++p)
{
for(vector<EndpointIPtr>::const_iterator r = _routerEndpoints.begin(); r != _routerEndpoints.end(); ++r)
{
if((*p)->equivalent(*r))
{
return true;
}
}
}
}
}
return false;
}
bool
Ice::ObjectAdapterI::isLocal(const ObjectPrx& proxy) const
{
ReferencePtr ref = proxy->__reference();
vector<EndpointIPtr>::const_iterator p;
vector<EndpointIPtr> endpoints;
IndirectReferencePtr ir = IndirectReferencePtr::dynamicCast(ref);
if(ir)
{
if(!ir->getAdapterId().empty())
{
//
// Proxy is local if the reference adapter id matches this
// adapter id or replica group id.
//
return ir->getAdapterId() == _id || ir->getAdapterId() == _replicaGroupId;
}
//
// Get Locator endpoint information for indirect references.
//
LocatorInfoPtr info = ir->getLocatorInfo();
if(info)
{
bool isCached;
try
{
endpoints = info->getEndpoints(ir, ir->getLocatorCacheTimeout(), isCached);
}
catch(const Ice::LocalException&)
{
return false;
}
}
else
{
return false;
}
}
else
{
endpoints = ref->getEndpoints();
}
IceUtil::Monitor<IceUtil::RecMutex>::Lock sync(*this);
checkForDeactivation();
//
// Proxies which have at least one endpoint in common with the
// endpoints used by this object adapter's incoming connection
// factories are considered local.
//
for(p = endpoints.begin(); p != endpoints.end(); ++p)
{
vector<IncomingConnectionFactoryPtr>::const_iterator q;
for(q = _incomingConnectionFactories.begin(); q != _incomingConnectionFactories.end(); ++q)
{
if((*q)->equivalent(*p))
{
return true;
}
}
}
//
// Proxies which have at least one endpoint in common with the
// router's server proxy endpoints (if any), are also considered
// local.
//
if(_routerInfo && _routerInfo->getRouter() == proxy->ice_getRouter())
{
for(p = endpoints.begin(); p != endpoints.end(); ++p)
{
if(binary_search(_routerEndpoints.begin(), _routerEndpoints.end(), *p)) // _routerEndpoints is sorted.
{
return true;
}
}
}
return false;
}