unit: remove union Unit

[elogind.git] / src / job.c

diff --git a/src/job.c b/src/job.c
index 5d4a092345e9aee79d923a3dc44f0c3a64128d6a..e57286fe89171a01a080c3e277d37bfd2608a817 100644 (file)
--- a/src/job.c
+++ b/src/job.c
@@ -1,4 +1,4 @@
-/*-*- Mode: C; c-basic-offset: 8 -*-*/
+/*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/

 
 /***
   This file is part of systemd.
 
 /***
   This file is part of systemd.


@@ -60,10 +60,10 @@ void job_free(Job *j) {
 
         /* Detach from next 'bigger' objects */
         if (j->installed) {
 
         /* Detach from next 'bigger' objects */
         if (j->installed) {

-                bus_job_send_removed_signal(j, !j->failed);
+                bus_job_send_removed_signal(j);

 
 

-                if (j->unit->meta.job == j) {
-                        j->unit->meta.job = NULL;
+                if (j->unit->job == j) {
+                        j->unit->job = NULL;

                         unit_add_to_gc_queue(j->unit);
                 }
 
                         unit_add_to_gc_queue(j->unit);
                 }
 


@@ -101,7 +101,7 @@ JobDependency* job_dependency_new(Job *subject, Job *object, bool matters, bool
         /* 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
         /* 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. */
+         * explicitly asked for) is the requester. */

 
         if (!(l = new0(JobDependency, 1)))
                 return NULL;
 
         if (!(l = new0(JobDependency, 1)))
                 return NULL;


@@ -147,7 +147,7 @@ void job_dump(Job *j, FILE*f, const char *prefix) {
                 "%s\tState: %s\n"
                 "%s\tForced: %s\n",
                 prefix, j->id,
                 "%s\tState: %s\n"
                 "%s\tForced: %s\n",
                 prefix, j->id,

-                prefix, j->unit->meta.id, job_type_to_string(j->type),
+                prefix, j->unit->id, job_type_to_string(j->type),

                 prefix, job_state_to_string(j->state),
                 prefix, yes_no(j->override));
 }
                 prefix, job_state_to_string(j->state),
                 prefix, yes_no(j->override));
 }


