QEvent::Type RunnableExcutedEvent::evType()
{
if(s_evType == QEvent::None)
{
s_evType = (QEvent::Type)registerEventType();
}
return s_evType;
}
static QEvent::Type evType()
{
if(s_evType == QEvent::None)
{
s_evType = (QEvent::Type)registerEventType();
}
return s_evType;
}
QEvent::Type capCustomEvent::eventType()
{
if(m_evType == QEvent::None)
{
m_evType = (QEvent::Type)registerEventType();
}
return m_evType;
}
RenderTaskDispatcher::RenderTaskDispatcher(QObject* parent) : QObject(parent)
{
registerEventType(DeleteLaterEvent::registeredType);
registerEventType(FinishedEvent::registeredType);
registerEventType(ImageReadyEvent::registeredType);
}
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;
}
void registerEventType(const char *sym, wxEventTypeTag<T> type,VALUE klass)
{
registerEventType(sym,type);
registerInfo<T>(klass);
}
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;
}
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;
}
void
CacheStrategyUtility::_onConfig(
const Metadata& m)
{
const char *param;
const Metadata *dm;
if (m.getName() != getName()) {
HAGGLE_ERR("Wrong config.\n");
return;
}
// load knapsack optimizer
param = m.getParameter("knapsack_optimizer");
if (!param) {
HAGGLE_DBG("No knapsack optimizer specified, using default.\n");
ksOptimizer = CacheKnapsackOptimizerFactory::getNewKnapsackOptimizer(getManager()->getKernel());
}
else {
ksOptimizer = CacheKnapsackOptimizerFactory::getNewKnapsackOptimizer(getManager()->getKernel(), param);
}
if (!ksOptimizer) {
HAGGLE_ERR("Could not initialize knapsack optimizer.\n");
return;
}
dm = m.getMetadata(param);
if (dm) {
ksOptimizer->onConfig(*dm);
}
// load global optimizer
param = m.getParameter("global_optimizer");
if (!param) {
HAGGLE_DBG("No specified, using default.\n");
globalOptimizer = CacheGlobalOptimizerFactory::getNewGlobalOptimizer(getManager()->getKernel());
}
else {
globalOptimizer = CacheGlobalOptimizerFactory::getNewGlobalOptimizer(getManager()->getKernel(), param);
}
if (!globalOptimizer) {
HAGGLE_ERR("Could not initialize global optimizer.\n");
return;
}
dm = m.getMetadata(param);
if (dm) {
globalOptimizer->onConfig(*dm);
}
// load utility function
param = m.getParameter("utility_function");
if (!param) {
HAGGLE_DBG("No utility function specified, using default.\n");
utilFunction = CacheUtilityFunctionFactory::getNewUtilityFunction(getManager(), globalOptimizer);
}
else {
utilFunction = CacheUtilityFunctionFactory::getNewUtilityFunction(getManager(), globalOptimizer, param);
}
if (!utilFunction) {
HAGGLE_ERR("Could not initialize utility function.\n");
return;
}
dm = m.getMetadata(param);
if (dm) {
utilFunction->onConfig(*dm);
}
param = m.getParameter("max_capacity_kb");
if (!param) {
HAGGLE_ERR("No maximum capacity specified\n");
return;
}
max_capacity_kb = atoi(param);
if (max_capacity_kb < 0) {
HAGGLE_ERR("Invalid max capacity.\n");
return;
}
param = m.getParameter("watermark_capacity_kb");
if (!param) {
HAGGLE_ERR("No watermark capacity specified\n");
return;
}
watermark_capacity_kb = atoi(param);
if ((watermark_capacity_kb < 0) || (watermark_capacity_kb > max_capacity_kb)) {
HAGGLE_ERR("Invalid watermark capacity.\n");
return;
}
param = m.getParameter("compute_period_ms");
if (param) {
computePeriodMs = atoi(param);
}
if (computePeriodMs < 0) {
HAGGLE_ERR("Invalid compute period.\n");
return;
}
param = m.getParameter("purge_poll_period_ms");
if (param) {
pollPeriodMs = atoi(param);
}
if (pollPeriodMs < 0) {
HAGGLE_ERR("Invalid poll period.\n");
return;
}
param = m.getParameter("purge_on_insert");
if (param) {
purgeOnInsert = (0 == strcmp("true", param));
}
param = m.getParameter("manage_only_remote_files");
if (param) {
manage_only_remote_files = (0 == strcmp("true", param));
}
param = m.getParameter("manage_locally_sent_files");
if (param) {
manage_locally_sent_files = (0 == strcmp("true", param));
}
param = m.getParameter("publish_stats_dataobject");
if (param) {
publish_stats_dataobject = (0 == strcmp("true", param));
}
param = m.getParameter("keep_in_bloomfilter");
if (param) {
keep_in_bloomfilter = (0 == strcmp("true", param));
}
param = m.getParameter("handle_zero_size");
if (param) {
handle_zero_size = (0 == strcmp("true", param));
}
//JM: START DB
param = m.getParameter("manage_db_purging");
if (param) {
allow_db_purging = (0 == strcmp("true", param));
}
param = m.getParameter("db_size_threshold");
if (param) {
db_size_threshold = atoll(param);
}
param = m.getParameter("self_benchmark_test");
if (param) {
self_test = (0 == strcmp("true", param));
}
//JM: END
param = m.getParameter("bloomfilter_remove_delay_ms");
if (param) {
bloomfilter_remove_delay_ms = atoi(param);
}
// SW: START: remove from local bloomfilter.
if (bloomfilter_remove_delay_ms >= 0) {
bloomfilterRemoveDelayEventType = registerEventType("BFRemoveDelay", onBloomfilterRemoveDelay);
if (bloomfilterRemoveDelayEventType <= 0) {
HAGGLE_ERR("Could not register bloomfilter remove delay event.\n");
}
}
//SW: END: remove from local bloomfilter.
if (publish_stats_dataobject) {
CacheReplacementTotalOrder *replacement =
new CacheReplacementTotalOrder(
getManager(),
"Timestamp",
"PublisherID",
"CacheStrategyUtility",
"stats");
// only keep the most up to date stats in the data base
stats_replacement_strat =
new CacheStrategyReplacementPurger(
getManager(),
replacement,
NULL,
false);
if (!stats_replacement_strat) {
HAGGLE_ERR("Could not allocate replacement strat\n");
}
else {
stats_replacement_strat->start();
}
}
periodicPurgeEventType = registerEventType("periodic purge event", onPeriodicEvent);
periodicPurgeEvent = new Event(periodicPurgeEventType);
// we re-use the event
periodicPurgeEvent->setAutoDelete(false);
firePeriodic();
if (!purgeOnInsert && (pollPeriodMs <= 0)) {
HAGGLE_DBG("WARNING: All purging is disabled, was this intended?\n");
}
// add debug printing
HAGGLE_DBG("Successfully initialized utiltiy cache strategy, knapsack optimizer: %s, global optimizer: %s, utiltiy function: %s, max capacity kb: %lld, watermark capacity kb: %lld, compute period ms: %d, purge poll period ms: %d, purge on insert; %s, manage only remote files: %s, publish stats dataobject: %s, db_purge: %s (%lld), self test:%s \n", getKnapsackOptimizer()->getName().c_str(), getGlobalOptimizer()->getName().c_str(), getUtilityFunction()->getName().c_str(), max_capacity_kb, watermark_capacity_kb, computePeriodMs, pollPeriodMs, purgeOnInsert ? "yes" : "no", manage_only_remote_files ? "yes" : "no", publish_stats_dataobject ? "yes (CacheStrategyUtility=stats)" : "no", allow_db_purging ? "yes" : "no", db_size_threshold, self_test ? "yes" : "no");
}
