static int load_module(void)
{
CHECK_PJSIP_SESSION_MODULE_LOADED();
if (ast_sip_register_service(&messaging_module) != PJ_SUCCESS) {
return AST_MODULE_LOAD_DECLINE;
}
if (pjsip_endpt_add_capability(ast_sip_get_pjsip_endpoint(),
NULL, PJSIP_H_ALLOW, NULL, 1,
&pjsip_message_method.name) != PJ_SUCCESS) {
ast_sip_unregister_service(&messaging_module);
return AST_MODULE_LOAD_DECLINE;
}
if (ast_msg_tech_register(&msg_tech)) {
ast_sip_unregister_service(&messaging_module);
return AST_MODULE_LOAD_DECLINE;
}
message_serializer = ast_sip_create_serializer("pjsip/messaging");
if (!message_serializer) {
ast_sip_unregister_service(&messaging_module);
ast_msg_tech_unregister(&msg_tech);
return AST_MODULE_LOAD_DECLINE;
}
ast_sip_session_register_supplement(&messaging_supplement);
return AST_MODULE_LOAD_SUCCESS;
}
static struct ast_taskprocessor *create_websocket_serializer(void)
{
char tps_name[AST_TASKPROCESSOR_MAX_NAME + 1];
/* Create name with seq number appended. */
ast_taskprocessor_build_name(tps_name, sizeof(tps_name), "pjsip/websocket");
return ast_sip_create_serializer(tps_name);
}
/*!
* \internal
* \brief Setup the serializers in the distributor pool.
* \since 13.10.0
*
* \retval 0 on success.
* \retval -1 on error.
*/
static int distributor_pool_setup(void)
{
char tps_name[AST_TASKPROCESSOR_MAX_NAME + 1];
int idx;
for (idx = 0; idx < ARRAY_LEN(distributor_pool); ++idx) {
/* Create name with seq number appended. */
ast_taskprocessor_build_name(tps_name, sizeof(tps_name), "pjsip/distributor");
distributor_pool[idx] = ast_sip_create_serializer(tps_name);
if (!distributor_pool[idx]) {
return -1;
}
}
return 0;
}
static struct serializer *serializer_create(const char *aor_name)
{
size_t size = strlen(aor_name) + 1;
struct serializer *ser = ao2_alloc(
sizeof(*ser) + size, serializer_destroy);
if (!ser) {
return NULL;
}
if (!(ser->serializer = ast_sip_create_serializer())) {
ao2_ref(ser, -1);
return NULL;
}
strcpy(ser->aor_name, aor_name);
return ser;
}
static int scheduler(struct ast_test *test, int serialized)
{
RAII_VAR(struct ast_taskprocessor *, tp1, NULL, ast_taskprocessor_unreference);
RAII_VAR(struct test_data *, test_data1, ao2_alloc(sizeof(*test_data1), data_cleanup), ao2_cleanup);
RAII_VAR(struct test_data *, test_data2, ao2_alloc(sizeof(*test_data2), data_cleanup), ao2_cleanup);
RAII_VAR(struct ast_sip_sched_task *, task1, NULL, ao2_cleanup);
RAII_VAR(struct ast_sip_sched_task *, task2, NULL, ao2_cleanup);
int duration;
int delay;
struct timeval task1_start;
ast_test_validate(test, test_data1 != NULL);
ast_test_validate(test, test_data2 != NULL);
test_data1->test = test;
test_data1->test_start = ast_tvnow();
test_data1->interval = 2000;
test_data1->sleep = 1000;
ast_mutex_init(&test_data1->lock);
ast_cond_init(&test_data1->cond, NULL);
test_data2->test = test;
test_data2->test_start = ast_tvnow();
test_data2->interval = 2000;
test_data2->sleep = 1000;
ast_mutex_init(&test_data2->lock);
ast_cond_init(&test_data2->cond, NULL);
if (serialized) {
ast_test_status_update(test, "This test will take about %3.1f seconds\n",
(test_data1->interval + test_data1->sleep + (MAX(test_data1->interval - test_data2->interval, 0)) + test_data2->sleep) / 1000.0);
tp1 = ast_sip_create_serializer("test-scheduler-serializer");
ast_test_validate(test, (tp1 != NULL));
} else {
ast_test_status_update(test, "This test will take about %3.1f seconds\n",
((MAX(test_data1->interval, test_data2->interval) + MAX(test_data1->sleep, test_data2->sleep)) / 1000.0));
}
task1 = ast_sip_schedule_task(tp1, test_data1->interval, task_1, NULL, test_data1, AST_SIP_SCHED_TASK_FIXED);
ast_test_validate(test, task1 != NULL);
task2 = ast_sip_schedule_task(tp1, test_data2->interval, task_1, NULL, test_data2, AST_SIP_SCHED_TASK_FIXED);
ast_test_validate(test, task2 != NULL);
waitfor(test_data1);
ast_sip_sched_task_cancel(task1);
ast_test_validate(test, test_data1->is_servant);
duration = ast_tvdiff_ms(test_data1->task_end, test_data1->test_start);
ast_test_validate(test, (duration > ((test_data1->interval + test_data1->sleep) * 0.9))
&& (duration < ((test_data1->interval + test_data1->sleep) * 1.1)));
ast_sip_sched_task_get_times(task1, NULL, &task1_start, NULL);
delay = ast_tvdiff_ms(task1_start, test_data1->test_start);
ast_test_validate(test, (delay > (test_data1->interval * 0.9)
&& (delay < (test_data1->interval * 1.1))));
waitfor(test_data2);
ast_sip_sched_task_cancel(task2);
ast_test_validate(test, test_data2->is_servant);
if (serialized) {
ast_test_validate(test, test_data1->tid == test_data2->tid);
ast_test_validate(test, ast_tvdiff_ms(test_data2->task_start, test_data1->task_end) >= 0);
} else {
ast_test_validate(test, test_data1->tid != test_data2->tid);
}
return AST_TEST_PASS;
}
