156 lines
3.0 KiB
C
156 lines
3.0 KiB
C
#include "runlevel.h"
|
|
|
|
#include "log.h"
|
|
#include "service.h"
|
|
|
|
#include <errno.h>
|
|
#include <fx/core/stringstream.h>
|
|
#include <fx/ds/array.h>
|
|
#include <fx/ds/dict.h>
|
|
#include <fx/serial.h>
|
|
#include <mango/log.h>
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
|
|
static struct queue runlevels = QUEUE_INIT;
|
|
|
|
struct queue *global_runlevels(void)
|
|
{
|
|
return &runlevels;
|
|
}
|
|
|
|
static int parse_runlevel_data(fx_object *in, struct runlevel *out)
|
|
{
|
|
if (!fx_object_is_type(in, FX_TYPE_DICT)) {
|
|
return -1;
|
|
}
|
|
|
|
fx_dict *in_runlevel = fx_dict_at(in, "runlevel");
|
|
if (!in_runlevel || !fx_object_is_type(in_runlevel, FX_TYPE_DICT)) {
|
|
return -1;
|
|
}
|
|
|
|
fx_string *name = fx_dict_at(in_runlevel, "name");
|
|
if (!name || !fx_object_is_type(name, FX_TYPE_STRING)) {
|
|
return -1;
|
|
}
|
|
|
|
fx_string *description = fx_dict_at(in_runlevel, "description");
|
|
if (!description || !fx_object_is_type(description, FX_TYPE_STRING)) {
|
|
return -1;
|
|
}
|
|
|
|
fx_array *deps = fx_dict_at(in_runlevel, "requires");
|
|
if (deps && !fx_object_is_type(deps, FX_TYPE_ARRAY)) {
|
|
return -1;
|
|
}
|
|
|
|
int ret = 0;
|
|
size_t dep_count = fx_array_size(deps);
|
|
fx_iterator *it = fx_iterator_begin(deps);
|
|
fx_foreach_ptr(fx_string, dep, it)
|
|
{
|
|
if (!fx_object_is_type(dep, FX_TYPE_STRING)) {
|
|
ret = -1;
|
|
break;
|
|
}
|
|
}
|
|
fx_iterator_unref(it);
|
|
|
|
if (ret != 0) {
|
|
return ret;
|
|
}
|
|
|
|
out->rl_requires_count = dep_count;
|
|
out->rl_requires = calloc(dep_count, sizeof(char *));
|
|
it = fx_iterator_begin(deps);
|
|
size_t i = 0;
|
|
fx_foreach_ptr(fx_string, dep, it)
|
|
{
|
|
out->rl_requires[i++] = fx_string_steal(dep);
|
|
}
|
|
fx_iterator_unref(it);
|
|
|
|
out->rl_name = fx_string_steal(name);
|
|
out->rl_description = fx_string_steal(description);
|
|
|
|
return 0;
|
|
}
|
|
|
|
int runlevel_load(const char *path, struct runlevel **out)
|
|
{
|
|
struct runlevel *rl = malloc(sizeof *rl);
|
|
if (!rl) {
|
|
errno = ENOMEM;
|
|
return -1;
|
|
}
|
|
|
|
FILE *fp = fopen(path, "r");
|
|
if (!fp) {
|
|
free(rl);
|
|
return -1;
|
|
}
|
|
|
|
fx_stream *in = fx_stream_open_fp(fp);
|
|
fx_serial_ctx *ctx = fx_toml_serial_ctx_create();
|
|
fx_object *data;
|
|
fx_result result = fx_serial_ctx_deserialise(ctx, in, &data, 0);
|
|
if (fx_result_is_error(result)) {
|
|
fx_throw(result);
|
|
free(rl);
|
|
errno = EFTYPE;
|
|
return -1;
|
|
}
|
|
|
|
if (parse_runlevel_data(data, rl) != 0) {
|
|
free(rl);
|
|
errno = EFTYPE;
|
|
return -1;
|
|
}
|
|
|
|
fx_stream_unref(in);
|
|
fx_object_unref(data);
|
|
|
|
fclose(fp);
|
|
|
|
*out = rl;
|
|
return 0;
|
|
}
|
|
|
|
struct runlevel *runlevel_find(const char *name)
|
|
{
|
|
struct queue_entry *cur = queue_first(&runlevels);
|
|
while (cur) {
|
|
struct runlevel *rl
|
|
= QUEUE_CONTAINER(struct runlevel, rl_entry, cur);
|
|
if (!strcmp(rl->rl_name, name)) {
|
|
return rl;
|
|
}
|
|
|
|
cur = queue_next(cur);
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
int runlevel_activate(struct runlevel *rl)
|
|
{
|
|
for (size_t i = 0; i < rl->rl_requires_count; i++) {
|
|
const char *svc_name = rl->rl_requires[i];
|
|
struct service *svc = service_find(svc_name);
|
|
if (!svc) {
|
|
log_fail("Cannot find service %s.", svc_name);
|
|
return -1;
|
|
}
|
|
|
|
int ret = service_start(svc);
|
|
if (ret != 0) {
|
|
return ret;
|
|
}
|
|
}
|
|
|
|
log_ok("Reached runlevel %s.", rl->rl_description);
|
|
return 0;
|
|
}
|