amxp_scheduler.c File Reference

#include <stdlib.h>
#include <stdio.h>
#include <amxc/amxc.h>
#include <amxp/amxp_scheduler.h>
#include <amxc/amxc_macros.h>

Go to the source code of this file.

Macros
#define	_GNU_SOURCE

Functions
static void	amxp_schedule_item_delete (amxc_llist_it_t *it)
static int	amxp_scheduler_compare_items (amxc_llist_it_t *it1, amxc_llist_it_t *it2)
static void	amxp_scheduler_reset_timer (amxp_scheduler_t *scheduler)
static void	amxp_scheduler_emit (amxp_scheduler_t *scheduler, amxp_scheduler_item_t *item, const char *signal, uint32_t duration, bool trigger)
static void	amxp_scheduler_item_stop (UNUSED amxp_timer_t *timer, void *priv)
static void	amxp_scheduler_check_item (amxp_scheduler_t *scheduler, amxp_scheduler_item_t *item)
static void	amxp_scheduler_trigger (amxp_timer_t *timer, void *priv)
static void	amxp_scheduler_add_signal (amxp_scheduler_t *scheduler, const char *signal, const char *id)
static void	amxp_scheduler_remove_signal (amxp_scheduler_t *scheduler, const char *signal, const char *id)
static amxp_scheduler_item_t *	amxp_scheduler_create_or_fetch (amxp_scheduler_t *scheduler, const char *id, uint32_t duration)
static void	amxp_scheduler_insert (amxp_scheduler_t *scheduler, const char *id, amxp_scheduler_item_t *item)
int	amxp_scheduler_new (amxp_scheduler_t **scheduler)
	Allocates a amxp_scheduler_t structures and initializes to an empty scheduler. More...
void	amxp_scheduler_delete (amxp_scheduler_t **scheduler)
	Frees the previously allocated amxp_scheduler_t structure. More...
int	amxp_scheduler_init (amxp_scheduler_t *scheduler)
	Initializes a amxp_scheduler_t to an empty scheduler. More...
void	amxp_scheduler_clean (amxp_scheduler_t *scheduler)
	Cleans the scheduler. More...
int	amxp_scheduler_enable (amxp_scheduler_t *scheduler, bool enable)
	Enables or disable the scheduler. More...
int	amxp_scheduler_use_local_time (amxp_scheduler_t *scheduler, bool use_local_time)
	Use local time or UTC time in calculation for next trigger times. More...
int	amxp_scheduler_update (amxp_scheduler_t *scheduler)
	Forces recalculation of the schedule items' next occurrence time. More...
int	amxp_scheduler_connect (amxp_scheduler_t *scheduler, const char *id, amxp_slot_fn_t fn, void *priv)
	Connects a callback function to the scheduler. More...
int	amxp_scheduler_disconnect (amxp_scheduler_t *scheduler, const char *id, amxp_slot_fn_t fn)
	Disconnects a callback function from the scheduler. More...
int	amxp_scheduler_set_cron_item (amxp_scheduler_t *scheduler, const char *id, const char *cron_expr, uint32_t duration)
	Adds a schedule item or updates a schedule item using a cron expression. More...
int	amxp_scheduler_set_cron_begin_end_item (amxp_scheduler_t *scheduler, const char *id, const char *cron_begin, const char *cron_end)
	Adds a schedule item or updates a schedule item using a cron expressions. More...
int	amxp_scheduler_set_weekly_item (amxp_scheduler_t *scheduler, const char *id, const char *time, const char *days_of_week, uint32_t duration)
	Adds a schedule item or updates a schedule item using a time and list of week days. More...
int	amxp_scheduler_set_weekly_begin_end_item (amxp_scheduler_t *scheduler, const char *id, const char *start_time, const char *end_time, const char *days_of_week)
	Adds a schedule item or updates a schedule item using a start time, end time and list of week days. More...
