source: mainline/uspace/srv/sysman/test/job_queue.c@ 25697163

/*
 * Copyright (c) 2015 Michal Koutny
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * - Redistributions of source code must retain the above copyright
 *   notice, this list of conditions and the following disclaimer.
 * - Redistributions in binary form must reproduce the above copyright
 *   notice, this list of conditions and the following disclaimer in the
 *   documentation and/or other materials provided with the distribution.
 * - The name of the author may not be used to endorse or promote products
 *   derived from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

#include <assert.h>
#include <fibril.h>
#include <pcut/pcut.h>
#include <stdbool.h>

#include "mock_unit.h"
#include "../job_queue.h"
#include "../sysman.h"

PCUT_INIT

PCUT_TEST_SUITE(job_queue);

static bool initialized = false;

static fid_t fibril_event_loop;

static void job_finished_cb(void *object, void *arg)
{
        job_t *job = object;
        job_t **job_ptr = arg;

        /* Pass job reference to the caller */
        *job_ptr = job;
}

PCUT_TEST_BEFORE
{
        mock_create_units();
        mock_set_units_state(STATE_STOPPED);

        if (!initialized) {
                sysman_events_init();
                job_queue_init();

#if 0
                fibril_condvar_initialize(&async_finished_cv);
                fibril_mutex_initialize(&async_finished_mtx);
#endif

                fibril_event_loop = fibril_create(sysman_events_loop, NULL);
                fibril_add_ready(fibril_event_loop);

                initialized = true;
        }
}

PCUT_TEST_AFTER
{
        mock_destroy_units();
}

PCUT_TEST(single_start_sync)
{
        unit_type_vmts[UNIT_TARGET]->start = &mock_unit_vmt_start_sync;

        unit_t *u = mock_units[UNIT_TARGET][0];
        job_t *job = NULL;

        errno_t rc = sysman_run_job(u, STATE_STARTED, 0, &job_finished_cb,
            &job);
        PCUT_ASSERT_INT_EQUALS(EOK, rc);

        sysman_process_queue();
        PCUT_ASSERT_NOT_NULL(job);
        PCUT_ASSERT_EQUALS(STATE_STARTED, u->state);

        job_del_ref(&job);
}

PCUT_TEST(single_start_async)
{
        unit_type_vmts[UNIT_TARGET]->start = &mock_unit_vmt_start_async;
        unit_type_vmts[UNIT_TARGET]->exposee_created =
            &mock_unit_vmt_exposee_created;

        unit_t *u = mock_units[UNIT_TARGET][0];
        job_t *job = NULL;

        errno_t rc = sysman_run_job(u, STATE_STARTED, 0, &job_finished_cb, &job);
        PCUT_ASSERT_INT_EQUALS(EOK, rc);

        sysman_process_queue();
        PCUT_ASSERT_EQUALS(STATE_STARTING, u->state);

        sysman_raise_event(&sysman_event_unit_exposee_created, u);
        sysman_process_queue();

        PCUT_ASSERT_NOT_NULL(job);
        PCUT_ASSERT_EQUALS(STATE_STARTED, u->state);

        job_del_ref(&job);
}

PCUT_TEST(multipath_to_started_unit)
{
        /* Setup mock behavior */
        unit_type_vmts[UNIT_SERVICE]->start = &mock_unit_vmt_start_sync;

        unit_type_vmts[UNIT_MOUNT]->start = &mock_unit_vmt_start_async;
        unit_type_vmts[UNIT_MOUNT]->exposee_created =
            &mock_unit_vmt_exposee_created;

        /* Define mock units */
        unit_t *s0 = mock_units[UNIT_SERVICE][0];
        unit_t *s1 = mock_units[UNIT_SERVICE][1];
        unit_t *m0 = mock_units[UNIT_MOUNT][0];

        /* All services require root fs */
        mock_add_edge(s0, m0);
        mock_add_edge(s1, m0);

        /* S1 requires another mount and S0 */
        mock_add_edge(s1, s0);

        /* Enforce initial state */
        m0->state = STATE_STARTED;

        /* Run test */
        job_t *job = NULL;
        errno_t rc = sysman_run_job(s1, STATE_STARTED, 0, &job_finished_cb, &job);
        PCUT_ASSERT_INT_EQUALS(EOK, rc);

        sysman_process_queue();

        PCUT_ASSERT_NOT_NULL(job);
        PCUT_ASSERT_EQUALS(STATE_STARTED, s0->state);
        PCUT_ASSERT_EQUALS(STATE_STARTED, s1->state);
}

PCUT_TEST(merge_jobs_with_callback)
{
        /* Setup mock behavior */
        unit_type_vmts[UNIT_SERVICE]->start = &mock_unit_vmt_start_async;
        unit_type_vmts[UNIT_SERVICE]->exposee_created =
            &mock_unit_vmt_exposee_created;

        /* Define mock units */
        unit_t *s0 = mock_units[UNIT_SERVICE][0];

        /* Create and start first job */
        job_t *j0 = NULL;
        errno_t rc = sysman_run_job(s0, STATE_STARTED, 0, &job_finished_cb, &j0);
        PCUT_ASSERT_INT_EQUALS(EOK, rc);

        sysman_process_queue();
        /* Job not finished */
        PCUT_ASSERT_NULL(j0);

        /*
         * While s0 is starting in j0, create second job that should be merged
         * into the existing one.
         */
        job_t *j1 = NULL;
        rc = sysman_run_job(s0, STATE_STARTED, 0, &job_finished_cb, &j1);
        PCUT_ASSERT_INT_EQUALS(EOK, rc);

        sysman_process_queue();
        /* Job not finished */
        PCUT_ASSERT_NULL(j1);

        sysman_raise_event(&sysman_event_unit_exposee_created, s0);
        sysman_process_queue();

        PCUT_ASSERT_NOT_NULL(j0);
        PCUT_ASSERT_NOT_NULL(j1);

        /*
         * Jobs were, merged so both callbacks should have been called with the
         * same job
         */
        PCUT_ASSERT_EQUALS(j0, j1);

        /* And there should be exactly two references (per each callback) */
        job_del_ref(&j0);
        job_del_ref(&j0);

        PCUT_ASSERT_NULL(j0);
}

PCUT_EXPORT(job_queue);