event_dispatcher.c 3.03 KB
/**
 * \file
 *
 * \author	Georg Hopp
 *
 * \copyright
 * Copyright © 2014 Georg Hopp
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */

#include <stdint.h>
#include <signal.h>
#include <stdio.h>
#include <time.h>

#include "trbase.h"
#include "trdata.h"

#include "tr/event_handler.h"
#include "tr/event_dispatcher.h"

volatile TR_EventDispatcher _TR_controlDispatcher;

static
void
terminate(int signum)
{
    signal(signum, SIG_IGN);
    /*
     * \todo do logging here
     */
	puts("signal ... go");
    TR_eventDispatcherShutdown(_TR_controlDispatcher);
}

static
void
init_signals(void)
{
    signal(SIGTERM, terminate);
    signal(SIGHUP, SIG_IGN);
    signal(SIGINT, terminate);
    signal(SIGQUIT, terminate);
    signal(SIGABRT, terminate);
    signal(SIGALRM, SIG_IGN);
    signal(SIGURG, SIG_IGN);

    signal(SIGPIPE, SIG_IGN);
}

static
int
eventDispatcherCtor(void * _this, va_list * params) {
	TR_EventDispatcher this = _this;

	this->events          = TR_new(TR_Queue);
	this->handler         = TR_new(TR_Hash);
	this->mode            = va_arg(*params, TR_EventDispatcherMode);
	this->default_handler = va_arg(*params, TR_EventHandler);
	this->running         = 0;
	this->heartbeat       = 0;
	this->nextbeat        = 0;

	if (! _TR_controlDispatcher) {
		_TR_controlDispatcher = this;
		init_signals();
	}

	return 0;
}

static
void
releaseHandlerQueues(const void * node, const void * data)
{
	TR_delete(*(void**)((TR_HashValue)node)->value);
}

static
void
eventDispatcherDtor(void * _this) {
	TR_EventDispatcher this  = _this;

	TR_hashEach(this->handler, NULL, releaseHandlerQueues);

	TR_hashCleanup(this->handler);
	TR_delete(this->handler);
	TR_delete(this->events);
}

static
void
eventDispatcherCvInit(TR_class_ptr cls)
{
	TR_EVENT_CREATE(cls, TR_DISPATCHER_EVENT_HEARTBEAT);
	TR_EVENT_CREATE(cls, TR_DISPATCHER_EVENT_USER_WAIT);
	TR_EVENT_CREATE(cls, TR_DISPATCHER_EVENT_DATA_WAIT);
	TR_EVENT_CREATE(cls, TR_DISPATCHER_EVENT_SHUTDOWN);
}

const char * TR_eventDispatcherStrings[] = {
	"TR_DISPATCHER_EVENT_HEARTBEAT",
	"TR_DISPATCHER_EVENT_USER_WAIT",
	"TR_DISPATCHER_EVENT_DATA_WAIT",
	"TR_DISPATCHER_EVENT_SHUTDOWN"
};

intptr_t dispatcher_events[TR_DISPATCHER_EVENT_MAX + 1];
TR_INIT_IFACE(TR_Class, eventDispatcherCtor, eventDispatcherDtor, NULL);
TR_CREATE_CLASS(
		TR_EventDispatcher,
		TR_EventSubject,
		eventDispatcherCvInit,
		TR_IF(TR_Class)) = {
	{
		TR_eventDispatcherStrings,
		TR_DISPATCHER_EVENT_MAX + 1,
		dispatcher_events
	}
};

// vim: set ts=4 sw=4: