heartbeat.c File Reference

#include <signal.h>
#include "gwlib/gwlib.h"
#include "msg.h"
#include "heartbeat.h"

Go to the source code of this file.

Data Structures
struct	hb_info

Functions
static int	find_hb (void *item, void *pattern)
static void	heartbeat_thread (void *arg)
long	heartbeat_start (hb_send_func_t *send_func, double freq, hb_load_func_t *load_func)
void	heartbeat_stop (long hb_thread)

Variables
static List *	heartbeats = NULL

Function Documentation

find_hb()

static int find_hb ( void *  item, void *  pattern  )

static

Definition at line 85 of file heartbeat.c.

References info().

Referenced by heartbeat_stop().

{
    long *threadnrp;
    struct hb_info *info;

    info = item;
    threadnrp = pattern;

    return info->thread == *threadnrp;
}

heartbeat_start()

long heartbeat_start	(	hb_send_func_t *	send_func,
		double	freq,
		hb_load_func_t *	load_func
	)

Definition at line 126 of file heartbeat.c.

References DEFAULT_HEARTBEAT, hb_info::freq, gwlist_append(), gwlist_create, gwthread_create, heartbeat_thread(), heartbeats, info(), hb_info::load_func, and hb_info::send_func.

Referenced by main(), and run_smppbox().

{
    struct hb_info *info;

    /* can't start with send_funct NULL */
    if (send_func == NULL)
        return -1;

    info = gw_malloc(sizeof(*info));
    info->send_func = send_func;
    info->freq = (freq <= 0 ? DEFAULT_HEARTBEAT : freq);
    info->load_func = load_func;
    info->running = 1;
    info->thread = gwthread_create(heartbeat_thread, info);
    if (info->thread >= 0) {
    if (heartbeats == NULL)
        heartbeats = gwlist_create();
    gwlist_append(heartbeats, info);
        return info->thread;
    } else {
        gw_free(info);
        return -1;
    }
}

heartbeat_stop()

void heartbeat_stop

(

long

hb_thread

)

Definition at line 160 of file heartbeat.c.

References ALL_HEARTBEATS, find_hb(), gw_assert(), gwlist_destroy(), gwlist_extract_first(), gwlist_extract_matching(), gwlist_len(), gwthread_join(), gwthread_wakeup(), heartbeats, info(), and warning().

Referenced by main().

{
    List *matching_info;
    struct hb_info *info;

    /*
     * First, check if there are heartbeats to stop.
     * If not, do not continue, otherwise this function will crash
     */
    if (heartbeats == NULL)
        return;

    if (hb_thread == ALL_HEARTBEATS) {
        while (NULL != (info = gwlist_extract_first(heartbeats))) {
            gw_assert(info);
            info->running = 0;
            gwthread_wakeup(info->thread);
            gwthread_join(info->thread);
            gw_free(info);
        }
    } else {
        matching_info = gwlist_extract_matching(heartbeats, &hb_thread, find_hb);
        if (matching_info == NULL) {
            warning(0, "Could not stop heartbeat %ld: not found.", hb_thread);
        return;
        }
        gw_assert(gwlist_len(matching_info) == 1);
        info = gwlist_extract_first(matching_info);
        gwlist_destroy(matching_info, NULL);
     
        info->running = 0;
        gwthread_wakeup(hb_thread);
        gwthread_join(hb_thread);
        gw_free(info);
    }
    if (gwlist_len(heartbeats) == 0) {
        gwlist_destroy(heartbeats, NULL);
        heartbeats = NULL;
    }
}

heartbeat_thread()

static void heartbeat_thread ( void *  arg )

static

Definition at line 96 of file heartbeat.c.

References gwthread_sleep(), info(), msg, and msg_create.

Referenced by heartbeat_start().

{
    struct hb_info *info;
    time_t last_hb;

    info = arg;
    last_hb = 0;

    while (info->running) {
        Msg *msg;

        gwthread_sleep(info->freq);

        /*
         * Because the sleep can be interrupted, we might end up sending
         * heartbeats faster than the configured heartbeat frequency.
         * This is not bad unless we send them way too fast.  Make sure
         * our frequency is not more than twice the configured one.
         */
        if (difftime(time(NULL), last_hb) < info->freq / 2)
            continue;

        msg = msg_create(heartbeat);
        if (NULL != info->load_func)
            msg->heartbeat.load = info->load_func();
        info->send_func(msg);
        last_hb = time(NULL);
    }
}

Variable Documentation

heartbeats

List* heartbeats = NULL

static

Definition at line 80 of file heartbeat.c.

Referenced by heartbeat_start(), and heartbeat_stop().