From 33a3fdd9781329379f74e11a7a2707816aad8c61 Mon Sep 17 00:00:00 2001 From: Lennart Poettering Date: Tue, 13 Nov 2018 19:57:43 +0100 Subject: [PATCH] core: move unit_status_emit_starting_stopping_reloading() and related calls to job.c MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit 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. --- src/core/job.c | 119 +++++++++++++++++++++++++++++++++++++++++------- src/core/unit.c | 86 ---------------------------------- src/core/unit.h | 1 - 3 files changed, 103 insertions(+), 103 deletions(-) diff --git a/src/core/job.c b/src/core/job.c index 1a4781dc8c2..42474ce59dd 100644 --- a/src/core/job.c +++ b/src/core/job.c @@ -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) { diff --git a/src/core/unit.c b/src/core/unit.c index c4a0b49edb6..1dc62768a24 100644 --- a/src/core/unit.c +++ b/src/core/unit.c @@ -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; diff --git a/src/core/unit.h b/src/core/unit.h index c6ee1dfc3b5..eb8f1f5653c 100644 --- a/src/core/unit.h +++ b/src/core/unit.h @@ -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);