bool Manager::init() { #define __CLASS__ Manager int ret; ret = setEventHandler(EVENT_TYPE_PREPARE_STARTUP, _onPrepareStartup); if (ret < 0) { HAGGLE_ERR("Could not register event handler\n"); return false; } ret = setEventHandler(EVENT_TYPE_STARTUP, _onStartup); if (ret < 0) { HAGGLE_ERR("Could not register event handler\n"); return false; } ret = setEventHandler(EVENT_TYPE_PREPARE_SHUTDOWN, _onPrepareShutdown); if (ret < 0) { HAGGLE_ERR("Could not register event handler\n"); return false; } ret = setEventHandler(EVENT_TYPE_SHUTDOWN, _onShutdown); if (ret < 0) { HAGGLE_ERR("Could not register event handler\n"); return false; } // CBMEN, HL - added event for dynamic configuration ret = setEventHandler(EVENT_TYPE_DYNAMIC_CONFIGURE, _onDynamicConfig); if (ret < 0) { HAGGLE_ERR("Could not register event handler\n"); return false; } // Register filter for node descriptions registerEventTypeForFilter(configEType, "Manager Configuration Filter Event", _onConfig, FILTER_CONFIG); if (!kernel->registerManager(this)) { HAGGLE_ERR("Could not register %s with kernel\n", name.c_str()); return false; } else { registered = true; } return init_derived(); }
void CCRecordGate::unregisterEvents() { CCLevelUpEventHandler *eventHandler = getEventHandler(); if (eventHandler) { CCLevelUpEventDispatcher::getInstance()->removeEventHandler(eventHandler); setEventHandler(NULL); } }
OPCEngine::~OPCEngine(void) { OPCShutdownRequest *sreq; _TRACE(TL_DEB, TG_ENG, (_T("> destructor"))); setEventHandler(NULL); setConfigurationFileHandler(NULL); m_creator->release(); m_nsRoot->release(); m_opcRoot->release(); g_engine = NULL; while(!m_shutdownList.IsEmpty()) { sreq = m_shutdownList.RemoveHead(); if (sreq->server) sreq->server->release(); delete sreq; } if (m_events[END_EVENT] != INVALID_HANDLE_VALUE) CloseHandle(m_events[END_EVENT]); if (m_events[SHUTDOWN_EVENT] != INVALID_HANDLE_VALUE) CloseHandle(m_events[SHUTDOWN_EVENT]); freeAllPoolEvents(); _TRACE(TL_DEB, TG_ENG, (_T("< destructor"))); }
void HTMLMarqueeElementImp::setOnstart(events::EventHandlerNonNull onstart) { setEventHandler(u"start", onstart); }
void HTMLMarqueeElementImp::setOnfinish(events::EventHandlerNonNull onfinish) { setEventHandler(u"finish", onfinish); }
void HTMLMarqueeElementImp::setOnbounce(events::EventHandlerNonNull onbounce) { setEventHandler(u"bounce", onbounce); }
void CCRecordGate::registerEvents() { if (!isOpen()) { setEventHandler(CCRecordGateEventHandler::create(this)); CCLevelUpEventDispatcher::getInstance()->addEventHandler(getEventHandler()); } }
bool SecurityManager::init_derived() { #define __CLASS__ SecurityManager int ret; ret = setEventHandler(EVENT_TYPE_DATAOBJECT_RECEIVED, onReceivedDataObject); if (ret < 0) { HAGGLE_ERR("Could not register event handler\n"); return false; } ret = setEventHandler(EVENT_TYPE_DATAOBJECT_SEND, onSendDataObject); if (ret < 0) { HAGGLE_ERR("Could not register event handler\n"); return false; } ret = setEventHandler(EVENT_TYPE_DATAOBJECT_INCOMING, onIncomingDataObject); if (ret < 0) { HAGGLE_ERR("Could not register event handler\n"); return false; } #ifdef DEBUG setEventHandler(EVENT_TYPE_DEBUG_CMD, onDebugCmdEvent); if (ret < 0) { HAGGLE_ERR("Could not register event handler\n"); return false; } #endif onRepositoryDataCallback = newEventCallback(onRepositoryData); /* This function must be called to load crypto algorithms used * for signing and verification of certificates. */ OpenSSL_add_all_algorithms(); #if defined(DEBUG) /* Load ssl error strings. Needed by ERR_error_string() */ ERR_load_crypto_strings(); #endif // -- retrieve CA key from memory caPrivKey = stringToRSAKey(ca_private_key, KEY_TYPE_PRIVATE); if (!caPrivKey) { HAGGLE_ERR("Could not read CA's private key from memory\n"); return false; } caPubKey = stringToRSAKey(ca_public_key, KEY_TYPE_PUBLIC); if (!caPubKey) { HAGGLE_ERR("Could not read CA's public key from memory\n"); return false; } HAGGLE_DBG("Successfully read CA's public key\n"); etype = registerEventType("SecurityTaskEvent", onSecurityTaskComplete); HAGGLE_DBG("Security level is set to %s\n", security_level_names[securityLevel]); helper = new SecurityHelper(this, etype); if (!helper || !helper->start()) { HAGGLE_ERR("Could not create or start security helper\n"); return false; } HAGGLE_DBG("Initialized security manager\n"); return true; }
bool DebugManager::init_derived() { #define __CLASS__ DebugManager #if defined(DEBUG) int i; for (i = EVENT_TYPE_PUBLIC_MIN; i < MAX_NUM_PUBLIC_EVENT_TYPES; i++) { setEventHandler(i, publicEvent); HAGGLE_DBG("Listening on %d:%s\n", i, Event::getPublicName(i)); } #endif server_sock = openSocket(DEFAULT_DEBUG_PORT); HAGGLE_DBG("Server sock is %d\n", server_sock); if (server_sock == INVALID_SOCKET || !kernel->registerWatchable(server_sock, this)) { CLOSE_SOCKET(server_sock); HAGGLE_ERR("Could not register socket\n"); return false; } #if (defined(OS_LINUX) && !defined(OS_ANDROID)) || (defined(OS_MACOSX) && !defined(OS_MACOSX_IPHONE)) if (interactive) { console = open("/dev/stdin", O_RDONLY); if (console == -1 || !kernel->registerWatchable(console, this)) { HAGGLE_ERR("Unable to open STDIN!\n"); CLOSE_SOCKET(server_sock); return false; } } #elif defined(OS_WINDOWS_DESKTOP) //#if 0 //Disabled if (interactive) { console = GetStdHandle(STD_INPUT_HANDLE); if (console == INVALID_HANDLE_VALUE || !kernel->registerWatchable(console, this)) { HAGGLE_ERR("Error - %s\n", StrError(GetLastError())); CLOSE_SOCKET(server_sock); return false; } // This will reset the console mode so that getchar() returns for // every character read SetConsoleMode(console, 0); // Flush any existing events on the console FlushConsoleInputBuffer(console); } //#endif // Disabled #endif #ifdef DEBUG_LEAKS debugEType = registerEventType("DebugManager Debug Event", onDebugReport); if (debugEType < 0) { HAGGLE_ERR("Could not register debug report event type...\n"); CLOSE_SOCKET(server_sock); return false; } #if defined(OS_WINDOWS_MOBILE) || defined(OS_ANDROID) kernel->addEvent(new Event(debugEType, NULL, 10)); #endif #endif #if ADD_LOG_FILE_TO_DATASTORE /* Log file distribution code: This uses the repository to save information about wether or not we have already added a data object to the source code. This is necessary in order not to insert more than one data object. Also, the data object will need to include the node ID of this node, which may not have been created yet, so this code delays the creation of that data object (if it needs to be created) until that is done. */ onFindRepositoryKeyCallback = newEventCallback(onFindRepositoryKey); kernel->getDataStore()->readRepository(new RepositoryEntry("DebugManager", "has saved log file data object"), onFindRepositoryKeyCallback); #endif onDumpDataStoreCallback = newEventCallback(onDumpDataStore); return true; }
DeviceFamily::DeviceFamily(BaseLib::Obj* bl, IFamilyEventSink* eventHandler) { _bl = bl; _eventHandler = eventHandler; if(_eventHandler) setEventHandler(_eventHandler); }
bool ProtocolManager::init_derived() { int ret; #define __CLASS__ ProtocolManager ret = setEventHandler(EVENT_TYPE_DATAOBJECT_SEND, onSendDataObject); if (ret < 0) { HAGGLE_ERR("Could not register event handler\n"); return false; } ret = setEventHandler(EVENT_TYPE_LOCAL_INTERFACE_UP, onLocalInterfaceUp); if (ret < 0) { HAGGLE_ERR("Could not register event handler\n"); return false; } ret = setEventHandler(EVENT_TYPE_LOCAL_INTERFACE_DOWN, onLocalInterfaceDown); if (ret < 0) { HAGGLE_ERR("Could not register event handler\n"); return false; } ret = setEventHandler(EVENT_TYPE_NEIGHBOR_INTERFACE_DOWN, onNeighborInterfaceDown); if (ret < 0) { HAGGLE_ERR("Could not register event handler\n"); return false; } ret = setEventHandler(EVENT_TYPE_NODE_UPDATED, onNodeUpdated); if (ret < 0) { HAGGLE_ERR("Could not register event handler\n"); return false; } delete_protocol_event = registerEventType("ProtocolManager protocol deletion event", onDeleteProtocolEvent); add_protocol_event = registerEventType("ProtocolManager protocol addition event", onAddProtocolEvent); send_data_object_actual_event = registerEventType("ProtocolManager send data object actual event", onSendDataObjectActual); protocol_shutdown_timeout_event = registerEventType("ProtocolManager Protocol Shutdown Timeout Event", onProtocolShutdownTimeout); if (protocol_shutdown_timeout_event < 0) { HAGGLE_ERR("Could not register protocol shutdown timeout event\n"); return false; } #ifdef DEBUG ret = setEventHandler(EVENT_TYPE_DEBUG_CMD, onDebugCmdEvent); if (ret < 0) { HAGGLE_ERR("Could not register event handler\n"); return false; } #endif return true; }
bool ReplicationManager::init_derived() { #define __CLASS__ ReplicationManager int ret; ret = setEventHandler(EVENT_TYPE_NODE_UPDATED, onNodeUpdated); if (ret < 0) { HAGGLE_ERR("Could not register event handler\n"); return false; } ret = setEventHandler(EVENT_TYPE_NODE_CONTACT_NEW, onNodeContactNew); if (ret < 0) { HAGGLE_ERR("Could not register event handler\n"); return false; } ret = setEventHandler(EVENT_TYPE_NODE_CONTACT_END, onNodeContactEnd); if (ret < 0) { HAGGLE_ERR("Could not register event handler\n"); return false; } ret = setEventHandler(EVENT_TYPE_DATAOBJECT_SEND, onSend); if (ret < 0) { HAGGLE_ERR("Could not register event handler\n"); return false; } ret = setEventHandler(EVENT_TYPE_DATAOBJECT_SEND_SUCCESSFUL, onSendSuccessful); if (ret < 0) { HAGGLE_ERR("Could not register event handler\n"); return false; } ret = setEventHandler(EVENT_TYPE_DATAOBJECT_SEND_FAILURE, onSendFailure); if (ret < 0) { HAGGLE_ERR("Could not register event handler\n"); return false; } ret = setEventHandler(EVENT_TYPE_DATAOBJECT_DELETED, onDeletedDataObject); if (ret < 0) { HAGGLE_ERR("Could not register event handler\n"); return false; } ret = setEventHandler(EVENT_TYPE_DATAOBJECT_NEW, onInsertedDataObject); if (ret < 0) { HAGGLE_ERR("Could not register event handler\n"); return false; } ret = setEventHandler(EVENT_TYPE_REPL_MANAGER, onReplicationManagerEvent); if (ret < 0) { HAGGLE_ERR("Could not register event handler\n"); return false; } HAGGLE_DBG("Starting data helper...\n"); return true; }