END_TEST
START_TEST(test_loop_job_order)
{
int32_t res;
qb_loop_t *l = qb_loop_create();
fail_if(l == NULL);
job_1_run_count = 0;
res = qb_loop_job_add(l, QB_LOOP_MED, &job_order_1, job_order_check);
ck_assert_int_eq(res, 0);
res = qb_loop_job_add(l, QB_LOOP_MED, &job_order_2, job_order_check);
ck_assert_int_eq(res, 0);
res = qb_loop_job_add(l, QB_LOOP_MED, &job_order_3, job_order_check);
ck_assert_int_eq(res, 0);
res = qb_loop_job_add(l, QB_LOOP_MED, &job_order_4, job_order_check);
ck_assert_int_eq(res, 0);
res = qb_loop_job_add(l, QB_LOOP_MED, &job_order_5, job_order_check);
ck_assert_int_eq(res, 0);
res = qb_loop_job_add(l, QB_LOOP_MED, &job_order_6, job_order_check);
ck_assert_int_eq(res, 0);
res = qb_loop_job_add(l, QB_LOOP_MED, &job_order_7, job_order_check);
ck_assert_int_eq(res, 0);
res = qb_loop_job_add(l, QB_LOOP_MED, &job_order_8, job_order_check);
ck_assert_int_eq(res, 0);
res = qb_loop_job_add(l, QB_LOOP_MED, &job_order_9, job_order_check);
ck_assert_int_eq(res, 0);
qb_loop_run(l);
qb_loop_destroy(l);
}
static void job_order_check(void *data)
{
int32_t * order = (int32_t *)data;
job_1_run_count++;
ck_assert_int_eq(job_1_run_count, *order);
if (job_1_run_count == 1) {
qb_loop_job_add(NULL, QB_LOOP_MED, &job_order_10, job_order_check);
qb_loop_job_add(NULL, QB_LOOP_MED, &job_order_11, job_order_check);
qb_loop_job_add(NULL, QB_LOOP_MED, &job_order_12, job_order_check);
qb_loop_job_add(NULL, QB_LOOP_MED, &job_order_13, job_order_check);
} else if (job_1_run_count >= 13) {
qb_loop_stop(NULL);
}
}
static void service_exit_schedwrk_handler (void *data) {
int res;
static int current_priority = 0;
static int current_service_engine = 0;
static int called = 0;
struct seus_handler_data *cb_data = (struct seus_handler_data *)data;
struct corosync_api_v1 *api = (struct corosync_api_v1 *)cb_data->api;
if (called == 0) {
log_printf(LOGSYS_LEVEL_NOTICE,
"Unloading all Corosync service engines.");
current_priority = service_priority_max ();
called = 1;
}
res = corosync_service_unlink_and_exit_priority (
api,
0,
¤t_priority,
¤t_service_engine);
if (res == 0) {
service_unlink_all_complete();
return;
}
qb_loop_job_add(cs_poll_handle_get(),
QB_LOOP_HIGH,
data,
service_exit_schedwrk_handler);
}
void corosync_service_unlink_all (
struct corosync_api_v1 *api,
void (*unlink_all_complete) (void))
{
static int called = 0;
static struct seus_handler_data cb_data;
assert (api);
service_unlink_all_complete = unlink_all_complete;
if (called) {
return;
}
if (called == 0) {
called = 1;
}
cb_data.api = api;
qb_loop_job_add(cs_poll_handle_get(),
QB_LOOP_HIGH,
&cb_data,
service_exit_schedwrk_handler);
}
END_TEST
START_TEST(test_loop_job_1)
{
int32_t res;
qb_loop_t *l = qb_loop_create();
fail_if(l == NULL);
res = qb_loop_job_add(l, QB_LOOP_LOW, NULL, job_1);
ck_assert_int_eq(res, 0);
res = qb_loop_job_add(l, QB_LOOP_LOW, l, job_stop);
ck_assert_int_eq(res, 0);
qb_loop_run(l);
ck_assert_int_eq(job_1_run_count, 1);
qb_loop_destroy(l);
}
static void schedule_processing(void)
{
qb_enter();
qb_loop_job_add(NULL, QB_LOOP_LOW, NULL, process_job);
qb_leave();
}
static void job_1_r(void *data)
{
int32_t res;
qb_loop_t *l = (qb_loop_t *)data;
job_1_run_count++;
res = qb_loop_job_add(l, QB_LOOP_MED, data, job_2);
ck_assert_int_eq(res, 0);
}
static int32_t
sig_handler(int32_t rsignal, void *data)
{
qb_loop_t *l = (qb_loop_t *)data;
qb_log(LOG_DEBUG, "caught signal %d", rsignal);
received_signum = rsignal;
received_sigs++;
qb_loop_job_add(l, QB_LOOP_LOW, NULL, job_stop);
return 0;
}
static void
job_rm_sig_handler(void *data)
{
int res;
qb_loop_t *l = (qb_loop_t *)data;
res = qb_loop_signal_del(l, sig_hdl);
ck_assert_int_eq(res, 0);
res = qb_loop_job_add(l, QB_LOOP_LOW, NULL, job_stop);
ck_assert_int_eq(res, 0);
}
static void
process_next_job(void* data)
{
crm_graph_t *transition = (crm_graph_t *)data;
enum transition_status graph_rc;
qb_enter();
if (!graph_updated) {
qb_loop_job_add(NULL, QB_LOOP_MED, transition, process_next_job);
qb_leave();
return;
}
graph_updated = FALSE;
graph_rc = run_graph(transition);
qb_log(LOG_DEBUG, "run_graph returned: %s", transition_status(graph_rc));
if (graph_rc == transition_active || graph_rc == transition_pending) {
qb_loop_job_add(NULL, QB_LOOP_MED, transition, process_next_job);
qb_leave();
return;
}
if (graph_rc != transition_complete) {
qb_log(LOG_ERR, "Transition failed: %s",
transition_status(graph_rc));
}
destroy_graph(transition);
// we don't want to free the input xml
working_set->input = NULL;
cleanup_alloc_calculations(working_set);
free(working_set);
working_set = NULL;
completed_fn(run_user_data, graph_rc);
qb_leave();
return;
}
int32_t
pe_process_state(xmlDocPtr doc,
pe_resource_execute_t exec_fn,
pe_transition_completed_t done_fn,
void *user_data, int debug)
{
crm_graph_t *transition = NULL;
xmlNode *xml_input = xmlDocGetRootElement(doc);
qb_enter();
if (working_set) {
qb_log(LOG_ERR, "Transition already in progress");
qb_leave();
return -EEXIST;
}
transition_count++;
if (debug) {
char filename[PATH_MAX];
assert(validate_xml(xml_input, "pacemaker-1.2", FALSE) == TRUE);
snprintf(filename, PATH_MAX, "/tmp/pe-%d-%d.xml",
getpid(), transition_count);
xmlSaveFormatFileEnc(filename, doc, "UTF-8", 1);
qb_log(LOG_INFO, "Executing deployable transition [%s]",
filename);
} else {
qb_log(LOG_INFO, "Executing deployable transition [%d]",
transition_count);
}
working_set = calloc(1, sizeof(pe_working_set_t));
run_fn = exec_fn;
completed_fn = done_fn;
run_user_data = user_data;
set_graph_functions(&graph_exec_fns);
set_working_set_defaults(working_set);
/* calculate output */
do_calculations(working_set, xml_input, NULL);
transition = unpack_graph(working_set->graph, __func__);
//print_graph(LOG_INFO, transition);
graph_updated = TRUE;
qb_loop_job_add(NULL, QB_LOOP_HIGH, transition, process_next_job);
qb_leave();
return 0;
}
/*
* External API
*/
int32_t instance_create(struct assembly *assembly)
{
qb_enter();
qb_util_stopwatch_start(assembly->sw_instance_create);
image_id_get(assembly->name, image_id_get_completion, assembly);
instance_create_from_image_id(assembly->image_id, instance_create_completion, assembly);
qb_loop_job_add(NULL, QB_LOOP_LOW, assembly, my_instance_state_get);
qb_leave();
return 0;
}
static void job_add_self(void *data)
{
int32_t res;
uint64_t elapsed1;
qb_loop_t *l = (qb_loop_t *)data;
job_1_run_count++;
qb_util_stopwatch_stop(rl_sw);
elapsed1 = qb_util_stopwatch_us_elapsed_get(rl_sw);
if (elapsed1 > (RATE_LIMIT_RUNTIME_SEC * QB_TIME_US_IN_SEC)) {
/* run for 3 seconds */
qb_loop_stop(l);
return;
}
res = qb_loop_job_add(l, QB_LOOP_MED, data, job_add_self);
ck_assert_int_eq(res, 0);
}
unsigned int corosync_service_unlink_and_exit (
struct corosync_api_v1 *api,
const char *service_name,
unsigned int service_ver)
{
struct service_unlink_and_exit_data *service_unlink_and_exit_data;
assert (api);
service_unlink_and_exit_data = malloc (sizeof (struct service_unlink_and_exit_data));
service_unlink_and_exit_data->api = api;
service_unlink_and_exit_data->name = strdup (service_name);
service_unlink_and_exit_data->ver = service_ver;
qb_loop_job_add(cs_poll_handle_get(),
QB_LOOP_HIGH,
service_unlink_and_exit_data,
service_unlink_and_exit_schedwrk_handler);
return (0);
}
static void service_unlink_and_exit_schedwrk_handler (void *data)
{
struct service_unlink_and_exit_data *service_unlink_and_exit_data =
data;
int res;
res = service_unlink_and_exit (
service_unlink_and_exit_data->api,
service_unlink_and_exit_data->name,
service_unlink_and_exit_data->ver);
if (res == 0) {
free (service_unlink_and_exit_data);
} else {
qb_loop_job_add(cs_poll_handle_get(),
QB_LOOP_HIGH,
data,
service_unlink_and_exit_schedwrk_handler);
}
}
END_TEST
START_TEST(test_loop_sig_only_get_one)
{
int res;
qb_loop_signal_handle handle;
qb_loop_t *l = qb_loop_create();
fail_if(l == NULL);
/* make sure we only get one call to the handler
* don't assume we are going to exit the loop.
*/
received_sigs = 0;
qb_loop_signal_add(l, QB_LOOP_LOW, SIGINT,
l, sig_handler, &handle);
res = qb_loop_job_add(l, QB_LOOP_MED, NULL, job_1);
ck_assert_int_eq(res, 0);
res = qb_loop_job_add(l, QB_LOOP_HIGH, NULL, job_1);
ck_assert_int_eq(res, 0);
res = qb_loop_job_add(l, QB_LOOP_MED, NULL, job_1);
ck_assert_int_eq(res, 0);
res = qb_loop_job_add(l, QB_LOOP_HIGH, NULL, job_1);
ck_assert_int_eq(res, 0);
res = qb_loop_job_add(l, QB_LOOP_HIGH, NULL, job_1);
ck_assert_int_eq(res, 0);
res = qb_loop_job_add(l, QB_LOOP_MED, NULL, job_1);
ck_assert_int_eq(res, 0);
kill(getpid(), SIGINT);
qb_loop_run(l);
ck_assert_int_eq(received_signum, SIGINT);
ck_assert_int_eq(received_sigs, 1);
qb_loop_destroy(l);
}
static int32_t
my_job_add(enum qb_loop_priority p, void *data, qb_loop_job_dispatch_fn fn)
{
return qb_loop_job_add(bms_loop, p, data, fn);
}
static void job_1_add_nuts(void *data)
{
int32_t res;
qb_loop_t *l = (qb_loop_t *)data;
job_1_run_count++;
res = qb_loop_job_add(l, QB_LOOP_HIGH, data, job_1);
ck_assert_int_eq(res, 0);
res = qb_loop_job_add(l, QB_LOOP_HIGH, data, job_1);
ck_assert_int_eq(res, 0);
res = qb_loop_job_add(l, QB_LOOP_HIGH, data, job_1);
ck_assert_int_eq(res, 0);
res = qb_loop_job_add(l, QB_LOOP_HIGH, data, job_1);
ck_assert_int_eq(res, 0);
res = qb_loop_job_add(l, QB_LOOP_HIGH, data, job_1);
ck_assert_int_eq(res, 0);
res = qb_loop_job_add(l, QB_LOOP_HIGH, data, job_1);
ck_assert_int_eq(res, 0);
res = qb_loop_job_add(l, QB_LOOP_HIGH, data, job_1);
ck_assert_int_eq(res, 0);
res = qb_loop_job_add(l, QB_LOOP_HIGH, data, job_1);
ck_assert_int_eq(res, 0);
res = qb_loop_job_add(l, QB_LOOP_MED, data, job_1);
ck_assert_int_eq(res, 0);
res = qb_loop_job_add(l, QB_LOOP_MED, data, job_1);
ck_assert_int_eq(res, 0);
res = qb_loop_job_add(l, QB_LOOP_MED, data, job_1);
ck_assert_int_eq(res, 0);
res = qb_loop_job_add(l, QB_LOOP_MED, data, job_1);
ck_assert_int_eq(res, 0);
res = qb_loop_job_add(l, QB_LOOP_LOW, data, job_1);
ck_assert_int_eq(res, 0);
res = qb_loop_job_add(l, QB_LOOP_LOW, data, job_1);
ck_assert_int_eq(res, 0);
if (job_1_run_count < 500) {
res = qb_loop_job_add(l, QB_LOOP_LOW, data, job_1_add_nuts);
ck_assert_int_eq(res, 0);
} else {
res = qb_loop_job_add(l, QB_LOOP_LOW, data, job_stop);
ck_assert_int_eq(res, 0);
}
ck_assert_int_eq(res, 0);
}
