job.h

   1 /*-*- Mode: C; c-basic-offset: 8 -*-*/
   2
   3 #ifndef foojobhfoo
   4 #define foojobhfoo
   5
   6 /***
   7   This file is part of systemd.
   8
   9   Copyright 2010 Lennart Poettering
  10
  11   systemd is free software; you can redistribute it and/or modify it
  12   under the terms of the GNU General Public License as published by
  13   the Free Software Foundation; either version 2 of the License, or
  14   (at your option) any later version.
  15
  16   systemd is distributed in the hope that it will be useful, but
  17   WITHOUT ANY WARRANTY; without even the implied warranty of
  18   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  19   General Public License for more details.
  20
  21   You should have received a copy of the GNU General Public License
  22   along with systemd; If not, see <http://www.gnu.org/licenses/>.
  23 ***/
  24
  25 #include <stdbool.h>
  26 #include <inttypes.h>
  27
  28 typedef struct Job Job;
  29 typedef struct JobDependency JobDependency;
  30 typedef enum JobType JobType;
  31 typedef enum JobState JobState;
  32 typedef enum JobMode JobMode;
  33
  34 #include "manager.h"
  35 #include "unit.h"
  36 #include "hashmap.h"
  37 #include "list.h"
  38
  39 enum JobType {
  40         JOB_START,                  /* if a unit does not support being started, we'll just wait until it becomes active */
  41         JOB_VERIFY_ACTIVE,
  42
  43         JOB_STOP,
  44
  45         JOB_RELOAD,                 /* if running reload */
  46         JOB_RELOAD_OR_START,        /* if running reload, if not running start */
  47
  48         /* Note that restarts are first treated like JOB_STOP, but
  49          * then instead of finishing are patched to become
  50          * JOB_START. */
  51         JOB_RESTART,                /* if running stop, then start unconditionally */
  52         JOB_TRY_RESTART,            /* if running stop and then start */
  53
  54         _JOB_TYPE_MAX,
  55         _JOB_TYPE_INVALID = -1
  56 };
  57
  58 enum JobState {
  59         JOB_WAITING,
  60         JOB_RUNNING,
  61         _JOB_STATE_MAX,
  62         _JOB_STATE_INVALID = -1
  63 };
  64
  65 enum JobMode {
  66         JOB_FAIL,
  67         JOB_REPLACE,
  68         _JOB_MODE_MAX,
  69         _JOB_MODE_INVALID = -1
  70 };
  71
  72 struct JobDependency {
  73         /* Encodes that the 'subject' job needs the 'object' job in
  74          * some way. This structure is used only while building a transaction. */
  75         Job *subject;
  76         Job *object;
  77
  78         bool matters;
  79
  80         LIST_FIELDS(JobDependency, subject);
  81         LIST_FIELDS(JobDependency, object);
  82 };
  83
  84 struct Job {
  85         Manager *manager;
  86         uint32_t id;
  87
  88         Unit *unit;
  89
  90         JobType type;
  91         JobState state;
  92
  93         bool installed:1;
  94         bool in_run_queue:1;
  95         bool matters_to_anchor:1;
  96         bool forced:1;
  97
  98         LIST_FIELDS(Job, transaction);
  99         LIST_FIELDS(Job, run_queue);
 100
 101         LIST_HEAD(JobDependency, subject_list);
 102         LIST_HEAD(JobDependency, object_list);
 103
 104         /* Used for graph algs as a "I have been here" marker */
 105         Job* marker;
 106         unsigned generation;
 107
 108 };
 109
 110 Job* job_new(Manager *m, JobType type, Unit *unit);
 111 void job_free(Job *job);
 112 void job_dump(Job *j, FILE*f, const char *prefix);
 113
 114 JobDependency* job_dependency_new(Job *subject, Job *object, bool matters);
 115 void job_dependency_free(JobDependency *l);
 116 void job_dependency_delete(Job *subject, Job *object, bool *matters);
 117
 118 bool job_is_anchor(Job *j);
 119
 120 int job_merge(Job *j, Job *other);
 121
 122 int job_type_merge(JobType *a, JobType b);
 123 bool job_type_is_mergeable(JobType a, JobType b);
 124 bool job_type_is_superset(JobType a, JobType b);
 125 bool job_type_is_conflicting(JobType a, JobType b);
 126
 127 bool job_is_runnable(Job *j);
 128
 129 void job_schedule_run(Job *j);
 130 int job_run_and_invalidate(Job *j);
 131 int job_finish_and_invalidate(Job *j, bool success);
 132
 133 const char* job_type_to_string(JobType t);
 134 JobType job_type_from_string(const char *s);
 135
 136 const char* job_state_to_string(JobState t);
 137 JobState job_state_from_string(const char *s);
 138
 139 const char* job_mode_to_string(JobMode t);
 140 JobMode job_mode_from_string(const char *s);
 141
 142 char *job_dbus_path(Job *j);
 143
 144 #endif