void Client::run(int argc, char** argv) { Ice::CommunicatorHolder communicator = initialize(argc, argv); ObjectPrx base = communicator->stringToProxy("Test.IceStorm/TopicManager"); IceStorm::TopicManagerPrx manager = IceStorm::TopicManagerPrx::checkedCast(base); if(!manager) { ostringstream os; os << argv[0] << ": `Test.IceStorm/TopicManager' is not running"; throw invalid_argument(os.str()); } ObjectAdapterPtr adapter = communicator->createObjectAdapterWithEndpoints("SingleAdapter", "default:udp"); TopicPrx topic = manager->create("single"); // // Create subscribers with different QoS. // SingleIPtr sub = new SingleI; topic->subscribeAndGetPublisher(IceStorm::QoS(), adapter->addWithUUID(sub)); adapter->activate(); // Ensure that getPublisher & getNonReplicatedPublisher work // correctly. Ice::ObjectPrx p1 = topic->getPublisher(); Ice::ObjectPrx p2 = topic->getNonReplicatedPublisher(); test(p1->ice_getAdapterId() == "PublishReplicaGroup"); test(p2->ice_getAdapterId() == "Test.IceStorm1.Publish" || p2->ice_getAdapterId() == "Test.IceStorm2.Publish" || p2->ice_getAdapterId() == "Test.IceStorm3.Publish"); // // Get a publisher object, create a twoway proxy and then cast to // a Single object. // SinglePrx single = SinglePrx::uncheckedCast(topic->getPublisher()->ice_twoway()); for(int i = 0; i < 1000; ++i) { single->event(i); } sub->waitForEvents(); }
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; }
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)); }
int run(int argc, char* argv[], const CommunicatorPtr& communicator) { IceUtilInternal::Options opts; opts.addOpt("", "ordered"); opts.addOpt("", "twoway"); opts.addOpt("", "events", IceUtilInternal::Options::NeedArg); 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; } 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("SingleAdapter", "default"); 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; } } int events = 1000; if(opts.isSet("events")) { events = atoi(opts.optArg("events").c_str()); } // // Create subscribers with different QoS. // SingleIPtr sub; IceStorm::QoS qos; if(opts.isSet("ordered")) { sub = new SingleI(communicator, "twoway ordered", events); qos["reliability"] = "ordered"; } else { sub = new SingleI(communicator, "twoway", events); } Ice::ObjectPrx prx = adapter->addWithUUID(sub); while(true) { try { topic->subscribeAndGetPublisher(qos, prx); break; } // If we're already subscribed then we're done (previously we // got an UnknownException which succeeded). catch(const IceStorm::AlreadySubscribed&) { break; } // This can happen if the replica group loses the majority // during subscription. In this case we retry. catch(const Ice::UnknownException&) { } } adapter->activate(); sub->waitForEvents(); topic->unsubscribe(prx); 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)); }
int run(int, char* argv[], const CommunicatorPtr& communicator) { 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("SingleAdapter", "default:udp"); // // Test topic name that is too long // if(string(argv[1]) != "transient") { try { manager->create(string(512, 'A')); test(false); } catch(const Ice::UnknownException&) { } } TopicPrx topic; try { topic = manager->retrieve("single"); } catch(const IceStorm::NoSuchTopic& e) { cerr << argv[0] << ": NoSuchTopic: " << e.name << endl; return EXIT_FAILURE; } // // Test subscriber identity that is too long // if(string(argv[1]) != "transient") { try { Ice::ObjectPrx object = communicator->stringToProxy(string(512, 'A') + ":default -p 10000"); topic->subscribeAndGetPublisher(IceStorm::QoS(), object); test(false); } catch(const Ice::UnknownException&) { } } // // Create subscribers with different QoS. // vector<SingleIPtr> subscribers; vector<Ice::Identity> subscriberIdentities; { subscribers.push_back(new SingleI(communicator, "default")); Ice::ObjectPrx object = adapter->addWithUUID(subscribers.back())->ice_oneway(); subscriberIdentities.push_back(object->ice_getIdentity()); topic->subscribeAndGetPublisher(IceStorm::QoS(), object); } { subscribers.push_back(new SingleI(communicator, "oneway")); Ice::ObjectPrx object = adapter->addWithUUID(subscribers.back())->ice_oneway(); subscriberIdentities.push_back(object->ice_getIdentity()); topic->subscribeAndGetPublisher(IceStorm::QoS(), object); } { subscribers.push_back(new SingleI(communicator, "twoway")); Ice::ObjectPrx object = adapter->addWithUUID(subscribers.back()); subscriberIdentities.push_back(object->ice_getIdentity()); topic->subscribeAndGetPublisher(IceStorm::QoS(), object); } { subscribers.push_back(new SingleI(communicator, "batch")); Ice::ObjectPrx object = adapter->addWithUUID(subscribers.back())->ice_batchOneway(); subscriberIdentities.push_back(object->ice_getIdentity()); topic->subscribeAndGetPublisher(IceStorm::QoS(), object); } { subscribers.push_back(new SingleI(communicator, "twoway ordered")); // Ordered IceStorm::QoS qos; qos["reliability"] = "ordered"; Ice::ObjectPrx object = adapter->addWithUUID(subscribers.back()); subscriberIdentities.push_back(object->ice_getIdentity()); topic->subscribeAndGetPublisher(qos, object); } { // Use a separate adapter to ensure a separate connection is used for the subscriber // (otherwise, if multiple UDP subscribers use the same connection we might get high // packet loss, see bug 1784). ObjectAdapterPtr adpt = communicator->createObjectAdapterWithEndpoints("UdpAdapter3", "udp"); subscribers.push_back(new SingleI(communicator, "datagram")); Ice::ObjectPrx object = adpt->addWithUUID(subscribers.back())->ice_datagram(); subscriberIdentities.push_back(object->ice_getIdentity()); topic->subscribeAndGetPublisher(IceStorm::QoS(), object); adpt->activate(); } { // Use a separate adapter to ensure a separate connection is used for the subscriber // (otherwise, if multiple UDP subscribers use the same connection we might get high // packet loss, see bug 1784). ObjectAdapterPtr adpt = communicator->createObjectAdapterWithEndpoints("UdpAdapter4", "udp"); subscribers.push_back(new SingleI(communicator, "batch datagram")); Ice::ObjectPrx object = adpt->addWithUUID(subscribers.back())->ice_batchDatagram(); subscriberIdentities.push_back(object->ice_getIdentity()); topic->subscribeAndGetPublisher(IceStorm::QoS(), object); adpt->activate(); } adapter->activate(); vector<Ice::Identity> ids = topic->getSubscribers(); test(ids.size() == subscriberIdentities.size()); for(vector<Ice::Identity>::const_iterator i = ids.begin(); i != ids.end(); ++i) { test(find(subscriberIdentities.begin(), subscriberIdentities.end(), *i) != subscriberIdentities.end()); } for(vector<SingleIPtr>::const_iterator p = subscribers.begin(); p != subscribers.end(); ++p) { (*p)->waitForEvents(); } return EXIT_SUCCESS; }
int run(int, char* argv[], const CommunicatorPtr& communicator) { 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("SingleAdapter", "default"); TopicPrx topic; try { topic = manager->retrieve("single"); } catch(const IceStorm::NoSuchTopic& e) { cerr << argv[0] << ": NoSuchTopic: " << e.name << endl; return EXIT_FAILURE; } SingleIPtr sub = new SingleI(); Ice::ObjectPrx prx = adapter->addWithUUID(sub); Ice::ObjectPrx control = adapter->addWithUUID(new ControllerI); IceStorm::QoS qos; while(true) { try { topic->subscribeAndGetPublisher(qos, prx); break; } // If we're already subscribed then we're done (previously we // got an UnknownException which succeeded). catch(const IceStorm::AlreadySubscribed&) { break; } // This can happen if the replica group loses the majority // during subscription. In this case we retry. catch(const Ice::UnknownException&) { } } adapter->activate(); cout << communicator->proxyToString(control) << endl; communicator->waitForShutdown(); cout << sub->nevents() << endl; return EXIT_SUCCESS; }