@@ -271,7 +271,7 @@ bool job_type_is_redundant(JobType a, UnitActiveState b) {
         case JOB_STOP:
                 return
                         b == UNIT_INACTIVE ||
         case JOB_STOP:
                 return
                         b == UNIT_INACTIVE ||

-                        b == UNIT_MAINTENANCE;
+                        b == UNIT_FAILED;

 
         case JOB_VERIFY_ACTIVE:
                 return
 
         case JOB_VERIFY_ACTIVE:
                 return


@@ -309,8 +309,12 @@ bool job_is_runnable(Job *j) {
 
         /* Checks whether there is any job running for the units this
          * job needs to be running after (in the case of a 'positive'
 
         /* Checks whether there is any job running for the units this
          * job needs to be running after (in the case of a 'positive'

-         * job type) or before (in the case of a 'negative' job type
-         * . */
+         * job type) or before (in the case of a 'negative' job
+         * type. */
+
+        /* First check if there is an override */
+        if (j->ignore_order)
+                return true;

 
         if (j->type == JOB_START ||
             j->type == JOB_VERIFY_ACTIVE ||
 
         if (j->type == JOB_START ||
             j->type == JOB_VERIFY_ACTIVE ||


@@ -322,19 +326,19 @@ bool job_is_runnable(Job *j) {
                  * dependencies, regardless whether they are
                  * starting or stopping something. */
 
                  * dependencies, regardless whether they are
                  * starting or stopping something. */
 

-                SET_FOREACH(other, j->unit->meta.dependencies[UNIT_AFTER], i)
-                        if (other->meta.job)
+                SET_FOREACH(other, j->unit->dependencies[UNIT_AFTER], i)
+                        if (other->job)

                                 return false;
         }
 
         /* Also, if something else is being stopped and we should
          * change state after it, then lets wait. */
 
                                 return false;
         }
 
         /* Also, if something else is being stopped and we should
          * change state after it, then lets wait. */
 

-        SET_FOREACH(other, j->unit->meta.dependencies[UNIT_BEFORE], i)
-                if (other->meta.job &&
-                    (other->meta.job->type == JOB_STOP ||
-                     other->meta.job->type == JOB_RESTART ||
-                     other->meta.job->type == JOB_TRY_RESTART))
+        SET_FOREACH(other, j->unit->dependencies[UNIT_BEFORE], i)
+                if (other->job &&
+                    (other->job->type == JOB_STOP ||
+                     other->job->type == JOB_RESTART ||
+                     other->job->type == JOB_TRY_RESTART))

                         return false;
 
         /* This means that for a service a and a service b where b
                         return false;
 
         /* This means that for a service a and a service b where b


@@ -385,8 +389,12 @@ int job_run_and_invalidate(Job *j) {
 
                 case JOB_START:
                         r = unit_start(j->unit);
 
                 case JOB_START:
                         r = unit_start(j->unit);

+
+                        /* If this unit cannot be started, then simply
+                         * wait */

                         if (r == -EBADR)
                                 r = 0;
                         if (r == -EBADR)
                                 r = 0;

+

                         break;
 
                 case JOB_VERIFY_ACTIVE: {
                         break;
 
                 case JOB_VERIFY_ACTIVE: {


@@ -402,6 +410,11 @@ int job_run_and_invalidate(Job *j) {
 
                 case JOB_STOP:
                         r = unit_stop(j->unit);
 
                 case JOB_STOP:
                         r = unit_stop(j->unit);

+
+                        /* If this unit cannot stopped, then simply
+                         * wait. */
+                        if (r == -EBADR)
+                                r = 0;

                         break;
 
                 case JOB_RELOAD:
                         break;
 
                 case JOB_RELOAD:


@@ -409,15 +422,21 @@ int job_run_and_invalidate(Job *j) {
                         break;
 
                 case JOB_RELOAD_OR_START:
                         break;
 
                 case JOB_RELOAD_OR_START:

-                        if (unit_active_state(j->unit) == UNIT_ACTIVE)
+                        if (unit_active_state(j->unit) == UNIT_ACTIVE) {
+                                j->type = JOB_RELOAD;

                                 r = unit_reload(j->unit);
                                 r = unit_reload(j->unit);

-                        else
+                        } else {
+                                j->type = JOB_START;

                                 r = unit_start(j->unit);
                                 r = unit_start(j->unit);

+
+                                if (r == -EBADR)
+                                        r = 0;
+                        }

                         break;
 
                 case JOB_RESTART: {
                         UnitActiveState t = unit_active_state(j->unit);
                         break;
 
                 case JOB_RESTART: {
                         UnitActiveState t = unit_active_state(j->unit);

-                        if (t == UNIT_INACTIVE || t == UNIT_MAINTENANCE || t == UNIT_ACTIVATING) {
+                        if (t == UNIT_INACTIVE || t == UNIT_FAILED || t == UNIT_ACTIVATING) {

                                 j->type = JOB_START;
                                 r = unit_start(j->unit);
                         } else
                                 j->type = JOB_START;
                                 r = unit_start(j->unit);
                         } else


@@ -427,13 +446,15 @@ int job_run_and_invalidate(Job *j) {
 
                 case JOB_TRY_RESTART: {
                         UnitActiveState t = unit_active_state(j->unit);
 
                 case JOB_TRY_RESTART: {
                         UnitActiveState t = unit_active_state(j->unit);

-                        if (t == UNIT_INACTIVE || t == UNIT_MAINTENANCE || t == UNIT_DEACTIVATING)
+                        if (t == UNIT_INACTIVE || t == UNIT_FAILED || t == UNIT_DEACTIVATING)

                                 r = -ENOEXEC;
                         else if (t == UNIT_ACTIVATING) {
                                 j->type = JOB_START;
                                 r = unit_start(j->unit);
                                 r = -ENOEXEC;
                         else if (t == UNIT_ACTIVATING) {
                                 j->type = JOB_START;
                                 r = unit_start(j->unit);

-                        } else
+                        } else {
+                                j->type = JOB_RESTART;

                                 r = unit_stop(j->unit);
                                 r = unit_stop(j->unit);

+                        }

                         break;
                 }
 
                         break;
                 }
 


@@ -443,21 +464,71 @@ int job_run_and_invalidate(Job *j) {
 
         if ((j = manager_get_job(m, id))) {
                 if (r == -EALREADY)
 
         if ((j = manager_get_job(m, id))) {
                 if (r == -EALREADY)

-                        r = job_finish_and_invalidate(j, true);
+                        r = job_finish_and_invalidate(j, JOB_DONE);
+                else if (r == -ENOEXEC)
+                        r = job_finish_and_invalidate(j, JOB_SKIPPED);

                 else if (r == -EAGAIN)
                         j->state = JOB_WAITING;
                 else if (r < 0)
                 else if (r == -EAGAIN)
                         j->state = JOB_WAITING;
                 else if (r < 0)

-                        r = job_finish_and_invalidate(j, false);
+                        r = job_finish_and_invalidate(j, JOB_FAILED);

         }
 
         return r;
 }
 
         }
 
         return r;
 }
 

-int job_finish_and_invalidate(Job *j, bool success) {
+static void job_print_status_message(Unit *u, JobType t, JobResult result) {
+        assert(u);
+
+        if (t == JOB_START) {
+
+                switch (result) {
+
+                case JOB_DONE:
+                        unit_status_printf(u, ANSI_HIGHLIGHT_GREEN_ON "  OK  " ANSI_HIGHLIGHT_OFF, "Started %s", unit_description(u));
+                        break;
+
+                case JOB_FAILED:
+                        unit_status_printf(u, ANSI_HIGHLIGHT_RED_ON "FAILED" ANSI_HIGHLIGHT_OFF, "Failed to start %s", unit_description(u));
+                        unit_status_printf(u, NULL, "See 'systemctl status %s' for details.", u->id);
+                        break;
+
+                case JOB_DEPENDENCY:
+                        unit_status_printf(u, ANSI_HIGHLIGHT_RED_ON " ABORT" ANSI_HIGHLIGHT_OFF, "Dependency failed. Aborted start of %s", unit_description(u));
+                        break;
+
+                case JOB_TIMEOUT:
+                        unit_status_printf(u, ANSI_HIGHLIGHT_RED_ON " TIME " ANSI_HIGHLIGHT_OFF, "Timed out starting %s", unit_description(u));
+                        break;
+
+                default:
+                        ;
+                }
+
+        } else if (t == JOB_STOP) {
+
+                switch (result) {
+
+                case JOB_TIMEOUT:
+                        unit_status_printf(u, ANSI_HIGHLIGHT_RED_ON " TIME " ANSI_HIGHLIGHT_OFF, "Timed out stopping %s", unit_description(u));
+                        break;
+
+                case JOB_DONE:
+                case JOB_FAILED:
+                        unit_status_printf(u, ANSI_HIGHLIGHT_GREEN_ON "  OK  " ANSI_HIGHLIGHT_OFF, "Stopped %s", unit_description(u));
+                        break;
+
+                default:
+                        ;
+                }
+        }
+}
+
+int job_finish_and_invalidate(Job *j, JobResult result) {

         Unit *u;
         Unit *other;
         JobType t;
         Iterator i;
         Unit *u;
         Unit *other;
         JobType t;
         Iterator i;

+        bool recursed = false;

 
         assert(j);
         assert(j->installed);
 
         assert(j);
         assert(j->installed);


@@ -465,82 +536,107 @@ int job_finish_and_invalidate(Job *j, bool success) {
         job_add_to_dbus_queue(j);
 
         /* Patch restart jobs so that they become normal start jobs */
         job_add_to_dbus_queue(j);
 
         /* Patch restart jobs so that they become normal start jobs */

-        if (success && (j->type == JOB_RESTART || j->type == JOB_TRY_RESTART)) {
+        if (result == JOB_DONE && (j->type == JOB_RESTART || j->type == JOB_TRY_RESTART)) {

 
                 log_debug("Converting job %s/%s -> %s/%s",
 
                 log_debug("Converting job %s/%s -> %s/%s",

-                          j->unit->meta.id, job_type_to_string(j->type),
-                          j->unit->meta.id, job_type_to_string(JOB_START));
+                          j->unit->id, job_type_to_string(j->type),
+                          j->unit->id, job_type_to_string(JOB_START));

 
                 j->state = JOB_WAITING;
                 j->type = JOB_START;
 
                 job_add_to_run_queue(j);
 
                 j->state = JOB_WAITING;
                 j->type = JOB_START;
 
                 job_add_to_run_queue(j);

-                return 0;
+
+                u = j->unit;
+                goto finish;

         }
 
         }
 

-        log_debug("Job %s/%s finished, success=%s", j->unit->meta.id, job_type_to_string(j->type), yes_no(success));
+        j->result = result;
+
+        log_debug("Job %s/%s finished, result=%s", j->unit->id, job_type_to_string(j->type), job_result_to_string(result));
+
+        if (result == JOB_FAILED)
+                j->manager->n_failed_jobs ++;

 
 

-        j->failed = !success;

         u = j->unit;
         t = j->type;
         job_free(j);
 
         u = j->unit;
         t = j->type;
         job_free(j);
 

-        if (!success)
-                unit_status_printf(u, "Starting %s " ANSI_HIGHLIGHT_ON "failed" ANSI_HIGHLIGHT_OFF ".\n", unit_description(u));
+        job_print_status_message(u, t, result);

 
         /* Fail depending jobs on failure */
 
         /* Fail depending jobs on failure */

-        if (!success) {
+        if (result != JOB_DONE) {

 
                 if (t == JOB_START ||
                     t == JOB_VERIFY_ACTIVE ||
                     t == JOB_RELOAD_OR_START) {
 
 
                 if (t == JOB_START ||
                     t == JOB_VERIFY_ACTIVE ||
                     t == JOB_RELOAD_OR_START) {
 

-                        SET_FOREACH(other, u->meta.dependencies[UNIT_REQUIRED_BY], i)
-                                if (!other->meta.ignore_dependency_failure &&
-                                    other->meta.job &&
-                                    (other->meta.job->type == JOB_START ||
-                                     other->meta.job->type == JOB_VERIFY_ACTIVE ||
-                                     other->meta.job->type == JOB_RELOAD_OR_START))
-                                        job_finish_and_invalidate(other->meta.job, false);
-
-                        SET_FOREACH(other, u->meta.dependencies[UNIT_REQUIRED_BY_OVERRIDABLE], i)
-                                if (!other->meta.ignore_dependency_failure &&
-                                    other->meta.job &&
-                                    !other->meta.job->override &&
-                                    (other->meta.job->type == JOB_START ||
-                                     other->meta.job->type == JOB_VERIFY_ACTIVE ||
-                                     other->meta.job->type == JOB_RELOAD_OR_START))
-                                        job_finish_and_invalidate(other->meta.job, false);
+                        SET_FOREACH(other, u->dependencies[UNIT_REQUIRED_BY], i)
+                                if (other->job &&
+                                    (other->job->type == JOB_START ||
+                                     other->job->type == JOB_VERIFY_ACTIVE ||
+                                     other->job->type == JOB_RELOAD_OR_START)) {
+                                        job_finish_and_invalidate(other->job, JOB_DEPENDENCY);
+                                        recursed = true;
+                                }
+
+                        SET_FOREACH(other, u->dependencies[UNIT_BOUND_BY], i)
+                                if (other->job &&
+                                    (other->job->type == JOB_START ||
+                                     other->job->type == JOB_VERIFY_ACTIVE ||
+                                     other->job->type == JOB_RELOAD_OR_START)) {
+                                        job_finish_and_invalidate(other->job, JOB_DEPENDENCY);
+                                        recursed = true;
+                                }
+
+                        SET_FOREACH(other, u->dependencies[UNIT_REQUIRED_BY_OVERRIDABLE], i)
+                                if (other->job &&
+                                    !other->job->override &&
+                                    (other->job->type == JOB_START ||
+                                     other->job->type == JOB_VERIFY_ACTIVE ||
+                                     other->job->type == JOB_RELOAD_OR_START)) {
+                                        job_finish_and_invalidate(other->job, JOB_DEPENDENCY);
+                                        recursed = true;
+                                }

 
                 } else if (t == JOB_STOP) {
 
 
                 } else if (t == JOB_STOP) {
 

-                        SET_FOREACH(other, u->meta.dependencies[UNIT_CONFLICTS], i)
-                                if (!other->meta.ignore_dependency_failure &&
-                                    other->meta.job &&
-                                    (other->meta.job->type == JOB_START ||
-                                     other->meta.job->type == JOB_VERIFY_ACTIVE ||
-                                     other->meta.job->type == JOB_RELOAD_OR_START))
-                                        job_finish_and_invalidate(other->meta.job, false);
-
-                        SET_FOREACH(other, u->meta.dependencies[UNIT_CONFLICTED_BY], i)
-                                if (!other->meta.ignore_dependency_failure &&
-                                    other->meta.job &&
-                                    (other->meta.job->type == JOB_START ||
-                                     other->meta.job->type == JOB_VERIFY_ACTIVE ||
-                                     other->meta.job->type == JOB_RELOAD_OR_START))
-                                        job_finish_and_invalidate(other->meta.job, false);
+                        SET_FOREACH(other, u->dependencies[UNIT_CONFLICTED_BY], i)
+                                if (other->job &&
+                                    (other->job->type == JOB_START ||
+                                     other->job->type == JOB_VERIFY_ACTIVE ||
+                                     other->job->type == JOB_RELOAD_OR_START)) {
+                                        job_finish_and_invalidate(other->job, JOB_DEPENDENCY);
+                                        recursed = true;
+                                }

                 }
         }
 
                 }
         }
 

+        /* Trigger OnFailure dependencies that are not generated by
+         * the unit itself. We don't tread JOB_CANCELED as failure in
+         * this context. And JOB_FAILURE is already handled by the
+         * unit itself. */
+        if (result == JOB_TIMEOUT || result == JOB_DEPENDENCY) {
+                log_notice("Job %s/%s failed with result '%s'.",
+                           u->id,
+                           job_type_to_string(t),
+                           job_result_to_string(result));
+
+                unit_trigger_on_failure(u);
+        }
+
+finish:

         /* Try to start the next jobs that can be started */
         /* Try to start the next jobs that can be started */

-        SET_FOREACH(other, u->meta.dependencies[UNIT_AFTER], i)
-                if (other->meta.job)
-                        job_add_to_run_queue(other->meta.job);
-        SET_FOREACH(other, u->meta.dependencies[UNIT_BEFORE], i)
-                if (other->meta.job)
-                        job_add_to_run_queue(other->meta.job);
+        SET_FOREACH(other, u->dependencies[UNIT_AFTER], i)
+                if (other->job)
+                        job_add_to_run_queue(other->job);
+        SET_FOREACH(other, u->dependencies[UNIT_BEFORE], i)
+                if (other->job)
+                        job_add_to_run_queue(other->job);

 
 

-        return 0;
+        manager_check_finished(u->manager);
+
+        return recursed;

 }
 
 int job_start_timer(Job *j) {
 }
 
 int job_start_timer(Job *j) {


@@ -549,7 +645,7 @@ int job_start_timer(Job *j) {
         int fd, r;
         assert(j);
 
         int fd, r;
         assert(j);
 

-        if (j->unit->meta.job_timeout <= 0 ||
+        if (j->unit->job_timeout <= 0 ||

             j->timer_watch.type == WATCH_JOB_TIMER)
                 return 0;
 
             j->timer_watch.type == WATCH_JOB_TIMER)
                 return 0;
 


@@ -561,7 +657,7 @@ int job_start_timer(Job *j) {
         }
 
         zero(its);
         }
 
         zero(its);

-        timespec_store(&its.it_value, j->unit->meta.job_timeout);
+        timespec_store(&its.it_value, j->unit->job_timeout);

 
         if (timerfd_settime(fd, 0, &its, NULL) < 0) {
                 r = -errno;
 
         if (timerfd_settime(fd, 0, &its, NULL) < 0) {
                 r = -errno;


@@ -631,8 +727,8 @@ void job_timer_event(Job *j, uint64_t n_elapsed, Watch *w) {
         assert(j);
         assert(w == &j->timer_watch);
 
         assert(j);
         assert(w == &j->timer_watch);
 

-        log_warning("Job %s/%s timed out.", j->unit->meta.id, job_type_to_string(j->type));
-        job_finish_and_invalidate(j, false);
+        log_warning("Job %s/%s timed out.", j->unit->id, job_type_to_string(j->type));
+        job_finish_and_invalidate(j, JOB_TIMEOUT);

 }
 
 static const char* const job_state_table[_JOB_STATE_MAX] = {
 }
 
 static const char* const job_state_table[_JOB_STATE_MAX] = {


@@ -657,7 +753,20 @@ DEFINE_STRING_TABLE_LOOKUP(job_type, JobType);
 static const char* const job_mode_table[_JOB_MODE_MAX] = {
         [JOB_FAIL] = "fail",
         [JOB_REPLACE] = "replace",
 static const char* const job_mode_table[_JOB_MODE_MAX] = {
         [JOB_FAIL] = "fail",
         [JOB_REPLACE] = "replace",

-        [JOB_ISOLATE] = "isolate"
+        [JOB_ISOLATE] = "isolate",
+        [JOB_IGNORE_DEPENDENCIES] = "ignore-dependencies",
+        [JOB_IGNORE_REQUIREMENTS] = "ignore-requirements"

 };
 
 DEFINE_STRING_TABLE_LOOKUP(job_mode, JobMode);
 };
 
 DEFINE_STRING_TABLE_LOOKUP(job_mode, JobMode);

+
+static const char* const job_result_table[_JOB_RESULT_MAX] = {
+        [JOB_DONE] = "done",
+        [JOB_CANCELED] = "canceled",
+        [JOB_TIMEOUT] = "timeout",
+        [JOB_FAILED] = "failed",
+        [JOB_DEPENDENCY] = "dependency",
+        [JOB_SKIPPED] = "skipped"
+};
+
+DEFINE_STRING_TABLE_LOOKUP(job_result, JobResult);