#include <switch.h>

Include dependency graph for switch_scheduler.c:

Data Structures
struct	switch_scheduler_task_container

Typedefs
typedef struct switch_scheduler_task_container	switch_scheduler_task_container_t

Functions
static void	switch_scheduler_execute (switch_scheduler_task_container_t *tp)

static void *SWITCH_THREAD_FUNC	task_own_thread (switch_thread_t thread, void obj)

static int	task_thread_loop (int done)

static void *SWITCH_THREAD_FUNC	switch_scheduler_task_thread (switch_thread_t thread, void obj)

uint32_t	switch_scheduler_add_task (time_t task_runtime, switch_scheduler_func_t func, const char desc, const char group, uint32_t cmd_id, void *cmd_arg, switch_scheduler_flag_t flags)
	Schedule a task in the future. More...

uint32_t	switch_scheduler_add_task_ex (time_t task_runtime, switch_scheduler_func_t func, const char desc, const char group, uint32_t cmd_id, void cmd_arg, switch_scheduler_flag_t flags, uint32_t task_id)
	Schedule a task in the future. More...

uint32_t	switch_scheduler_del_task_id (uint32_t task_id)
	Delete a scheduled task. More...

uint32_t	switch_scheduler_del_task_group (const char *group)
	Delete a scheduled task based on the group name. More...

void	switch_scheduler_task_thread_start (void)
	Start the scheduler system. More...

void	switch_scheduler_task_thread_stop (void)
	Stop the scheduler system. More...

Variables
struct {
switch_scheduler_task_container_t * task_list

switch_mutex_t * task_mutex

uint32_t task_id

int task_thread_running

switch_queue_t * event_queue

switch_memory_pool_t * memory_pool

}	globals = { 0 }

switch_thread_t *	task_thread_p = NULL

Typedef Documentation

◆ switch_scheduler_task_container_t

typedef struct switch_scheduler_task_container switch_scheduler_task_container_t

Definition at line 48 of file switch_scheduler.c.

Function Documentation

◆ switch_scheduler_execute()

static void switch_scheduler_execute ( switch_scheduler_task_container_t * tp )

static

Definition at line 59 of file switch_scheduler.c.

Referenced by task_own_thread(), and task_thread_loop().

 {
         switch_event_t *event;
         //switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Executing task %u %s (%s)\n", tp->task.task_id, tp->desc, switch_str_nil(tp->task.group));
 
         tp->func(&tp->task);
 
         switch_mutex_lock(globals.task_mutex);
         if (tp->task.repeat) {
                 tp->task.runtime = switch_epoch_time_now(NULL) + tp->task.repeat;
         }
 
         if (!tp->destroy_requested && tp->task.runtime > tp->executed) {
                 tp->executed = 0;
                 if (switch_event_create(&event, SWITCH_EVENT_RE_SCHEDULE) == SWITCH_STATUS_SUCCESS) {
                         switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Task-ID", "%u", tp->task.task_id);
                         switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Task-Desc", tp->desc);
                         switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Task-Group", switch_str_nil(tp->task.group));
                         switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Task-Runtime", "%" SWITCH_INT64_T_FMT, tp->task.runtime);
                         switch_queue_push(globals.event_queue, event);
                         event = NULL;
                 }
         } else {
                 tp->destroyed = 1;
         }
         switch_mutex_unlock(globals.task_mutex);
 }

◆ switch_scheduler_task_thread()

static void* SWITCH_THREAD_FUNC switch_scheduler_task_thread	(	switch_thread_t *	thread,
		void *	obj
	)

static

Definition at line 181 of file switch_scheduler.c.

References globals, SWITCH_CHANNEL_LOG, switch_event_destroy(), switch_event_fire, SWITCH_LOG_NOTICE, switch_log_printf(), switch_queue_pop_timeout(), switch_queue_trypop(), SWITCH_STATUS_SUCCESS, and task_thread_loop().

Referenced by switch_scheduler_task_thread_start().

 {
         void *pop;
         globals.task_thread_running = 1;
 
         switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_NOTICE, "Starting task thread\n");
         while (globals.task_thread_running == 1) {
                 if (task_thread_loop(0)) {
                         break;
                 }
                 if (switch_queue_pop_timeout(globals.event_queue, &pop, 500000) == SWITCH_STATUS_SUCCESS) {
                         switch_event_t *event = (switch_event_t *) pop;
                         switch_event_fire(&event);
                 }
         }
 
         task_thread_loop(1);
 
         switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_NOTICE, "Task thread ending\n");
 
         while(switch_queue_trypop(globals.event_queue, &pop) == SWITCH_STATUS_SUCCESS) {
                 switch_event_t *event = (switch_event_t *) pop;
                 switch_event_destroy(&event);
         }
 
         globals.task_thread_running = 0;
 
         return NULL;
 }

