From e5b5ae50f02d7814f37b15329da2adce0fb30825 Mon Sep 17 00:00:00 2001 From: Lennart Poettering Date: Wed, 20 Jan 2010 02:12:51 +0100 Subject: [PATCH] implement transaction engine --- job.c | 105 ++++++++++- job.h | 52 ++++- main.c | 2 +- manager.c | 556 +++++++++++++++++++++++++++++++++++++++++++++--------- manager.h | 12 +- name.c | 50 +++-- name.h | 2 +- 7 files changed, 652 insertions(+), 127 deletions(-) diff --git a/job.c b/job.c index 2f7912d26..3e8cca1e8 100644 --- a/job.c +++ b/job.c @@ -20,7 +20,7 @@ Job* job_new(Manager *m, JobType type, Name *name) { j->type = type; j->name = name; - /* We don't link it here, that's what job_link() is for */ + /* We don't link it here, that's what job_dependency() is for */ return j; } @@ -37,13 +37,96 @@ void job_free(Job *j) { hashmap_remove(j->manager->jobs, UINT32_TO_PTR(j->id)); } - hashmap_remove(j->manager->jobs_to_add, j->name); - set_remove(j->manager->jobs_to_remove, j); + manager_transaction_delete_job(j->manager, j); - /* Free data and next 'smaller' objects */ free(j); } +JobDependency* job_dependency_new(Job *subject, Job *object, bool matters) { + JobDependency *l; + + assert(object); + + /* Adds a new job link, which encodes that the 'subject' job + * needs the 'object' job in some way. If 'subject' is NULL + * this means the 'anchor' job (i.e. the one the user + * explcitily asked for) is the requester. */ + + if (!(l = new(JobDependency, 1))) + return NULL; + + l->subject = subject; + l->object = object; + l->matters = matters; + + if (subject) { + l->subject_next = subject->subject_list; + subject->subject_list = l; + } else { + l->subject_next = object->manager->transaction_anchor; + object->manager->transaction_anchor = l; + } + + if (l->subject_next) + l->subject_next->subject_prev = l; + l->subject_prev = NULL; + + if ((l->object_next = object->object_list)) + l->object_next->object_prev = l; + l->object_prev = NULL; + object->object_list = l; + + return l; +} + +void job_dependency_free(JobDependency *l) { + assert(l); + + if (l->subject_prev) + l->subject_prev->subject_next = l->subject_next; + else if (l->subject) + l->subject->subject_list = l->subject_next; + else + l->object->manager->transaction_anchor = l->subject_next; + + if (l->subject_next) + l->subject_next->subject_prev = l->subject_prev; + + if (l->object_prev) + l->object_prev->object_next = l->object_next; + else + l->object->object_list = l->object_next; + + if (l->object_next) + l->object_next->object_prev = l->object_prev; + + free(l); +} + +void job_dependency_delete(Job *subject, Job *object, bool *matters) { + JobDependency *l; + + assert(object); + + for (l = object->object_list; l; l = l->object_next) { + assert(l->object == object); + + if (l->subject == subject) + break; + } + + if (!l) { + if (matters) + *matters = false; + return; + } + + if (matters) + *matters = l->matters; + + job_dependency_free(l); +} + void job_dump(Job *j, FILE*f) { static const char* const job_type_table[_JOB_TYPE_MAX] = { @@ -51,9 +134,9 @@ void job_dump(Job *j, FILE*f) { [JOB_STOP] = "stop", [JOB_VERIFY_STARTED] = "verify-started", [JOB_RELOAD] = "reload", + [JOB_RELOAD_OR_START] = "reload-or-start", [JOB_RESTART] = "restart", [JOB_TRY_RESTART] = "try-restart", - [JOB_RESTART_FINISH] = "restart-finish" }; static const char* const job_state_table[_JOB_STATE_MAX] = { @@ -71,3 +154,15 @@ void job_dump(Job *j, FILE*f) { job_type_table[j->type], job_state_table[j->state]); } + +bool job_is_anchor(Job *j) { + JobDependency *l; + + assert(j); + + for (l = j->object_list; l; l = l->object_next) + if (!l->subject) + return true; + + return false; +} diff --git a/job.h b/job.h index 0cb0a6e81..f337307f0 100644 --- a/job.h +++ b/job.h @@ -7,8 +7,10 @@ #include typedef struct Job Job; +typedef struct JobDependency JobDependency; typedef enum JobType JobType; typedef enum JobMode JobMode; +typedef enum JobState JobState; #include "manager.h" #include "name.h" @@ -19,19 +21,20 @@ enum JobType { JOB_START, JOB_STOP, JOB_VERIFY_STARTED, - JOB_RELOAD, - JOB_RESTART, - JOB_TRY_RESTART, /* restart if running */ - JOB_RESTART_FINISH, /* 2nd part of a restart, i.e. the actual starting */ - _JOB_TYPE_MAX + JOB_RELOAD, /* reload if running */ + JOB_RELOAD_OR_START, /* reload if running, start if not running */ + JOB_RESTART, /* stop if running, then start unconditionally */ + JOB_TRY_RESTART, /* stop and start if running */ + _JOB_TYPE_MAX, + _JOB_TYPE_INVALID = -1 }; -typedef enum JobState { +enum JobState { JOB_WAITING, JOB_RUNNING, JOB_DONE, _JOB_STATE_MAX -} JobState; +}; enum JobMode { JOB_FAIL, @@ -39,19 +42,52 @@ enum JobMode { _JOB_MODE_MAX }; +struct JobDependency { + /* Encodes that the 'subject' job needs the 'object' job in + * some way. This structure is used only while building a transaction. */ + Job *subject; + Job *object; + + bool matters; + + /* Linked list for the subjects, resp objects */ + JobDependency *subject_prev, *subject_next; + JobDependency *object_prev, *object_next; +}; + struct Job { Manager *manager; uint32_t id; + Name *name; + JobType type; JobState state; - Name *name; bool linked:1; + bool matters_to_anchor:1; + + /* These fields are used only while building a transaction */ + Job *transaction_next, *transaction_prev; + + JobDependency *subject_list; + JobDependency *object_list; + + /* used for graph algs as a "I have been here" marker */ + Job* marker; + unsigned generation; }; Job* job_new(Manager *m, JobType type, Name *name); void job_free(Job *job); void job_dump(Job *j, FILE*f); +JobDependency* job_dependency_new(Job *subject, Job *object, bool matters); +void job_dependency_free(JobDependency *l); +void job_dependency_delete(Job *subject, Job *object, bool *matters); + +bool job_is_anchor(Job *j); + +int job_merge(Job *j, Job *other); + #endif diff --git a/main.c b/main.c index a5c169454..de7572efa 100644 --- a/main.c +++ b/main.c @@ -24,7 +24,7 @@ int main(int argc, char *argv[]) { } - if ((r = manager_add_job(m, JOB_START, milestone, JOB_REPLACE, &job)) < 0) { + if ((r = manager_add_job(m, JOB_START, milestone, JOB_REPLACE, false, &job)) < 0) { fprintf(stderr, "Failed to start default milestone: %s\n", strerror(-r)); goto finish; } diff --git a/manager.c b/manager.c index d2708aacf..a870db6cc 100644 --- a/manager.c +++ b/manager.c @@ -22,10 +22,7 @@ Manager* manager_new(void) { if (!(m->jobs = hashmap_new(trivial_hash_func, trivial_compare_func))) goto fail; - if (!(m->jobs_to_add = hashmap_new(trivial_hash_func, trivial_compare_func))) - goto fail; - - if (!(m->jobs_to_remove = set_new(trivial_hash_func, trivial_compare_func))) + if (!(m->transaction_jobs = hashmap_new(trivial_hash_func, trivial_compare_func))) goto fail; return m; @@ -37,19 +34,19 @@ fail: void manager_free(Manager *m) { Name *n; + Job *j; assert(m); while ((n = hashmap_first(m->names))) name_free(n); + while ((j = hashmap_steal_first(m->transaction_jobs))) + job_free(j); + hashmap_free(m->names); hashmap_free(m->jobs); - - /* FIXME: This is incomplete */ - - hashmap_free(m->jobs_to_add); - set_free(m->jobs_to_remove); + hashmap_free(m->transaction_jobs); free(m); } @@ -58,140 +55,521 @@ static void transaction_abort(Manager *m) { Job *j; assert(m); - assert(m->n_dependency_depth == 0); - while ((j = hashmap_steal_first(m->jobs_to_add))) - job_free(j); + while ((j = hashmap_first(m->transaction_jobs))) + if (j->linked) + manager_transaction_delete_job(m, j); + else + job_free(j); + + assert(hashmap_isempty(m->transaction_jobs)); + assert(!m->transaction_anchor); +} + +static void transaction_find_jobs_that_matter_to_anchor(Manager *m, Job *j, unsigned generation) { + JobDependency *l; + + assert(m); + + for (l = j ? j->subject_list : m->transaction_anchor; l; l = l->subject_next) { + + /* This link does not matter */ + if (!l->matters) + continue; + + /* This name has already been marked */ + if (l->object->generation == generation) + continue; + + l->object->matters_to_anchor = true; + l->object->generation = generation; + + transaction_find_jobs_that_matter_to_anchor(m, l->object, generation); + } +} + +static bool types_match(JobType a, JobType b, JobType c, JobType d) { + return + (a == c && b == d) || + (a == d && b == c); +} + +static int types_merge(JobType *a, JobType b) { + if (*a == b) + return 0; - set_clear(m->jobs_to_remove); + if (types_match(*a, b, JOB_START, JOB_VERIFY_STARTED)) + *a = JOB_START; + else if (types_match(*a, b, JOB_START, JOB_RELOAD) || + types_match(*a, b, JOB_START, JOB_RELOAD_OR_START) || + types_match(*a, b, JOB_VERIFY_STARTED, JOB_RELOAD_OR_START) || + types_match(*a, b, JOB_RELOAD, JOB_RELOAD_OR_START)) + *a = JOB_RELOAD_OR_START; + else if (types_match(*a, b, JOB_START, JOB_RESTART) || + types_match(*a, b, JOB_START, JOB_TRY_RESTART) || + types_match(*a, b, JOB_VERIFY_STARTED, JOB_RESTART) || + types_match(*a, b, JOB_RELOAD, JOB_RESTART) || + types_match(*a, b, JOB_RELOAD_OR_START, JOB_RESTART) || + types_match(*a, b, JOB_RELOAD_OR_START, JOB_TRY_RESTART) || + types_match(*a, b, JOB_RESTART, JOB_TRY_RESTART)) + *a = JOB_RESTART; + else if (types_match(*a, b, JOB_VERIFY_STARTED, JOB_RELOAD)) + *a = JOB_RELOAD; + else if (types_match(*a, b, JOB_VERIFY_STARTED, JOB_TRY_RESTART) || + types_match(*a, b, JOB_RELOAD, JOB_TRY_RESTART)) + *a = JOB_TRY_RESTART; + + return -EEXIST; } -static int transaction_activate(Manager *m) { +static void manager_merge_and_delete_prospective_job(Manager *m, Job *j, Job *other, JobType t) { + JobDependency *l, *last; + + assert(j); + assert(other); + assert(j->name == other->name); + assert(!j->linked); + + j->type = t; + j->state = JOB_WAITING; + + j->matters_to_anchor = j->matters_to_anchor || other->matters_to_anchor; + + /* Patch us in as new owner of the JobDependency objects */ + last = NULL; + for (l = other->subject_list; l; l = l->subject_next) { + assert(l->subject == other); + l->subject = j; + last = l; + } + + /* Merge both lists */ + if (last) { + last->subject_next = j->subject_list; + if (j->subject_list) + j->subject_list->subject_prev = last; + j->subject_list = other->subject_list; + } + + /* Patch us in as new owner of the JobDependency objects */ + last = NULL; + for (l = other->object_list; l; l = l->object_next) { + assert(l->object == other); + l->object = j; + last = l; + } + + /* Merge both lists */ + if (last) { + last->object_next = j->object_list; + if (j->object_list) + j->object_list->object_prev = last; + j->object_list = other->object_list; + } + + + /* Kill the other job */ + other->subject_list = NULL; + other->object_list = NULL; + manager_transaction_delete_job(m, other); +} + +static int transaction_merge_jobs(Manager *m) { Job *j; + void *state; + int r; + + assert(m); + + HASHMAP_FOREACH(j, m->transaction_jobs, state) { + JobType t = j->type; + Job *k; + + for (k = j->transaction_next; k; k = k->transaction_next) + if ((r = types_merge(&t, k->type)) < 0) + return r; + + while ((k = j->transaction_next)) { + if (j->linked) { + manager_merge_and_delete_prospective_job(m, k, j, t); + j = k; + } else + manager_merge_and_delete_prospective_job(m, j, k, t); + } + + assert(!j->transaction_next); + assert(!j->transaction_prev); + } + + return r; +} + +static int transaction_verify_order_one(Manager *m, Job *j, Job *from, unsigned generation) { + void *state; + Name *n; int r; + + assert(m); + assert(j); + + /* Did we find a loop? */ + if (j->marker && j->generation == generation) { + Job *k; + + /* So, we already have been here. We have a + * loop. Let's try to break it. We go backwards in our + * path and try to find a suitable job to remove. */ + + for (k = from; k; k = (k->generation == generation ? k->marker : NULL)) { + if (!k->matters_to_anchor) { + manager_transaction_delete_job(m, k); + return -EAGAIN; + } + + /* Check if this in fact was the beginning of + * the loop */ + if (k == j) + break; + } + + return -ELOOP; + } + + j->marker = from; + j->generation = generation; + + /* We assume that the the dependencies are both-ways, and + * hence can ignore NAME_AFTER */ + + SET_FOREACH(n, j->name->meta.dependencies[NAME_BEFORE], state) { + Job *o; + + if (!(o = hashmap_get(m->transaction_jobs, n))) + if (!(o = n->meta.job)) + continue; + + if ((r = transaction_verify_order_one(m, o, j, generation)) < 0) + return r; + } + + return 0; +} + +static int transaction_verify_order(Manager *m, unsigned *generation) { + bool again; + assert(m); + assert(generation); + + do { + Job *j; + int r; + void *state; + + again = false; + + HASHMAP_FOREACH(j, m->transaction_jobs, state) { + + /* Assume merged */ + assert(!j->transaction_next); + assert(!j->transaction_prev); + + if ((r = transaction_verify_order_one(m, j, NULL, (*generation)++)) < 0) { + + /* There was a loop, but it was fixed, + * we need to restart our algorithm */ + if (r == -EAGAIN) { + again = true; + break; + } + + return r; + } + } + } while (again); + + return 0; +} + +static void transaction_collect_garbage(Manager *m) { + bool again; + + assert(m); + + do { + void *state; + Job *j; + + again = false; + + HASHMAP_FOREACH(j, m->transaction_jobs, state) { + if (j->object_list) + continue; + + manager_transaction_delete_job(m, j); + again = true; + break; + } + + } while (again); +} + +static int transaction_is_destructive(Manager *m, JobMode mode) { void *state; + Job *j; assert(m); - assert(m->n_dependency_depth == 0); - /* This applies the changes recorded in jobs_to_add and - * jobs_to_remove to the actual list of jobs */ + /* Checks whether applying this transaction means that + * existing jobs would be replaced */ - HASHMAP_FOREACH(j, m->jobs_to_add, state) { - assert(!j->linked); + HASHMAP_FOREACH(j, m->transaction_jobs, state) + if (j->name->meta.job && j->name->meta.job != j) + return -EEXIST; - if ((r = hashmap_put(j->manager->jobs, UINT32_TO_PTR(j->id), j)) < 0) + return 0; +} + +static int transaction_apply(Manager *m, JobMode mode) { + void *state; + Job *j; + int r; + + HASHMAP_FOREACH(j, m->transaction_jobs, state) { + if (j->linked) + continue; + + if ((r = hashmap_put(m->jobs, UINT32_TO_PTR(j->id), j)) < 0) goto rollback; } - /* all entries are now registered, now make sure the names - * know about that. */ + while ((j = hashmap_steal_first(m->transaction_jobs))) { + if (j->linked) + continue; + + if (j->name->meta.job) + job_free(j->name->meta.job); - while ((j = hashmap_steal_first(m->jobs_to_add))) { j->name->meta.job = j; j->linked = true; - } - while ((j = set_steal_first(m->jobs_to_remove))) - job_free(j); + /* We're fully installed. Now let's free data we don't + * need anymore. */ + + assert(!j->transaction_next); + assert(!j->transaction_prev); + + while (j->subject_list) + job_dependency_free(j->subject_list); + while (j->object_list) + job_dependency_free(j->object_list); + } return 0; rollback: - HASHMAP_FOREACH(j, m->jobs_to_add, state) - hashmap_remove(j->manager->jobs, UINT32_TO_PTR(j->id)); + HASHMAP_FOREACH(j, m->transaction_jobs, state) { + if (j->linked) + continue; + + hashmap_remove(m->jobs, UINT32_TO_PTR(j->id)); + } + + return r; +} + + +static int transaction_activate(Manager *m, JobMode mode) { + int r; + unsigned generation = 1; + + assert(m); + + /* This applies the changes recorded in transaction_jobs to + * the actual list of jobs, if possible. */ + + /* First step: figure out which jobs matter */ + transaction_find_jobs_that_matter_to_anchor(m, NULL, generation++); + + /* Second step: let's merge entries we can merge */ + if ((r = transaction_merge_jobs(m)) < 0) + goto rollback; + + /* Third step: verify order makes sense */ + if ((r = transaction_verify_order(m, &generation)) < 0) + goto rollback; + + /* Third step: do garbage colletion */ + transaction_collect_garbage(m); + + /* Fourth step: check whether we can actually apply this */ + if (mode == JOB_FAIL) + if ((r = transaction_is_destructive(m, mode)) < 0) + goto rollback; + + /* Fifth step: apply changes */ + if ((r = transaction_apply(m, mode)) < 0) + goto rollback; + + assert(hashmap_isempty(m->transaction_jobs)); + assert(!m->transaction_anchor); + + return 0; +rollback: transaction_abort(m); return r; } -int manager_add_job(Manager *m, JobType type, Name *name, JobMode mode, Job **_ret) { - Job *ret, *other; - void *state; - Name *dep; +static Job* transaction_add_job(Manager *m, JobType type, Name *name, bool *is_new) { + Job *j, *f; int r; assert(m); - assert(type < _JOB_TYPE_MAX); assert(name); - assert(mode < _JOB_MODE_MAX); - /* Check for conflicts, first against the jobs we shall - * create */ - if ((other = hashmap_get(m->jobs_to_add, name))) { + /* Looks for an axisting prospective job and returns that. If + * it doesn't exist it is created and added to the prospective + * jobs list. */ - if (other->type != type) - return -EEXIST; + f = hashmap_get(m->transaction_jobs, name); - } else if (name->meta.job) { + for (j = f; j; j = j->transaction_next) { + assert(j->name == name); - if (name->meta.job->type != type) { + if (j->type == type) { + if (is_new) + *is_new = false; + return j; + } + } - if (mode == JOB_FAIL) - return -EEXIST; + if (name->meta.job && name->meta.job->type == type) + j = name->meta.job; + else if (!(j = job_new(m, type, name))) + return NULL; - if ((r = set_put(m->jobs_to_remove, name->meta.job)) < 0) - return r; - } + if ((r = hashmap_replace(m->transaction_jobs, name, j)) < 0) { + job_free(j); + return NULL; } - if (!(ret = job_new(m, type, name))) - return -ENOMEM; + j->transaction_next = f; - m->n_dependency_depth ++; + if (f) + f->transaction_prev = j; - if ((r = hashmap_put(m->jobs_to_add, name, ret)) < 0) - goto fail; + j->generation = 0; + j->marker = NULL; + j->matters_to_anchor = false; - if (type == JOB_START || type == JOB_VERIFY_STARTED || type == JOB_RESTART_FINISH) { - SET_FOREACH(dep, ret->name->meta.dependencies[NAME_REQUIRES], state) - if ((r = manager_add_job(m, type, dep, mode, NULL)) < 0) - goto fail; - SET_FOREACH(dep, ret->name->meta.dependencies[NAME_SOFT_REQUIRES], state) - if ((r = manager_add_job(m, type, dep, JOB_FAIL, NULL)) < 0) - goto fail; - SET_FOREACH(dep, ret->name->meta.dependencies[NAME_WANTS], state) - if ((r = manager_add_job(m, type, dep, JOB_FAIL, NULL)) < 0) - goto fail; - SET_FOREACH(dep, ret->name->meta.dependencies[NAME_REQUISITE], state) - if ((r = manager_add_job(m, JOB_VERIFY_STARTED, dep, mode, NULL)) < 0) - goto fail; - SET_FOREACH(dep, ret->name->meta.dependencies[NAME_SOFT_REQUISITE], state) - if ((r = manager_add_job(m, JOB_VERIFY_STARTED, dep, JOB_FAIL, NULL)) < 0) - goto fail; - SET_FOREACH(dep, ret->name->meta.dependencies[NAME_CONFLICTS], state) - if ((r = manager_add_job(m, type, dep, mode, NULL)) < 0) - goto fail; - - } else if (type == JOB_STOP || type == JOB_RESTART || type == JOB_TRY_RESTART) { - - SET_FOREACH(dep, ret->name->meta.dependencies[NAME_REQUIRED_BY], state) - if ((r = manager_add_job(m, type, dep, mode, NULL)) < 0) - goto fail; - } + if (is_new) + *is_new = true; - if (--m->n_dependency_depth <= 0) - if ((r = transaction_activate(m)) < 0) { - transaction_abort(m); - return r; - } + return j; +} +void manager_transaction_delete_job(Manager *m, Job *j) { + assert(m); + assert(j); - if (_ret) - *_ret = ret; + if (j->transaction_prev) + j->transaction_prev->transaction_next = j->transaction_next; + else if (j->transaction_next) + hashmap_replace(m->transaction_jobs, j->name, j->transaction_next); + else + hashmap_remove_value(m->transaction_jobs, j->name, j); + + if (j->transaction_next) + j->transaction_next->transaction_prev = j->transaction_prev; + + j->transaction_prev = j->transaction_next = NULL; + + while (j->subject_list) + job_dependency_free(j->subject_list); + while (j->object_list) + job_dependency_free(j->object_list); +} + +static int real_add_job(Manager *m, JobType type, Name *name, Job *by, bool matters, bool force, Job **_ret) { + Job *ret; + void *state; + Name *dep; + int r; + bool is_new; + + assert(m); + assert(type < _JOB_TYPE_MAX); + assert(name); + + /* First add the job. */ + if (!(ret = transaction_add_job(m, type, name, &is_new))) + return -ENOMEM; + + /* Then, add a link to the job. */ + if (!job_dependency_new(by, ret, matters)) + return -ENOMEM; + + if (is_new) { + /* Finally, recursively add in all dependencies. */ + if (type == JOB_START || type == JOB_RELOAD_OR_START) { + SET_FOREACH(dep, ret->name->meta.dependencies[NAME_REQUIRES], state) + if ((r = real_add_job(m, JOB_START, dep, ret, true, force, NULL)) < 0) + goto fail; + SET_FOREACH(dep, ret->name->meta.dependencies[NAME_SOFT_REQUIRES], state) + if ((r = real_add_job(m, JOB_START, dep, ret, !force, force, NULL)) < 0) + goto fail; + SET_FOREACH(dep, ret->name->meta.dependencies[NAME_WANTS], state) + if ((r = real_add_job(m, JOB_START, dep, ret, false, force, NULL)) < 0) + goto fail; + SET_FOREACH(dep, ret->name->meta.dependencies[NAME_REQUISITE], state) + if ((r = real_add_job(m, JOB_VERIFY_STARTED, dep, ret, true, force, NULL)) < 0) + goto fail; + SET_FOREACH(dep, ret->name->meta.dependencies[NAME_SOFT_REQUISITE], state) + if ((r = real_add_job(m, JOB_VERIFY_STARTED, dep, ret, !force, force, NULL)) < 0) + goto fail; + SET_FOREACH(dep, ret->name->meta.dependencies[NAME_CONFLICTS], state) + if ((r = real_add_job(m, JOB_STOP, dep, ret, true, force, NULL)) < 0) + goto fail; + + } else if (type == JOB_STOP || type == JOB_RESTART || type == JOB_TRY_RESTART) { + + SET_FOREACH(dep, ret->name->meta.dependencies[NAME_REQUIRED_BY], state) + if ((r = real_add_job(m, type, dep, ret, true, force, NULL)) < 0) + goto fail; + } + + /* JOB_VERIFY_STARTED, JOB_RELOAD require no dependency handling */ + } return 0; fail: - job_free(ret); + return r; +} + +int manager_add_job(Manager *m, JobType type, Name *name, JobMode mode, bool force, Job **_ret) { + int r; + Job *ret; + + assert(m); + assert(type < _JOB_TYPE_MAX); + assert(name); + assert(mode < _JOB_MODE_MAX); - if (--m->n_dependency_depth <= 0) + if ((r = real_add_job(m, type, name, NULL, true, force, &ret))) { transaction_abort(m); + return r; + } - return r; -} + if ((r = transaction_activate(m, mode)) < 0) + return r; + + if (_ret) + *_ret = ret; + return 0; +} Job *manager_get_job(Manager *m, uint32_t id) { assert(m); @@ -314,7 +692,7 @@ finish: if ((r = name_load_dropin(name)) < 0) return r; - if ((r = name_link_names(name)) < 0) + if ((r = name_link_names(name, true)) < 0) return r; name->meta.state = NAME_LOADED; diff --git a/manager.h b/manager.h index 3ee3b0ac5..ad62b74a7 100644 --- a/manager.h +++ b/manager.h @@ -29,13 +29,11 @@ struct Manager { /* Names that need to be loaded */ LIST_HEAD(Meta, load_queue); /* this is actually more a stack than a queue, but uh. */ - /* Jobs to be added resp. removed. */ - Hashmap *jobs_to_add; /* Name object => Job object 1:1 */ - Set *jobs_to_remove; + /* Jobs to be added */ + Hashmap *transaction_jobs; /* Name object => Job object list 1:1 */ + JobDependency *transaction_anchor; bool dispatching_load_queue:1; - - unsigned n_dependency_depth; }; Manager* manager_new(void); @@ -45,9 +43,11 @@ Job *manager_get_job(Manager *m, uint32_t id); Name *manager_get_name(Manager *m, const char *name); int manager_load_name(Manager *m, const char *name, Name **_ret); -int manager_add_job(Manager *m, JobType job, Name *name, JobMode mode, Job **_ret); +int manager_add_job(Manager *m, JobType type, Name *name, JobMode mode, bool force, Job **_ret); void manager_dump_names(Manager *s, FILE *f); void manager_dump_jobs(Manager *s, FILE *f); +void manager_transaction_delete_job(Manager *m, Job *j); + #endif diff --git a/name.c b/name.c index 0ef7a77ff..f4ad17687 100644 --- a/name.c +++ b/name.c @@ -80,7 +80,8 @@ Name *name_new(Manager *m) { return n; } -int name_link_names(Name *n) { +/* FIXME: Does not rollback on failure! */ +int name_link_names(Name *n, bool replace) { char *t; void *state; int r; @@ -90,15 +91,15 @@ int name_link_names(Name *n) { if (!n->meta.linked) return 0; - /* Link all names that aren't linked yet */ + /* Link all names that aren't linked yet. */ SET_FOREACH(t, n->meta.names, state) - if ((r = hashmap_put(n->meta.manager->names, t, n)) < 0) { - - if (r == -EEXIST && hashmap_get(n->meta.manager->names, t) == n) - continue; - - return r; + if (replace) { + if ((r = hashmap_replace(n->meta.manager->names, t, n)) < 0) + return r; + } else { + if ((r = hashmap_put(n->meta.manager->names, t, n)) < 0) + return r; } return 0; @@ -113,13 +114,13 @@ int name_link(Name *n) { n->meta.linked = true; - if ((r = name_link_names(n) < 0)) { + if ((r = name_link_names(n, false) < 0)) { char *t; void *state; /* Rollback the registered names */ SET_FOREACH(t, n->meta.names, state) - hashmap_remove(n->meta.manager->names, t); + hashmap_remove_value(n->meta.manager->names, t, n); n->meta.linked = false; return r; @@ -162,7 +163,7 @@ void name_free(Name *name) { void *state; SET_FOREACH(t, name->meta.names, state) - assert_se(hashmap_remove(name->meta.manager->names, t) == name); + hashmap_remove_value(name->meta.manager->names, t, name); if (name->meta.state == NAME_STUB) LIST_REMOVE(Meta, name->meta.manager->load_queue, &name->meta); @@ -303,6 +304,7 @@ static int ensure_in_set(Set **s, void *data) { return 0; } +/* FIXME: Does not rollback on failure! */ int name_augment(Name *n) { int r; void* state; @@ -310,7 +312,8 @@ int name_augment(Name *n) { assert(n); - /* Adds in the missing links to make all dependencies bidirectional */ + /* Adds in the missing links to make all dependencies + * bidirectional. */ SET_FOREACH(other, n->meta.dependencies[NAME_BEFORE], state) if ((r = ensure_in_set(&other->meta.dependencies[NAME_AFTER], n) < 0)) @@ -357,15 +360,18 @@ static int ensure_merge(Set **s, Set *other) { return 0; } +/* FIXME: Does not rollback on failure! */ int name_merge(Name *name, Name *other) { int r; NameDependency d; assert(name); assert(other); - assert(name->meta.manager == other->meta.manager); + /* This merges 'other' into 'name'. FIXME: This does not + * rollback on failure. */ + if (name->meta.type != other->meta.type) return -EINVAL; @@ -381,10 +387,15 @@ int name_merge(Name *name, Name *other) { if ((r = ensure_merge(&name->meta.dependencies[d], other->meta.dependencies[d])) < 0) return r; - if (name->meta.linked) - if ((r = name_link_names(name)) < 0) + /* Hookup new deps and names */ + if (name->meta.linked) { + if ((r = name_augment(name)) < 0) return r; + if ((r = name_link_names(name, true)) < 0) + return r; + } + return 0; } @@ -424,7 +435,7 @@ void name_dump(Name *n, FILE *f) { fprintf(f, "Name %s\n" "\tDescription: %s\n" - "\tState: %s\n", + "\tName State: %s\n", name_id(n), n->meta.description ? n->meta.description : name_id(n), state_table[n->meta.state]); @@ -445,7 +456,12 @@ void name_dump(Name *n, FILE *f) { else t = s; - fprintf(f, "\t%s in state %s\n", t, socket_state_table[n->socket.state]); + fprintf(f, + "\tAddress: %s\n" + "\tSocket State: %s\n", + t, + socket_state_table[n->socket.state]); + free(s); break; } diff --git a/name.h b/name.h index 67ca6f10e..c67e839d4 100644 --- a/name.h +++ b/name.h @@ -279,7 +279,7 @@ bool name_is_valid(const char *n); Name *name_new(Manager *m); void name_free(Name *name); int name_link(Name *name); -int name_link_names(Name *name); +int name_link_names(Name *name, bool replace); int name_merge(Name *name, Name *other); int name_augment(Name *n); const char* name_id(Name *n); -- 2.30.2