ObjectPrx
IceGrid::RegistryNodeAdminRouter::getTarget(const Current& current)
{
ObjectPrx target;
if(!_collocNodeName.empty() && current.id.name == _collocNodeName)
{
// Straight to the local Admin object
target = current.adapter->getCommunicator()->getAdmin();
}
else
{
try
{
target = _database->getNode(current.id.name)->getAdminProxy();
}
catch(const NodeUnreachableException&)
{
}
catch(const NodeNotExistException&)
{
}
if(target == 0)
{
throw ObjectNotExistException(__FILE__, __LINE__);
}
}
return target->ice_facet(current.facet);
}
void
IceGrid::AdminCallbackRouter::ice_invoke_async(const AMD_Object_ice_invokePtr& cb,
const pair<const Byte*, const Byte*>& inParams,
const Current& current)
{
ConnectionPtr con;
{
IceUtil::Mutex::Lock sync(_mutex);
map<string, ConnectionPtr>::iterator p = _categoryToConnection.find(current.id.category);
if(p == _categoryToConnection.end())
{
throw ObjectNotExistException(__FILE__, __LINE__);
}
con = p->second;
}
ObjectPrx target = con->createProxy(current.id)->ice_facet(current.facet);
//
// Call with AMI
//
target->begin_ice_invoke(current.operation, current.mode, inParams, current.ctx,
newCallback_Object_ice_invoke(this,
&AdminCallbackRouter::invokeResponse,
&AdminCallbackRouter::invokeException),
cb);
}
void
AsyncResult::invokeSent()
{
assert(_callback);
try
{
AsyncResultPtr self(this);
_callback->sent(self);
}
catch(const std::exception& ex)
{
warning(ex);
}
catch(...)
{
warning();
}
if(_observer)
{
ObjectPrx proxy = getProxy();
if(!proxy || !proxy->ice_isTwoway())
{
_observer.detach();
}
}
}
ObjectPrx
IceGrid::RegistryServerAdminRouter::getTarget(const Current& current)
{
ObjectPrx target = 0;
try
{
target = _database->getServer(current.id.name)->getAdminProxy();
}
catch(const ServerNotExistException&)
{
}
catch(const NodeUnreachableException&)
{
}
catch(const DeploymentException&)
{
}
if(target == 0)
{
throw ObjectNotExistException(__FILE__, __LINE__);
}
return target->ice_facet(current.facet);
}
ObjectPrx
IceGrid::RegistryReplicaAdminRouter::getTarget(const Current& current)
{
ObjectPrx target;
if(current.id.name == _name)
{
// Straight to the local Admin object
target = current.adapter->getCommunicator()->getAdmin();
}
else
{
try
{
// Forward to Admin object in remote replica
target = _database->getReplica(current.id.name)->getAdminProxy();
}
catch(const RegistryNotExistException&)
{
}
}
if(target == 0)
{
throw ObjectNotExistException(__FILE__, __LINE__);
}
return target->ice_facet(current.facet);
}
ProxyOutgoingAsyncBase::ProxyOutgoingAsyncBase(const ObjectPrx& prx,
const string& operation,
const CallbackBasePtr& delegate,
const LocalObjectPtr& cookie) :
OutgoingAsyncBase(prx->ice_getCommunicator(), prx->__reference()->getInstance(), operation, delegate, cookie),
_proxy(prx),
_mode(Normal),
_cnt(0),
_sent(false)
{
}
void
IceInternal::ProxyFactory::proxyToStream(const ObjectPrx& proxy, BasicStream* s) const
{
if(proxy)
{
s->write(proxy->__reference()->getIdentity());
proxy->__reference()->streamWrite(s);
}
else
{
Identity ident;
s->write(ident);
}
}
ObjectPrx
IceInternal::ProxyFactory::referenceToProxy(const ReferencePtr& ref) const
{
if(ref)
{
ObjectPrx proxy = new ::IceProxy::Ice::Object;
proxy->setup(ref);
return proxy;
}
else
{
return 0;
}
}
void
IceGrid::AdminRouter::ice_invoke_async(const AMD_Object_ice_invokePtr& cb,
const pair<const Byte*, const Byte*>& inParams,
const Current& current)
{
ObjectPrx target = getTarget(current);
assert(target != 0);
//
// Call with AMI
//
Callback_Object_ice_invokePtr amiCb =
newCallback_Object_ice_invoke(new CallbackI(cb), &CallbackI::response, &CallbackI::exception);
target->begin_ice_invoke(current.operation, current.mode, inParams, current.ctx, amiCb);
}
virtual
void run()
{
CommunicatorPtr communicator = initialize(initData);
ObjectPrx routerBase = communicator->stringToProxy(
"Glacier2/router:" + TestHelper::getTestEndpoint(communicator->getProperties(), 50));
_router = Glacier2::RouterPrx::checkedCast(routerBase);
communicator->setDefaultRouter(_router);
ostringstream os;
os << "userid-" << _id;
Glacier2::SessionPrx session = _router->createSession(os.str(), "abc123");
communicator->getProperties()->setProperty("Ice.PrintAdapterReady", "");
ObjectAdapterPtr adapter = communicator->createObjectAdapterWithRouter("CallbackReceiverAdapter", _router);
adapter->activate();
string category = _router->getCategoryForClient();
_callbackReceiver = new CallbackReceiverI;
Identity ident;
ident.name = "callbackReceiver";
ident.category = category;
CallbackReceiverPrx receiver = CallbackReceiverPrx::uncheckedCast(adapter->add(_callbackReceiver, ident));
ObjectPrx base = communicator->stringToProxy(
"c1/callback:" + TestHelper::getTestEndpoint(communicator->getProperties()));
base = base->ice_oneway();
CallbackPrx callback = CallbackPrx::uncheckedCast(base);
{
Lock sync(*this);
_initialized = true;
notifyAll();
}
{
Lock sync(*this);
while(!_notified)
{
wait();
}
}
//
// Stress the router until the connection is closed.
//
stress(callback, receiver);
communicator->destroy();
}
OutgoingAsync::OutgoingAsync(const ObjectPrx& prx,
const string& operation,
const CallbackBasePtr& delegate,
const LocalObjectPtr& cookie) :
ProxyOutgoingAsyncBase(prx, operation, delegate, cookie),
_encoding(getCompatibleEncoding(prx->__reference()->getEncoding()))
{
}
ProxyGetConnection::ProxyGetConnection(const ObjectPrx& prx,
const string& operation,
const CallbackBasePtr& delegate,
const LocalObjectPtr& cookie) :
ProxyOutgoingAsyncBase(prx, operation, delegate, cookie)
{
_observer.attach(prx.get(), operation, 0);
}
ProxyFlushBatch::ProxyFlushBatch(const ObjectPrx& proxy,
const string& operation,
const CallbackBasePtr& delegate,
const LocalObjectPtr& cookie) :
ProxyOutgoingAsyncBase(proxy, operation, delegate, cookie)
{
_observer.attach(proxy.get(), operation, 0);
}
vector<EndpointIPtr>
IceInternal::RouterInfo::setServerEndpoints(const Ice::ObjectPrx& /*serverProxy*/)
{
IceUtil::Mutex::Lock sync(*this);
if(_serverEndpoints.empty()) // Lazy initialization.
{
ObjectPrx serverProxy = _router->getServerProxy();
if(!serverProxy)
{
throw NoEndpointException(__FILE__, __LINE__);
}
serverProxy = serverProxy->ice_router(0); // The server proxy cannot be routed.
_serverEndpoints = serverProxy->__reference()->getEndpoints();
}
return _serverEndpoints;
}
ObjectPtr
Ice::ObjectAdapterI::findByProxy(const ObjectPrx& proxy) const
{
IceUtil::Monitor<IceUtil::RecMutex>::Lock sync(*this);
checkForDeactivation();
ReferencePtr ref = proxy->__reference();
return findFacet(ref->getIdentity(), ref->getFacet());
}
void
IceGrid::RegistryNodeAdminRouter::ice_invoke_async(const AMD_Object_ice_invokePtr& cb,
const std::pair<const Ice::Byte*, const Ice::Byte*>& inParams,
const Current& current)
{
ObjectPrx target;
if(!_collocNodeName.empty() && current.id.name == _collocNodeName)
{
// Straight to the local Admin object
target = current.adapter->getCommunicator()->getAdmin();
}
else
{
try
{
target = _database->getNode(current.id.name)->getAdminProxy();
}
catch(const NodeUnreachableException&)
{
}
catch(const NodeNotExistException&)
{
}
if(target == 0)
{
if(_traceLevels->admin > 0)
{
Ice::Trace out(_traceLevels->logger, _traceLevels->adminCat);
out << "could not find Admin proxy for node `" << current.id.name << "'";
}
throw ObjectNotExistException(__FILE__, __LINE__);
}
}
target = target->ice_facet(current.facet);
invokeOnTarget(target, cb, inParams, current);
}
PropertyDict
IceInternal::ProxyFactory::proxyToProperty(const ObjectPrx& proxy, const string& prefix) const
{
if(proxy)
{
return proxy->__reference()->toProperty(prefix);
}
else
{
return PropertyDict();
}
}
string
IceInternal::ProxyFactory::proxyToString(const ObjectPrx& proxy) const
{
if(proxy)
{
return proxy->__reference()->toString();
}
else
{
return "";
}
}
Ice::OutputStream::write(const ObjectPrx& v)
#endif
{
if(v)
{
v->__write(*this);
}
else
{
Identity ident;
write(ident);
}
}
void
IceGrid::RegistryServerAdminRouter::ice_invoke_async(const AMD_Object_ice_invokePtr& cb,
const std::pair<const Ice::Byte*, const Ice::Byte*>& inParams,
const Current& current)
{
ObjectPrx target = 0;
try
{
ServerEntryPtr server = _database->getServer(current.id.name);
try
{
target = server->getAdminProxy();
}
catch(const SynchronizationException&)
{
server->addSyncCallback(new SynchronizationCallbackI(this, cb, inParams, current));
return; // Wait for the server synchronization to complete and retry.
}
}
catch(const ServerNotExistException&)
{
}
catch(const NodeUnreachableException&)
{
}
catch(const DeploymentException&)
{
}
if(target == 0)
{
throw ObjectNotExistException(__FILE__, __LINE__);
}
target = target->ice_facet(current.facet);
invokeOnTarget(target, cb, inParams, current);
}
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));
}
virtual
void run()
{
CommunicatorPtr communicator = initialize(initData);
ObjectPrx routerBase = communicator->stringToProxy("Glacier2/router:default -p 12347 -t 10000");
Glacier2::RouterPrx router = Glacier2::RouterPrx::checkedCast(routerBase);
communicator->setDefaultRouter(router);
ostringstream os;
os << "userid-" << _id;
Glacier2::SessionPrx session = router->createSession(os.str(), "abc123");
communicator->getProperties()->setProperty("Ice.PrintAdapterReady", "");
ObjectAdapterPtr adapter = communicator->createObjectAdapterWithRouter("CallbackReceiverAdapter", router);
adapter->activate();
string category = router->getCategoryForClient();
{
Lock sync(*this);
_callbackReceiver = new CallbackReceiverI;
notify();
}
Identity ident;
ident.name = "callbackReceiver";
ident.category = category;
CallbackReceiverPrx receiver = CallbackReceiverPrx::uncheckedCast(adapter->add(_callbackReceiver, ident));
ObjectPrx base = communicator->stringToProxy("c1/callback:tcp -p 12010 -t 10000");
base = base->ice_oneway();
CallbackPrx callback = CallbackPrx::uncheckedCast(base);
//
// Block the CallbackReceiver in wait() to prevent the client from
// processing other incoming calls and wait to receive the callback.
//
callback->initiateWaitCallback(receiver);
test(_callbackReceiver->waitCallbackOK());
//
// Notify the main thread that the callback was received.
//
{
Lock sync(*this);
_callback = true;
notify();
}
//
// Callback the client with a large payload. This should cause
// the Glacier2 request queue thread to block trying to send the
// callback to the client because the client is currently blocked
// in CallbackReceiverI::waitCallback() and can't process more
// requests.
//
callback->initiateCallbackWithPayload(receiver);
test(_callbackReceiver->callbackWithPayloadOK());
try
{
router->destroySession();
test(false);
}
catch(const Ice::ConnectionLostException&)
{
}
catch(const Ice::LocalException&)
{
test(false);
}
communicator->destroy();
}
int
CallbackClient::run(int argc, char* argv[])
{
ObjectPrx routerBase;
{
cout << "testing stringToProxy for router... " << flush;
routerBase = communicator()->stringToProxy("Glacier2/router:default -p 12347 -t 10000");
cout << "ok" << endl;
}
Glacier2::RouterPrx router;
{
cout << "testing checked cast for router... " << flush;
router = Glacier2::RouterPrx::checkedCast(routerBase);
test(router);
cout << "ok" << endl;
}
{
cout << "installing router with communicator... " << flush;
communicator()->setDefaultRouter(router);
cout << "ok" << endl;
}
{
cout << "getting the session timeout... " << flush;
Ice::Long timeout = router->getSessionTimeout();
test(timeout == 30);
cout << "ok" << endl;
}
ObjectPrx base;
{
cout << "testing stringToProxy for server object... " << flush;
base = communicator()->stringToProxy("c1/callback:tcp -p 12010 -t 10000");
cout << "ok" << endl;
}
{
cout << "trying to ping server before session creation... " << flush;
try
{
base->ice_ping();
test(false);
}
catch(const ConnectionLostException&)
{
cout << "ok" << endl;
}
}
Glacier2::SessionPrx session;
{
cout << "trying to create session with wrong password... " << flush;
try
{
session = router->createSession("userid", "xxx");
test(false);
}
catch(const Glacier2::PermissionDeniedException&)
{
cout << "ok" << endl;
}
}
{
cout << "trying to destroy non-existing session... " << flush;
try
{
router->destroySession();
test(false);
}
catch(const Glacier2::SessionNotExistException&)
{
cout << "ok" << endl;
}
}
{
cout << "creating session with correct password... " << flush;
session = router->createSession("userid", "abc123");
cout << "ok" << endl;
}
{
cout << "trying to create a second session... " << flush;
try
{
router->createSession("userid", "abc123");
test(false);
}
catch(const Glacier2::CannotCreateSessionException&)
{
cout << "ok" << endl;
}
}
{
cout << "pinging server after session creation... " << flush;
base->ice_ping();
cout << "ok" << endl;
}
CallbackPrx twoway;
{
cout << "testing checked cast for server object... " << flush;
twoway = CallbackPrx::checkedCast(base);
test(twoway);
cout << "ok" << endl;
}
ObjectAdapterPtr adapter;
{
cout << "creating and activating callback receiver adapter with router... " << flush;
communicator()->getProperties()->setProperty("Ice.PrintAdapterReady", "0");
adapter = communicator()->createObjectAdapterWithRouter("CallbackReceiverAdapter", router);
adapter->activate();
cout << "ok" << endl;
}
string category;
{
cout << "getting category from router... " << flush;
category = router->getCategoryForClient();
cout << "ok" << endl;
}
CallbackReceiverI* callbackReceiverImpl;
ObjectPtr callbackReceiver;
CallbackReceiverPrx twowayR;
CallbackReceiverPrx fakeTwowayR;
{
cout << "creating and adding callback receiver object... " << flush;
callbackReceiverImpl = new CallbackReceiverI;
callbackReceiver = callbackReceiverImpl;
Identity callbackReceiverIdent;
callbackReceiverIdent.name = "callbackReceiver";
callbackReceiverIdent.category = category;
twowayR = CallbackReceiverPrx::uncheckedCast(adapter->add(callbackReceiver, callbackReceiverIdent));
Identity fakeCallbackReceiverIdent;
fakeCallbackReceiverIdent.name = "callbackReceiver";
fakeCallbackReceiverIdent.category = "dummy";
fakeTwowayR = CallbackReceiverPrx::uncheckedCast(adapter->add(callbackReceiver, fakeCallbackReceiverIdent));
cout << "ok" << endl;
}
{
cout << "testing oneway callback... " << flush;
CallbackPrx oneway = CallbackPrx::uncheckedCast(twoway->ice_oneway());
CallbackReceiverPrx onewayR = CallbackReceiverPrx::uncheckedCast(twowayR->ice_oneway());
Context context;
context["_fwd"] = "o";
oneway->initiateCallback(onewayR, context);
test(callbackReceiverImpl->callbackOK());
cout << "ok" << endl;
}
{
cout << "testing twoway callback... " << flush;
Context context;
context["_fwd"] = "t";
twoway->initiateCallback(twowayR, context);
test(callbackReceiverImpl->callbackOK());
cout << "ok" << endl;
}
//
// Send 3 twoway request to callback the receiver. The callback
// receiver only reply to the callback once it received the 3
// callbacks. This test ensures that Glacier2 doesn't serialize
// twoway requests (see bug 337 for more information).
//
{
cout << "testing concurrent twoway callback... " << flush;
Context context;
context["_fwd"] = "t";
AMI_Callback_initiateConcurrentCallbackIPtr cb0 = new AMI_Callback_initiateConcurrentCallbackI();
twoway->initiateConcurrentCallback_async(cb0, 0, twowayR, context);
AMI_Callback_initiateConcurrentCallbackIPtr cb1 = new AMI_Callback_initiateConcurrentCallbackI();
twoway->initiateConcurrentCallback_async(cb1, 1, twowayR, context);
AMI_Callback_initiateConcurrentCallbackIPtr cb2 = new AMI_Callback_initiateConcurrentCallbackI();
twoway->initiateConcurrentCallback_async(cb2, 2, twowayR, context);
test(callbackReceiverImpl->answerConcurrentCallbacks(3));
test(cb0->waitResponse() == 0);
test(cb1->waitResponse() == 1);
test(cb2->waitResponse() == 2);
cout << "ok" << endl;
}
{
cout << "ditto, but with user exception... " << flush;
Context context;
context["_fwd"] = "t";
try
{
twoway->initiateCallbackEx(twowayR, context);
test(false);
}
catch(const CallbackException& ex)
{
test(ex.someValue == 3.14);
test(ex.someString == "3.14");
}
test(callbackReceiverImpl->callbackOK());
cout << "ok" << endl;
}
{
cout << "trying twoway callback with fake category... " << flush;
Context context;
context["_fwd"] = "t";
try
{
twoway->initiateCallback(fakeTwowayR, context);
test(false);
}
catch(const ObjectNotExistException&)
{
cout << "ok" << endl;
}
}
{
cout << "testing whether other allowed category is accepted... " << flush;
Context context;
context["_fwd"] = "t";
CallbackPrx otherCategoryTwoway = CallbackPrx::uncheckedCast(
twoway->ice_identity(communicator()->stringToIdentity("c2/callback")));
otherCategoryTwoway->initiateCallback(twowayR, context);
test(callbackReceiverImpl->callbackOK());
cout << "ok" << endl;
}
{
cout << "testing whether disallowed category gets rejected... " << flush;
Context context;
context["_fwd"] = "t";
try
{
CallbackPrx otherCategoryTwoway = CallbackPrx::uncheckedCast(
twoway->ice_identity(communicator()->stringToIdentity("c3/callback")));
otherCategoryTwoway->initiateCallback(twowayR, context);
test(false);
}
catch(const ObjectNotExistException&)
{
cout << "ok" << endl;
}
}
{
cout << "testing whether user-id as category is accepted... " << flush;
Context context;
context["_fwd"] = "t";
CallbackPrx otherCategoryTwoway = CallbackPrx::uncheckedCast(
twoway->ice_identity(communicator()->stringToIdentity("_userid/callback")));
otherCategoryTwoway->initiateCallback(twowayR, context);
test(callbackReceiverImpl->callbackOK());
cout << "ok" << endl;
}
{
cout << "testing buffered mode... " << flush;
//
// Start 3 misbehaving clients.
//
const int nClients = 3; // Passwords need to be added to the password file if more clients are needed.
int i;
vector<MisbehavedClientPtr> clients;
for(i = 0; i < nClients; ++i)
{
clients.push_back(new MisbehavedClient(i));
clients.back()->start();
clients.back()->waitForCallback();
}
//
// Sleep for one second to make sure the router starts sending
// the callback with the payload to the clients.
//
IceUtil::ThreadControl::sleep(IceUtil::Time::seconds(1));
//
// Initiate few callbacks with a large payload. Because of
// the buffered mode, this shouldn't block even though the
// misbehaved client are not answering their callback
// requests.
//
Context context;
context["_fwd"] = "t";
twoway->initiateCallbackWithPayload(twowayR, context);
test(callbackReceiverImpl->callbackWithPayloadOK());
twoway->initiateCallbackWithPayload(twowayR, context);
test(callbackReceiverImpl->callbackWithPayloadOK());
twoway->initiateCallbackWithPayload(twowayR, context);
test(callbackReceiverImpl->callbackWithPayloadOK());
twoway->initiateCallbackWithPayload(twowayR, context);
test(callbackReceiverImpl->callbackWithPayloadOK());
for(vector<MisbehavedClientPtr>::const_iterator p = clients.begin(); p != clients.end(); ++p)
{
(*p)->notifyWaitCallback();
(*p)->getThreadControl().join();
}
cout << "ok" << endl;
}
{
cout << "stress test... " << flush;
const int nClients = 3; // Passwords need to be added to the password file if more clients are needed.
int i;
vector<StressClientPtr> clients;
for(i = 0; i < nClients; ++i)
{
switch(IceUtil::random(3))
{
case 0:
clients.push_back(new PingStressClient(i));
break;
case 1:
clients.push_back(new CallbackStressClient(i));
break;
case 2:
clients.push_back(new CallbackWithPayloadStressClient(i));
break;
default:
assert(false);
break;
}
clients.back()->start();
}
for(vector<StressClientPtr>::const_iterator p = clients.begin(); p != clients.end(); ++p)
{
(*p)->notifyThread();
}
//
// Let the stress client run for a bit.
//
IceUtil::ThreadControl::sleep(IceUtil::Time::seconds(3));
//
// Send some callbacks.
//
Context context;
context["_fwd"] = "t";
twoway->initiateCallback(twowayR);
test(callbackReceiverImpl->callbackOK());
//
// Kill the stress clients.
//
for(vector<StressClientPtr>::const_iterator q = clients.begin(); q != clients.end(); ++q)
{
(*q)->kill();
(*q)->getThreadControl().join();
}
cout << "ok" << endl;
}
{
cout << "testing server shutdown... " << flush;
twoway->shutdown();
// No ping, otherwise the router prints a warning message if it's
// started with --Ice.Warn.Connections.
cout << "ok" << endl;
/*
try
{
base->ice_ping();
test(false);
}
// If we use the glacier router, the exact exception reason gets
// lost.
catch(const UnknownLocalException&)
{
cout << "ok" << endl;
}
*/
}
{
cout << "destroying session... " << flush;
try
{
router->destroySession();
test(false);
}
catch(const Ice::ConnectionLostException&)
{
}
catch(const Ice::LocalException&)
{
test(false);
}
cout << "ok" << endl;
}
{
cout << "trying to ping server after session destruction... " << flush;
try
{
base->ice_ping();
test(false);
}
catch(const ConnectionLostException&)
{
cout << "ok" << endl;
}
}
if(argc >= 2 && strcmp(argv[1], "--shutdown") == 0)
{
{
cout << "uninstalling router with communicator... " << flush;
communicator()->setDefaultRouter(0);
cout << "ok" << endl;
}
ObjectPrx adminBase;
{
cout << "testing stringToProxy for admin object... " << flush;
adminBase = communicator()->stringToProxy("Glacier2/admin:tcp -h 127.0.0.1 -p 12348 -t 10000");
cout << "ok" << endl;
}
/*
{
cout << "uninstalling router with admin object... " << flush;
adminBase->ice_router(0);
cout << "ok" << endl;
}
*/
Glacier2::AdminPrx admin;
{
cout << "testing checked cast for admin object... " << flush;
admin = Glacier2::AdminPrx::checkedCast(adminBase);
test(admin);
cout << "ok" << endl;
}
cout << "testing Glacier2 shutdown... " << flush;
admin->shutdown();
try
{
admin->ice_ping();
test(false);
}
catch(const Ice::LocalException&)
{
cout << "ok" << endl;
}
}
return EXIT_SUCCESS;
}
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));
}
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;
}
int
run(int argc, char* argv[], const CommunicatorPtr& communicator)
{
bool batch = false;
int idx = 1;
while(idx < argc)
{
if(strcmp(argv[idx], "-b") == 0)
{
batch = true;
for(int i = idx ; i + 1 < argc ; ++i)
{
argv[i] = argv[i + 1];
}
--argc;
}
else if(strcmp(argv[idx], "-h") == 0 || strcmp(argv[idx], "--help") == 0)
{
usage(argv[0]);
return EXIT_SUCCESS;
}
else if(argv[idx][0] == '-')
{
cerr << argv[0] << ": unknown option `" << argv[idx] << "'" << endl;
usage(argv[0]);
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;
}
ObjectPrx base = communicator->stringToProxy(managerProxy);
IceStorm::TopicManagerPrx manager = IceStorm::TopicManagerPrx::checkedCast(base);
if(!manager)
{
cerr << argv[0] << ": `" << managerProxy << "' is not running" << endl;
return EXIT_FAILURE;
}
ObjectAdapterPtr adapter = communicator->createObjectAdapterWithEndpoints("SubscriberAdapter", "default");
EventIPtr eventFed1 = new EventI(communicator);
//
// Activate the servants.
//
ObjectPrx obj = adapter->addWithUUID(eventFed1);
IceStorm::QoS qos;
if(batch)
{
obj = obj->ice_batchOneway();
}
else
{
obj = obj->ice_oneway();
}
TopicPrx fed1;
try
{
fed1 = manager->retrieve("fed1");
}
catch(const IceStorm::NoSuchTopic& e)
{
cerr << argv[0] << ": NoSuchTopic: " << e.name << endl;
return EXIT_FAILURE;
}
fed1->subscribeAndGetPublisher(qos, obj);
adapter->activate();
communicator->waitForShutdown();
fed1->unsubscribe(obj);
return EXIT_SUCCESS;
}
Ice::ObjectPrx
Freeze::BackgroundSaveEvictorI::addFacet(const ObjectPtr& servant, const Identity& ident, const string& facet)
{
checkIdentity(ident);
checkServant(servant);
DeactivateController::Guard deactivateGuard(_deactivateController);
ObjectStore<BackgroundSaveEvictorElement>* store = findStore(facet, _createDb);
if(store == 0)
{
throw NotFoundException(__FILE__, __LINE__, "addFacet: could not open database for facet '"
+ facet + "'");
}
bool alreadyThere = false;
for(;;)
{
//
// Create a new entry
//
BackgroundSaveEvictorElementPtr element = new BackgroundSaveEvictorElement(*store);
element->status = dead;
BackgroundSaveEvictorElementPtr oldElt = store->putIfAbsent(ident, element);
if(oldElt != 0)
{
element = oldElt;
}
{
Lock sync(*this);
if(element->stale)
{
//
// Try again
//
continue;
}
fixEvictPosition(element);
IceUtil::Mutex::Lock lock(element->mutex);
switch(element->status)
{
case clean:
case created:
case modified:
{
alreadyThere = true;
break;
}
case destroyed:
{
element->status = modified;
element->rec.servant = servant;
//
// No need to push it on the modified queue, as a destroyed object
// is either already on the queue or about to be saved. When saved,
// it becomes dead.
//
break;
}
case dead:
{
element->status = created;
ObjectRecord& rec = element->rec;
rec.servant = servant;
if(store->keepStats())
{
rec.stats.creationTime = IceUtil::Time::now(IceUtil::Time::Monotonic).toMilliSeconds();
rec.stats.lastSaveTime = 0;
rec.stats.avgSaveTime = 0;
}
addToModifiedQueue(element);
break;
}
default:
{
assert(0);
break;
}
}
}
break; // for(;;)
}
if(alreadyThere)
{
AlreadyRegisteredException ex(__FILE__, __LINE__);
ex.kindOfObject = "servant";
ex.id = _communicator->identityToString(ident);
if(!facet.empty())
{
ex.id += " -f " + IceUtilInternal::escapeString(facet, "");
}
throw ex;
}
if(_trace >= 1)
{
Trace out(_communicator->getLogger(), "Freeze.Evictor");
out << "added object \"" << _communicator->identityToString(ident) << "\"";
if(!facet.empty())
{
out << " with facet \"" << facet << "\"";
}
out << " to Db \"" << _filename << "\"";
}
ObjectPrx obj = _adapter->createProxy(ident);
if(!facet.empty())
{
obj = obj->ice_facet(facet);
}
return obj;
}
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;
}
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)
