char *add_handler(char *event, void (*fn)(void *), void *arg)
{
char *err;
ENTER_EVENT_LOCK;
if (!handler_thread) {
if (err = _create_handler_thread()) {
RELEASE_EVENT_LOCK;
return err;
}
}
/* suspend handler */
if (err = _suspend_handler()) {
RELEASE_EVENT_LOCK;
return err;
}
if (err = _create_event(event, fn, arg)) {
RELEASE_EVENT_LOCK;
return err;
}
/* reset the handler to wake up and listen on the new event */
if (err = _resume_handler()) {
RELEASE_EVENT_LOCK;
return err;
}
RELEASE_EVENT_LOCK;
return NULL;
}
/*
* updown_event_metric_update
*
* updown event module metric_update function. Store results the
* updown cache appropriately.
*/
static int
updown_event_metric_update(const char *nodename,
const char *metric_name,
unsigned int metric_value_type,
unsigned int metric_value_len,
void *metric_value,
struct cerebro_event **event)
{
int *state = NULL;
int rv = 0;
/* If the node isn't recorded, it's the first notification
* that it's down.
*/
if (!(state = hash_find(node_states, nodename)))
{
if (!(state = _create_entry(nodename)))
return -1;
}
if (*state == UPDOWN_EVENT_STATE_DOWN)
{
struct cerebro_event *eventPtr = NULL;
if ((eventPtr = _create_event(nodename, UPDOWN_EVENT_STATE_UP)))
{
*event = eventPtr;
rv = 1;
}
}
*state = UPDOWN_EVENT_STATE_UP;
return rv;
}
/*
* updown_event_node_timeout
*
* updown event module node_timeout function
*/
static int
updown_event_node_timeout(const char *nodename,
struct cerebro_event **event)
{
int *state = NULL;
int rv = 0;
/* If the node isn't recorded, it's the first notification
* that it's down.
*/
if (!(state = hash_find(node_states, nodename)))
{
if (!(state = _create_entry(nodename)))
return -1;
}
#if 0
/* For debugging */
if (*state == UPDOWN_EVENT_STATE_INIT)
{
struct cerebro_event *eventPtr = NULL;
if ((eventPtr = _create_event(nodename, UPDOWN_EVENT_STATE_DOWN)))
{
*event = eventPtr;
rv = 1;
}
}
#endif
if (*state == UPDOWN_EVENT_STATE_UP)
{
struct cerebro_event *eventPtr = NULL;
if ((eventPtr = _create_event(nodename, UPDOWN_EVENT_STATE_DOWN)))
{
*event = eventPtr;
rv = 1;
}
}
*state = UPDOWN_EVENT_STATE_DOWN;
return rv;
}
crawlback_object * crawlback_add_callback(crawlback_object * c, crawlback_callback_type callback_type,
crawlback_callback callback, void * d) {
switch(callback_type) {
case EVENT_START:
c->start_cb = callback;
c->start_ev = _create_event(d);
c->start_cb_set = 1;
break;
case EVENT_RUN:
c->run_cb = callback;
c->run_ev = _create_event(d);
c->run_cb_set = 1;
break;
case EVENT_END:
c->end_cb = callback;
c->end_ev = _create_event(d);
c->end_cb_set = 1;
break;
}
return c;
}
// Event Observer Interface
void
dmz::RenderPluginEventOSG::close_event (
const Handle EventHandle,
const EventType &Type,
const EventLocalityEnum Locality) {
const Handle TypeHandle = Type.get_handle ();
if (!_ignore.contains (TypeHandle)) {
TypeStruct *ts = _get_type (EventHandle, Type);
if (ts) { _create_event (EventHandle, *ts); }
}
}
char *add_rotation_handler(char *event, void (*fn)(void *), void *arg)
{
char *err;
if (err = _create_event(event, fn, arg)) {
return err;
}
if (!handler_thread) {
if (err = _create_rotation_thread()) {
return err;
}
}
return NULL;
}
char *_create_handler_thread()
{
char *err;
/* The first event the thread will wait on is the event to suspend
* the event handler thread */
if (err = _create_event(suspend, _wait_for_resume, NULL)) {
return err;
}
handler_thread = systhread_start(15, 65536, _wait_for_events,
NULL);
if (handler_thread == NULL) {
err = (char *)MALLOC(ERR_MSG_LEN);
util_snprintf(err, ERR_MSG_LEN, "Failed to start event handler thread %s",
system_errmsg());
return err;
}
return NULL;
}