int	amxp_scheduler_remove_item (amxp_scheduler_t *scheduler, const char *id)
	Removes a schedule item from the scheduler. More...
int	amxp_scheduler_enable_item (amxp_scheduler_t *scheduler, const char *id, bool enable)
	Enables or disable a schedule item. More...
amxp_signal_mngr_t *	amxp_scheduler_get_sigmngr (amxp_scheduler_t *scheduler)
	Gets the signal manager of a scheduler. More...

Macro Definition Documentation

_GNU_SOURCE

#define _GNU_SOURCE

Definition at line 56 of file amxp_scheduler.c.

Function Documentation

amxp_schedule_item_delete()

static void amxp_schedule_item_delete ( amxc_llist_it_t *  it )

static

Definition at line 66 of file amxp_scheduler.c.

                                                           {
    amxp_scheduler_item_t* item = amxc_container_of(it, amxp_scheduler_item_t, lit);
 
    amxp_cron_clean(&item->cron);
    amxp_timer_delete(&item->timer);
    amxc_htable_it_clean(&item->hit, NULL);
    free(item);
}

amxp_scheduler_add_signal()

static void amxp_scheduler_add_signal ( amxp_scheduler_t *  scheduler, const char *  signal, const char *  id  )

static

Definition at line 242 of file amxp_scheduler.c.

                                                                                                       {
    amxc_string_t strsignal;
    amxc_string_init(&strsignal, 0);
 
    amxc_string_setf(&strsignal, "%s:%s", signal, id);
    amxp_sigmngr_add_signal(&scheduler->sigmngr, amxc_string_get(&strsignal, 0));
 
    amxc_string_clean(&strsignal);
}

amxp_scheduler_check_item()

static void amxp_scheduler_check_item ( amxp_scheduler_t *  scheduler, amxp_scheduler_item_t *  item  )

static

Definition at line 151 of file amxp_scheduler.c.

                                                                   {
    amxc_ts_t now;
    amxc_ts_t prev = { 0, 0, 0};
    uint32_t duration = 0;
    amxc_ts_now(&now);
 
    when_false(scheduler->sigmngr.enabled, exit);
    when_false(item->enabled, exit);
    if((item->duration == 0) && !item->end_time_is_set) {
        if((item->timer != NULL) && (item->timer->state == amxp_timer_running)) {
            amxp_scheduler_emit(scheduler, item, "stop", 0, false);
            amxp_timer_delete(&item->timer);
        }
        goto exit;
    }
 
    if(scheduler->use_local_time) {
        amxc_ts_to_local(&now);
    }
 
    duration = item->duration;
    amxp_cron_prev(&item->cron, &now, &prev);
    if((duration == 0) && item->end_time_is_set) {
        amxc_ts_t end = { 0, 0, 0};
        amxp_cron_next(&item->end_cron, &prev, &end);
        duration = end.sec - prev.sec;
    }
 
    prev.sec += duration;
    if(prev.sec > now.sec) {
        if(item->timer == NULL) {
            amxp_timer_new(&item->timer, amxp_scheduler_item_stop, item);
        }
        if(item->timer->state != amxp_timer_running) {
            amxp_scheduler_emit(scheduler, item, "start", prev.sec - now.sec, false);
        }
        amxp_timer_start(item->timer, (prev.sec - now.sec) * 1000);
    } else {
        if((item->timer != NULL) && (item->timer->state == amxp_timer_running)) {
            amxp_scheduler_emit(scheduler, item, "stop", 0, false);
            amxp_timer_delete(&item->timer);
        }
    }
 
exit:
    return;
}

amxp_scheduler_compare_items()

static int amxp_scheduler_compare_items ( amxc_llist_it_t *  it1, amxc_llist_it_t *  it2  )

static

