Scheduler

Collaboration diagram for Scheduler:

Data Structures
struct	switch_scheduler_task

Functions
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_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...

Detailed Description

Function Documentation

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.

Parameters

task_runtime	the time in epoch seconds to execute the task.
func	the callback function to execute when the task is executed.
desc	an arbitrary description of the task.
group	a group id tag to link multiple tasks to a single entity.
cmd_id	an arbitrary index number be used in the callback.
cmd_arg	user data to be passed to the callback.
flags	flags to alter behaviour

Returns

the id of the task

Definition at line 208 of file switch_scheduler.c.

References switch_scheduler_task::cmd_arg, switch_scheduler_task::cmd_id, switch_scheduler_task::created, switch_scheduler_task_container::desc, switch_scheduler_task_container::flags, switch_scheduler_task_container::func, globals, switch_scheduler_task::group, switch_scheduler_task::hash, switch_scheduler_task_container::next, switch_scheduler_task::repeat, switch_scheduler_task::runtime, switch_assert, SWITCH_CHANNEL_LOG, switch_ci_hashfunc_default(), switch_epoch_time_now(), switch_event_add_header(), switch_event_add_header_string(), SWITCH_EVENT_ADD_SCHEDULE, switch_event_create, SWITCH_INT64_T_FMT, SWITCH_LOG_DEBUG, switch_log_printf(), switch_mutex_lock(), switch_mutex_unlock(), switch_queue_push(), SWITCH_STACK_BOTTOM, SWITCH_STATUS_SUCCESS, switch_str_nil, switch_zmalloc, switch_scheduler_task_container::task, and switch_scheduler_task::task_id.

Referenced by switch_core_init(), switch_core_session_sched_heartbeat(), switch_ivr_schedule_broadcast(), switch_ivr_schedule_hangup(), switch_ivr_schedule_transfer(), switch_nat_late_init(), and switch_rtp_init().

{
        switch_scheduler_task_container_t *container, *tp;
        switch_event_t *event;
        switch_time_t now = switch_epoch_time_now(NULL);
        switch_ssize_t hlen = -1;

        switch_mutex_lock(globals.task_mutex);
        switch_zmalloc(container, sizeof(*container));
        switch_assert(func);

        if (task_runtime < now) {
                container->task.repeat = (uint32_t)task_runtime;
                task_runtime += now;
        }

        container->func = func;
        container->task.created = now;
        container->task.runtime = task_runtime;
        container->task.group = strdup(group ? group : "none");
        container->task.cmd_id = cmd_id;
        container->task.cmd_arg = cmd_arg;
        container->flags = flags;
        container->desc = strdup(desc ? desc : "none");
        container->task.hash = switch_ci_hashfunc_default(container->task.group, &hlen);

        for (tp = globals.task_list; tp && tp->next; tp = tp->next);

        if (tp) {
                tp->next = container;
        } else {
                globals.task_list = container;
        }

        for (container->task.task_id = 0; !container->task.task_id; container->task.task_id = ++globals.task_id);

        switch_mutex_unlock(globals.task_mutex);

        tp = container;
        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Added task %u %s (%s) to run at %" SWITCH_INT64_T_FMT "\n",
                                          tp->task.task_id, tp->desc, switch_str_nil(tp->task.group), tp->task.runtime);

        if (switch_event_create(&event, SWITCH_EVENT_ADD_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;
        }
        return container->task.task_id;
}

uint32_t switch_scheduler_del_task_group

(

const char *

group

)

Delete a scheduled task based on the group name.

Parameters

group

the group name

Returns

the number of jobs deleted

Definition at line 293 of file switch_scheduler.c.

References switch_scheduler_task_container::destroyed, globals, switch_scheduler_task::group, switch_scheduler_task::hash, hash, switch_scheduler_task_container::next, SSHF_NO_DEL, SWITCH_CHANNEL_LOG, switch_ci_hashfunc_default(), switch_log_printf(), SWITCH_LOG_WARNING, switch_mutex_lock(), switch_mutex_unlock(), switch_test_flag, switch_scheduler_task_container::task, switch_scheduler_task::task_id, and zstr.

Referenced by switch_core_session_perform_destroy().