◆ task_own_thread()

static void* SWITCH_THREAD_FUNC task_own_thread	(	switch_thread_t *	thread,
		void *	obj
	)

static

Definition at line 87 of file switch_scheduler.c.

References switch_scheduler_task_container::in_thread, switch_scheduler_task_container::pool, switch_core_destroy_memory_pool, and switch_scheduler_execute().

Referenced by task_thread_loop().

 {
         switch_scheduler_task_container_t *tp = (switch_scheduler_task_container_t *) obj;
         switch_memory_pool_t *pool;
 
         pool = tp->pool;
         tp->pool = NULL;
 
         switch_scheduler_execute(tp);
         switch_core_destroy_memory_pool(&pool);
         tp->in_thread = 0;
 
         return NULL;
 }

◆ task_thread_loop()

static int task_thread_loop ( int done )

static

Definition at line 102 of file switch_scheduler.c.

Referenced by switch_scheduler_task_thread().

 {
         switch_scheduler_task_container_t *tofree, *tp, *last = NULL;
 
 
         switch_mutex_lock(globals.task_mutex);
 
         for (tp = globals.task_list; tp; tp = tp->next) {
                 if (done) {
                         tp->destroyed = 1;
                 } else if (!tp->destroyed) {
                         int64_t now = switch_epoch_time_now(NULL);
                         if (now >= tp->task.runtime && !tp->in_thread) {
                                 int32_t diff = (int32_t) (now - tp->task.runtime);
                                 if (diff > 1) {
                                         switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_WARNING, "Task was executed late by %d seconds %u %s (%s)\n",
                                                                           diff, tp->task.task_id, tp->desc, switch_str_nil(tp->task.group));
                                 }
                                 tp->executed = now;
                                 if (switch_test_flag(tp, SSHF_OWN_THREAD)) {
                                         switch_thread_t *thread;
                                         switch_threadattr_t *thd_attr;
                                         switch_core_new_memory_pool(&tp->pool);
                                         switch_threadattr_create(&thd_attr, tp->pool);
                                         switch_threadattr_detach_set(thd_attr, 1);
                                         tp->in_thread = 1;
                                         switch_thread_create(&thread, thd_attr, task_own_thread, tp, tp->pool);
                                 } else {
                                         tp->running = 1;
                                         switch_mutex_unlock(globals.task_mutex);
                                         switch_scheduler_execute(tp);
                                         switch_mutex_lock(globals.task_mutex);
                                         tp->running = 0;
                                 }
                         }
                 }
         }
         switch_mutex_unlock(globals.task_mutex);
         switch_mutex_lock(globals.task_mutex);
         for (tp = globals.task_list; tp;) {
                 if (tp->destroyed && !tp->in_thread) {
                         switch_event_t *event;
 
                         tofree = tp;
                         tp = tp->next;
                         switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Deleting task %u %s (%s)\n",
                                                           tofree->task.task_id, tofree->desc, switch_str_nil(tofree->task.group));
 
 
                         if (switch_event_create(&event, SWITCH_EVENT_DEL_SCHEDULE) == SWITCH_STATUS_SUCCESS) {
                                 switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Task-ID", "%u", tofree->task.task_id);
                                 switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Task-Desc", tofree->desc);
                                 switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Task-Group", switch_str_nil(tofree->task.group));
                                 switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Task-Runtime", "%" SWITCH_INT64_T_FMT, tofree->task.runtime);
                                 switch_queue_push(globals.event_queue, event);
                                 event = NULL;
                         }
 
                         if (last) {
                                 last->next = tofree->next;
                         } else {
                                 globals.task_list = tofree->next;
                         }
                         switch_safe_free(tofree->task.group);
                         if (tofree->task.cmd_arg && switch_test_flag(tofree, SSHF_FREE_ARG)) {
                                 free(tofree->task.cmd_arg);
                         }
                         switch_safe_free(tofree->desc);
                         free(tofree);
                 } else {
                         last = tp;
                         tp = tp->next;
                 }
         }
         switch_mutex_unlock(globals.task_mutex);
 
         return done;
 }