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;
}