{
        switch_scheduler_task_container_t *tp;
        uint32_t delcnt = 0;
        switch_ssize_t hlen = -1;
        unsigned long hash = 0;

        if (zstr(group)) {
                return 0;
        }
        
        hash = switch_ci_hashfunc_default(group, &hlen);

        switch_mutex_lock(globals.task_mutex);
        for (tp = globals.task_list; tp; tp = tp->next) {
                if (tp->destroyed) {
                        continue;
                }
                if (hash == tp->task.hash && !strcmp(tp->task.group, group)) {
                        if (switch_test_flag(tp, SSHF_NO_DEL)) {
                                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_WARNING, "Attempt made to delete undeletable task #%u (group %s)\n",
                                                                  tp->task.task_id, group);
                                continue;
                        }
                        tp->destroyed++;
                        delcnt++;
                }
        }
        switch_mutex_unlock(globals.task_mutex);

        return delcnt;
}

uint32_t switch_scheduler_del_task_id

(

uint32_t

task_id

)

Delete a scheduled task.

Parameters

task_id

the id of the task

Returns

the number of jobs deleted

Definition at line 263 of file switch_scheduler.c.

References switch_scheduler_task_container::destroyed, globals, switch_scheduler_task::group, switch_scheduler_task_container::next, switch_scheduler_task_container::running, SSHF_NO_DEL, SWITCH_CHANNEL_LOG, switch_log_printf(), SWITCH_LOG_WARNING, switch_mutex_lock(), switch_mutex_unlock(), switch_test_flag, switch_scheduler_task_container::task, and switch_scheduler_task::task_id.

Referenced by switch_core_session_unsched_heartbeat().

{
        switch_scheduler_task_container_t *tp;
        uint32_t delcnt = 0;

        switch_mutex_lock(globals.task_mutex);
        for (tp = globals.task_list; tp; tp = tp->next) {
                if (tp->task.task_id == task_id) {
                        if (switch_test_flag(tp, SSHF_NO_DEL)) {
                                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_WARNING, "Attempt made to delete undeletable task #%u (group %s)\n",
                                                                  tp->task.task_id, tp->task.group);
                                break;
                        }

                        if (tp->running) {
                                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_WARNING, "Attempt made to delete running task #%u (group %s)\n",
                                                                  tp->task.task_id, tp->task.group);
                                break;
                        }

                        tp->destroyed++;
                        delcnt++;
                        break;
                }
        }
        switch_mutex_unlock(globals.task_mutex);

        return delcnt;
}

void switch_scheduler_task_thread_start

(

void

)

Start the scheduler system.

Definition at line 328 of file switch_scheduler.c.

References globals, switch_core_new_memory_pool, switch_mutex_init(), SWITCH_MUTEX_NESTED, switch_queue_create(), switch_scheduler_task_thread(), switch_thread_create(), switch_threadattr_create(), and task_thread_p.

Referenced by switch_core_init().

{

        switch_threadattr_t *thd_attr;

        switch_core_new_memory_pool(&globals.memory_pool);
        switch_threadattr_create(&thd_attr, globals.memory_pool);
        switch_mutex_init(&globals.task_mutex, SWITCH_MUTEX_NESTED, globals.memory_pool);
        switch_queue_create(&globals.event_queue, 250000, globals.memory_pool);

        switch_thread_create(&task_thread_p, thd_attr, switch_scheduler_task_thread, NULL, globals.memory_pool);
}

void switch_scheduler_task_thread_stop

(

void

)

Stop the scheduler system.

Definition at line 341 of file switch_scheduler.c.

References globals, SWITCH_CHANNEL_LOG, switch_core_destroy_memory_pool, SWITCH_LOG_CONSOLE, switch_log_printf(), switch_thread_join(), switch_yield, and task_thread_p.

Referenced by switch_core_destroy().

{
        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "Stopping Task Thread\n");
        if (globals.task_thread_running == 1) {
                int sanity = 0;
                switch_status_t st;

                globals.task_thread_running = -1;

                switch_thread_join(&st, task_thread_p);

                while (globals.task_thread_running) {
                        switch_yield(100000);
                        if (++sanity > 10) {
                                break;
                        }
                }
        }
        
        switch_core_destroy_memory_pool(&globals.memory_pool);

}