ConnectionManager::ConnectionManager(const int port, const Config &cfg) { this->_cfgMgr = cfg; #if defined(WIN32) || defined(WIN64) this->cmInitWSA(); #endif this->cmSetSocket(); this->cmBind(port); this->_cfgMgr.setPort(Tools::intToString(port)); this->_cfgMgr.setIp(std::string(inet_ntoa(this->_src_inf.sin_addr))); this->cmListen(); this->_selectTime.tv_sec = 0; this->_selectTime.tv_usec = 100; std::cout << "Socket #" << this->_sock << " OK ! Listening on port " << port << "." << std::endl; this->_cfgMgr.dump(); ModuleManager *mm; mm = ModuleManager::getInstance(); // mm->LoadModule("mod_bf.dll", this->_cfgMgr); mm->LoadModule("./zia_ban.dll", this->_cfgMgr); mm->LoadModule("./zia_html.dll", this->_cfgMgr); // mm->LoadModule("zia_ban.dll", this->_cfgMgr); // mm->LoadModule("mod_test1.dll", this->_cfgMgr); }
bool ModuleList::dropMimeData(QTreeWidgetItem *parent, int index, const QMimeData *data, Qt::DropAction action) { cout << "DROP! Formats: " << data->formats().join(";").toStdString() << endl; if (!parent) { return false; } MyMimeData *mmd = (MyMimeData*) data; QTreeWidgetItem * draggedItem = mmd->indexes().first(); QTreeWidgetItem * targetItem = parent; ModuleManager * mm = MainWindow::getLastInstance()->getModuleManager(); ComparisonDialog dia; if ((mm->getMatchingModule(draggedItem))->getModuleManager() == mm) { cout << "Ja! 1" << endl; } if ((mm->getMatchingModule(targetItem))->getModuleManager() == mm) { cout << "Ja! 2" << endl; } dia.addWidgets(ModuleManager::cloneModule( mm->getMatchingModule(draggedItem)), ModuleManager::cloneModule( mm->getMatchingModule(targetItem))); dia.setModal(true); dia.exec(); return true; }
void mod_module_manager_register_module ( Mod_ModuleManager* manager, const char* module ) { ModuleManager* mngr = (ModuleManager*)manager; mngr->registerModule( std::string( module ) ); }
GF::GF() { boost::property_tree::ptree ac, audioCodecs, vc, videoCodecs; gst_init (NULL, NULL); moduleManager.loadModulesFromDirectories ("../../src/server"); mediaPipelineId = moduleManager.getFactory ("MediaPipeline")->createObject ( config, "", Json::Value() )->getId(); }
int ModuleManager::requestML(const char *path, const char *types, lo_arg **argv, int argc, void *data, void *user_data) { ModuleManager *mm = (ModuleManager *)user_data; mm->sendModuleList(); return 1; }
AutoCommon::~AutoCommon(void) { ModuleManager *pModMng = ModuleManager::instance(); pModMng->UnRegisterModule(this); #ifdef SDB_COMMON_HAS_TIMER delete m_pTimerThread; #endif #ifdef SDB_COMMON_HAS_EVENT delete m_pEventThread; #endif };
int main() { Server *s; Coordinator *co; ModuleManager *mm; XBeeController *xbc; Serial *se; MyModule *mym; int mIndex; char dn[128]; dn[0] = '/'; printf("Please Enter Your Device Name!\n"); scanf("%s", &dn[1]); s = new Server(); xbc = new XBeeController(s, "/XBC", "/dev/cu.usbserial-A50178PJ"); mm = new ModuleManager(s, dn); co = new Coordinator(s, "/Coordinator"); se = new Serial(s, "/Serial", "/dev/cu.usbmodemfd131"); mym = new MyModule(s, "/MM"); mm->sendModuleList(); xbc->co = co; co->xbc = xbc; se->connectTo(mym, "/Stream"); while (1) { printf("Enter Module Index\n"); scanf("%d", &mIndex); if (!mIndex) break; if (mIndex == -1) { co->ml->requestML(); co->ml->displayModules(); } if (mym->tID) co->ml->createModule(mym->tID, mIndex); } return 0; }
AutoCommon::AutoCommon(char *szModName):BaseModule(szModName),CmdIFModule(szModName,this) { std::string strTemp; #ifdef SDB_COMMON_HAS_EVENT m_pEventThread = NULL; m_pEventThread = new mod::EventThread(strTemp); #endif #ifdef SDB_COMMON_HAS_TIMER m_pTimerThread = NULL; strTemp = m_strModName+"Timer"; m_pTimerThread = new mod::TimerThread(strTemp,150000); #endif ModuleManager *pModMng = ModuleManager::instance(); pModMng->RegisterModule(this); };
GF::GF() { boost::property_tree::ptree ac, audioCodecs, vc, videoCodecs; gst_init(nullptr, nullptr); moduleManager.loadModulesFromDirectories ("../../src/server:../../.."); config.add ("configPath", "../../../tests" ); config.add ("modules.kurento.SdpEndpoint.numAudioMedias", 1); config.add ("modules.kurento.SdpEndpoint.numVideoMedias", 1); ac.put ("name", "opus/48000/2"); audioCodecs.push_back (std::make_pair ("", ac) ); config.add_child ("modules.kurento.SdpEndpoint.audioCodecs", audioCodecs); vc.put ("name", "VP8/90000"); videoCodecs.push_back (std::make_pair ("", vc) ); config.add_child ("modules.kurento.SdpEndpoint.videoCodecs", videoCodecs); mediaPipelineId = moduleManager.getFactory ("MediaPipeline")->createObject ( config, "", Json::Value() )->getId(); }
static std::shared_ptr <RtpEndpointImpl> createRtpEndpoint (bool useIpv6) { std::shared_ptr <kurento::MediaObjectImpl> rtpEndpoint; Json::Value constructorParams; constructorParams ["mediaPipeline"] = mediaPipelineId; constructorParams ["useIpv6"] = useIpv6; rtpEndpoint = moduleManager.getFactory ("RtpEndpoint")->createObject ( config, "", constructorParams ); return std::dynamic_pointer_cast <RtpEndpointImpl> (rtpEndpoint); }
static std::shared_ptr <RecorderEndpointImpl> createRecorderEndpoint () { std::shared_ptr <kurento::MediaObjectImpl> recorderEndpoint; Json::Value constructorParams; std::string tmp_file = std::tmpnam (nullptr); constructorParams ["mediaPipeline"] = mediaPipelineId; constructorParams ["uri"] = "file://" + tmp_file; recorderEndpoint = moduleManager.getFactory ("RecorderEndpoint")->createObject ( config, "", constructorParams ); return std::dynamic_pointer_cast <RecorderEndpointImpl> (recorderEndpoint); }
namespace kurento { static ModuleManager moduleManager; ModuleManager &getModuleManager () { return moduleManager; } void loadModules (const std::string &path) { moduleManager.loadModulesFromDirectories (path); } } /* kurento */
// argument is a configFile int main(int argc, char** argv){ // Declare a group of options that will be allowed only on command line po::options_description generic("Generic options"); generic.add_options() ("version,v", "print version string") ("help,h", "produce help message") ; po::options_description config("Program options"); config.add_options() ("configuration,c", po::value< string >(), "defines the path to an already created and stored chain configuration, written in yaml") ("input,i", po::value< vector<string> >()->composing(), "defines an input, can be used multiple times format: inputName:fileName inputName is optional if there is only one input") ("output,o", po::value< vector<string> >()->composing(), "defines an output, can be used multiple times, format: outputName:fileName. outputName is optional, if there is only one input. Output is optional, if there is only one input and one output, the output filename will be chosen from the input name in this case.") ("param,p", po::value< vector<string> >()->composing(), "defines a parameter, format: name:value") ; // Hidden options, will be allowed command line, but will not be shown to the user. po::options_description hidden("Hidden options"); hidden.add_options() ("modulename,m", po::value< string>(), "defines the name of the module") ; // These two lines say that all positional options should be translated into "-modulename" options. po::positional_options_description p; p.add("modulename", -1); // Declare an options description instance which will include all the options po::options_description allOptions("Allowed options"); allOptions.add(generic).add(config).add(hidden); // Declare an options description instance which will be shown to the user po::options_description visibleOptions("Allowed options"); visibleOptions.add(generic).add(config); // process input parameters and store the result in vm po::variables_map vm; store(po::command_line_parser(argc, argv).options(allOptions).positional(p).run(), vm); po::notify(vm); if (argc < 2) { std::cerr << "Usage Error!\n\n"; cout << "Usage:" << endl; cout << argv[0] << " -c <path to configuration file> run a processing chain from a config file." << endl; cout << argv[0] << " <moduleName> -i <input> [-p <params> -o <output>] run a single module." << endl; cout << "\n"; // show help cout << visibleOptions; return 1; } // used by the module manager to access Qt components, TODO maybe move to module manager? QApplication app (argc,argv); ModuleManager mm; Configuration conf; if (vm.count("configuration")){ // run a processing chain from a config file. // ./uipf -c example.yam // loads the configFile and create a Configuration string configFileName = argv[2]; conf.load(configFileName); } else{ // run a single module. // ./uipf <moduleName> ...options... if (vm.count("version")) { cout << "Version: 1.0" << "\n"; return 0; } if (vm.count("help")) { cout << "Usage:" << endl; cout << argv[0] << " -c <path to configuration file> run a processing chain from a config file." << endl; cout << argv[0] << " <moduleName> -i <input> [-p <params> -o <output>] run a single module." << endl; cout << "\n"; cout << visibleOptions; return 0; } if (!vm.count("modulename") || !vm.count("input")){ std::cerr << "Usage Error!\n\n"; cout << "Usage:" << endl; cout << argv[0] << " -c <path to configuration file> run a processing chain from a config file." << endl; cout << argv[0] << " <moduleName> -i <input> [-p <params> -o <output>] run a single module." << endl; cout << "\n"; // show help cout << visibleOptions; return 1; } string modName = vm["modulename"].as<string>(); if (!mm.hasModule(modName)) { LOG_E("Module " + modName + " does not exist!"); return 1; } MetaData md = mm.getModuleMetaData(modName); ProcessingStep processModule; processModule.name = "processModule"; processModule.module = modName; if (vm.count("input")) { vector<string> inputs = vm["input"].as< vector<string> >(); // this step is repeated as often, as the number of load modules is created for (unsigned int i=0; i<inputs.size(); i++){ ProcessingStep loadModule; loadModule.name = "loadModule" + to_string(i); loadModule.module = "loadImage"; string source = utils::secondPart(inputs[i]); loadModule.params.insert (pair<string,string>("filename",source) ); conf.addProcessingStep(loadModule); // the input params of the module are set map<string, DataDescription> in = md.getInputs(); string name; // if there is only one input, the name is optional on the command line, will be taken from metadata if (in.size() == 1) { auto it = in.cbegin(); name = it->first; } else { name = utils::firstPart(inputs[i]); } pair<string,string> loadWithValue(loadModule.name, "image"); processModule.inputs.insert(pair<string, pair<string, string> >(name, loadWithValue)); } // if only one input, create an output automatically, if none is given explicitly if (inputs.size() == 1 && vm.count("output") == 0){ map<string, DataDescription> out = md.getOutputs(); // if only one output exists if(out.size() ==1){ auto it = out.cbegin(); string outName = it->first; pair<string, string> storeSource(processModule.name,outName); ProcessingStep storeModule; storeModule.name = "storeModule"; storeModule.module = "storeImage"; // where does the image come from storeModule.inputs.insert (pair<string, pair<string, string> >("image", storeSource)); // where should it be stored string newName = utils::rename(utils::secondPart(inputs[0])); storeModule.params.insert (pair<string,string>("filename", newName)); conf.addProcessingStep(storeModule); } } } if (vm.count("output")) { map<string, DataDescription> out = md.getOutputs(); vector<string> outputs = vm["output"].as< vector<string> >(); // this step is repeated as often, as the number of store modules is created for (unsigned int i=0; i<outputs.size(); i++){ // if there is only one output, the name is optional on the command line, will be taken from metadata string outName; if (out.size() == 1) { auto it = out.cbegin(); outName = it->first; } else { outName = utils::firstPart(outputs[i]); } pair<string, string> storeSource(processModule.name, outName); ProcessingStep storeModule; storeModule.name = "storeModule" + to_string(i); storeModule.module = "storeImage"; // where does the image come from storeModule.inputs.insert (pair<string, pair<string, string> >("image",storeSource) ); // where should it be stored string storeName = utils::secondPart(outputs[i]); storeModule.params.insert (pair<string,string>("filename",storeName) ); conf.addProcessingStep(storeModule); } } if (vm.count("param")) { vector<string> params = vm["param"].as< vector<string> >(); // this step is repeated as often, as the number of params is inserted for (unsigned int i=0; i<params.size(); i++){ processModule.params.insert (pair<string,string>(utils::firstPart(params[i]), utils::secondPart(params[i]))); } } conf.addProcessingStep(processModule); } // print the loaded config LOG_I("Here is the loaded configuration:"); conf.print(); // validate configuration and show errors pair< vector<string>, vector<string> > errors = conf.validate(mm.getAllModuleMetaData()); if (!errors.first.empty()) { LOG_E("There are configuration errors!"); for(unsigned int i = 0; i < errors.first.size(); ++i) { LOG_E(errors.first[i]); } return 1; } // run the current configuration mm.run(conf); return 0; }
GF::GF() { gst_init (NULL, NULL); moduleManager.loadModulesFromDirectories ("../../src/server"); }
static nodes_iterator nodes_end(const ModuleManager &Manager) { return Manager.end(); }
static nodes_iterator nodes_begin(const ModuleManager &Manager) { return Manager.begin(); }
void ModuleManager::ensureModuleLoaded(const std::string& moduleName) { ModulePtr module = g_modules.getModule(moduleName); if(!module || !module->load()) g_logger.fatal(stdext::format("Unable to load '%s' module", moduleName)); }
void ModuleManager::ensureModuleLoaded(const std::string& moduleName) { ModulePtr module = g_modules.getModule(moduleName); if(!module || !module->load()) logFatal("Unable to load '", moduleName, "' module"); }
GF::GF() { gst_init(nullptr, nullptr); moduleManager.loadModulesFromDirectories ("../../src/server"); }
void loadModules (const std::string &path) { moduleManager.loadModulesFromDirectories (path); }
void ContentManager::initialize(ModuleManager& manager) { mModules = manager.filter(ModuleKind::eContentModule); }