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;
}
