GF_EXPORT GF_Err gf_modules_close_interface(GF_BaseInterface *ifce) { ModuleInstance *par; s32 i; if (!ifce) return GF_BAD_PARAM; par = (ModuleInstance *) ifce->HPLUG; if (!par || !ifce->InterfaceType) return GF_BAD_PARAM; i = gf_list_find(par->plugman->plug_list, par); if (i<0) return GF_BAD_PARAM; i = gf_list_find(par->interfaces, ifce); if (i<0) return GF_BAD_PARAM; gf_list_rem(par->interfaces, (u32) i); par->destroy_func(ifce); gf_modules_unload_library(par); //GF_LOG(GF_LOG_DEBUG, GF_LOG_CORE, ("[Core] interface %s unloaded\n", ifce->module_name)); return GF_OK; }
GF_EXPORT GF_BaseInterface *gf_modules_load_interface(GF_ModuleManager *pm, u32 whichplug, u32 InterfaceFamily) { const char *opt; char szKey[32]; ModuleInstance *inst; GF_BaseInterface *ifce; if (!pm){ GF_LOG(GF_LOG_ERROR, GF_LOG_CORE, ("[Core] gf_modules_load_interface() : No Module Manager set\n")); return NULL; } inst = (ModuleInstance *) gf_list_get(pm->plug_list, whichplug); if (!inst){ GF_LOG(GF_LOG_ERROR, GF_LOG_CORE, ("[Core] gf_modules_load_interface() : no module %d exist.\n", whichplug)); return NULL; } GF_LOG(GF_LOG_DEBUG, GF_LOG_CORE, ("[Core] Load interface...%s\n", inst->name)); /*look in cache*/ if (!pm->cfg){ GF_LOG(GF_LOG_ERROR, GF_LOG_CORE, ("[Core] No pm->cfg has been set !!!\n")); return NULL; } opt = gf_cfg_get_key(pm->cfg, "PluginsCache", inst->name); if (opt) { const char * ifce_str = gf_4cc_to_str(InterfaceFamily); snprintf(szKey, 32, "%s:yes", ifce_str ? ifce_str : "(null)"); if (!strstr(opt, szKey)){ return NULL; } } if (!gf_modules_load_library(inst)) { GF_LOG(GF_LOG_ERROR, GF_LOG_CORE, ("[Core] Cannot load library %s\n", inst->name)); gf_cfg_set_key(pm->cfg, "PluginsCache", inst->name, "Invalid Plugin"); return NULL; } if (!inst->query_func) { GF_LOG(GF_LOG_ERROR, GF_LOG_CORE, ("[Core] Library %s missing GPAC export symbols\n", inst->name)); gf_cfg_set_key(pm->cfg, "PluginsCache", inst->name, "Invalid Plugin"); goto err_exit; } /*build cache*/ if (!opt) { u32 i; Bool found = 0; char *key; const u32 *si = inst->query_func(); if (!si) { GF_LOG(GF_LOG_WARNING, GF_LOG_CORE, ("[Core] GPAC module %s has no supported interfaces - disabling\n", inst->name)); gf_cfg_set_key(pm->cfg, "PluginsCache", inst->name, "Invalid Plugin"); goto err_exit; } i=0; while (si[i]) i++; key = gf_malloc(sizeof(char) * 10 * i); key[0] = 0; i=0; while (si[i]) { snprintf(szKey, 32, "%s:yes ", gf_4cc_to_str(si[i])); strcat(key, szKey); if (InterfaceFamily==si[i]) found = 1; i++; } gf_cfg_set_key(pm->cfg, "PluginsCache", inst->name, key); gf_free(key); if (!found) goto err_exit; } if (!inst->query_func || !inst->query_func(InterfaceFamily) ) goto err_exit; ifce = (GF_BaseInterface *) inst->load_func(InterfaceFamily); /*sanity check*/ if (!ifce) goto err_exit; #if defined(TARGET_OS_IPHONE) || defined(TARGET_IPHONE_SIMULATOR) if (!strcmp(inst->name, "gm_sdl_out.dylib")) { if (InterfaceFamily == GF_VIDEO_OUTPUT_INTERFACE) { ifce = SDL_Module_Load_Video(); fprintf(stderr, "*** Loading SDL Video: %p ***\n", ifce); } else if (InterfaceFamily == GF_AUDIO_OUTPUT_INTERFACE) { ifce = SDL_Module_Load_Audio(); fprintf(stderr, "*** Loading SDL Audio: %p ***\n", ifce); } } #endif if (!ifce->module_name || (ifce->InterfaceType != InterfaceFamily)) { inst->destroy_func(ifce); goto err_exit; } gf_list_add(inst->interfaces, ifce); /*keep track of parent*/ ifce->HPLUG = inst; GF_LOG(GF_LOG_DEBUG, GF_LOG_CORE, ("[Core] Load interface %s DONE.\n", inst->name)); return ifce; err_exit: GF_LOG(GF_LOG_DEBUG, GF_LOG_CORE, ("[Core] Load interface %s exit label, freing library...\n", inst->name)); gf_modules_unload_library(inst); GF_LOG(GF_LOG_DEBUG, GF_LOG_CORE, ("[Core] Load interface %s EXIT.\n", inst->name)); return NULL; }
Literal invoke() { return instance->callExport(name, arguments); }
int main(int argc, char *argv[]){ try { // JBS little trick. Baptize the logger with a nice module // instance so that the logging will be focused. ModuleInstance myself("localhost", "anycast", "core", "theonlyone"); OcfaLogger::Instance()->baptize(&myself); OcfaGroup groupguard("ocfa"); Anycast::AnyCast *a; if (OcfaConfig::Instance()->getValue("daemonize") != "false"){ daemonize(); } if (OcfaConfig::Instance()->getValue("recover") == "true"){ a = new Anycast::AnyCast("anycast", "anycast", true); } else { a = new Anycast::AnyCast("anycast", "anycast", false); } AnycastMessageBox *mb = dynamic_cast<AnycastMessageBox *>(MessageBox::createInstance("anycast", "anycast")); if (!mb){ OcfaLogger::Instance()->syslog(LOG_ERR, "main ") << "MessageBox not expected type !" << endl; return 1; } Anycast::MonitorMessageFactory *factory = new Anycast::MonitorMessageFactory(mb); a->setMonitorMessageFactory(&factory); Message *msg = 0; bool haltreceived = false; while ((!haltreceived) || (a->getActiveModuleCount() > 0)){ msg = mb->getNextMessage(100, 0); if (msg != 0){ ModuleInstance *sender = msg->getSender(); string instanceuri = sender->getInstanceURI(); string modulename = sender->getModuleName(); a->getLogStream(LOG_INFO) << "Received message type: " << static_cast<int>(msg->getType()) << "and prio " << msg->getPriority() << endl; switch (msg->getType()){ case Message::mtTaskProgress:{ a->getLogStream(LOG_INFO) << "Message::mtTaskProgress" << endl; ModuleInstance *receiver = msg->getReceiver(); string instreceiver = receiver->getInstanceURI(); string instmodname = receiver->getModuleName(); unsigned int id = atoi(msg->getSubject().c_str()); a->dropMessage(instmodname, instreceiver, id); if (haltreceived){ break; // stop sending new messages when halt is received } Message *tosend = a->getMessage(instmodname); id = MsgIDBroker::Instance()->lastID(); if (tosend != 0){ mb->sendTask(tosend, id); // the message 'tosend' will be deleted if task is done } break; }; case Message::mtModuleInstance:{ a->getLogStream(LOG_INFO) << "Message::mtModuleInstance" << endl; OcfaLogger::Instance()->syslog(ocfa::misc::LOG_INFO, "Anycast: ") << "Received mtModuleInstance: " << instanceuri << endl; // copy sender because it will be used and stored by anycast ModuleInstance *copysender = new ModuleInstance(sender); a->addModuleInstance(modulename, instanceuri, copysender); Message *tosend = 0; while ((tosend = a->getMessage(modulename))!= 0){ unsigned int id = MsgIDBroker::Instance()->lastID(); mb->sendTask(tosend, id); // the message 'tosend' will be deleted if task is done } a->printQueues(); break; }; case Message::mtModuleDisconnect:{ a->getLogStream(LOG_INFO) << "Message::mtModuleDisconnect" << endl; a->removeModuleInstance(modulename, instanceuri); a->printQueues(); break; } case Message::mtHalt: { OcfaLogger::Instance()->syslog(ocfa::misc::LOG_NOTICE, "Anycast: ") << "Received HALT. Waiting for " << a->getActiveModuleCount() << " modules to go away ..." << endl; haltreceived = true; break; } case Message::mtRecover: {//FIXME: think we need to do something here. a->getLogStream(LOG_INFO) << "Message::mtRecover" << endl; break; } case Message::mtEvidence:{ a->getLogStream(LOG_INFO) << "Message::mtEvidence" << endl; } case Message::mtSubscribe: case Message::mtUnsubscribe: case Message::mtEOC: case Message::mtHeartBeat: case Message::mtSystem: // all other messages should probably be relayed a->getLogStream(LOG_INFO) << "Processable message" << endl; ModuleInstance *recepient = msg->getReceiver(); string rcptmodulename = recepient->getModuleName(); // modulename is used to denote moduletype a->addMessage(rcptmodulename, msg); if (haltreceived){ a->getLogStream(LOG_INFO) << "HALT STATE: dropping message" << endl; break; // if we receive a halt, we stop sending new tasks } Message *tosend = a->getMessage(rcptmodulename); unsigned int id = MsgIDBroker::Instance()->lastID(); a->printQueues(); if (tosend != 0){ a->getLogStream(LOG_INFO) << "Calling sendTask on messagebox" << endl; mb->sendTask(tosend, id); // the message 'tosend' will be deleted if task is done } else { a->getLogStream(LOG_INFO) << "Problem getting at message" << endl; } // Check whether there are any messages for the monitor. This is one of the times that the // anycast cannot simple react on new messages. tosend = a->getMessage("monitor"); if (tosend != 0){ unsigned int id = MsgIDBroker::Instance()->lastID(); a->printQueues(); if (tosend != 0){ a->getLogStream(LOG_INFO) << "Calling sendTask on messagebox" << endl; mb->sendTask(tosend, id); // the message 'tosend' will be deleted if task is done } else { a->getLogStream(LOG_INFO) << "Problem getting at message" << endl; } } } delete msg; msg = 0; } } a->Log( "Exiting the Anycast module on user request!"); delete a; OcfaLogger::Instance()->syslog(LOG_DEBUG, "main: ") << "Deleted AnyCast object. Deleting MessageBox .." << endl; delete mb; OcfaLogger::Instance()->syslog(LOG_DEBUG, "main: ") << "MessageBox deleted. Anycast done !" << endl; } catch (OcfaException &e) { std::cerr << "Exception: " << e.what() << endl; //e.logWhat(); return -1; } catch (exception &e) { OcfaLogger::Instance()->syslog(LOG_ERR, "main ") << "Exception: " << e.what() << endl; return -1; } return 0; }
static void run_asserts(size_t* i, bool* checked, AllocatingModule* wasm, Element* root, std::unique_ptr<SExpressionWasmBuilder>* builder, Name entry) { ShellExternalInterface* interface = nullptr; ModuleInstance* instance = nullptr; if (wasm) { interface = new ShellExternalInterface(); instance = new ModuleInstance(*wasm, interface); if (entry.is()) { Function* function = wasm->getFunction(entry); if (!function) { std::cerr << "Unknown entry " << entry << std::endl; } else { ModuleInstance::LiteralList arguments; for (NameType param : function->params) { arguments.push_back(Literal(param.type)); } try { instance->callExport(entry, arguments); } catch (ExitException&) { } } } } while (*i < root->size()) { Element& curr = *(*root)[*i]; IString id = curr[0]->str(); if (id == MODULE) break; *checked = true; Colors::red(std::cerr); std::cerr << *i << '/' << (root->size() - 1); Colors::green(std::cerr); std::cerr << " CHECKING: "; Colors::normal(std::cerr); std::cerr << curr << '\n'; if (id == ASSERT_INVALID) { // a module invalidity test AllocatingModule wasm; bool invalid = false; std::unique_ptr<SExpressionWasmBuilder> builder; try { builder = std::unique_ptr<SExpressionWasmBuilder>( new SExpressionWasmBuilder(wasm, *curr[1], [&]() { invalid = true; throw ParseException(); }) ); } catch (const ParseException&) { invalid = true; } if (!invalid) { // maybe parsed ok, but otherwise incorrect invalid = !WasmValidator().validate(wasm); } assert(invalid); } else if (id == INVOKE) { assert(wasm); Invocation invocation(curr, instance, *builder->get()); invocation.invoke(); } else { // an invoke test assert(wasm); bool trapped = false; Literal result; try { Invocation invocation(*curr[1], instance, *builder->get()); result = invocation.invoke(); } catch (const TrapException&) { trapped = true; } if (id == ASSERT_RETURN) { assert(!trapped); if (curr.size() >= 3) { Literal expected = builder->get() ->parseExpression(*curr[2]) ->dyn_cast<Const>() ->value; std::cerr << "seen " << result << ", expected " << expected << '\n'; verify_result(expected, result); } else { Literal expected; std::cerr << "seen " << result << ", expected " << expected << '\n'; verify_result(expected, result); } } if (id == ASSERT_TRAP) assert(trapped); } *i += 1; } }
// this method should only be called by client-like applications bool ConnectMessagingEndPoint::connect(){ ACE_SOCK_Connector _connector_send, _connector_receive ; // try creating a listen in range 23200-30000 int baseport=23200; ReceiveSockHandler *receivesockhandler = 0; while (baseport < 30000){ try { receivesockhandler = new ReceiveSockHandler(baseport); break; } catch (std::string &e){ getLogStream(LOG_INFO) << "SockHandler construct failed for port " << baseport << endl; baseport++; } } if (receivesockhandler == 0){ throw OcfaException("Create listen failed"); } else { getLogStream(LOG_DEBUG) << "Listening on " << baseport << endl; } if (ACE_Reactor::instance()->register_handler(receivesockhandler, ACE_Event_Handler::ACCEPT_MASK) == -1){ ocfaLog(LOG_ERR,"Register of receivehandler failed"); return false; } // now start the thread which waits for incoming connections activate(); // connect our outgoing stream if (_connector_send.connect(_sock_outstream,_remote_addr_send) == -1){ ocfaLog(LOG_ERR, "connect failed"); return false; } else { ocfaLog(LOG_DEBUG, "Connector open succeeded"); // connected ! // create message holding info, serialize and send ACE_INET_Addr localendpoint; _sock_outstream.get_local_addr(localendpoint); ostringstream instname; instname << "Inst" << localendpoint.get_port_number(); // delete the old modinst and replace with a more accurate one string mname = _moduleinstance->getModuleName(); string mnamespace = _moduleinstance->getNameSpace(); delete(_moduleinstance); ocfaLog(LOG_DEBUG,"IP is: " + string(localendpoint.get_host_addr())); _moduleinstance = new ModuleInstance(localendpoint.get_host_addr(), mname, mnamespace, instname.str()); _moduleinstance->setPort(localendpoint.get_port_number()); ModuleInstance *mcopy = new ModuleInstance(*_moduleinstance); mcopy->setPort(localendpoint.get_port_number()); ostringstream strbaseport; strbaseport << baseport; Message *sockinfo = new ConcreteMessage(_moduleinstance, mcopy, Message::BROADCAST, Message::mtModuleInstance, strbaseport.str(), "", 0); //RJM:CODEREVIEW shouldn't we be deleting mcopy MessageWrapper *msgwrapper = new MessageWrapper(MessageWrapper::mwInternalConnect, sockinfo); getLogStream(LOG_DEBUG) << "MessageType: " << static_cast<int>(sockinfo->getType()) << " moduleinstance: " << sockinfo->getReceiver()->getInstanceURI() << endl; sndMessage(msgwrapper); ocfaLog(LOG_DEBUG, "Sent message. Deleting"); delete msgwrapper; delete sockinfo; return true; } }