ObserverTopic::ObserverTopic(const IceStorm::TopicManagerPrx& topicManager, const string& name, Ice::Long dbSerial) :
_logger(topicManager->ice_getCommunicator()->getLogger()), _serial(0), _dbSerial(dbSerial)
{
for(int i = 0; i < static_cast<int>(sizeof(encodings) / sizeof(Ice::EncodingVersion)); ++i)
{
ostringstream os;
os << name << "-" << Ice::encodingVersionToString(encodings[i]);
IceStorm::TopicPrx t;
try
{
t = topicManager->create(os.str());
}
catch(const IceStorm::TopicExists&)
{
t = topicManager->retrieve(os.str());
}
//
// NOTE: collocation optimization needs to be turned on for the
// topic because the subscribe() method is given a fixed proxy
// which can't be marshalled.
//
_topics[encodings[i]] = t->ice_collocationOptimized(true);
_basePublishers.push_back(
t->getPublisher()->ice_collocationOptimized(false)->ice_encodingVersion(encodings[i]));
}
}
serverI::serverI(char* ipToSet, char *portToSet){
port = portToSet;
ip = ipToSet;
ic = Ice::initialize();
cout<<"----- Initialisation des fichiers audio :";
if(initFiles())
cout<<" OK"<<endl;
else{
cerr << " Erreur" << endl;
exit(1);
}
cout<<"----- Initialisation du Topic :";
// PREPARE TOPIC FOR PUBLISHING
string topicName = "serv";
Ice::ObjectPrx obj = ic->stringToProxy("server/TopicManager:tcp -h "+ip+" -p 10000");
IceStorm::TopicManagerPrx manager = IceStorm::TopicManagerPrx::checkedCast(obj);
if(!manager)
{
exit(1);
}
IceStorm::TopicPrx topic;
try
{
cout<<"OK"<<endl;
topic = manager->retrieve(topicName);
}
catch(const IceStorm::NoSuchTopic&)
{
try
{
cout<<"OK"<<endl;
topic = manager->create(topicName);
}
catch(const IceStorm::TopicExists&)
{
cout<<"Error"<<endl;
exit(1);
}
}
Ice::ObjectPrx publisher = topic->getPublisher();
publisher = publisher->ice_oneway();
serv = MonitorPrx::uncheckedCast(publisher);
cout<<"----- Lancement du serveur "<<endl;
initStreaming();
}
int
Publisher::run(int argc, char* argv[])
{
Ice::PropertiesPtr properties = communicator()->getProperties();
IceStorm::TopicManagerPrx manager =
IceStorm::TopicManagerPrx::checkedCast(communicator()->stringToProxy("DemoIceStorm/TopicManager"));
if(manager == 0)
{
cerr << appName() << ": no topic manager found, make sure application was deployed." << endl;
return EXIT_FAILURE;
}
string topicName = "time";
if(argc != 1)
{
topicName = argv[1];
}
IceStorm::TopicPrx topic;
try
{
topic = manager->retrieve(topicName);
}
catch(const IceStorm::NoSuchTopic&)
{
cerr << appName() << ": topics not created yet, run subscriber." << endl;
return EXIT_FAILURE;
}
//
// Get the topic's publisher object, and configure a Clock proxy
// with per-request load balancing.
//
ClockPrx clock = ClockPrx::uncheckedCast(topic->getPublisher()->ice_oneway()->ice_connectionCached(false));
try
{
while(true)
{
clock->tick(IceUtil::Time::now().toDateTime());
IceUtil::ThreadControl::sleep(IceUtil::Time::seconds(1));
}
}
catch(const Ice::CommunicatorDestroyedException&)
{
// Ignore
}
return EXIT_SUCCESS;
}
bool Publisher::Startup(void)
{
this->IceInitialize();
IceStorm::TopicManagerPrx manager;
try {
manager = IceStorm::TopicManagerPrx::checkedCast(this->IceCommunicator->propertyToProxy("TopicManager.Proxy"));
} catch (const Ice::ConnectionRefusedException & e) {
SCLOG_ERROR << PUBLISHER_INFO << "Failed to initialize IceStorm. Check if IceBox is running: " << e.what() << std::endl;
return false;
}
if (!manager) {
SCLOG_ERROR << PUBLISHER_INFO << "Invalid proxy" << std::endl;
return false;
}
// Retrieve the topic.
IceStorm::TopicPrx topic;
try {
topic = manager->retrieve(this->TopicName);
} catch(const IceStorm::NoSuchTopic&) {
try {
topic = manager->create(this->TopicName);
}
catch(const IceStorm::TopicExists&) {
SCLOG_ERROR << PUBLISHER_INFO << "Topic not found. Try again." << std::endl;
return false;
}
}
// Get the topic's publisher object, and create topic proxy
Ice::ObjectPrx publisher = topic->getPublisher();
// Get the topic's publisher object, and create a proper proxy depending on
// the topic.
switch (this->Topic) {
case Topic::CONTROL:
PublisherControl = ControlPrx::uncheckedCast(publisher);
break;
case Topic::DATA:
PublisherData = DataPrx::uncheckedCast(publisher);
break;
default:
SCASSERT(false);
}
//BaseType::Startup();
return true;
}
int
Server::run(int argc, char*[])
{
if(argc > 1)
{
cerr << appName() << ": too many arguments" << endl;
return EXIT_FAILURE;
}
Ice::PropertiesPtr properties = communicator()->getProperties();
IceStorm::TopicManagerPrx manager = IceStorm::TopicManagerPrx::checkedCast(
communicator()->propertyToProxy("TopicManager.Proxy"));
if(!manager)
{
cerr << appName() << ": invalid proxy" << endl;
return EXIT_FAILURE;
}
IceStorm::TopicPrx topic;
try
{
topic = manager->retrieve("counter");
}
catch(const IceStorm::NoSuchTopic&)
{
try
{
topic = manager->create("counter");
}
catch(const IceStorm::TopicExists&)
{
cerr << appName() << ": topic exists, please try again." << endl;
return EXIT_FAILURE;
}
}
//
// Create the servant to receive the events.
//
Ice::ObjectAdapterPtr adapter = communicator()->createObjectAdapter("Counter");
Demo::CounterPtr counter = new CounterI(topic);
adapter->add(counter, communicator()->stringToIdentity("counter"));
adapter->activate();
communicator()->waitForShutdown();
return EXIT_SUCCESS;
}
ReplicaCache::ReplicaCache(const Ice::CommunicatorPtr& communicator, const IceStorm::TopicManagerPrx& topicManager) :
_communicator(communicator)
{
IceStorm::TopicPrx t;
try
{
t = topicManager->create("ReplicaObserverTopic");
}
catch(const IceStorm::TopicExists&)
{
t = topicManager->retrieve("ReplicaObserverTopic");
}
const_cast<IceStorm::TopicPrx&>(_topic) = IceStorm::TopicPrx::uncheckedCast(t->ice_collocationOptimized(true));
const_cast<ReplicaObserverPrx&>(_observers) = ReplicaObserverPrx::uncheckedCast(_topic->getPublisher());
}
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, 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;
}
IceStorm::TopicManagerPrx manager = IceStorm::TopicManagerPrx::checkedCast(
communicator->stringToProxy(managerProxy));
if(!manager)
{
cerr << argv[0] << ": `" << managerProxy << "' is not running" << endl;
return EXIT_FAILURE;
}
TopicPrx topic;
try
{
topic = manager->retrieve("single");
}
catch(const NoSuchTopic& e)
{
cerr << argv[0] << ": NoSuchTopic: " << e.name << endl;
return EXIT_FAILURE;
}
assert(topic);
//
// 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);
}
return EXIT_SUCCESS;
}
int
Subscriber::run(int argc, char* argv[])
{
Ice::StringSeq args = Ice::argsToStringSeq(argc, argv);
args = communicator()->getProperties()->parseCommandLineOptions("Clock", args);
Ice::stringSeqToArgs(args, argc, argv);
bool batch = false;
enum Option { None, Datagram, Twoway, Oneway, Ordered};
Option option = None;
string topicName = "time";
string id;
string retryCount;
int i;
for(i = 1; i < argc; ++i)
{
string optionString = argv[i];
Option oldoption = option;
if(optionString == "--datagram")
{
option = Datagram;
}
else if(optionString == "--twoway")
{
option = Twoway;
}
else if(optionString == "--oneway")
{
option = Oneway;
}
else if(optionString == "--ordered")
{
option = Ordered;
}
else if(optionString == "--batch")
{
batch = true;
}
else if(optionString == "--id")
{
++i;
if(i >= argc)
{
usage(argv[0]);
return EXIT_FAILURE;
}
id = argv[i];
}
else if(optionString == "--retryCount")
{
++i;
if(i >= argc)
{
usage(argv[0]);
return EXIT_FAILURE;
}
retryCount = argv[i];
}
else if(optionString.substr(0, 2) == "--")
{
usage(argv[0]);
return EXIT_FAILURE;
}
else
{
topicName = argv[i++];
break;
}
if(oldoption != option && oldoption != None)
{
usage(argv[0]);
return EXIT_FAILURE;
}
}
if(i != argc)
{
usage(argv[0]);
return EXIT_FAILURE;
}
if(!retryCount.empty())
{
if(option == None)
{
option = Twoway;
}
else if(option != Twoway && option != Ordered)
{
cerr << argv[0] << ": retryCount requires a twoway proxy" << endl;
return EXIT_FAILURE;
}
}
if(batch && (option == Twoway || option == Ordered))
{
cerr << argv[0] << ": batch can only be set with oneway or datagram" << endl;
return EXIT_FAILURE;
}
IceStorm::TopicManagerPrx manager = IceStorm::TopicManagerPrx::checkedCast(
communicator()->propertyToProxy("TopicManager.Proxy"));
if(!manager)
{
cerr << appName() << ": invalid proxy" << endl;
return EXIT_FAILURE;
}
IceStorm::TopicPrx topic;
try
{
topic = manager->retrieve(topicName);
}
catch(const IceStorm::NoSuchTopic&)
{
try
{
topic = manager->create(topicName);
}
catch(const IceStorm::TopicExists&)
{
cerr << appName() << ": temporary failure. try again." << endl;
return EXIT_FAILURE;
}
}
Ice::ObjectAdapterPtr adapter = communicator()->createObjectAdapter("Clock.Subscriber");
//
// Add a servant for the Ice object. If --id is used the identity
// comes from the command line, otherwise a UUID is used.
//
// id is not directly altered since it is used below to detect
// whether subscribeAndGetPublisher can raise AlreadySubscribed.
//
Ice::Identity subId;
subId.name = id;
if(subId.name.empty())
{
subId.name = IceUtil::generateUUID();
}
Ice::ObjectPrx subscriber = adapter->add(new ClockI, subId);
//
// Activate the object adapter before subscribing.
//
adapter->activate();
IceStorm::QoS qos;
if(!retryCount.empty())
{
qos["retryCount"] = retryCount;
}
//
// Set up the proxy.
//
if(option == Datagram)
{
if(batch)
{
subscriber = subscriber->ice_batchDatagram();
}
else
{
subscriber = subscriber->ice_datagram();
}
}
else if(option == Twoway)
{
// Do nothing to the subscriber proxy. Its already twoway.
}
else if(option == Ordered)
{
// Do nothing to the subscriber proxy. Its already twoway.
qos["reliability"] = "ordered";
}
else if(option == Oneway || option == None)
{
if(batch)
{
subscriber = subscriber->ice_batchOneway();
}
else
{
subscriber = subscriber->ice_oneway();
}
}
try
{
topic->subscribeAndGetPublisher(qos, subscriber);
}
catch(const IceStorm::AlreadySubscribed&)
{
// If we're manually setting the subscriber id ignore.
if(id.empty())
{
throw;
}
cout << "reactivating persistent subscriber" << endl;
}
shutdownOnInterrupt();
communicator()->waitForShutdown();
topic->unsubscribe(subscriber);
return EXIT_SUCCESS;
}
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;
}
int
run(int argc, char* argv[], const CommunicatorPtr& communicator)
{
IceUtilInternal::Options opts;
opts.addOpt("", "cycle");
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;
}
IceStorm::TopicManagerPrx manager = IceStorm::TopicManagerPrx::checkedCast(
communicator->stringToProxy(managerProxy));
if(!manager)
{
cerr << argv[0] << ": `" << managerProxy << "' is not running" << endl;
return EXIT_FAILURE;
}
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;
}
}
assert(topic);
//
// Get a publisher object, create a twoway proxy and then cast to
// a Single object.
//
if(opts.isSet("cycle"))
{
Ice::ObjectPrx prx = topic->getPublisher()->ice_twoway();
vector<SinglePrx> single;
Ice::EndpointSeq endpoints = prx->ice_getEndpoints();
for(Ice::EndpointSeq::const_iterator p = endpoints.begin(); p != endpoints.end(); ++p)
{
if((*p)->toString().substr(0, 3) != "udp")
{
Ice::EndpointSeq e;
e.push_back(*p);
single.push_back(SinglePrx::uncheckedCast(prx->ice_endpoints(e)));
}
}
if(single.size() <= 1)
{
cerr << argv[0] << ": Not enough endpoints in publisher proxy" << endl;
return EXIT_FAILURE;
}
int which = 0;
for(int i = 0; i < 1000; ++i)
{
single[which]->event(i);
which = (which + 1) % static_cast<int>(single.size());
}
}
else
{
SinglePrx single = SinglePrx::uncheckedCast(topic->getPublisher()->ice_twoway());
for(int i = 0; i < 1000; ++i)
{
single->event(i);
}
}
return EXIT_SUCCESS;
}
int ::AprilTagsComp::run(int argc, char* argv[])
{
QCoreApplication a(argc, argv); // NON-GUI application
sigset_t sigs;
sigemptyset(&sigs);
sigaddset(&sigs, SIGHUP);
sigaddset(&sigs, SIGINT);
sigaddset(&sigs, SIGTERM);
sigprocmask(SIG_UNBLOCK, &sigs, 0);
int status=EXIT_SUCCESS;
RGBDPrx rgbd_proxy;
RGBDBusPrx rgbdbus_proxy;
AprilTagsPrx apriltags_proxy;
CameraPrx camera_proxy;
string proxy, tmp;
initialize();
try
{
if (not GenericMonitor::configGetString(communicator(), prefix, "RGBDProxy", proxy, ""))
{
cout << "[" << PROGRAM_NAME << "]: Can't read configuration for proxy RGBDProxy\n";
}
rgbd_proxy = RGBDPrx::uncheckedCast( communicator()->stringToProxy( proxy ) );
}
catch(const Ice::Exception& ex)
{
cout << "[" << PROGRAM_NAME << "]: Exception: " << ex;
return EXIT_FAILURE;
}
rInfo("RGBDProxy initialized Ok!");
mprx["RGBDProxy"] = (::IceProxy::Ice::Object*)(&rgbd_proxy);//Remote server proxy creation example
try
{
if (not GenericMonitor::configGetString(communicator(), prefix, "RGBDBusProxy", proxy, ""))
{
cout << "[" << PROGRAM_NAME << "]: Can't read configuration for proxy RGBDBusProxy\n";
}
rgbdbus_proxy = RGBDBusPrx::uncheckedCast( communicator()->stringToProxy( proxy ) );
}
catch(const Ice::Exception& ex)
{
cout << "[" << PROGRAM_NAME << "]: Exception: " << ex;
return EXIT_FAILURE;
}
rInfo("RGBDBusProxy initialized Ok!");
mprx["RGBDBusProxy"] = (::IceProxy::Ice::Object*)(&rgbdbus_proxy);//Remote server proxy creation example
try
{
if (not GenericMonitor::configGetString(communicator(), prefix, "CameraProxy", proxy, ""))
{
cout << "[" << PROGRAM_NAME << "]: Can't read configuration for proxy CameraProxy\n";
}
camera_proxy = CameraPrx::uncheckedCast( communicator()->stringToProxy( proxy ) );
}
catch(const Ice::Exception& ex)
{
cout << "[" << PROGRAM_NAME << "]: Exception: " << ex;
return EXIT_FAILURE;
}
rInfo("CameraProxy initialized Ok!");
mprx["CameraProxy"] = (::IceProxy::Ice::Object*)(&camera_proxy);//Remote server proxy creation example
IceStorm::TopicManagerPrx topicManager = IceStorm::TopicManagerPrx::checkedCast(communicator()->propertyToProxy("TopicManager.Proxy"));
IceStorm::TopicPrx apriltags_topic;
while (!apriltags_topic)
{
try
{
apriltags_topic = topicManager->retrieve("AprilTags");
}
catch (const IceStorm::NoSuchTopic&)
{
try
{
apriltags_topic = topicManager->create("AprilTags");
}
catch (const IceStorm::TopicExists&){
// Another client created the topic.
}
}
}
Ice::ObjectPrx apriltags_pub = apriltags_topic->getPublisher()->ice_oneway();
AprilTagsPrx apriltags = AprilTagsPrx::uncheckedCast(apriltags_pub);
mprx["AprilTagsPub"] = (::IceProxy::Ice::Object*)(&apriltags);
SpecificWorker *worker = new SpecificWorker(mprx);
//Monitor thread
SpecificMonitor *monitor = new SpecificMonitor(worker,communicator());
QObject::connect(monitor, SIGNAL(kill()), &a, SLOT(quit()));
QObject::connect(worker, SIGNAL(kill()), &a, SLOT(quit()));
monitor->start();
if ( !monitor->isRunning() )
return status;
while (!monitor->ready)
{
usleep(10000);
}
try
{
// Server adapter creation and publication
if (not GenericMonitor::configGetString(communicator(), prefix, "CommonBehavior.Endpoints", tmp, ""))
{
cout << "[" << PROGRAM_NAME << "]: Can't read configuration for proxy CommonBehavior\n";
}
Ice::ObjectAdapterPtr adapterCommonBehavior = communicator()->createObjectAdapterWithEndpoints("commonbehavior", tmp);
CommonBehaviorI *commonbehaviorI = new CommonBehaviorI(monitor );
adapterCommonBehavior->add(commonbehaviorI, communicator()->stringToIdentity("commonbehavior"));
adapterCommonBehavior->activate();
// Server adapter creation and publication
if (not GenericMonitor::configGetString(communicator(), prefix, "GetAprilTags.Endpoints", tmp, ""))
{
cout << "[" << PROGRAM_NAME << "]: Can't read configuration for proxy GetAprilTags";
}
Ice::ObjectAdapterPtr adapterGetAprilTags = communicator()->createObjectAdapterWithEndpoints("GetAprilTags", tmp);
GetAprilTagsI *getapriltags = new GetAprilTagsI(worker);
adapterGetAprilTags->add(getapriltags, communicator()->stringToIdentity("getapriltags"));
adapterGetAprilTags->activate();
cout << "[" << PROGRAM_NAME << "]: GetAprilTags adapter created in port " << tmp << endl;
// Server adapter creation and publication
cout << SERVER_FULL_NAME " started" << endl;
// User defined QtGui elements ( main window, dialogs, etc )
#ifdef USE_QTGUI
//ignoreInterrupt(); // Uncomment if you want the component to ignore console SIGINT signal (ctrl+c).
a.setQuitOnLastWindowClosed( true );
#endif
// Run QT Application Event Loop
a.exec();
status = EXIT_SUCCESS;
}
catch(const Ice::Exception& ex)
{
status = EXIT_FAILURE;
cout << "[" << PROGRAM_NAME << "]: Exception raised on main thread: " << endl;
cout << ex;
#ifdef USE_QTGUI
a.quit();
#endif
monitor->exit(0);
}
return status;
}
void
allTests(const Ice::CommunicatorPtr& communicator)
{
{
cout << "Testing Glacier2 stub... " << flush;
char** argv = 0;
int argc = 0;
SessionHelperClient client;
client.run(argc, argv);
cout << "ok" << endl;
}
{
cout << "Testing IceStorm stub... " << flush;
IceStorm::TopicManagerPrx manager =
IceStorm::TopicManagerPrx::uncheckedCast(communicator->stringToProxy("test:default -p 12010"));
IceStorm::QoS qos;
IceStorm::TopicPrx topic;
string topicName = "time";
try
{
topic = manager->retrieve(topicName);
test(false);
}
catch(const IceStorm::NoSuchTopic&)
{
test(false);
}
catch(const Ice::LocalException&)
{
}
Ice::ObjectAdapterPtr adapter = communicator->createObjectAdapterWithEndpoints("subscriber" ,"tcp");
Ice::ObjectPrx subscriber = adapter->addWithUUID(new ClockI);
adapter->activate();
try
{
topic->subscribeAndGetPublisher(qos, subscriber);
test(false);
}
catch(const IceStorm::AlreadySubscribed&)
{
test(false);
}
catch(const IceUtil::NullHandleException&)
{
}
cout << "ok" << endl;
}
{
cout << "Testing IceGrid stub... " << flush;
Ice::ObjectPrx base = communicator->stringToProxy("test:default -p 12010");
IceGrid::RegistryPrx registry = IceGrid::RegistryPrx::uncheckedCast(base);
IceGrid::AdminSessionPrx session;
IceGrid::AdminPrx admin;
try
{
session = registry->createAdminSession("username", "password");
test(false);
}
catch(const IceGrid::PermissionDeniedException&)
{
test(false);
}
catch(const Ice::LocalException&)
{
}
try
{
admin = session->getAdmin();
test(false);
}
catch(const IceUtil::NullHandleException&)
{
}
cout << "ok" << endl;
}
}
int ::mycomp::run(int argc, char* argv[])
{
#ifdef USE_QTGUI
QApplication a(argc, argv); // GUI application
#else
QCoreApplication a(argc, argv); // NON-GUI application
#endif
int status=EXIT_SUCCESS;
ControllerPrx controller_proxy;
DifferentialRobotPrx differentialrobot_proxy;
LaserPrx laser_proxy;
string proxy, tmp;
initialize();
try
{
if (not GenericMonitor::configGetString(communicator(), prefix, "ControllerProxy", proxy, ""))
{
cout << "[" << PROGRAM_NAME << "]: Can't read configuration for proxy ControllerProxy\n";
}
controller_proxy = ControllerPrx::uncheckedCast( communicator()->stringToProxy( proxy ) );
}
catch(const Ice::Exception& ex)
{
cout << "[" << PROGRAM_NAME << "]: Exception: " << ex;
return EXIT_FAILURE;
}
rInfo("ControllerProxy initialized Ok!");
mprx["ControllerProxy"] = (::IceProxy::Ice::Object*)(&controller_proxy);//Remote server proxy creation example
try
{
if (not GenericMonitor::configGetString(communicator(), prefix, "DifferentialRobotProxy", proxy, ""))
{
cout << "[" << PROGRAM_NAME << "]: Can't read configuration for proxy DifferentialRobotProxy\n";
}
differentialrobot_proxy = DifferentialRobotPrx::uncheckedCast( communicator()->stringToProxy( proxy ) );
}
catch(const Ice::Exception& ex)
{
cout << "[" << PROGRAM_NAME << "]: Exception: " << ex;
return EXIT_FAILURE;
}
rInfo("DifferentialRobotProxy initialized Ok!");
mprx["DifferentialRobotProxy"] = (::IceProxy::Ice::Object*)(&differentialrobot_proxy);//Remote server proxy creation example
try
{
if (not GenericMonitor::configGetString(communicator(), prefix, "LaserProxy", proxy, ""))
{
cout << "[" << PROGRAM_NAME << "]: Can't read configuration for proxy LaserProxy\n";
}
laser_proxy = LaserPrx::uncheckedCast( communicator()->stringToProxy( proxy ) );
}
catch(const Ice::Exception& ex)
{
cout << "[" << PROGRAM_NAME << "]: Exception: " << ex;
return EXIT_FAILURE;
}
rInfo("LaserProxy initialized Ok!");
mprx["LaserProxy"] = (::IceProxy::Ice::Object*)(&laser_proxy);//Remote server proxy creation example
IceStorm::TopicManagerPrx topicManager = IceStorm::TopicManagerPrx::checkedCast(communicator()->propertyToProxy("TopicManager.Proxy"));
SpecificWorker *worker = new SpecificWorker(mprx);
//Monitor thread
SpecificMonitor *monitor = new SpecificMonitor(worker,communicator());
QObject::connect(monitor, SIGNAL(kill()), &a, SLOT(quit()));
QObject::connect(worker, SIGNAL(kill()), &a, SLOT(quit()));
monitor->start();
if ( !monitor->isRunning() )
return status;
while (!monitor->ready)
{
usleep(10000);
}
try
{
// Server adapter creation and publication
if (not GenericMonitor::configGetString(communicator(), prefix, "CommonBehavior.Endpoints", tmp, ""))
{
cout << "[" << PROGRAM_NAME << "]: Can't read configuration for proxy CommonBehavior\n";
}
Ice::ObjectAdapterPtr adapterCommonBehavior = communicator()->createObjectAdapterWithEndpoints("commonbehavior", tmp);
CommonBehaviorI *commonbehaviorI = new CommonBehaviorI(monitor );
adapterCommonBehavior->add(commonbehaviorI, communicator()->stringToIdentity("commonbehavior"));
adapterCommonBehavior->activate();
// Server adapter creation and publication
if (not GenericMonitor::configGetString(communicator(), prefix, "AprilTagsTopic.Endpoints", tmp, ""))
{
cout << "[" << PROGRAM_NAME << "]: Can't read configuration for proxy AprilTagsProxy";
}
Ice::ObjectAdapterPtr AprilTags_adapter = communicator()->createObjectAdapterWithEndpoints("apriltags", tmp);
AprilTagsPtr apriltagsI_ = new AprilTagsI(worker);
Ice::ObjectPrx apriltags = AprilTags_adapter->addWithUUID(apriltagsI_)->ice_oneway();
IceStorm::TopicPrx apriltags_topic;
if(!apriltags_topic) {
try {
apriltags_topic = topicManager->create("AprilTags");
}
catch (const IceStorm::TopicExists&) {
//Another client created the topic
try {
apriltags_topic = topicManager->retrieve("AprilTags");
}
catch(const IceStorm::NoSuchTopic&)
{
//Error. Topic does not exist
}
}
IceStorm::QoS qos;
apriltags_topic->subscribeAndGetPublisher(qos, apriltags);
}
AprilTags_adapter->activate();
// Server adapter creation and publication
cout << SERVER_FULL_NAME " started" << endl;
// User defined QtGui elements ( main window, dialogs, etc )
#ifdef USE_QTGUI
//ignoreInterrupt(); // Uncomment if you want the component to ignore console SIGINT signal (ctrl+c).
a.setQuitOnLastWindowClosed( true );
#endif
// Run QT Application Event Loop
a.exec();
status = EXIT_SUCCESS;
}
catch(const Ice::Exception& ex)
{
status = EXIT_FAILURE;
cout << "[" << PROGRAM_NAME << "]: Exception raised on main thread: " << endl;
cout << ex;
#ifdef USE_QTGUI
a.quit();
#endif
monitor->exit(0);
}
return status;
}
int ::speech::run(int argc, char* argv[])
{
#ifdef USE_QTGUI
QApplication a(argc, argv); // GUI application
#else
QCoreApplication a(argc, argv); // NON-GUI application
#endif
int status=EXIT_SUCCESS;
SpeechInformPrx speechinform_proxy;
string proxy, tmp;
initialize();
IceStorm::TopicManagerPrx topicManager = IceStorm::TopicManagerPrx::checkedCast(communicator()->propertyToProxy("TopicManager.Proxy"));
IceStorm::TopicPrx speechinform_topic;
while (!speechinform_topic)
{
try
{
speechinform_topic = topicManager->retrieve("SpeechInform");
}
catch (const IceStorm::NoSuchTopic&)
{
try
{
speechinform_topic = topicManager->create("SpeechInform");
}
catch (const IceStorm::TopicExists&) {
// Another client created the topic.
}
}
}
Ice::ObjectPrx speechinform_pub = speechinform_topic->getPublisher()->ice_oneway();
SpeechInformPrx speechinform = SpeechInformPrx::uncheckedCast(speechinform_pub);
mprx["SpeechInformPub"] = (::IceProxy::Ice::Object*)(&speechinform);
SpecificWorker *worker = new SpecificWorker(mprx);
//Monitor thread
SpecificMonitor *monitor = new SpecificMonitor(worker,communicator());
QObject::connect(monitor, SIGNAL(kill()), &a, SLOT(quit()));
QObject::connect(worker, SIGNAL(kill()), &a, SLOT(quit()));
monitor->start();
if ( !monitor->isRunning() )
return status;
while (!monitor->ready)
{
usleep(10000);
}
try
{
// Server adapter creation and publication
if (not GenericMonitor::configGetString(communicator(), prefix, "CommonBehavior.Endpoints", tmp, ""))
{
cout << "[" << PROGRAM_NAME << "]: Can't read configuration for proxy CommonBehavior\n";
}
Ice::ObjectAdapterPtr adapterCommonBehavior = communicator()->createObjectAdapterWithEndpoints("commonbehavior", tmp);
CommonBehaviorI *commonbehaviorI = new CommonBehaviorI(monitor );
adapterCommonBehavior->add(commonbehaviorI, communicator()->stringToIdentity("commonbehavior"));
adapterCommonBehavior->activate();
// Server adapter creation and publication
if (not GenericMonitor::configGetString(communicator(), prefix, "SpeechSIMDTopic.Endpoints", tmp, ""))
{
cout << "[" << PROGRAM_NAME << "]: Can't read configuration for proxy SpeechSIMDProxy";
}
Ice::ObjectAdapterPtr SpeechSIMD_adapter = communicator()->createObjectAdapterWithEndpoints("speechsimd", tmp);
SpeechSIMDPtr speechsimdI_ = new SpeechSIMDI(worker);
Ice::ObjectPrx speechsimd = SpeechSIMD_adapter->addWithUUID(speechsimdI_)->ice_oneway();
IceStorm::TopicPrx speechsimd_topic;
if(!speechsimd_topic) {
try {
speechsimd_topic = topicManager->create("SpeechSIMD");
}
catch (const IceStorm::TopicExists&) {
//Another client created the topic
try {
speechsimd_topic = topicManager->retrieve("SpeechSIMD");
}
catch(const IceStorm::NoSuchTopic&)
{
//Error. Topic does not exist
}
}
IceStorm::QoS qos;
speechsimd_topic->subscribeAndGetPublisher(qos, speechsimd);
}
SpeechSIMD_adapter->activate();
// Server adapter creation and publication
cout << SERVER_FULL_NAME " started" << endl;
// User defined QtGui elements ( main window, dialogs, etc )
#ifdef USE_QTGUI
//ignoreInterrupt(); // Uncomment if you want the component to ignore console SIGINT signal (ctrl+c).
a.setQuitOnLastWindowClosed( true );
#endif
// Run QT Application Event Loop
a.exec();
status = EXIT_SUCCESS;
}
catch(const Ice::Exception& ex)
{
status = EXIT_FAILURE;
cout << "[" << PROGRAM_NAME << "]: Exception raised on main thread: " << endl;
cout << ex;
#ifdef USE_QTGUI
a.quit();
#endif
monitor->exit(0);
}
return status;
}
int
run(int argc, char* argv[], const CommunicatorPtr& communicator)
{
IceUtilInternal::Options opts;
opts.addOpt("", "id", IceUtilInternal::Options::NeedArg);
opts.addOpt("", "unsub");
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;
try
{
topic = manager->retrieve("single");
}
catch(const IceStorm::NoSuchTopic& e)
{
cerr << argv[0] << ": NoSuchTopic: " << e.name << endl;
return EXIT_FAILURE;
}
Ice::ObjectPrx prx = adapter->add(new SingleI(), communicator->stringToIdentity(opts.optArg("id")));
if(opts.isSet("unsub"))
{
topic->unsubscribe(prx);
}
else
{
IceStorm::QoS qos;
qos["persistent"] = "true";
topic->subscribeAndGetPublisher(qos, prx);
}
return EXIT_SUCCESS;
}
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;
}
int inversekinematicsAgentComp::run(int argc, char* argv[])
{
#ifdef USE_QTGUI
QApplication a(argc, argv); // GUI application
#else
QCoreApplication a(argc, argv); // NON-GUI application
#endif
int status=EXIT_SUCCESS;
// Remote server proxy access example
// RemoteComponentPrx remotecomponent_proxy;
BodyInverseKinematicsPrx bodyinversekinematics_proxy;
AGMAgentTopicPrx agmagenttopic_proxy;
string proxy;
// User variables
initialize();
// Remote server proxy creation example
// try
// {
// // Load the remote server proxy
// proxy = getProxyString("RemoteProxy");
// remotecomponent_proxy = RemotePrx::uncheckedCast( communicator()->stringToProxy( proxy ) );
// if( !remotecomponent_proxy )
// {
// rInfo(QString("Error loading proxy!"));
// return EXIT_FAILURE;
// }
//catch(const Ice::Exception& ex)
//{
// cout << "[" << PROGRAM_NAME << "]: Exception: " << ex << endl;
// return EXIT_FAILURE;
//}
//rInfo("RemoteProxy initialized Ok!");
// // Now you can use remote server proxy (remotecomponent_proxy) as local object
//Remote server proxy creation example
try
{
bodyinversekinematics_proxy = BodyInverseKinematicsPrx::uncheckedCast( communicator()->stringToProxy( getProxyString("BodyInverseKinematicsProxy") ) );
}
catch(const Ice::Exception& ex)
{
cout << "[" << PROGRAM_NAME << "]: Exception: " << ex;
return EXIT_FAILURE;
}
rInfo("BodyInverseKinematicsProxy initialized Ok!");
mprx["BodyInverseKinematicsProxy"] = (::IceProxy::Ice::Object*)(&bodyinversekinematics_proxy);
IceStorm::TopicManagerPrx topicManager = IceStorm::TopicManagerPrx::checkedCast(communicator()->propertyToProxy("TopicManager.Proxy"));
IceStorm::TopicPrx agmagenttopic_topic;
while(!agmagenttopic_topic){
try {
agmagenttopic_topic = topicManager->retrieve("AGMAgentTopic");
}catch (const IceStorm::NoSuchTopic&){
try{
agmagenttopic_topic = topicManager->create("AGMAgentTopic");
}catch (const IceStorm::TopicExists&){
// Another client created the topic.
}
}
}
Ice::ObjectPrx agmagenttopic_pub = agmagenttopic_topic->getPublisher()->ice_oneway();
AGMAgentTopicPrx agmagenttopic = AGMAgentTopicPrx::uncheckedCast(agmagenttopic_pub);
mprx["AGMAgentTopicPub"] = (::IceProxy::Ice::Object*)(&agmagenttopic);
GenericWorker *worker = new SpecificWorker(mprx);
//Monitor thread
GenericMonitor *monitor = new SpecificMonitor(worker,communicator());
QObject::connect(monitor,SIGNAL(kill()),&a,SLOT(quit()));
QObject::connect(worker,SIGNAL(kill()),&a,SLOT(quit()));
monitor->start();
if ( !monitor->isRunning() )
return status;
try
{
// Server adapter creation and publication
Ice::ObjectAdapterPtr adapterCommonBehavior = communicator()->createObjectAdapter("CommonBehavior");
CommonBehaviorI *commonbehaviorI = new CommonBehaviorI(monitor );
adapterCommonBehavior->add(commonbehaviorI, communicator()->stringToIdentity("commonbehavior"));
adapterCommonBehavior->activate();
// Server adapter creation and publication
Ice::ObjectAdapterPtr AGMExecutiveTopic_adapter = communicator()->createObjectAdapter("AGMExecutiveTopicTopic");
AGMExecutiveTopicPtr agmexecutivetopicI_ = new AGMExecutiveTopicI(worker);
Ice::ObjectPrx agmexecutivetopic_proxy = AGMExecutiveTopic_adapter->addWithUUID(agmexecutivetopicI_)->ice_oneway();
IceStorm::TopicPrx agmexecutivetopic_topic;
while(!agmexecutivetopic_topic){
try {
agmexecutivetopic_topic = topicManager->retrieve("AGMExecutiveTopic");
IceStorm::QoS qos;
agmexecutivetopic_topic->subscribeAndGetPublisher(qos, agmexecutivetopic_proxy);
}
catch (const IceStorm::NoSuchTopic&) {
// Error! No topic found!
}
}
AGMExecutiveTopic_adapter->activate();
// Server adapter creation and publication
Ice::ObjectAdapterPtr adapterAGMCommonBehavior = communicator()->createObjectAdapter("AGMCommonBehaviorComp");
AGMCommonBehaviorI *agmcommonbehavior = new AGMCommonBehaviorI(worker);
adapterAGMCommonBehavior->add(agmcommonbehavior, communicator()->stringToIdentity("agmcommonbehavior"));
adapterAGMCommonBehavior->activate();
cout << SERVER_FULL_NAME " started" << endl;
// User defined QtGui elements ( main window, dialogs, etc )
#ifdef USE_QTGUI
//ignoreInterrupt(); // Uncomment if you want the component to ignore console SIGINT signal (ctrl+c).
a.setQuitOnLastWindowClosed( true );
#endif
// Run QT Application Event Loop
a.exec();
status = EXIT_SUCCESS;
}
catch(const Ice::Exception& ex)
{
status = EXIT_FAILURE;
cout << "[" << PROGRAM_NAME << "]: Exception raised on main thread: " << endl;
cout << ex;
#ifdef USE_QTGUI
a.quit();
#endif
monitor->exit(0);
}
return status;
}
int
run(int argc, char* argv[], const CommunicatorPtr& communicator)
{
IceUtilInternal::Options opts;
opts.addOpt("", "events", IceUtilInternal::Options::NeedArg);
opts.addOpt("", "qos", IceUtilInternal::Options::NeedArg, "", IceUtilInternal::Options::Repeat);
opts.addOpt("", "slow");
opts.addOpt("", "erratic", IceUtilInternal::Options::NeedArg);
try
{
opts.parse(argc, (const char**)argv);
}
catch(const IceUtilInternal::BadOptException& e)
{
cerr << argv[0] << ": " << e.reason << endl;
return EXIT_FAILURE;
}
int events = 1000;
string s = opts.optArg("events");
if(!s.empty())
{
events = atoi(s.c_str());
}
if(events <= 0)
{
cerr << argv[0] << ": events must be > 0." << endl;
return EXIT_FAILURE;
}
IceStorm::QoS cmdLineQos;
vector<string> sqos = opts.argVec("qos");
for(vector<string>::const_iterator q = sqos.begin(); q != sqos.end(); ++q)
{
string::size_type off = q->find(",");
if(off == string::npos)
{
cerr << argv[0] << ": parse error: no , in QoS" << endl;
return EXIT_FAILURE;
}
cmdLineQos[q->substr(0, off)] = q->substr(off+1);
}
bool slow = opts.isSet("slow");
bool erratic = false;
int erraticNum = 0;
s = opts.optArg("erratic");
if(!s.empty())
{
erratic = true;
erraticNum = atoi(s.c_str());
}
if(events <= 0)
{
cerr << argv[0] << ": events must be > 0." << 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;
}
IceStorm::TopicManagerPrx manager = IceStorm::TopicManagerPrx::checkedCast(
communicator->stringToProxy(managerProxy));
if(!manager)
{
cerr << argv[0] << ": `" << managerProxy << "' is not running" << endl;
return EXIT_FAILURE;
}
vector<Subscription> subs;
if(erratic)
{
for(int i = 0 ; i < erraticNum; ++i)
{
ostringstream os;
os << "SubscriberAdapter" << i;
Subscription item;
item.adapter = communicator->createObjectAdapterWithEndpoints(os.str(), "default");
item.servant = new ErraticEventI(communicator, events);
item.qos["reliability"] = "twoway";
subs.push_back(item);
}
}
else if(slow)
{
Subscription item;
item.adapter = communicator->createObjectAdapterWithEndpoints("SubscriberAdapter", "default");
item.servant = new SlowEventI(communicator, events);
item.qos = cmdLineQos;
subs.push_back(item);
}
else
{
Subscription item;
item.adapter = communicator->createObjectAdapterWithEndpoints("SubscriberAdapter", "default");
item.qos = cmdLineQos;
map<string, string>::const_iterator p = item.qos.find("reliability");
if(p != item.qos.end() && p->second == "ordered")
{
item.servant = new OrderEventI(communicator, events);
}
else
{
item.servant = new CountEventI(communicator, events);
}
subs.push_back(item);
}
TopicPrx topic;
try
{
topic = manager->retrieve("fed1");
}
catch(const IceStorm::NoSuchTopic& e)
{
cerr << argv[0] << ": NoSuchTopic: " << e.name << endl;
return EXIT_FAILURE;
}
{
for(vector<Subscription>::iterator p = subs.begin(); p != subs.end(); ++p)
{
p->obj = p->adapter->addWithUUID(p->servant);
IceStorm::QoS qos;
string reliability = "";
IceStorm::QoS::const_iterator q = p->qos.find("reliability");
if(q != p->qos.end())
{
reliability = q->second;
}
if(reliability == "twoway")
{
// Do nothing.
}
else if(reliability == "ordered")
{
qos["reliability"] = "ordered";
}
else if(reliability == "batch")
{
p->obj = p->obj->ice_batchOneway();
}
else //if(reliability == "oneway")
{
p->obj = p->obj->ice_oneway();
}
topic->subscribeAndGetPublisher(qos, p->obj);
}
}
{
for(vector<Subscription>::iterator p = subs.begin(); p != subs.end(); ++p)
{
p->adapter->activate();
}
}
communicator->waitForShutdown();
{
for(vector<Subscription>::const_iterator p = subs.begin(); p != subs.end(); ++p)
{
topic->unsubscribe(p->obj);
if(p->servant->count() != events)
{
cerr << "expected " << events << " events but got " << p->servant->count() << " events." << endl;
return EXIT_FAILURE;
}
}
}
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: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 ::dialogagent::run(int argc, char* argv[])
{
#ifdef USE_QTGUI
QApplication a(argc, argv); // GUI application
#else
QCoreApplication a(argc, argv); // NON-GUI application
#endif
sigset_t sigs;
sigemptyset(&sigs);
sigaddset(&sigs, SIGHUP);
sigaddset(&sigs, SIGINT);
sigaddset(&sigs, SIGTERM);
sigprocmask(SIG_UNBLOCK, &sigs, 0);
int status=EXIT_SUCCESS;
SpeechPrx speech_proxy;
AGMExecutivePrx agmexecutive_proxy;
string proxy, tmp;
initialize();
try
{
if (not GenericMonitor::configGetString(communicator(), prefix, "SpeechProxy", proxy, ""))
{
cout << "[" << PROGRAM_NAME << "]: Can't read configuration for proxy SpeechProxy\n";
}
speech_proxy = SpeechPrx::uncheckedCast( communicator()->stringToProxy( proxy ) );
}
catch(const Ice::Exception& ex)
{
cout << "[" << PROGRAM_NAME << "]: Exception: " << ex;
return EXIT_FAILURE;
}
rInfo("SpeechProxy initialized Ok!");
mprx["SpeechProxy"] = (::IceProxy::Ice::Object*)(&speech_proxy);//Remote server proxy creation example
try
{
if (not GenericMonitor::configGetString(communicator(), prefix, "AGMExecutiveProxy", proxy, ""))
{
cout << "[" << PROGRAM_NAME << "]: Can't read configuration for proxy AGMExecutiveProxy\n";
}
agmexecutive_proxy = AGMExecutivePrx::uncheckedCast( communicator()->stringToProxy( proxy ) );
}
catch(const Ice::Exception& ex)
{
cout << "[" << PROGRAM_NAME << "]: Exception: " << ex;
return EXIT_FAILURE;
}
rInfo("AGMExecutiveProxy initialized Ok!");
mprx["AGMExecutiveProxy"] = (::IceProxy::Ice::Object*)(&agmexecutive_proxy);//Remote server proxy creation example
IceStorm::TopicManagerPrx topicManager = IceStorm::TopicManagerPrx::checkedCast(communicator()->propertyToProxy("TopicManager.Proxy"));
SpecificWorker *worker = new SpecificWorker(mprx);
//Monitor thread
SpecificMonitor *monitor = new SpecificMonitor(worker,communicator());
QObject::connect(monitor, SIGNAL(kill()), &a, SLOT(quit()));
QObject::connect(worker, SIGNAL(kill()), &a, SLOT(quit()));
monitor->start();
if ( !monitor->isRunning() )
return status;
while (!monitor->ready)
{
usleep(10000);
}
try
{
// Server adapter creation and publication
if (not GenericMonitor::configGetString(communicator(), prefix, "CommonBehavior.Endpoints", tmp, ""))
{
cout << "[" << PROGRAM_NAME << "]: Can't read configuration for proxy CommonBehavior\n";
}
Ice::ObjectAdapterPtr adapterCommonBehavior = communicator()->createObjectAdapterWithEndpoints("commonbehavior", tmp);
CommonBehaviorI *commonbehaviorI = new CommonBehaviorI(monitor );
adapterCommonBehavior->add(commonbehaviorI, communicator()->stringToIdentity("commonbehavior"));
adapterCommonBehavior->activate();
// Server adapter creation and publication
if (not GenericMonitor::configGetString(communicator(), prefix, "AGMCommonBehavior.Endpoints", tmp, ""))
{
cout << "[" << PROGRAM_NAME << "]: Can't read configuration for proxy AGMCommonBehavior";
}
Ice::ObjectAdapterPtr adapterAGMCommonBehavior = communicator()->createObjectAdapterWithEndpoints("AGMCommonBehavior", tmp);
AGMCommonBehaviorI *agmcommonbehavior = new AGMCommonBehaviorI(worker);
adapterAGMCommonBehavior->add(agmcommonbehavior, communicator()->stringToIdentity("agmcommonbehavior"));
adapterAGMCommonBehavior->activate();
cout << "[" << PROGRAM_NAME << "]: AGMCommonBehavior adapter created in port " << tmp << endl;
// Server adapter creation and publication
if (not GenericMonitor::configGetString(communicator(), prefix, "AGMExecutiveTopicTopic.Endpoints", tmp, ""))
{
cout << "[" << PROGRAM_NAME << "]: Can't read configuration for proxy AGMExecutiveTopicProxy";
}
Ice::ObjectAdapterPtr AGMExecutiveTopic_adapter = communicator()->createObjectAdapterWithEndpoints("agmexecutivetopic", tmp);
AGMExecutiveTopicPtr agmexecutivetopicI_ = new AGMExecutiveTopicI(worker);
Ice::ObjectPrx agmexecutivetopic = AGMExecutiveTopic_adapter->addWithUUID(agmexecutivetopicI_)->ice_oneway();
IceStorm::TopicPrx agmexecutivetopic_topic;
if(!agmexecutivetopic_topic){
try {
agmexecutivetopic_topic = topicManager->create("AGMExecutiveTopic");
}
catch (const IceStorm::TopicExists&) {
//Another client created the topic
try{
agmexecutivetopic_topic = topicManager->retrieve("AGMExecutiveTopic");
}
catch(const IceStorm::NoSuchTopic&)
{
//Error. Topic does not exist
}
}
IceStorm::QoS qos;
agmexecutivetopic_topic->subscribeAndGetPublisher(qos, agmexecutivetopic);
}
AGMExecutiveTopic_adapter->activate();
// Server adapter creation and publication
cout << SERVER_FULL_NAME " started" << endl;
// User defined QtGui elements ( main window, dialogs, etc )
#ifdef USE_QTGUI
//ignoreInterrupt(); // Uncomment if you want the component to ignore console SIGINT signal (ctrl+c).
a.setQuitOnLastWindowClosed( true );
#endif
// Run QT Application Event Loop
a.exec();
status = EXIT_SUCCESS;
}
catch(const Ice::Exception& ex)
{
status = EXIT_FAILURE;
cout << "[" << PROGRAM_NAME << "]: Exception raised on main thread: " << endl;
cout << ex;
#ifdef USE_QTGUI
a.quit();
#endif
monitor->exit(0);
}
return status;
}
/***********************************************************
subscribe to icestorm
***********************************************************/
void MapHandler::IcestormSubscribe()
{
Ice::ObjectPrx proxy = _adapter->addWithUUID(new InfosReceiverServant(&_SD));
_observer = LbaNet::ActorsObserverPrx::uncheckedCast(proxy);
IceStorm::TopicManagerPrx manager;
try
{
manager = IceStorm::TopicManagerPrx::uncheckedCast(
_communicator->propertyToProxy("TopicManagerProxy"));
}
catch(const IceUtil::Exception& ex)
{
std::cout<<"MapHandler - Exception getting the actor topic manager: "<<ex.what()<<std::endl;
}
catch(...)
{
std::cout<<"MapHandler - Unknown exception getting the actor topic manager. "<<std::endl;
}
try
{
_topic = manager->create(_mapName);
}
catch(const IceStorm::TopicExists&)
{
_topic = manager->retrieve(_mapName);
}
catch(const IceUtil::Exception& ex)
{
std::cout<<"MapHandler - Exception creating actor topic "<<ex.what()<<std::endl;
}
catch(...)
{
std::cout<<"MapHandler - Unknown exception creating actor topic. "<<std::endl;
}
try
{
_topic->subscribeAndGetPublisher(IceStorm::QoS(), _observer);
}
catch(const IceUtil::Exception& ex)
{
std::cout<<"MapHandler - Exception creating actor publisher "<<ex.what()<<std::endl;
}
catch(...)
{
std::cout<<"MapHandler - Unknown exception creating actor publisher. "<<std::endl;
}
Ice::ObjectPrx pub;
try
{
pub = _topic->getPublisher();
_publisher = ActorsObserverPrx::uncheckedCast(pub->ice_oneway());
}
catch(const IceUtil::Exception& ex)
{
std::cout<<"MapHandler - Exception getting the publisher "<<ex.what()<<std::endl;
}
catch(...)
{
std::cout<<"MapHandler - Unknown exception getting the publisher. "<<std::endl;
}
}
int
run(int argc, char* argv[], const CommunicatorPtr& communicator)
{
IceUtilInternal::Options opts;
opts.addOpt("", "count", 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;
}
TopicPrx fed1;
try
{
fed1 = manager->retrieve("fed1");
}
catch(const NoSuchTopic& e)
{
cerr << argv[0] << ": NoSuchTopic: " << e.name << endl;
return EXIT_FAILURE;
}
EventPrx eventFed1 = EventPrx::uncheckedCast(fed1->getPublisher()->ice_oneway());
string arg = opts.optArg("count");
int count = 1;
if(arg.empty())
{
count = atoi(arg.c_str());
}
while(true)
{
for(int i = 0; i < 10; ++i)
{
eventFed1->pub("fed1");
}
//
// Before we exit, we ping all proxies as twoway, to make sure
// that all oneways are delivered.
//
EventPrx::uncheckedCast(eventFed1->ice_twoway())->ice_ping();
if(count == 0)
{
break;
}
--count;
IceUtil::ThreadControl::sleep(IceUtil::Time::seconds(1));
}
return EXIT_SUCCESS;
}
int
Publisher::run(int argc, char* argv[])
{
IceUtil::Options opts;
opts.addOpt("", "datagram");
opts.addOpt("", "twoway");
opts.addOpt("", "oneway");
IceUtil::Options::StringVector remaining;
try
{
remaining = opts.parse(argc, (const char**)argv);
}
catch(const IceUtil::BadOptException& e)
{
cerr << argv[0] << ": " << e.reason << endl;
return EXIT_FAILURE;
}
IceStorm::TopicManagerPrx manager = IceStorm::TopicManagerPrx::checkedCast(
communicator()->propertyToProxy("IceStorm.TopicManager.Proxy"));
if(!manager)
{
cerr << appName() << ": invalid proxy" << endl;
return EXIT_FAILURE;
}
string topicName = "time";
if(!remaining.empty())
{
topicName = remaining.front();
}
//
// Retrieve the topic.
//
IceStorm::TopicPrx topic;
try
{
topic = manager->retrieve(topicName);
}
catch(const IceStorm::NoSuchTopic&)
{
try
{
topic = manager->create(topicName);
}
catch(const IceStorm::TopicExists&)
{
cerr << appName() << ": temporary failure. try again." << endl;
return EXIT_FAILURE;
}
}
//
// Get the topic's publisher object, and create a Clock proxy with
// the mode specified as an argument of this application.
//
Ice::ObjectPrx publisher = topic->getPublisher();
int optsSet = 0;
if(opts.isSet("datagram"))
{
publisher = publisher->ice_datagram();
++optsSet;
}
else if(opts.isSet("twoway"))
{
// Do nothing.
++optsSet;
}
else if(opts.isSet("oneway") || optsSet == 0)
{
publisher = publisher->ice_oneway();
++optsSet;
}
if(optsSet != 1)
{
usage(appName());
return EXIT_FAILURE;
}
ClockPrx clock = ClockPrx::uncheckedCast(publisher);
cout << "publishing tick events. Press ^C to terminate the application." << endl;
try
{
while(true)
{
clock->tick(IceUtil::Time::now().toDateTime());
IceUtil::ThreadControl::sleep(IceUtil::Time::seconds(1));
}
}
catch(const Ice::CommunicatorDestroyedException&)
{
// Ignore
}
return EXIT_SUCCESS;
}
int JoystickPublishComp::run(int argc, char* argv[])
{
#ifdef USE_QTGUI
QApplication a(argc, argv); // GUI application
#else
QCoreApplication a(argc, argv); // NON-GUI application
#endif
int status=EXIT_SUCCESS;
// Remote server proxy access example
// RemoteComponentPrx remotecomponent_proxy;
string proxy;
// User variables
initialize();
// Remote server proxy creation example
// try
// {
// // Load the remote server proxy
// proxy = getProxyString("RemoteProxy");
// remotecomponent_proxy = RemotePrx::uncheckedCast( communicator()->stringToProxy( proxy ) );
// if( !remotecomponent_proxy )
// {
// rInfo(QString("Error loading proxy!"));
// return EXIT_FAILURE;
// }
//catch(const Ice::Exception& ex)
//{
// cout << "[" << PROGRAM_NAME << "]: Exception: " << ex << endl;
// return EXIT_FAILURE;
//}
//rInfo("RemoteProxy initialized Ok!");
// // Now you can use remote server proxy (remotecomponent_proxy) as local object
IceStorm::TopicManagerPrx topicManager = IceStorm::TopicManagerPrx::checkedCast(communicator()->propertyToProxy("TopicManager.Proxy"));
IceStorm::TopicPrx joystickadapter_topic;
while(!joystickadapter_topic){
try {
joystickadapter_topic = topicManager->create("JoystickAdapter"); // communicator()->getProperties()->getProperty("JoystickAdapter") does not work!
}catch (const IceStorm::TopicExists&){
// Another client created the topic.
try{
joystickadapter_topic = topicManager->retrieve("JoystickAdapter"); // communicator()->getProperties()->getProperty("JoystickAdapter") does not work!
}catch (const IceStorm::NoSuchTopic&){
//Error. Topic does not exist.
}
}
}
Ice::ObjectPrx joystickadapter_pub = joystickadapter_topic->getPublisher()->ice_oneway();
JoystickAdapterPrx joystickadapter = JoystickAdapterPrx::uncheckedCast(joystickadapter_pub);
mprx["JoystickAdapterPub"] = (::IceProxy::Ice::Object*)(&joystickadapter);
GenericWorker *worker = new SpecificWorker(mprx);
//Monitor thread
GenericMonitor *monitor = new SpecificMonitor(worker,communicator());
QObject::connect(monitor,SIGNAL(kill()),&a,SLOT(quit()));
QObject::connect(worker,SIGNAL(kill()),&a,SLOT(quit()));
monitor->start();
if ( !monitor->isRunning() )
return status;
try
{
// Server adapter creation and publication
Ice::ObjectAdapterPtr adapterCommonBehavior = communicator()->createObjectAdapter("CommonBehavior");
CommonBehaviorI *commonbehaviorI = new CommonBehaviorI(monitor );
adapterCommonBehavior->add(commonbehaviorI, communicator()->stringToIdentity("commonbehavior"));
adapterCommonBehavior->activate();
// Server adapter creation and publication
cout << SERVER_FULL_NAME " started" << endl;
// User defined QtGui elements ( main window, dialogs, etc )
#ifdef USE_QTGUI
//ignoreInterrupt(); // Uncomment if you want the component to ignore console SIGINT signal (ctrl+c).
a.setQuitOnLastWindowClosed( true );
#endif
// Run QT Application Event Loop
a.exec();
status = EXIT_SUCCESS;
}
catch(const Ice::Exception& ex)
{
status = EXIT_FAILURE;
cout << "[" << PROGRAM_NAME << "]: Exception raised on main thread: " << endl;
cout << ex;
#ifdef USE_QTGUI
a.quit();
#endif
monitor->exit(0);
}
return status;
}
void main()
{
Ice::InitializationData initData;
initData.properties = Ice::createProperties();
initData.properties->setProperty("Ice.MessageSizeMax", "102400" );//默认是1024，单位KB
initData.properties->setProperty("Ice.ThreadPool.Server.Size", "1");
initData.properties->setProperty("Ice.ThreadPool.Server.SizeMax", "1000" );
initData.properties->setProperty("Ice.ThreadPool.Server.SizeWarn", "1024");
Ice::CommunicatorPtr communicatorPtr = Ice::initialize(initData);
char szStormHost[100]={0};
char szStromPort[10]={0};
char szDir[MAX_PATH] = {0};
GetModuleFileName(NULL,szDir,MAX_PATH);
string strIniFile = szDir;
strIniFile = strIniFile.substr(0,strIniFile.length()-3) + "ini";
GetPrivateProfileString("NewsPub","StormHost","localhost",szStormHost,100,strIniFile.c_str());
WritePrivateProfileString("NewsPub","StormHost",szStormHost,strIniFile.c_str());
GetPrivateProfileString("NewsPub","StromPort","10000",szStromPort,100,strIniFile.c_str());
WritePrivateProfileString("NewsPub","StromPort",szStromPort,strIniFile.c_str());
char szStr[1000]={0};
sprintf_s(szStr,"StormNewsDemo/TopicManager:tcp -h %s -p %s",szStormHost,szStromPort);
// icestorm的地址"StormNewsDemo/TopicManager:tcp -h xiangzhenwei.peraportal.com -p 10000"
IceStorm::TopicManagerPrx manager = NULL;
try
{
manager = IceStorm::TopicManagerPrx::checkedCast(communicatorPtr->stringToProxy(szStr));
}
catch (const Ice::Exception &e)
{
cerr << e.what();
return;
}
if(!manager)
{
cerr << "NewsSub.exe" << ": invalid proxy" << endl;
return;
}
IceStorm::TopicPrx topic;
try
{
topic = manager->retrieve("news");
}
catch(const IceStorm::NoSuchTopic&)
{
try
{
topic = manager->create("news");
}
catch(const IceStorm::TopicExists&)
{
cerr << "NewsSub.exe" << ": temporary failure. try again." << endl;
return;
}
}
// 接收端监听消息的地址"tcp -h 0.0.0.0:udp -h 0.0.0.0"
string strEndPoint = "tcp -h 0.0.0.0:udp -h 0.0.0.0";
Ice::ObjectAdapterPtr adapter = communicatorPtr->createObjectAdapterWithEndpoints("News.Subscriber", strEndPoint );
//
// Add a servant for the Ice object. If --id is used the identity
// comes from the command line, otherwise a UUID is used.
//
// id is not directly altered since it is used below to detect
// whether subscribeAndGetPublisher can raise AlreadySubscribed.
//
Ice::Identity subId;
subId.name = IceUtil::generateUUID();
Ice::ObjectPrx subscriber = adapter->add(new NewsI, subId);
g_strClientId = subId.name;
Ice::CommunicatorPtr communicatorPtr2 = InitCommunicator();
char szEndPoints[1000]={0};
sprintf_s(szEndPoints,"Pera601DemoServerService:tcp -h %s -p %s -t 5000", szStormHost, "20131");
try
{
PcIdToWsServerPrx m_pPrx = PcIdToWsServerPrx::checkedCast(communicatorPtr2->stringToProxy(szEndPoints));
m_pPrx = m_pPrx->ice_twoway()->ice_timeout(20000)->ice_secure(false);
m_pPrx->TellClientId(subId.name);
}
catch(const Ice::Exception& ex)
{
printf("远程调用服务端失败,ICE异常：%s", ex.ice_name().c_str());
return;
}
//
// Activate the object adapter before subscribing.
//
adapter->activate();
subscriber = subscriber->ice_oneway();
IceStorm::QoS qos;
qos["retryCount"] = 3;
try
{
topic->subscribeAndGetPublisher(qos, subscriber);
}
catch(const IceStorm::AlreadySubscribed&)
{
// If we're manually setting the subscriber id ignore.
cout << "reactivating persistent subscriber" << endl;
}
communicatorPtr->waitForShutdown();
topic->unsubscribe(subscriber);
}
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;
}
TopicPrx fed1;
try
{
fed1 = manager->retrieve("fed1");
}
catch(const NoSuchTopic& e)
{
cerr << argv[0] << ": NoSuchTopic: " << e.name << endl;
return EXIT_FAILURE;
}
TopicPrx fed2;
try
{
fed2 = manager->retrieve("fed2");
}
catch(const NoSuchTopic& e)
{
cerr << argv[0] << ": NoSuchTopic: " << e.name << endl;
return EXIT_FAILURE;
}
TopicPrx fed3;
try
{
fed3 = manager->retrieve("fed3");
}
catch(const NoSuchTopic& e)
{
cerr << argv[0] << ": NoSuchTopic: " << e.name << endl;
return EXIT_FAILURE;
}
EventPrx eventFed1 = EventPrx::uncheckedCast(fed1->getPublisher()->ice_oneway());
EventPrx eventFed2 = EventPrx::uncheckedCast(fed2->getPublisher()->ice_oneway());
EventPrx eventFed3 = EventPrx::uncheckedCast(fed3->getPublisher()->ice_oneway());
Ice::Context context;
int i;
context["cost"] = "0";
for(i = 0; i < 10; ++i)
{
eventFed1->pub("fed1:0", context);
}
context["cost"] = "10";
for(i = 0; i < 10; ++i)
{
eventFed1->pub("fed1:10", context);
}
context["cost"] = "15";
for(i = 0; i < 10; ++i)
{
eventFed1->pub("fed1:15", context);
}
context["cost"] = "0";
for(i = 0; i < 10; ++i)
{
eventFed2->pub("fed2:0", context);
}
context["cost"] = "5";
for(i = 0; i < 10; ++i)
{
eventFed2->pub("fed2:5", context);
}
context["cost"] = "0";
for(i = 0; i < 10; ++i)
{
eventFed3->pub("fed3:0", context);
}
//
// Before we exit, we ping all proxies as twoway, to make sure
// that all oneways are delivered.
//
EventPrx::uncheckedCast(eventFed1->ice_twoway())->ice_ping();
EventPrx::uncheckedCast(eventFed2->ice_twoway())->ice_ping();
EventPrx::uncheckedCast(eventFed3->ice_twoway())->ice_ping();
return EXIT_SUCCESS;
}
int
Publisher::run(int argc, char* argv[])
{
enum Option { None, Datagram, Twoway, Oneway };
Option option = None;
string topicName = "time";
int i;
for(i = 1; i < argc; ++i)
{
string optionString = argv[i];
Option oldoption = option;
if(optionString == "--datagram")
{
option = Datagram;
}
else if(optionString == "--twoway")
{
option = Twoway;
}
else if(optionString == "--oneway")
{
option = Oneway;
}
else if(optionString.substr(0, 2) == "--")
{
usage(argv[0]);
return EXIT_FAILURE;
}
else
{
topicName = argv[i++];
break;
}
if(oldoption != option && oldoption != None)
{
usage(argv[0]);
return EXIT_FAILURE;
}
}
if(i != argc)
{
usage(argv[0]);
return EXIT_FAILURE;
}
IceStorm::TopicManagerPrx manager = IceStorm::TopicManagerPrx::checkedCast(
communicator()->propertyToProxy("TopicManager.Proxy"));
if(!manager)
{
cerr << appName() << ": invalid proxy" << endl;
return EXIT_FAILURE;
}
//
// Retrieve the topic.
//
IceStorm::TopicPrx topic;
try
{
topic = manager->retrieve(topicName);
}
catch(const IceStorm::NoSuchTopic&)
{
try
{
topic = manager->create(topicName);
}
catch(const IceStorm::TopicExists&)
{
cerr << appName() << ": temporary failure. try again." << endl;
return EXIT_FAILURE;
}
}
//
// Get the topic's publisher object, and create a Clock proxy with
// the mode specified as an argument of this application.
//
Ice::ObjectPrx publisher = topic->getPublisher();
if(option == Datagram)
{
publisher = publisher->ice_datagram();
}
else if(option == Twoway)
{
// Do nothing.
}
else if(option == Oneway || option == None)
{
publisher = publisher->ice_oneway();
}
ClockPrx clock = ClockPrx::uncheckedCast(publisher);
cout << "publishing tick events. Press ^C to terminate the application." << endl;
try
{
while(true)
{
clock->tick(IceUtil::Time::now().toDateTime());
IceUtil::ThreadControl::sleep(IceUtil::Time::seconds(1));
}
}
catch(const Ice::CommunicatorDestroyedException&)
{
// Ignore
}
return EXIT_SUCCESS;
}
int objectDetectionComp::run(int argc, char* argv[])
{
#ifdef USE_QTGUI
QApplication a(argc, argv); // GUI application
#else
QCoreApplication a(argc, argv); // NON-GUI application
#endif
int status=EXIT_SUCCESS;
// Remote server proxy access example
// RemoteComponentPrx remotecomponent_proxy;
InnerModelManagerPrx innermodelmanager_proxy;
RGBDPrx rgbd_proxy;
string proxy;
// User variables
initialize();
// Remote server proxy creation example
// try
// {
// // Load the remote server proxy
// proxy = getProxyString("RemoteProxy");
// remotecomponent_proxy = RemotePrx::uncheckedCast( communicator()->stringToProxy( proxy ) );
// if( !remotecomponent_proxy )
// {
// rInfo(QString("Error loading proxy!"));
// return EXIT_FAILURE;
// }
//catch(const Ice::Exception& ex)
//{
// cout << "[" << PROGRAM_NAME << "]: Exception: " << ex << endl;
// return EXIT_FAILURE;
//}
//rInfo("RemoteProxy initialized Ok!");
// // Now you can use remote server proxy (remotecomponent_proxy) as local object
//Remote server proxy creation example
try
{
innermodelmanager_proxy = InnerModelManagerPrx::uncheckedCast( communicator()->stringToProxy( getProxyString("InnerModelManagerProxy") ) );
}
catch(const Ice::Exception& ex)
{
cout << "[" << PROGRAM_NAME << "]: Exception: " << ex;
return EXIT_FAILURE;
}
rInfo("InnerModelManagerProxy initialized Ok!");
mprx["InnerModelManagerProxy"] = (::IceProxy::Ice::Object*)(&innermodelmanager_proxy);//Remote server proxy creation example
try
{
rgbd_proxy = RGBDPrx::uncheckedCast( communicator()->stringToProxy( getProxyString("RGBDProxy") ) );
}
catch(const Ice::Exception& ex)
{
cout << "[" << PROGRAM_NAME << "]: Exception: " << ex;
return EXIT_FAILURE;
}
rInfo("RGBDProxy initialized Ok!");
mprx["RGBDProxy"] = (::IceProxy::Ice::Object*)(&rgbd_proxy);
IceStorm::TopicManagerPrx topicManager = IceStorm::TopicManagerPrx::checkedCast(communicator()->propertyToProxy("TopicManager.Proxy"));
GenericWorker *worker = new SpecificWorker(mprx);
//Monitor thread
GenericMonitor *monitor = new SpecificMonitor(worker,communicator());
QObject::connect(monitor,SIGNAL(kill()),&a,SLOT(quit()));
QObject::connect(worker,SIGNAL(kill()),&a,SLOT(quit()));
monitor->start();
if ( !monitor->isRunning() )
return status;
try
{
// Server adapter creation and publication
Ice::ObjectAdapterPtr adapterCommonBehavior = communicator()->createObjectAdapter("CommonBehavior");
CommonBehaviorI *commonbehaviorI = new CommonBehaviorI(monitor );
adapterCommonBehavior->add(commonbehaviorI, communicator()->stringToIdentity("commonbehavior"));
adapterCommonBehavior->activate();
// Server adapter creation and publication
Ice::ObjectAdapterPtr AprilTags_adapter = communicator()->createObjectAdapter("AprilTagsTopic");
AprilTagsPtr apriltagsI_ = new AprilTagsI(worker);
Ice::ObjectPrx apriltags_proxy = AprilTags_adapter->addWithUUID(apriltagsI_)->ice_oneway();
IceStorm::TopicPrx apriltags_topic;
if(!apriltags_topic){
try {
apriltags_topic = topicManager->create("AprilTags");
}
catch (const IceStorm::TopicExists&) {
//Another client created the topic
try{
apriltags_topic = topicManager->retrieve("AprilTags");
}catch(const IceStorm::NoSuchTopic&){
//Error. Topic does not exist
}
}
IceStorm::QoS qos;
apriltags_topic->subscribeAndGetPublisher(qos, apriltags_proxy);
}
AprilTags_adapter->activate();
// Server adapter creation and publication
Ice::ObjectAdapterPtr adapterobjectDetection = communicator()->createObjectAdapter("objectDetectionComp");
objectDetectionI *objectdetection = new objectDetectionI(worker);
adapterobjectDetection->add(objectdetection, communicator()->stringToIdentity("objectdetection"));
adapterobjectDetection->activate();
cout << SERVER_FULL_NAME " started" << endl;
// User defined QtGui elements ( main window, dialogs, etc )
#ifdef USE_QTGUI
//ignoreInterrupt(); // Uncomment if you want the component to ignore console SIGINT signal (ctrl+c).
a.setQuitOnLastWindowClosed( true );
#endif
// Run QT Application Event Loop
a.exec();
status = EXIT_SUCCESS;
}
catch(const Ice::Exception& ex)
{
status = EXIT_FAILURE;
cout << "[" << PROGRAM_NAME << "]: Exception raised on main thread: " << endl;
cout << ex;
#ifdef USE_QTGUI
a.quit();
#endif
monitor->exit(0);
}
return status;
}
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;
}
