shaba/systemd
1
0
Fork 0
mirror of https://github.com/systemd/systemd.git synced 2024-11-02 10:51:20 +03:00
Code

core: move unit_status_emit_starting_stopping_reloading() and related calls to job.c

Browse Source 
This call is only used by job.c and very specific to job handling.
Moreover the very similar logic of job_emit_status_message() is already
in job.c.

Hence, let's clean this up, and move both sets of functions to job.c,
and rename them a bit so that they express precisely what they do:

1. unit_status_emit_starting_stopping_reloading() →
   job_emit_begin_status_message()
2. job_emit_status_message() → job_emit_done_status_message()

The first call is after all what we call when we begin with the
execution of a job, and the second call what we call when we are done
wiht it.

Just some moving and renaming, not other changes, and hence no change in
behaviour.
This commit is contained in:
Lennart Poettering 2018-11-13 19:57:43 +01:00
parent f8c34706f5
commit 33a3fdd978
3 changed files with 103 additions and 103 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

119
src/core/job.c
View File

@ -509,6 +509,93 @@ static void job_change_type(Job *j, JobType newtype) {
j->type = newtype;
}
_pure_ static const char* job_get_begin_status_message_format(Unit *u, JobType t) {
const char *format;
const UnitStatusMessageFormats *format_table;
assert(u);
assert(IN_SET(t, JOB_START, JOB_STOP, JOB_RELOAD));
if (t != JOB_RELOAD) {
format_table = &UNIT_VTABLE(u)->status_message_formats;
if (format_table) {
format = format_table->starting_stopping[t == JOB_STOP];
if (format)
return format;
}
}
/* Return generic strings */
if (t == JOB_START)
return "Starting %s.";
else if (t == JOB_STOP)
return "Stopping %s.";
else
return "Reloading %s.";
}
static void job_print_begin_status_message(Unit *u, JobType t) {
const char *format;
assert(u);
/* Reload status messages have traditionally not been printed to console. */
if (!IN_SET(t, JOB_START, JOB_STOP))
return;
format = job_get_begin_status_message_format(u, t);
DISABLE_WARNING_FORMAT_NONLITERAL;
unit_status_printf(u, "", format);
REENABLE_WARNING;
}
static void job_log_begin_status_message(Unit *u, JobType t) {
const char *format, *mid;
char buf[LINE_MAX];
assert(u);
if (!IN_SET(t, JOB_START, JOB_STOP, JOB_RELOAD))
return;
if (log_on_console())
return;
/* We log status messages for all units and all operations. */
format = job_get_begin_status_message_format(u, t);
DISABLE_WARNING_FORMAT_NONLITERAL;
(void) snprintf(buf, sizeof buf, format, unit_description(u));
REENABLE_WARNING;
mid = t == JOB_START ? "MESSAGE_ID=" SD_MESSAGE_UNIT_STARTING_STR :
t == JOB_STOP ? "MESSAGE_ID=" SD_MESSAGE_UNIT_STOPPING_STR :
"MESSAGE_ID=" SD_MESSAGE_UNIT_RELOADING_STR;
/* Note that we deliberately use LOG_MESSAGE() instead of
* LOG_UNIT_MESSAGE() here, since this is supposed to mimic
* closely what is written to screen using the status output,
* which is supposed the highest level, friendliest output
* possible, which means we should avoid the low-level unit
* name. */
log_struct(LOG_INFO,
LOG_MESSAGE("%s", buf),
LOG_UNIT_ID(u),
LOG_UNIT_INVOCATION_ID(u),
mid);
}
static void job_emit_begin_status_message(Unit *u, JobType t) {
assert(u);
assert(t >= 0);
assert(t < _JOB_TYPE_MAX);
job_log_begin_status_message(u, t);
job_print_begin_status_message(u, t);
}
static int job_perform_on_unit(Job **j) {
uint32_t id;
Manager *m;
@ -554,7 +641,7 @@ static int job_perform_on_unit(Job **j) {
* actually did something. */
*j = manager_get_job(m, id);
if (*j && r > 0)
unit_status_emit_starting_stopping_reloading(u, t);
job_emit_begin_status_message(u, t);
return r;
}
@ -641,7 +728,7 @@ int job_run_and_invalidate(Job *j) {
return r;
}
_pure_ static const char *job_get_status_message_format(Unit *u, JobType t, JobResult result) {
_pure_ static const char *job_get_done_status_message_format(Unit *u, JobType t, JobResult result) {
static const char *const generic_finished_start_job[_JOB_RESULT_MAX] = {
[JOB_DONE] = "Started %s.",
@ -702,7 +789,7 @@ _pure_ static const char *job_get_status_message_format(Unit *u, JobType t, JobR
static const struct {
const char *color, *word;
} job_print_status_messages [_JOB_RESULT_MAX] = {
} job_print_done_status_messages[_JOB_RESULT_MAX] = {
[JOB_DONE] = { ANSI_OK_COLOR, " OK " },
[JOB_TIMEOUT] = { ANSI_HIGHLIGHT_RED, " TIME " },
[JOB_FAILED] = { ANSI_HIGHLIGHT_RED, "FAILED" },
@ -714,7 +801,7 @@ static const struct {
[JOB_ONCE] = { ANSI_HIGHLIGHT_RED, " ONCE " },
};
static void job_print_status_message(Unit *u, JobType t, JobResult result) {
static void job_print_done_status_message(Unit *u, JobType t, JobResult result) {
const char *format;
const char *status;
@ -726,19 +813,19 @@ static void job_print_status_message(Unit *u, JobType t, JobResult result) {
if (t == JOB_RELOAD)
return;
if (!job_print_status_messages[result].word)
if (!job_print_done_status_messages[result].word)
return;
format = job_get_status_message_format(u, t, result);
format = job_get_done_status_message_format(u, t, result);
if (!format)
return;
if (log_get_show_color())
status = strjoina(job_print_status_messages[result].color,
job_print_status_messages[result].word,
status = strjoina(job_print_done_status_messages[result].color,
job_print_done_status_messages[result].word,
ANSI_NORMAL);
else
status = job_print_status_messages[result].word;
status = job_print_done_status_messages[result].word;
if (result != JOB_DONE)
manager_flip_auto_status(u->manager, true);
@ -755,7 +842,7 @@ static void job_print_status_message(Unit *u, JobType t, JobResult result) {
}
}
static void job_log_status_message(Unit *u, uint32_t job_id, JobType t, JobResult result) {
static void job_log_done_status_message(Unit *u, uint32_t job_id, JobType t, JobResult result) {
const char *format, *mid;
char buf[LINE_MAX];
static const int job_result_log_level[_JOB_RESULT_MAX] = {
@ -778,10 +865,10 @@ static void job_log_status_message(Unit *u, uint32_t job_id, JobType t, JobResul
/* Skip printing if output goes to the console, and job_print_status_message()
will actually print something to the console. */
if (log_on_console() && job_print_status_messages[result].word)
if (log_on_console() && job_print_done_status_messages[result].word)
return;
format = job_get_status_message_format(u, t, result);
format = job_get_done_status_message_format(u, t, result);
if (!format)
return;
@ -832,15 +919,15 @@ static void job_log_status_message(Unit *u, uint32_t job_id, JobType t, JobResul
mid);
}
static void job_emit_status_message(Unit *u, uint32_t job_id, JobType t, JobResult result) {
static void job_emit_done_status_message(Unit *u, uint32_t job_id, JobType t, JobResult result) {
assert(u);
/* No message if the job did not actually do anything due to failed condition. */
if (t == JOB_START && result == JOB_DONE && !u->condition_result)
return;
job_log_status_message(u, job_id, t, result);
job_print_status_message(u, t, result);
job_log_done_status_message(u, job_id, t, result);
job_print_done_status_message(u, t, result);
}
static void job_fail_dependencies(Unit *u, UnitDependency d) {
@ -895,7 +982,7 @@ int job_finish_and_invalidate(Job *j, JobResult result, bool recursive, bool alr
/* If this job did nothing to respective unit we don't log the status message */
if (!already)
job_emit_status_message(u, j->id, t, result);
job_emit_done_status_message(u, j->id, t, result);
/* Patch restart jobs so that they become normal start jobs */
if (result == JOB_DONE && t == JOB_RESTART) {

86
src/core/unit.c
View File

@ -1627,92 +1627,6 @@ void unit_status_printf(Unit *u, const char *status, const char *unit_status_msg
REENABLE_WARNING;
}
_pure_ static const char* unit_get_status_message_format(Unit *u, JobType t) {
const char *format;
const UnitStatusMessageFormats *format_table;
assert(u);
assert(IN_SET(t, JOB_START, JOB_STOP, JOB_RELOAD));
if (t != JOB_RELOAD) {
format_table = &UNIT_VTABLE(u)->status_message_formats;
if (format_table) {
format = format_table->starting_stopping[t == JOB_STOP];
if (format)
return format;
}
}
/* Return generic strings */
if (t == JOB_START)
return "Starting %s.";
else if (t == JOB_STOP)
return "Stopping %s.";
else
return "Reloading %s.";
}
static void unit_status_print_starting_stopping(Unit *u, JobType t) {
const char *format;
assert(u);
/* Reload status messages have traditionally not been printed to console. */
if (!IN_SET(t, JOB_START, JOB_STOP))
return;
format = unit_get_status_message_format(u, t);
DISABLE_WARNING_FORMAT_NONLITERAL;
unit_status_printf(u, "", format);
REENABLE_WARNING;
}
static void unit_status_log_starting_stopping_reloading(Unit *u, JobType t) {
const char *format, *mid;
char buf[LINE_MAX];
assert(u);
if (!IN_SET(t, JOB_START, JOB_STOP, JOB_RELOAD))
return;
if (log_on_console())
return;
/* We log status messages for all units and all operations. */
format = unit_get_status_message_format(u, t);
DISABLE_WARNING_FORMAT_NONLITERAL;
(void) snprintf(buf, sizeof buf, format, unit_description(u));
REENABLE_WARNING;
mid = t == JOB_START ? "MESSAGE_ID=" SD_MESSAGE_UNIT_STARTING_STR :
t == JOB_STOP ? "MESSAGE_ID=" SD_MESSAGE_UNIT_STOPPING_STR :
"MESSAGE_ID=" SD_MESSAGE_UNIT_RELOADING_STR;
/* Note that we deliberately use LOG_MESSAGE() instead of
* LOG_UNIT_MESSAGE() here, since this is supposed to mimic
* closely what is written to screen using the status output,
* which is supposed the highest level, friendliest output
* possible, which means we should avoid the low-level unit
* name. */
log_struct(LOG_INFO,
LOG_MESSAGE("%s", buf),
LOG_UNIT_ID(u),
LOG_UNIT_INVOCATION_ID(u),
mid);
}
void unit_status_emit_starting_stopping_reloading(Unit *u, JobType t) {
assert(u);
assert(t >= 0);
assert(t < _JOB_TYPE_MAX);
unit_status_log_starting_stopping_reloading(u, t);
unit_status_print_starting_stopping(u, t);
}
int unit_start_limit_test(Unit *u) {
const char *reason;

1
src/core/unit.h
View File

@ -701,7 +701,6 @@ int unit_coldplug(Unit *u);
void unit_catchup(Unit *u);
void unit_status_printf(Unit *u, const char *status, const char *unit_status_msg_format) _printf_(3, 0);
void unit_status_emit_starting_stopping_reloading(Unit *u, JobType t);
bool unit_need_daemon_reload(Unit *u);