void
IceInternal::RouterInfo::addProxy(const ObjectPrx& proxy)
{
assert(proxy); // Must not be called for null proxies.
{
IceUtil::Mutex::Lock sync(*this);
if(_identities.find(proxy->ice_getIdentity()) != _identities.end())
{
//
// Only add the proxy to the router if it's not already in our local map.
//
return;
}
}
ObjectProxySeq proxies;
proxies.push_back(proxy);
addAndEvictProxies(proxy, _router->addProxies(proxies));
}
void
Glacier2::Blobject::invoke(ObjectPrx& proxy, const AMD_Object_ice_invokePtr& amdCB,
const std::pair<const Byte*, const Byte*>& inParams, const Current& current)
{
//
// Set the correct facet on the proxy.
//
if(!current.facet.empty())
{
proxy = proxy->ice_facet(current.facet);
}
//
// Modify the proxy according to the request id. This can
// be overridden by the _fwd context.
//
if(current.requestId == 0)
{
if(_alwaysBatch && _requestQueue)
{
proxy = proxy->ice_batchOneway();
}
else
{
proxy = proxy->ice_oneway();
}
}
else if(current.requestId > 0)
{
proxy = proxy->ice_twoway();
}
//
// Modify the proxy according to the _fwd context field.
//
Context::const_iterator p = current.ctx.find("_fwd");
if(p != current.ctx.end())
{
for(unsigned int i = 0; i < p->second.length(); ++i)
{
char option = p->second[i];
switch(option)
{
case 't':
{
proxy = proxy->ice_twoway();
break;
}
case 'o':
{
if(_alwaysBatch && _requestQueue)
{
proxy = proxy->ice_batchOneway();
}
else
{
proxy = proxy->ice_oneway();
}
break;
}
case 'd':
{
if(_alwaysBatch && _requestQueue)
{
proxy = proxy->ice_batchDatagram();
}
else
{
proxy = proxy->ice_datagram();
}
break;
}
case 'O':
{
if(_requestQueue)
{
proxy = proxy->ice_batchOneway();
}
else
{
proxy = proxy->ice_oneway();
}
break;
}
case 'D':
{
if(_requestQueue)
{
proxy = proxy->ice_batchDatagram();
}
else
{
proxy = proxy->ice_datagram();
}
break;
}
case 's':
{
proxy = proxy->ice_secure(true);
break;
}
case 'z':
{
proxy = proxy->ice_compress(true);
break;
}
default:
{
Warning out(_instance->logger());
out << "unknown forward option `" << option << "'";
break;
}
}
}
}
if(_requestTraceLevel >= 1)
{
Trace out(_instance->logger(), "Glacier2");
if(_reverseConnection)
{
out << "reverse ";
}
out << "routing";
if(_requestQueue)
{
out << " (buffered)";
}
else
{
out << " (not buffered)";
}
if(_reverseConnection)
{
out << "\nidentity = " << _instance->communicator()->identityToString(proxy->ice_getIdentity());
}
else
{
out << "\nproxy = " << _instance->communicator()->proxyToString(proxy);
}
out << "\noperation = " << current.operation;
out << "\ncontext = ";
Context::const_iterator q = current.ctx.begin();
while(q != current.ctx.end())
{
out << q->first << '/' << q->second;
if(++q != current.ctx.end())
{
out << ", ";
}
}
}
if(_requestQueue)
{
//
// If we are in buffered mode, we create a new request and add
// it to the request queue. If the request is twoway, we use
// AMI.
//
bool override;
try
{
override = _requestQueue->addRequest(new Request(proxy, inParams, current, _forwardContext, _context,
amdCB));
}
catch(const ObjectNotExistException& ex)
Glacier2::PermissionsVerifierPrx
RegistryI::getPermissionsVerifier(const ObjectAdapterPtr& adapter,
const IceGrid::LocatorPrx& locator,
const string& verifierProperty,
const string& passwordsProperty)
{
//
// Get the permissions verifier, or create a default one if no
// verifier is specified.
//
ObjectPrx verifier;
string verifierPropertyValue = _communicator->getProperties()->getProperty(verifierProperty);
if(!verifierPropertyValue.empty())
{
try
{
try
{
verifier = _communicator->propertyToProxy(verifierProperty);
}
catch(const ProxyParseException&)
{
//
// Check if the property is just the identity of the null permissions verifier
// (the identity might contain spaces which would prevent it to be parsed as a
// proxy).
//
if(_communicator->stringToIdentity(verifierPropertyValue) ==
_nullPermissionsVerifier->ice_getIdentity())
{
verifier = _communicator->stringToProxy("\"" + verifierPropertyValue + "\"");
}
}
if(!verifier)
{
Error out(_communicator->getLogger());
out << "permissions verifier `" + verifierPropertyValue + "' is invalid";
return 0;
}
assert(_nullPermissionsVerifier);
if(verifier->ice_getIdentity() == _nullPermissionsVerifier->ice_getIdentity())
{
verifier = _nullPermissionsVerifier;
}
}
catch(const LocalException& ex)
{
Error out(_communicator->getLogger());
out << "permissions verifier `" + verifierPropertyValue + "' is invalid:\n" << ex;
return 0;
}
}
else if(!passwordsProperty.empty())
{
//
// No nativeToUTF8 conversion necessary here, since no string
// converter is installed by IceGrid the string is UTF-8.
//
IceUtilInternal::ifstream passwordFile(passwordsProperty);
if(!passwordFile)
{
Error out(_communicator->getLogger());
string err = strerror(errno);
out << "cannot open `" + passwordsProperty + "' for reading: " + err;
return 0;
}
map<string, string> passwords;
while(true)
{
string userId;
passwordFile >> userId;
if(!passwordFile)
{
break;
}
string password;
passwordFile >> password;
if(!passwordFile)
{
break;
}
assert(!userId.empty());
assert(!password.empty());
passwords.insert(make_pair(userId, password));
}
verifier = adapter->addWithUUID(new CryptPermissionsVerifierI(passwords));
}
Glacier2::PermissionsVerifierPrx
RegistryI::getPermissionsVerifier(const ObjectAdapterPtr& adapter,
const IceGrid::LocatorPrx& locator,
const string& verifierProperty,
const string& passwordsProperty,
bool nowarn)
{
//
// Get the permissions verifier, or create a default one if no
// verifier is specified.
//
ObjectPrx verifier;
string verifierPropertyValue = _communicator->getProperties()->getProperty(verifierProperty);
if(!verifierPropertyValue.empty())
{
try
{
verifier = _communicator->propertyToProxy(verifierProperty);
if(!verifier)
{
Error out(_communicator->getLogger());
out << "permissions verifier `" + verifierPropertyValue + "' is invalid";
return 0;
}
assert(_nullPermissionsVerifier);
if(verifier->ice_getIdentity() == _nullPermissionsVerifier->ice_getIdentity())
{
verifier = _nullPermissionsVerifier;
}
}
catch(const LocalException& ex)
{
Error out(_communicator->getLogger());
out << "permissions verifier `" + verifierPropertyValue + "' is invalid:\n" << ex;
return 0;
}
}
else if(!passwordsProperty.empty())
{
ifstream passwordFile(passwordsProperty.c_str());
if(!passwordFile)
{
Error out(_communicator->getLogger());
string err = strerror(errno);
out << "cannot open `" + passwordsProperty + "' for reading: " + err;
return 0;
}
map<string, string> passwords;
while(true)
{
string userId;
passwordFile >> userId;
if(!passwordFile)
{
break;
}
string password;
passwordFile >> password;
if(!passwordFile)
{
break;
}
assert(!userId.empty());
assert(!password.empty());
passwords.insert(make_pair(userId, password));
}
verifier = adapter->addWithUUID(new CryptPermissionsVerifierI(passwords));
}
ObjectProxySeq
Glacier2::RoutingTable::add(const ObjectProxySeq& unfiltered, const Current& current)
{
IceUtil::Mutex::Lock sync(*this);
size_t sz = _map.size();
//
// We 'pre-scan' the list, applying our validation rules. The
// ensures that our state is not modified if this operation results
// in a rejection.
//
ObjectProxySeq proxies;
for(ObjectProxySeq::const_iterator prx = unfiltered.begin(); prx != unfiltered.end(); ++prx)
{
if(!*prx) // We ignore null proxies.
{
continue;
}
if(!_verifier->verify(*prx))
{
current.con->close(true);
throw ObjectNotExistException(__FILE__, __LINE__);
}
ObjectPrx proxy = (*prx)->ice_twoway()->ice_secure(false)->ice_facet(""); // We add proxies in default form.
proxies.push_back(proxy);
}
ObjectProxySeq evictedProxies;
for(ObjectProxySeq::const_iterator prx = proxies.begin(); prx != proxies.end(); ++prx)
{
ObjectPrx proxy = *prx;
EvictorMap::iterator p = _map.find(proxy->ice_getIdentity());
if(p == _map.end())
{
if(_traceLevel == 1 || _traceLevel >= 3)
{
Trace out(_communicator->getLogger(), "Glacier2");
out << "adding proxy to routing table:\n" << _communicator->proxyToString(proxy);
}
EvictorEntryPtr entry = new EvictorEntry;
p = _map.insert(_map.begin(), pair<const Identity, EvictorEntryPtr>(proxy->ice_getIdentity(), entry));
EvictorQueue::iterator q = _queue.insert(_queue.end(), p);
entry->proxy = proxy;
entry->pos = q;
}
else
{
if(_traceLevel == 1 || _traceLevel >= 3)
{
Trace out(_communicator->getLogger(), "Glacier2");
out << "proxy already in routing table:\n" << _communicator->proxyToString(proxy);
}
EvictorEntryPtr entry = p->second;
_queue.erase(entry->pos);
EvictorQueue::iterator q = _queue.insert(_queue.end(), p);
entry->pos = q;
}
while(static_cast<int>(_map.size()) > _maxSize)
{
p = _queue.front();
if(_traceLevel >= 2)
{
Trace out(_communicator->getLogger(), "Glacier2");
out << "evicting proxy from routing table:\n" << _communicator->proxyToString(p->second->proxy);
}
evictedProxies.push_back(p->second->proxy);
_map.erase(p);
_queue.pop_front();
}
}
if(_observer)
{
_observer->routingTableSize(static_cast<Ice::Int>(_map.size()) - static_cast<Ice::Int>(sz));
}
return evictedProxies;
}