Definition at line 75 of file amxp_scheduler.c.

                                                                                    {
    amxp_scheduler_item_t* item1 = amxc_container_of(it1, amxp_scheduler_item_t, lit);
    amxp_scheduler_item_t* item2 = amxc_container_of(it2, amxp_scheduler_item_t, lit);
 
    return item1->next.sec - item2->next.sec;
}

amxp_scheduler_create_or_fetch()

static amxp_scheduler_item_t* amxp_scheduler_create_or_fetch ( amxp_scheduler_t *  scheduler, const char *  id, uint32_t  duration  )

static

Definition at line 270 of file amxp_scheduler.c.

                                                                                {
    amxp_scheduler_item_t* item = NULL;
    amxc_htable_it_t* hit = NULL;
    bool enabled = true;
 
    when_null(scheduler, exit);
    when_str_empty(id, exit);
 
    hit = amxc_htable_get(&scheduler->items, id);
    if(hit != NULL) {
        item = amxc_container_of(hit, amxp_scheduler_item_t, hit);
        enabled = item != NULL? item->enabled:true;
    } else {
        item = (amxp_scheduler_item_t*) calloc(1, sizeof(amxp_scheduler_item_t));
    }
    when_null(item, exit);
 
    item->duration = duration;
    item->enabled = enabled;
 
exit:
    return item;
}

amxp_scheduler_emit()

static void amxp_scheduler_emit ( amxp_scheduler_t *  scheduler, amxp_scheduler_item_t *  item, const char *  signal, uint32_t  duration, bool  trigger  )

static

Definition at line 105 of file amxp_scheduler.c.

                                              {
    amxc_var_t data;
    amxc_string_t strsignal;
    amxp_signal_t* s = NULL;
    const char* id = amxc_htable_it_get_key(&item->hit);
    amxc_var_init(&data);
    amxc_var_set_type(&data, AMXC_VAR_ID_HTABLE);
    amxc_var_add_key(cstring_t, &data, "id", id);
    amxc_string_init(&strsignal, 0);
 
    amxc_string_setf(&strsignal, "%s:%s", signal, id);
 
    if(duration != 0) {
        amxc_var_add_key(uint32_t, &data, "duration", duration);
    }
 
    amxc_var_add_key(cstring_t, &data, "reason", signal);
 
    s = amxp_sigmngr_find_signal(&scheduler->sigmngr, amxc_string_get(&strsignal, 0));
    when_null(s, exit);
    if(trigger) {
        if(!s->triggered) {
            amxp_sigmngr_trigger_signal(&scheduler->sigmngr, amxc_string_get(&strsignal, 0), &data);
        }
    } else {
        amxp_sigmngr_emit_signal(&scheduler->sigmngr, amxc_string_get(&strsignal, 0), &data);
    }
 
exit:
    amxc_string_clean(&strsignal);
    amxc_var_clean(&data);
}

amxp_scheduler_insert()

static void amxp_scheduler_insert ( amxp_scheduler_t *  scheduler, const char *  id, amxp_scheduler_item_t *  item  )

static

Definition at line 296 of file amxp_scheduler.c.

                                                               {
 
    amxc_ts_t now;
 
    amxc_ts_now(&now);
    if(scheduler->use_local_time) {
        amxc_ts_to_local(&now);
    }
 
    amxp_cron_next(&item->cron, &now, &item->next);
    amxc_llist_prepend(&scheduler->ordered_items, &item->lit);
    amxc_htable_insert(&scheduler->items, id, &item->hit);
 
    amxp_scheduler_add_signal(scheduler, "trigger", id);
    amxp_scheduler_add_signal(scheduler, "start", id);
    amxp_scheduler_add_signal(scheduler, "stop", id);
 
    amxp_scheduler_check_item(scheduler, item);
    amxp_scheduler_reset_timer(scheduler);
}

amxp_scheduler_item_stop()

static void amxp_scheduler_item_stop ( UNUSED amxp_timer_t *  timer, void *  priv  )

static

