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(); }
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 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; }
CounterI::CounterI(const IceStorm::TopicPrx& topic) : _value(0), _topic(topic), _publisher(CounterObserverPrx::uncheckedCast(topic->getPublisher())) { }
int Producer::run(int argc, char* argv[]) { EnabledMap::iterator it; IceUtil::Mutex::Lock broadcastLock(broadcastMutex); broadcastLock.release(); // start up Ice server Ice::ObjectAdapterPtr adapter = communicator()->createObjectAdapterWithEndpoints("ImageProvider", PRODUCER_ENDPOINT); Ice::Identity id = communicator()->stringToIdentity("ImageProvider"); adapter->add(this, id); adapter->activate(); // get topic manager topicManager = IceStorm::TopicManagerPrx::checkedCast(communicator()->stringToProxy(TOPIC_MANAGER)); // get topic proxies to publish to IceStorm::TopicPrx embeddedTopicPrx; IceStorm::TopicPrx sharedMemoryTopicPrx; try { embeddedTopicPrx = topicManager->retrieve("ImageReceiverEmbedded"); } catch (const IceStorm::NoSuchTopic&) { embeddedTopicPrx = topicManager->create("ImageReceiverEmbedded"); } try { sharedMemoryTopicPrx = topicManager->retrieve("ImageReceiverSharedMemory"); } catch (const IceStorm::NoSuchTopic&) { sharedMemoryTopicPrx = topicManager->create("ImageReceiverSharedMemory"); } embeddedTopic = ImageReceiverEmbeddedPrx::uncheckedCast(embeddedTopicPrx->getPublisher()->ice_oneway()); sharedMemoryTopic = ImageReceiverSharedMemoryPrx::uncheckedCast(sharedMemoryTopicPrx->getPublisher()->ice_oneway()); while (!communicator()->isShutdown()) { // broadcast data broadcastLock.acquire(); for (it = broadcastEnabled.begin(); it != broadcastEnabled.end(); ++it) { if (it->second > 0) { // TODO: broadcast correct image type based on it->first.second switch (it->first.first) { case Embedded: embeddedTopic->receiveImageEmbedded(Blob(), it->first.second); break; case SharedMemory: sharedMemoryTopic->receiveImageSharedMemory(SharedMemorySegment(), it->first.second); break; } } } broadcastLock.release(); // "wait" for next image IceUtil::ThreadControl::sleep(IceUtil::Time::milliSeconds(30)); // ~30 images/second } return 0; }
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 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; }