source: mainline/uspace/srv/sysman/configuration.c@ 2dda1d4

/*
 * 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 <adt/hash.h>
#include <adt/hash_table.h>
#include <adt/list.h>
#include <assert.h>
#include <errno.h>
#include <fibril_synch.h>

#include "configuration.h"
#include "dep.h"
#include "log.h"

static hash_table_t units;

/* Hash table functions */
static size_t units_ht_hash(const ht_link_t *item)
{
        unit_t *unit =
            hash_table_get_inst(item, unit_t, units);
        return hash_string(unit->name);
}

static size_t units_ht_key_hash(void *key)
{
        return hash_string((const char *)key);
}

static bool units_ht_equal(const ht_link_t *item1, const ht_link_t *item2)
{
        return str_cmp(
            hash_table_get_inst(item1, unit_t, units)->name,
            hash_table_get_inst(item2, unit_t, units)->name) == 0;
}

static bool units_ht_key_equal(void *key, const ht_link_t *item)
{
        return str_cmp((const char *)key,
            hash_table_get_inst(item, unit_t, units)->name) == 0;
}


static hash_table_ops_t units_ht_ops = {
        .hash            = &units_ht_hash,
        .key_hash        = &units_ht_key_hash,
        .equal           = &units_ht_equal,
        .key_equal       = &units_ht_key_equal,
        .remove_callback = NULL // TODO realy unneeded?
};

/* Configuration functions */

void configuration_init(void)
{
        hash_table_create(&units, 0, 0, &units_ht_ops);
}

int configuration_add_unit(unit_t *unit)
{
        assert(unit);
        assert(unit->state == STATE_EMBRYO);
        assert(unit->name != NULL);
        sysman_log(LVL_DEBUG2, "%s('%s')", __func__, unit_name(unit));

        if (hash_table_insert_unique(&units, &unit->units)) {
                return EOK;
        } else {
                return EEXISTS;
        }
}

void configuration_start_update(void) {
        sysman_log(LVL_DEBUG2, "%s", __func__);
}

static bool configuration_commit_unit(ht_link_t *ht_link, void *arg)
{
        unit_t *unit = hash_table_get_inst(ht_link, unit_t, units);
        // TODO state locking?
        if (unit->state == STATE_EMBRYO) {
                unit->state = STATE_STOPPED;
        }

        list_foreach(unit->dependencies, dependencies, unit_dependency_t, dep) {
                if (dep->state == DEP_EMBRYO) {
                        dep->state = DEP_VALID;
                }
        }
        return true;
}

/** Marks newly added units as usable (via state change) */
void configuration_commit(void)
{
        sysman_log(LVL_DEBUG2, "%s", __func__);

        /*
         * Apply commit to all units, each commited unit commits its outgoing
         * deps, thus eventually commiting all embryo deps as well.
         */
        hash_table_apply(&units, &configuration_commit_unit, NULL);
}

static bool configuration_rollback_unit(ht_link_t *ht_link, void *arg)
{
        unit_t *unit = hash_table_get_inst(ht_link, unit_t, units);

        list_foreach_safe(unit->dependencies, cur_link, next_link) {
                unit_dependency_t *dep =
                    list_get_instance(cur_link, unit_dependency_t, dependencies);
                if (dep->state == DEP_EMBRYO) {
                        dep_remove_dependency(&dep);
                }
        }

        if (unit->state == STATE_EMBRYO) {
                hash_table_remove_item(&units, ht_link);
                unit_destroy(&unit);
        }

        return true;
}

void configuration_rollback(void)
{
        sysman_log(LVL_DEBUG2, "%s", __func__);

        hash_table_apply(&units, &configuration_rollback_unit, NULL);
}

static bool configuration_resolve_unit(ht_link_t *ht_link, void *arg)
{
        bool *has_error_ptr = arg;
        unit_t *unit = hash_table_get_inst(ht_link, unit_t, units);

        list_foreach(unit->dependencies, dependencies, unit_dependency_t, dep) {
                assert(dep->dependant == unit);
                assert((dep->dependency != NULL) != (dep->dependency_name != NULL));
                if (dep->dependency) {
                        continue;
                }

                unit_t *dependency =
                    configuration_find_unit_by_name(dep->dependency_name);
                if (dependency == NULL) {
                        sysman_log(LVL_ERROR,
                            "Cannot resolve dependency of '%s' to unit '%s'",
                            unit_name(unit), dep->dependency_name);
                        *has_error_ptr = true;
                        // TODO should we just leave the sprout untouched?
                } else {
                        dep_resolve_dependency(dep, dependency);
                }
        }

        return true;
}

/** Resolve unresolved dependencies between any pair of units
 *
 * @return EOK      on success
 * @return ENONENT  when one or more resolution fails, information is logged
 */
int configuration_resolve_dependecies(void)
{
        sysman_log(LVL_DEBUG2, "%s", __func__);

        bool has_error = false;
        hash_table_apply(&units, &configuration_resolve_unit, &has_error);

        return has_error ? ENOENT : EOK;
}

unit_t *configuration_find_unit_by_name(const char *name)
{
        ht_link_t *ht_link = hash_table_find(&units, (void *)name);
        if (ht_link != NULL) {
                return hash_table_get_inst(ht_link, unit_t, units);
        } else {
                return NULL;
        }
}