Definition at line 143 of file amxp_scheduler.c.

                                                                             {
    amxp_scheduler_item_t* item = (amxp_scheduler_item_t*) priv;
    amxp_scheduler_t* scheduler = amxc_container_of(item->lit.llist, amxp_scheduler_t, ordered_items);
 
    amxp_timer_delete(&item->timer);
    amxp_scheduler_emit(scheduler, item, "stop", 0, false);
}

amxp_scheduler_remove_signal()

static void amxp_scheduler_remove_signal ( amxp_scheduler_t *  scheduler, const char *  signal, const char *  id  )

static

Definition at line 252 of file amxp_scheduler.c.

                                                                                                          {
    amxc_string_t strsignal;
    amxp_signal_t* s = NULL;
    amxc_string_init(&strsignal, 0);
 
    amxc_string_setf(&strsignal, "%s:%s", signal, id);
    s = amxp_sigmngr_find_signal(&scheduler->sigmngr, amxc_string_get(&strsignal, 0));
    if(s != NULL) {
        if(s->triggered) {
            amxp_sigmngr_remove_signal(&scheduler->sigmngr, amxc_string_get(&strsignal, 0));
        } else {
            amxp_signal_delete(&s);
        }
    }
 
    amxc_string_clean(&strsignal);
}

amxp_scheduler_reset_timer()

static void amxp_scheduler_reset_timer ( amxp_scheduler_t *  scheduler )

static

Definition at line 82 of file amxp_scheduler.c.

                                                                    {
    amxc_llist_it_t* it = NULL;
    amxp_scheduler_item_t* item = NULL;
    uint64_t next = 0;
 
    amxc_llist_sort(&scheduler->ordered_items, amxp_scheduler_compare_items);
    it = amxc_llist_get_first(&scheduler->ordered_items);
    if(it == NULL) {
        amxp_timer_stop(scheduler->timer);
        goto exit;
    }
 
    item = amxc_container_of(it, amxp_scheduler_item_t, lit);
    next = amxp_cron_time_until_next(&item->cron, scheduler->use_local_time);
 
    if(scheduler->sigmngr.enabled) {
        amxp_timer_start(scheduler->timer, next * 1000);
    }
 
exit:
    return;
}

amxp_scheduler_trigger()

static void amxp_scheduler_trigger ( amxp_timer_t *  timer, void *  priv  )

static

Definition at line 200 of file amxp_scheduler.c.

                                                                    {
    amxp_scheduler_t* scheduler = (amxp_scheduler_t*) priv;
    amxc_llist_it_t* it = amxc_llist_get_first(&scheduler->ordered_items);
    amxp_scheduler_item_t* item = amxc_container_of(it, amxp_scheduler_item_t, lit);
    amxc_ts_t now;
    uint32_t duration = 0;
 
    when_false(timer == scheduler->timer, exit);
    amxc_ts_now(&now);
 
    if(scheduler->use_local_time) {
        amxc_ts_to_local(&now);
    }
 
    while(it != NULL && item->next.sec <= now.sec) {
        if(item->enabled) {
            duration = item->duration;
            if((duration == 0) && item->end_time_is_set) {
                amxc_ts_t end = { 0, 0, 0};
                amxp_cron_next(&item->end_cron, &now, &end);
                duration = end.sec - now.sec;
            }
            if(duration == 0) {
                amxp_scheduler_emit(scheduler, item, "trigger", 0, false);
            } else {
                amxp_scheduler_emit(scheduler, item, "start", duration, false);
                amxp_timer_new(&item->timer, amxp_scheduler_item_stop, item);
                amxp_timer_start(item->timer, duration * 1000);
            }
        }
        amxp_cron_next(&item->cron, &now, &item->next);
        it = amxc_llist_it_get_next(it);
        if(it != NULL) {
            item = amxc_container_of(it, amxp_scheduler_item_t, lit);
        }
    }
 
    amxp_scheduler_reset_timer(scheduler);
exit:
    return;
}