| Message ID | 20210509213217.449489-2-lenaic@lhuard.fr (mailing list archive) |
|---|---|
| State | New, archived |
| Headers | show |
| Series | maintenance: use systemd timers on Linux | expand |
On 2021-05-09 23:32:17+0200, Lénaïc Huard <lenaic@lhuard.fr> wrote: > The existing mechanism for scheduling background maintenance is done > through cron. On Linux systems managed by systemd, systemd provides an > alternative to schedule recurring tasks: systemd timers. > > +static int systemd_timer_enable_unit(int enable, > + enum schedule_priority schedule, > + const char *cmd) > +{ > + struct child_process child = CHILD_PROCESS_INIT; > + const char *frequency = get_frequency(schedule); > + > + strvec_split(&child.args, cmd); > + strvec_pushl(&child.args, "--user", enable ? "enable" : "disable", > + "--now", NULL); > + strvec_pushf(&child.args, "git-maintenance@%s.timer", frequency); > + > + if (start_command(&child)) > + die(_("failed to run systemctl")); > + return finish_command(&child); > +} > + > +static int systemd_timer_delete_unit_templates(void) > +{ > + char *filename = xdg_config_home_systemd("git-maintenance@.timer"); > + unlink(filename); > + free(filename); > + > + filename = xdg_config_home_systemd("git-maintenance@.service"); > + unlink(filename); > + free(filename); > + > + return 0; > +} > + > +static int systemd_timer_delete_units(const char *cmd) > +{ > + return systemd_timer_enable_unit(0, SCHEDULE_HOURLY, cmd) || > + systemd_timer_enable_unit(0, SCHEDULE_DAILY, cmd) || > + systemd_timer_enable_unit(0, SCHEDULE_WEEKLY, cmd) || > + systemd_timer_delete_unit_templates(); > +} I'm not using any systemd-based distros. However, isn't this try to enable all systemd's {hourly,daily,weekly} user's timer, then delete the templates?^W^W^W^W^W^W^W^W^W^W^W^W^W^W^W^W^W^W^W^W^W^W^W^W^W^W^W Argh, we're disabling those systemd timer units first, by passing 0 as first argument of systemd_timer_delete_units. The fact that I read that twice, and still wrote down above reply makes me think that above code is not self-explanatory enough. May we switch to something else? Let's say using enum? > +static int systemd_timer_write_unit_templates(const char *exec_path) > +{ > + char *filename; > + FILE *file; > + const char *unit; > + > + filename = xdg_config_home_systemd("git-maintenance@.timer"); > + if (safe_create_leading_directories(filename)) > + die(_("failed to create directories for '%s'"), filename); This message is used by other codes, less works for translator, nice! > + file = xfopen(filename, "w"); > + free(filename); I'm sure if we should use FREE_AND_NULL(filename) instead? Since, filename will be reused later. > + > + unit = "# This file was created and is maintained by Git.\n" > + "# Any edits made in this file might be replaced in the future\n" > + "# by a Git command.\n" > + "\n" > + "[Unit]\n" > + "Description=Optimize Git repositories data\n" > + "\n" > + "[Timer]\n" > + "OnCalendar=%i\n" > + "Persistent=true\n" > + "\n" > + "[Install]\n" > + "WantedBy=timers.target\n"; > + fputs(unit, file); > + fclose(file); > + > + filename = xdg_config_home_systemd("git-maintenance@.service"); > + if (safe_create_leading_directories(filename)) > + die(_("failed to create directories for '%s'"), filename); > + file = xfopen(filename, "w"); > + free(filename); > + > + unit = "# This file was created and is maintained by Git.\n" > + "# Any edits made in this file might be replaced in the future\n" > + "# by a Git command.\n" > + "\n" > + "[Unit]\n" > + "Description=Optimize Git repositories data\n" > + "\n" > + "[Service]\n" > + "Type=oneshot\n" > + "ExecStart=\"%1$s/git\" --exec-path=\"%1$s\" for-each-repo --config=maintenance.repo maintenance run --schedule=%%i\n" > + "LockPersonality=yes\n" > + "MemoryDenyWriteExecute=yes\n" > + "NoNewPrivileges=yes\n" > + "RestrictAddressFamilies=AF_UNIX AF_INET AF_INET6\n" > + "RestrictNamespaces=yes\n" > + "RestrictRealtime=yes\n" > + "RestrictSUIDSGID=yes\n" > + "SystemCallArchitectures=native\n" > + "SystemCallFilter=@system-service\n"; > + fprintf(file, unit, exec_path); I think others have strong opinion on not using "%1$s", and prefer simple "%s" and using "exec_path" twice instead. > + fclose(file); > + > + return 0; > +} > + > +static int systemd_timer_setup_units(const char *cmd) > +{ > + const char *exec_path = git_exec_path(); > + > + return systemd_timer_write_unit_templates(exec_path) || > + systemd_timer_enable_unit(1, SCHEDULE_HOURLY, cmd) || > + systemd_timer_enable_unit(1, SCHEDULE_DAILY, cmd) || > + systemd_timer_enable_unit(1, SCHEDULE_WEEKLY, cmd); > +} > + > +static int systemd_timer_update_schedule(int run_maintenance, int fd, > + const char *cmd) > +{ > + if (run_maintenance) > + return systemd_timer_setup_units(cmd); > + else > + return systemd_timer_delete_units(cmd); > +} > + > +enum scheduler { > + SCHEDULER_INVALID = -1, > + SCHEDULER_AUTO = 0, > + SCHEDULER_CRON = 1, > + SCHEDULER_SYSTEMD = 2, > + SCHEDULER_LAUNCHCTL = 3, > + SCHEDULER_SCHTASKS = 4, I think explicitly writing down values doesn't make things clearer, -1 would be nice, not a strong opinion, though. Anyway, would it be better to move those type declaration to top of file? > +}; > + > +static const struct { > + int (*is_available)(const char *cmd); > + int (*update_schedule)(int run_maintenance, int fd, const char *cmd); > + const char *cmd; > +} scheduler_fn[] = { > + [SCHEDULER_CRON] = { is_crontab_available, crontab_update_schedule, > + "crontab" }, > + [SCHEDULER_SYSTEMD] = { is_systemd_timer_available, > + systemd_timer_update_schedule, "systemctl" }, > + [SCHEDULER_LAUNCHCTL] = { is_launchctl_available, > + launchctl_update_schedule, "launchctl" }, > + [SCHEDULER_SCHTASKS] = { is_schtasks_available, > + schtasks_update_schedule, "schtasks" }, > +}; > + > +static enum scheduler parse_scheduler(const char *value) > +{ > + if (!value) > + return SCHEDULER_INVALID; > + else if (!strcasecmp(value, "auto")) > + return SCHEDULER_AUTO; > + else if (!strcasecmp(value, "cron") || !strcasecmp(value, "crontab")) > + return SCHEDULER_CRON; > + else if (!strcasecmp(value, "systemd") || > + !strcasecmp(value, "systemd-timer")) > + return SCHEDULER_SYSTEMD; > + else if (!strcasecmp(value, "launchctl")) > + return SCHEDULER_LAUNCHCTL; > + else if (!strcasecmp(value, "schtasks")) > + return SCHEDULER_SCHTASKS; > + else > + return SCHEDULER_INVALID; > +} > + > +static int maintenance_opt_scheduler(const struct option *opt, const char *arg, > + int unset) > +{ > + enum scheduler *scheduler = opt->value; > + > + if (unset) > + die(_("--no-scheduler is not allowed")); I think it's better to use OPT_CALLBACK_F in the options list and we will write below code instead: BUG_ON_OPT_NEG(unset) > + > + *scheduler = parse_scheduler(arg); > + > + if (*scheduler == SCHEDULER_INVALID) > + die(_("unrecognized --scheduler argument '%s'"), arg); Most of other callbacks do this instead: return error(_("messsage.... '%s'"), arg); > + > + return 0; > +} > + > +struct maintenance_start_opts { > + enum scheduler scheduler; > +}; > + > +static void resolve_auto_scheduler(enum scheduler *scheduler) > +{ > + if (*scheduler != SCHEDULER_AUTO) > + return; > + > #if defined(__APPLE__) > -static const char platform_scheduler[] = "launchctl"; > + *scheduler = SCHEDULER_LAUNCHCTL; > + return; > + > #elif defined(GIT_WINDOWS_NATIVE) > -static const char platform_scheduler[] = "schtasks"; > + *scheduler = SCHEDULER_SCHTASKS; > + return; > + > +#elif defined(__linux__) > + if (is_systemd_timer_available("systemctl")) > + *scheduler = SCHEDULER_SYSTEMD; > + else if (is_crontab_available("crontab")) > + *scheduler = SCHEDULER_CRON; > + else > + die(_("neither systemd timers nor crontab are available")); > + return; > + > #else > -static const char platform_scheduler[] = "crontab"; > + *scheduler = SCHEDULER_CRON; > + return; > #endif > +} > > -static int update_background_schedule(int enable) > +static void validate_scheduler(enum scheduler scheduler) > { > - int result; > - const char *scheduler = platform_scheduler; > - const char *cmd = scheduler; > + const char *cmd; > + > + if (scheduler == SCHEDULER_INVALID) > + BUG("invalid scheduler"); > + if (scheduler == SCHEDULER_AUTO) > + BUG("resolve_auto_scheduler should have been called before"); > + > + cmd = scheduler_fn[scheduler].cmd; > + if (!scheduler_fn[scheduler].is_available(cmd)) > + die(_("%s scheduler is not available"), cmd); > +} > + > +static int update_background_schedule(const struct maintenance_start_opts *opts, > + int enable) > +{ > + unsigned int i; > + int res, result = 0; > + enum scheduler scheduler; > + const char *cmd = NULL; > char *testing; > struct lock_file lk; > char *lock_path = xstrfmt("%s/schedule", the_repository->objects->odb->path); > > + if (hold_lock_file_for_update(&lk, lock_path, LOCK_NO_DEREF) < 0) > + return error(_("another process is scheduling background maintenance")); > + > testing = xstrdup_or_null(getenv("GIT_TEST_MAINT_SCHEDULER")); > if (testing) { > char *sep = strchr(testing, ':'); > if (!sep) > die("GIT_TEST_MAINT_SCHEDULER unparseable: %s", testing); > *sep = '\0'; > - scheduler = testing; > + scheduler = parse_scheduler(testing); > cmd = sep + 1; > + result = scheduler_fn[scheduler].update_schedule( > + enable, get_lock_file_fd(&lk), cmd); > + goto done; > } > > - if (hold_lock_file_for_update(&lk, lock_path, LOCK_NO_DEREF) < 0) > - return error(_("another process is scheduling background maintenance")); > - > - if (!strcmp(scheduler, "launchctl")) > - result = launchctl_update_schedule(enable, get_lock_file_fd(&lk), cmd); > - else if (!strcmp(scheduler, "schtasks")) > - result = schtasks_update_schedule(enable, get_lock_file_fd(&lk), cmd); > - else if (!strcmp(scheduler, "crontab")) > - result = crontab_update_schedule(enable, get_lock_file_fd(&lk), cmd); > - else > - die("unknown background scheduler: %s", scheduler); > + for (i = 1; i < ARRAY_SIZE(scheduler_fn); i++) { > + int enable_scheduler = enable && (opts->scheduler == i); > + cmd = scheduler_fn[i].cmd; > + if (!scheduler_fn[i].is_available(cmd)) > + continue; > + res = scheduler_fn[i].update_schedule( > + enable_scheduler, get_lock_file_fd(&lk), cmd); > + if (enable_scheduler) > + result = res; > + } > > +done: > rollback_lock_file(&lk); > free(testing); > return result; > } > > -static int maintenance_start(void) > +static const char *const builtin_maintenance_start_usage[] = { > + N_("git maintenance start [--scheduler=<scheduler>]"), NULL > +}; > + > +static int maintenance_start(int argc, const char **argv, const char *prefix) > { > + struct maintenance_start_opts opts; > + struct option builtin_maintenance_start_options[] = { > + OPT_CALLBACK( > + 0, "scheduler", &opts.scheduler, N_("scheduler"), > + N_("scheduler to use to trigger git maintenance run"), > + maintenance_opt_scheduler), Following up my comment above, we're better to use: OPT_CALLBACK_F(0, "scheduler", &opts.scheduler, N_("scheduler"), N_("............"), PARSE_OPT_NONEG, maintenance_opt_scheduler), > + OPT_END() > + }; > + memset(&opts, 0, sizeof(opts)); > + > + argc = parse_options(argc, argv, prefix, > + builtin_maintenance_start_options, > + builtin_maintenance_start_usage, 0); > + > + resolve_auto_scheduler(&opts.scheduler); > + validate_scheduler(opts.scheduler); > + > + if (argc > 0) > + usage_with_options(builtin_maintenance_start_usage, > + builtin_maintenance_start_options); > + > if (maintenance_register()) > warning(_("failed to add repo to global config")); > - > - return update_background_schedule(1); > + return update_background_schedule(&opts, 1); > } > > static int maintenance_stop(void) > { > - return update_background_schedule(0); > + return update_background_schedule(NULL, 0); > } > > static const char builtin_maintenance_usage[] = N_("git maintenance <subcommand> [<options>]"); > @@ -2027,7 +2354,7 @@ int cmd_maintenance(int argc, const char **argv, const char *prefix) > if (!strcmp(argv[1], "run")) > return maintenance_run(argc - 1, argv + 1, prefix); > if (!strcmp(argv[1], "start")) > - return maintenance_start(); > + return maintenance_start(argc - 1, argv + 1, prefix); > if (!strcmp(argv[1], "stop")) > return maintenance_stop(); > if (!strcmp(argv[1], "register")) > diff --git a/t/t7900-maintenance.sh b/t/t7900-maintenance.sh > index 2412d8c5c0..6e6316cd90 100755 > --- a/t/t7900-maintenance.sh > +++ b/t/t7900-maintenance.sh > @@ -20,6 +20,20 @@ test_xmllint () { > fi > } > > +test_lazy_prereq SYSTEMD_ANALYZE ' > + systemd-analyze --help >out && > + grep verify out > +' > + > +test_systemd_analyze_verify () { > + if test_have_prereq SYSTEMD_ANALYZE > + then > + systemd-analyze verify "$@" > + else > + true The "else" leg is not necessary. > + fi > +} > + > test_expect_success 'help text' ' > test_expect_code 129 git maintenance -h 2>err && > test_i18ngrep "usage: git maintenance <subcommand>" err && > @@ -615,6 +629,43 @@ test_expect_success 'start and stop Windows maintenance' ' > test_cmp expect args > ' > > +test_expect_success 'start and stop Linux/systemd maintenance' ' > + write_script print-args <<-\EOF && > + echo $* >>args To avoid any possible incompatibility with zillion echo implementation out there. printf should be prefered over echo. Not a in this test case, however, it costs us nothing anyway. printf "%s\n" "$*" > + EOF > + > + rm -f args && > + GIT_TEST_MAINT_SCHEDULER="systemd:./print-args" git maintenance start && > + > + # start registers the repo > + git config --get --global --fixed-value maintenance.repo "$(pwd)" && > + > + test_systemd_analyze_verify "$HOME/.config/systemd/user/git-maintenance@.service" && > + > + rm -f expect && > + for frequency in hourly daily weekly > + do > + echo "--user enable --now git-maintenance@${frequency}.timer" >>expect || return 1 > + done && And here, we can have a nicer syntax with printf: printf "--user enable --now git-maintenance@%s.timer\n" hourly daily weekly >expect && With printf, we don't even need "rm -f expect" above. > + test_cmp expect args && > + > + rm -f args && > + GIT_TEST_MAINT_SCHEDULER="systemd:./print-args" git maintenance stop && > + > + # stop does not unregister the repo > + git config --get --global --fixed-value maintenance.repo "$(pwd)" && > + > + test_path_is_missing "$HOME/.config/systemd/user/git-maintenance@.timer" && > + test_path_is_missing "$HOME/.config/systemd/user/git-maintenance@.service" && > + > + rm -f expect && > + for frequency in hourly daily weekly > + do > + echo "--user disable --now git-maintenance@${frequency}.timer" >>expect || return 1 > + done && Ditto. All of this was written without testing, because I don't have any systemd based system near my hand, right now. So, please take it with a grain of salt.
On Sun, May 9, 2021 at 9:20 PM Đoàn Trần Công Danh <congdanhqx@gmail.com> wrote: > On 2021-05-09 23:32:17+0200, Lénaïc Huard <lenaic@lhuard.fr> wrote: > > +static int systemd_timer_delete_units(const char *cmd) > > +{ > > + return systemd_timer_enable_unit(0, SCHEDULE_HOURLY, cmd) || > > + systemd_timer_enable_unit(0, SCHEDULE_DAILY, cmd) || > > + systemd_timer_enable_unit(0, SCHEDULE_WEEKLY, cmd) || > > + systemd_timer_delete_unit_templates(); > > +} > > Argh, we're disabling those systemd timer units first, by passing 0 as > first argument of systemd_timer_delete_units. > > The fact that I read that twice, and still wrote down above reply > makes me think that above code is not self-explanatory enough. > May we switch to something else? Let's say using enum? This is modeled after existing scheduler functions in this file, in which the `enable` argument is a simple 0 or 1, so changing this to an enum just for this function would be inconsistent. Changing all the functions to `enum` in a preparatory patch could indeed improve readability, however, that's tangential cleanup which may be outside the scope of this submission. > > + file = xfopen(filename, "w"); > > + free(filename); > > I'm sure if we should use FREE_AND_NULL(filename) instead? > Since, filename will be reused later. Indeed, probably a good idea, as it would make catching mistakes easier. > > + "ExecStart=\"%1$s/git\" --exec-path=\"%1$s\" for-each-repo --config=maintenance.repo maintenance run --schedule=%%i\n" > > I think others have strong opinion on not using "%1$s", > and prefer simple "%s" and using "exec_path" twice instead. I brought it up only because I hadn't seen it in Git sources, and wasn't sure if we'd want to start using it. Aside from Ævar, who seemed reasonably in favor of it, nobody else chimed in, so it could go either way, I suppose. > > +test_systemd_analyze_verify () { > > + if test_have_prereq SYSTEMD_ANALYZE > > + then > > + systemd-analyze verify "$@" > > + else > > + true > > The "else" leg is not necessary. This was patterned after the existing test_xmllint() function in this file which has the `else true` leg. I wrote test_xmllint(), so I'll take blame. But you're right, the `if` will return success if the prerequisite is not set, so the `else` leg is indeed not needed. (Cleaning up the test_xmllint() function is outside the scope of this patch.) > > +test_expect_success 'start and stop Linux/systemd maintenance' ' > > + write_script print-args <<-\EOF && > > + echo $* >>args > > To avoid any possible incompatibility with zillion echo implementation > out there. printf should be prefered over echo. Not a in this test > case, however, it costs us nothing anyway. > > printf "%s\n" "$*" This, too, is patterned after existing auxiliary scripts created by these test functions, and you're correct that it's potentially dangerous. A manual inspection of all the existing instances shows that `echo $*` happens to be safe for those cases but that doesn't excuse being sloppy about it, so the existing cases probably ought to be cleaned up. But, again, that is outside the scope of this series. For this particular case, though... > > + for frequency in hourly daily weekly > > + do > > + echo "--user enable --now git-maintenance@${frequency}.timer" >>expect || return 1 > > + done && > > And here, we can have a nicer syntax with printf: > > printf "--user enable --now git-maintenance@%s.timer\n" hourly daily weekly >expect && > > With printf, we don't even need "rm -f expect" above. ... you're quite correct that `printf` is the way to go both here and in the generated `print-args` script since these arguments start with hyphen.
Eric Sunshine <sunshine@sunshineco.com> writes: >> I think others have strong opinion on not using "%1$s", >> and prefer simple "%s" and using "exec_path" twice instead. > > I brought it up only because I hadn't seen it in Git sources, and > wasn't sure if we'd want to start using it. Aside from Ævar, who > seemed reasonably in favor of it, nobody else chimed in, so it could > go either way, I suppose. If this were a piece of code that _everybody_ would use on _all_ the supported platforms, I would suggest declaring that this is a weather-balloon to see if some platforms have trouble using it. But unfortunately this is not such a piece of code. Dependence on systemd should strictly be opt-in. So my preference is - here, just do it in the dumb and simple way - somewhere else, find code that is compiled and run for everybody on all platforms that feeds two same arguments to printf format, and update it to use "%1$x" twice, mark it clearly as a weather balloon, and document it (see how what 512f41cf did is documented in Documentation/CodingGuidelines and mimick, but tone it down as we haven't declared it safe to use (yet). It is likely that we need rearrangement of argument order for po/ files anyway, but a misimplementation might not handle using the same placeholder twice, and that is why I'd like to be a bit extra careful.
Hi Lénaïc Thanks for updating the patch, I've left some comments below. Aside from one possible bug, they mostly revolve around not passing the name of scheduler command around when that name is fixed and functions which do not check for errors but return a success/failure value (either they should check the return values of the system calls they make or be declared as void if it is safe to ignore the failures) On 09/05/2021 22:32, Lénaïc Huard wrote: > The existing mechanism for scheduling background maintenance is done > through cron. On Linux systems managed by systemd, systemd provides an > alternative to schedule recurring tasks: systemd timers. > > The main motivations to implement systemd timers in addition to cron > are: > * cron is optional and Linux systems running systemd might not have it > installed. > * The execution of `crontab -l` can tell us if cron is installed but not > if the daemon is actually running. > * With systemd, each service is run in its own cgroup and its logs are > tagged by the service inside journald. With cron, all scheduled tasks > are running in the cron daemon cgroup and all the logs of the > user-scheduled tasks are pretended to belong to the system cron > service. > Concretely, a user that doesn’t have access to the system logs won’t > have access to the log of its own tasks scheduled by cron whereas he > will have access to the log of its own tasks scheduled by systemd > timer. > Although `cron` attempts to send email, that email may go unseen by > the user because these days, local mailboxes are not heavily used > anymore. > > In order to choose which scheduler to use between `cron` and user > systemd timers, a new option > `--scheduler=auto|cron|systemd|launchctl|schtasks` has been added to > `git maintenance start`. > When `git maintenance start --scheduler=XXX` is run, it not only > registers `git maintenance run` tasks in the scheduler XXX, it also > removes the `git maintenance run` tasks from all the other schedulers I'm not sure it is actually doing that at the moment - see my comment in update_background_schedule() > to > ensure we cannot have two schedulers launching concurrent identical > tasks. > > The default value is `auto` which chooses a suitable scheduler for the > system. > On Linux, if user systemd timers are available, they will be used as git > maintenance scheduler. If not, `cron` will be used if it is available. > If none is available, it will fail. I think defaulting to systemd timers when both systemd and cron are installed is sensible given the problems associated with testing whether crond is actually running in that scenario. > `git maintenance stop` doesn't have any `--scheduler` parameter because > this command will try to remove the `git maintenance run` tasks from all > the available schedulers. > > In order to schedule git maintenance, we need two unit template files: > * ~/.config/systemd/user/git-maintenance@.service > to define the command to be started by systemd and > * ~/.config/systemd/user/git-maintenance@.timer > to define the schedule at which the command should be run. > > Those units are templates that are parametrized by the frequency. > > Based on those templates, 3 timers are started: > * git-maintenance@hourly.timer > * git-maintenance@daily.timer > * git-maintenance@weekly.timer > > The command launched by those three timers are the same than with the > other scheduling methods: > > git for-each-repo --config=maintenance.repo maintenance run > --schedule=%i > > with the full path for git to ensure that the version of git launched > for the scheduled maintenance is the same as the one used to run > `maintenance start`. > > The timer unit contains `Persistent=true` so that, if the computer is > powered down when a maintenance task should run, the task will be run > when the computer is back powered on. > > Signed-off-by: Lénaïc Huard <lenaic@lhuard.fr> > --- > Documentation/git-maintenance.txt | 60 +++++ > builtin/gc.c | 375 ++++++++++++++++++++++++++++-- > t/t7900-maintenance.sh | 51 ++++ > 3 files changed, 462 insertions(+), 24 deletions(-) > > diff --git a/Documentation/git-maintenance.txt b/Documentation/git-maintenance.txt > index 80ddd33ceb..f012923333 100644 > --- a/Documentation/git-maintenance.txt > +++ b/Documentation/git-maintenance.txt > @@ -181,6 +181,20 @@ OPTIONS > `maintenance.<task>.enabled` configured as `true` are considered. > See the 'TASKS' section for the list of accepted `<task>` values. > > +--scheduler=auto|crontab|systemd-timer|launchctl|schtasks:: > + When combined with the `start` subcommand, specify the scheduler > + to use to run the hourly, daily and weekly executions of > + `git maintenance run`. > + The possible values for `<scheduler>` depend on the system: `crontab` > + is available on POSIX systems, `systemd-timer` is available on Linux > + systems, `launchctl` is available on MacOS and `schtasks` is available > + on Windows. > + By default or when `auto` is specified, the most appropriate scheduler > + for the system is used. On MacOS, `launchctl` is used. On Windows, > + `schtasks` is used. On Linux, `systemd-timers` is used if user systemd > + timers are available, otherwise, `crontab` is used. On all other systems, > + `crontab` is used. > + > > TROUBLESHOOTING > --------------- > @@ -279,6 +293,52 @@ schedule to ensure you are executing the correct binaries in your > schedule. > > > +BACKGROUND MAINTENANCE ON LINUX SYSTEMD SYSTEMS > +----------------------------------------------- > + > +While Linux supports `cron`, depending on the distribution, `cron` may > +be an optional package not necessarily installed. On modern Linux > +distributions, systemd timers are superseding it. > + > +If user systemd timers are available, they will be used as a replacement > +of `cron`. > + > +In this case, `git maintenance start` will create user systemd timer units > +and start the timers. The current list of user-scheduled tasks can be found > +by running `systemctl --user list-timers`. The timers written by `git > +maintenance start` are similar to this: > + > +----------------------------------------------------------------------- > +$ systemctl --user list-timers > +NEXT LEFT LAST PASSED UNIT ACTIVATES > +Thu 2021-04-29 19:00:00 CEST 42min left Thu 2021-04-29 18:00:11 CEST 17min ago git-maintenance@hourly.timer git-maintenance@hourly.service > +Fri 2021-04-30 00:00:00 CEST 5h 42min left Thu 2021-04-29 00:00:11 CEST 18h ago git-maintenance@daily.timer git-maintenance@daily.service > +Mon 2021-05-03 00:00:00 CEST 3 days left Mon 2021-04-26 00:00:11 CEST 3 days ago git-maintenance@weekly.timer git-maintenance@weekly.service > +----------------------------------------------------------------------- > + > +One timer is registered for each `--schedule=<frequency>` option. > + > +The definition of the systemd units can be inspected in the following files: > + > +----------------------------------------------------------------------- > +~/.config/systemd/user/git-maintenance@.timer > +~/.config/systemd/user/git-maintenance@.service > +~/.config/systemd/user/timers.target.wants/git-maintenance@hourly.timer > +~/.config/systemd/user/timers.target.wants/git-maintenance@daily.timer > +~/.config/systemd/user/timers.target.wants/git-maintenance@weekly.timer > +----------------------------------------------------------------------- > + > +`git maintenance start` will overwrite these files and start the timer > +again with `systemctl --user`, so any customization should be done by > +creating a drop-in file, i.e. a `.conf` suffixed file in the > +`~/.config/systemd/user/git-maintenance@.service.d` directory. > + > +`git maintenance stop` will stop the user systemd timers and delete > +the above mentioned files. > + > +For more details, see systemd.timer(5) > + > + > BACKGROUND MAINTENANCE ON MACOS SYSTEMS > --------------------------------------- > > diff --git a/builtin/gc.c b/builtin/gc.c > index ef7226d7bc..7c72aa3b99 100644 > --- a/builtin/gc.c > +++ b/builtin/gc.c > @@ -1544,6 +1544,15 @@ static const char *get_frequency(enum schedule_priority schedule) > } > } > > +static int is_launchctl_available(const char *cmd) None of these is_..._available() function needs the cmd parameter. It matches the existing pattern of the existing ..._update_schedule() functions but they don't really need the cmd argument either so I would drop the argument for the new functions. > +{ > +#ifdef __APPLE__ > + return 1; > +#else > + return 0; > +#endif > +} > + > static char *launchctl_service_name(const char *frequency) > { > struct strbuf label = STRBUF_INIT; > @@ -1710,6 +1719,15 @@ static int launchctl_update_schedule(int run_maintenance, int fd, const char *cm > return launchctl_remove_plists(cmd); > } > > +static int is_schtasks_available(const char *cmd) > +{ > +#ifdef GIT_WINDOWS_NATIVE > + return 1; > +#else > + return 0; > +#endif > +} > + > static char *schtasks_task_name(const char *frequency) > { > struct strbuf label = STRBUF_INIT; > @@ -1872,6 +1890,28 @@ static int schtasks_update_schedule(int run_maintenance, int fd, const char *cmd > return schtasks_remove_tasks(cmd); > } > > +static int is_crontab_available(const char *cmd) > +{ > + static int cached_result = -1; > + struct child_process child = CHILD_PROCESS_INIT; > + > + if (cached_result != -1) > + return cached_result; > + > + strvec_split(&child.args, cmd); > + strvec_push(&child.args, "-l"); > + child.no_stdin = 1; > + child.no_stdout = 1; > + child.no_stderr = 1; > + child.silent_exec_failure = 1; > + > + if (start_command(&child)) > + return cached_result = 0; > + /* Ignore exit code, as an empty crontab will return error. */ > + finish_command(&child); > + return cached_result = 1; > +} > + > #define BEGIN_LINE "# BEGIN GIT MAINTENANCE SCHEDULE" > #define END_LINE "# END GIT MAINTENANCE SCHEDULE" > > @@ -1959,61 +1999,348 @@ static int crontab_update_schedule(int run_maintenance, int fd, const char *cmd) > return result; > } > > +static int is_systemd_timer_available(const char *cmd) > +{ > +#ifdef __linux__ > + static int cached_result = -1; > + struct child_process child = CHILD_PROCESS_INIT; > + > + if (cached_result != -1) > + return cached_result; > + > + strvec_split(&child.args, cmd); > + strvec_pushl(&child.args, "--user", "list-timers", NULL); > + child.no_stdin = 1; > + child.no_stdout = 1; > + child.no_stderr = 1; > + child.silent_exec_failure = 1; > + > + if (start_command(&child)) > + return cached_result = 0; This is maybe a bit too clever. It would be clearer to separate the assignment of the cached result and the return statement. > + if (finish_command(&child)) > + return cached_result = 0; > + return cached_result = 1; > +#else > + return 0; > +#endif > +} > + > +static char *xdg_config_home_systemd(const char *filename) > +{ > + const char *home, *config_home; > + > + assert(filename); > + config_home = getenv("XDG_CONFIG_HOME"); > + if (config_home && *config_home) > + return mkpathdup("%s/systemd/user/%s", config_home, filename); > + > + home = getenv("HOME"); > + if (home) > + return mkpathdup("%s/.config/systemd/user/%s", home, filename); > + > + die(_("failed to get $XDG_CONFIG_HOME and $HOME")); > +} This is largely a copy of xdg_config_home(), I would prefer to see this function calling that rather than duplicating it. static char *xdg_config_home_systemd(const char *filename) { struct strbuf buf = STRBUF_INIT; char *path; strbuf_addf(&buf, "systemd/user/%s", filename); path = xdg_config_home(buf.buf); strbuf_release(&buf); return path; } Even better would be to modify xdg_config_home() to take a format string. > +static int systemd_timer_enable_unit(int enable, > + enum schedule_priority schedule, > + const char *cmd) The cmd argument is pointless, it will always be "systemctl" and you have even hard coded that value into the error message below. > +{ > + struct child_process child = CHILD_PROCESS_INIT; > + const char *frequency = get_frequency(schedule); > + > + strvec_split(&child.args, cmd); > + strvec_pushl(&child.args, "--user", enable ? "enable" : "disable", > + "--now", NULL); > + strvec_pushf(&child.args, "git-maintenance@%s.timer", frequency); > + > + if (start_command(&child)) > + die(_("failed to run systemctl")); > + return finish_command(&child); There is a strange mix of dying and returning an error here. Also should this be printing a message if finish_command() returns a non-zero value? If systemctl fails then there is not much we can do to recover so dying on any error might be ok unless we need to perform some cleanup if it fails like removing the timer unit files. What is the exit code of systemctl if a unit is already enabled and we try to enbale it again (and the same for disabling a disabled unit)? > +} > + > +static int systemd_timer_delete_unit_templates(void) > +{ > + char *filename = xdg_config_home_systemd("git-maintenance@.timer"); > + unlink(filename); This is missing error handling (and below). If there is a good reason to ignore the errors then there is no point in returning a value from this function > + free(filename); > + > + filename = xdg_config_home_systemd("git-maintenance@.service"); > + unlink(filename); > + free(filename); > + > + return 0; > +} > + > +static int systemd_timer_delete_units(const char *cmd) > +{ > + return systemd_timer_enable_unit(0, SCHEDULE_HOURLY, cmd) || > + systemd_timer_enable_unit(0, SCHEDULE_DAILY, cmd) || > + systemd_timer_enable_unit(0, SCHEDULE_WEEKLY, cmd) || > + systemd_timer_delete_unit_templates(); > +} > + > +static int systemd_timer_write_unit_templates(const char *exec_path) > +{ > + char *filename; > + FILE *file; > + const char *unit; > + > + filename = xdg_config_home_systemd("git-maintenance@.timer"); > + if (safe_create_leading_directories(filename)) > + die(_("failed to create directories for '%s'"), filename); > + file = xfopen(filename, "w"); > + free(filename); > + > + unit = "# This file was created and is maintained by Git.\n" > + "# Any edits made in this file might be replaced in the future\n" > + "# by a Git command.\n" > + "\n" > + "[Unit]\n" > + "Description=Optimize Git repositories data\n" > + "\n" > + "[Timer]\n" > + "OnCalendar=%i\n" > + "Persistent=true\n" > + "\n" > + "[Install]\n" > + "WantedBy=timers.target\n"; > + fputs(unit, file); > + fclose(file); > + > + filename = xdg_config_home_systemd("git-maintenance@.service"); > + if (safe_create_leading_directories(filename)) Haven't we already created this path if it was missing above for the first file? > + die(_("failed to create directories for '%s'"), filename); > + file = xfopen(filename, "w"); Do we want to try and remove the first file if we cannot write the second file to leave the file system in a consitent state? If so you'll need to use something like fopen_or_warn() and check the return value. > + free(filename); > + > + unit = "# This file was created and is maintained by Git.\n" > + "# Any edits made in this file might be replaced in the future\n" > + "# by a Git command.\n" > + "\n" > + "[Unit]\n" > + "Description=Optimize Git repositories data\n" > + "\n" > + "[Service]\n" > + "Type=oneshot\n" > + "ExecStart=\"%1$s/git\" --exec-path=\"%1$s\" for-each-repo --config=maintenance.repo maintenance run --schedule=%%i\n" > + "LockPersonality=yes\n" > + "MemoryDenyWriteExecute=yes\n" > + "NoNewPrivileges=yes\n" > + "RestrictAddressFamilies=AF_UNIX AF_INET AF_INET6\n" > + "RestrictNamespaces=yes\n" > + "RestrictRealtime=yes\n" > + "RestrictSUIDSGID=yes\n" After a quick read of the systemd.exec man page it is unclear to me if these Restrict... lines are needed as we already have NoNewPrivileges=yes - maybe they have some effect if `git maintence` is run as root? > + "SystemCallArchitectures=native\n" > + "SystemCallFilter=@system-service\n"; > + fprintf(file, unit, exec_path); > + fclose(file); > + > + return 0; As we don't return any errors but die instead there is no need to return a value. On the other hand maybe we should be checking the return values of fclose() and possibly fputs() / fprint(). > +} > + > +static int systemd_timer_setup_units(const char *cmd) > +{ > + const char *exec_path = git_exec_path(); > + > + return systemd_timer_write_unit_templates(exec_path) || > + systemd_timer_enable_unit(1, SCHEDULE_HOURLY, cmd) || > + systemd_timer_enable_unit(1, SCHEDULE_DAILY, cmd) || > + systemd_timer_enable_unit(1, SCHEDULE_WEEKLY, cmd); If any step fails do we need to try and reverse the preceding steps to avoid leaving so units enabled but not others. In practice this is probably pretty unlikely so maybe we don't need to worry. > +} > + > +static int systemd_timer_update_schedule(int run_maintenance, int fd, > + const char *cmd) No need for the cmd argument > +{ > + if (run_maintenance) > + return systemd_timer_setup_units(cmd); > + else > + return systemd_timer_delete_units(cmd); > +} > + > +enum scheduler { > + SCHEDULER_INVALID = -1, > + SCHEDULER_AUTO = 0, > + SCHEDULER_CRON = 1, > + SCHEDULER_SYSTEMD = 2, > + SCHEDULER_LAUNCHCTL = 3, > + SCHEDULER_SCHTASKS = 4, > +}; > + > +static const struct { > + int (*is_available)(const char *cmd); > + int (*update_schedule)(int run_maintenance, int fd, const char *cmd); > + const char *cmd; > +} scheduler_fn[] = { > + [SCHEDULER_CRON] = { is_crontab_available, crontab_update_schedule, > + "crontab" }, > + [SCHEDULER_SYSTEMD] = { is_systemd_timer_available, > + systemd_timer_update_schedule, "systemctl" }, > + [SCHEDULER_LAUNCHCTL] = { is_launchctl_available, > + launchctl_update_schedule, "launchctl" }, > + [SCHEDULER_SCHTASKS] = { is_schtasks_available, > + schtasks_update_schedule, "schtasks" }, > +}; > + > +static enum scheduler parse_scheduler(const char *value) > +{ > + if (!value) > + return SCHEDULER_INVALID; > + else if (!strcasecmp(value, "auto")) > + return SCHEDULER_AUTO; > + else if (!strcasecmp(value, "cron") || !strcasecmp(value, "crontab")) > + return SCHEDULER_CRON; > + else if (!strcasecmp(value, "systemd") || > + !strcasecmp(value, "systemd-timer")) > + return SCHEDULER_SYSTEMD; > + else if (!strcasecmp(value, "launchctl")) > + return SCHEDULER_LAUNCHCTL; > + else if (!strcasecmp(value, "schtasks")) > + return SCHEDULER_SCHTASKS; > + else > + return SCHEDULER_INVALID; > +} > + > +static int maintenance_opt_scheduler(const struct option *opt, const char *arg, > + int unset) > +{ > + enum scheduler *scheduler = opt->value; > + > + if (unset) > + die(_("--no-scheduler is not allowed")); As others have said it would be better to BUG() here and pass PARSE_OPT_NONEG when defining the option below. > + > + *scheduler = parse_scheduler(arg); > + > + if (*scheduler == SCHEDULER_INVALID) > + die(_("unrecognized --scheduler argument '%s'"), arg); > + > + return 0; > +} > + > +struct maintenance_start_opts { > + enum scheduler scheduler; > +}; > + > +static void resolve_auto_scheduler(enum scheduler *scheduler) > +{ > + if (*scheduler != SCHEDULER_AUTO) > + return; > + > #if defined(__APPLE__) > -static const char platform_scheduler[] = "launchctl"; > + *scheduler = SCHEDULER_LAUNCHCTL; > + return; > + > #elif defined(GIT_WINDOWS_NATIVE) > -static const char platform_scheduler[] = "schtasks"; > + *scheduler = SCHEDULER_SCHTASKS; > + return; > + > +#elif defined(__linux__) > + if (is_systemd_timer_available("systemctl")) > + *scheduler = SCHEDULER_SYSTEMD; > + else if (is_crontab_available("crontab")) > + *scheduler = SCHEDULER_CRON; > + else > + die(_("neither systemd timers nor crontab are available")); > + return; > + > #else > -static const char platform_scheduler[] = "crontab"; > + *scheduler = SCHEDULER_CRON; > + return; > #endif > +} > > -static int update_background_schedule(int enable) > +static void validate_scheduler(enum scheduler scheduler) > { > - int result; > - const char *scheduler = platform_scheduler; > - const char *cmd = scheduler; > + const char *cmd; > + > + if (scheduler == SCHEDULER_INVALID) > + BUG("invalid scheduler"); > + if (scheduler == SCHEDULER_AUTO) > + BUG("resolve_auto_scheduler should have been called before"); > + > + cmd = scheduler_fn[scheduler].cmd; > + if (!scheduler_fn[scheduler].is_available(cmd)) > + die(_("%s scheduler is not available"), cmd); > +} > + > +static int update_background_schedule(const struct maintenance_start_opts *opts, > + int enable) > +{ > + unsigned int i; > + int res, result = 0; > + enum scheduler scheduler; > + const char *cmd = NULL; > char *testing; > struct lock_file lk; > char *lock_path = xstrfmt("%s/schedule", the_repository->objects->odb->path); > > + if (hold_lock_file_for_update(&lk, lock_path, LOCK_NO_DEREF) < 0) > + return error(_("another process is scheduling background maintenance")); > + > testing = xstrdup_or_null(getenv("GIT_TEST_MAINT_SCHEDULER")); > if (testing) { > char *sep = strchr(testing, ':'); > if (!sep) > die("GIT_TEST_MAINT_SCHEDULER unparseable: %s", testing); > *sep = '\0'; > - scheduler = testing; > + scheduler = parse_scheduler(testing); > cmd = sep + 1; > + result = scheduler_fn[scheduler].update_schedule( > + enable, get_lock_file_fd(&lk), cmd); > + goto done; > } > > - if (hold_lock_file_for_update(&lk, lock_path, LOCK_NO_DEREF) < 0) > - return error(_("another process is scheduling background maintenance")); > - > - if (!strcmp(scheduler, "launchctl")) > - result = launchctl_update_schedule(enable, get_lock_file_fd(&lk), cmd); > - else if (!strcmp(scheduler, "schtasks")) > - result = schtasks_update_schedule(enable, get_lock_file_fd(&lk), cmd); > - else if (!strcmp(scheduler, "crontab")) > - result = crontab_update_schedule(enable, get_lock_file_fd(&lk), cmd); > - else > - die("unknown background scheduler: %s", scheduler); > + for (i = 1; i < ARRAY_SIZE(scheduler_fn); i++) { > + int enable_scheduler = enable && (opts->scheduler == i); > + cmd = scheduler_fn[i].cmd; > + if (!scheduler_fn[i].is_available(cmd)) > + continue; > + res = scheduler_fn[i].update_schedule( > + enable_scheduler, get_lock_file_fd(&lk), cmd); > + if (enable_scheduler) > + result = res; If I have understood the code correctly then if systemd timers are currently enabled and the user runs `git maintenance --scheduler=cron` then cron will be enabled and the loop will quit before we get the the entry to disable systemd timers leaving both running. I think it would be cleaner and clearer to loop over the schedulers disabling them first and then enable the one the user has selected. > + } > > +done: > rollback_lock_file(&lk); > free(testing); > return result; > } > > -static int maintenance_start(void) > +static const char *const builtin_maintenance_start_usage[] = { > + N_("git maintenance start [--scheduler=<scheduler>]"), NULL > +}; > + > +static int maintenance_start(int argc, const char **argv, const char *prefix) > { > + struct maintenance_start_opts opts; struct maintenance_start_opts opts = { 0 }; would avoid the need for the memset() call below Thanks again for working on this. Best Wishes Phillip > + struct option builtin_maintenance_start_options[] = { > + OPT_CALLBACK( > + 0, "scheduler", &opts.scheduler, N_("scheduler"), > + N_("scheduler to use to trigger git maintenance run"), > + maintenance_opt_scheduler), > + OPT_END() > + }; > + memset(&opts, 0, sizeof(opts)); > + > + argc = parse_options(argc, argv, prefix, > + builtin_maintenance_start_options, > + builtin_maintenance_start_usage, 0); > + > + resolve_auto_scheduler(&opts.scheduler); > + validate_scheduler(opts.scheduler); > + > + if (argc > 0) > + usage_with_options(builtin_maintenance_start_usage, > + builtin_maintenance_start_options); > + > if (maintenance_register()) > warning(_("failed to add repo to global config")); > - > - return update_background_schedule(1); > + return update_background_schedule(&opts, 1); > } > > static int maintenance_stop(void) > { > - return update_background_schedule(0); > + return update_background_schedule(NULL, 0); > } > > static const char builtin_maintenance_usage[] = N_("git maintenance <subcommand> [<options>]"); > @@ -2027,7 +2354,7 @@ int cmd_maintenance(int argc, const char **argv, const char *prefix) > if (!strcmp(argv[1], "run")) > return maintenance_run(argc - 1, argv + 1, prefix); > if (!strcmp(argv[1], "start")) > - return maintenance_start(); > + return maintenance_start(argc - 1, argv + 1, prefix); > if (!strcmp(argv[1], "stop")) > return maintenance_stop(); > if (!strcmp(argv[1], "register")) > diff --git a/t/t7900-maintenance.sh b/t/t7900-maintenance.sh > index 2412d8c5c0..6e6316cd90 100755 > --- a/t/t7900-maintenance.sh > +++ b/t/t7900-maintenance.sh > @@ -20,6 +20,20 @@ test_xmllint () { > fi > } > > +test_lazy_prereq SYSTEMD_ANALYZE ' > + systemd-analyze --help >out && > + grep verify out > +' > + > +test_systemd_analyze_verify () { > + if test_have_prereq SYSTEMD_ANALYZE > + then > + systemd-analyze verify "$@" > + else > + true > + fi > +} > + > test_expect_success 'help text' ' > test_expect_code 129 git maintenance -h 2>err && > test_i18ngrep "usage: git maintenance <subcommand>" err && > @@ -615,6 +629,43 @@ test_expect_success 'start and stop Windows maintenance' ' > test_cmp expect args > ' > > +test_expect_success 'start and stop Linux/systemd maintenance' ' > + write_script print-args <<-\EOF && > + echo $* >>args > + EOF > + > + rm -f args && > + GIT_TEST_MAINT_SCHEDULER="systemd:./print-args" git maintenance start && > + > + # start registers the repo > + git config --get --global --fixed-value maintenance.repo "$(pwd)" && > + > + test_systemd_analyze_verify "$HOME/.config/systemd/user/git-maintenance@.service" && > + > + rm -f expect && > + for frequency in hourly daily weekly > + do > + echo "--user enable --now git-maintenance@${frequency}.timer" >>expect || return 1 > + done && > + test_cmp expect args && > + > + rm -f args && > + GIT_TEST_MAINT_SCHEDULER="systemd:./print-args" git maintenance stop && > + > + # stop does not unregister the repo > + git config --get --global --fixed-value maintenance.repo "$(pwd)" && > + > + test_path_is_missing "$HOME/.config/systemd/user/git-maintenance@.timer" && > + test_path_is_missing "$HOME/.config/systemd/user/git-maintenance@.service" && > + > + rm -f expect && > + for frequency in hourly daily weekly > + do > + echo "--user disable --now git-maintenance@${frequency}.timer" >>expect || return 1 > + done && > + test_cmp expect args > +' > + > test_expect_success 'register preserves existing strategy' ' > git config maintenance.strategy none && > git maintenance register && >
On Mon, May 10, 2021 at 2:04 PM Phillip Wood <phillip.wood123@gmail.com> wrote: > On 09/05/2021 22:32, Lénaïc Huard wrote: > > +static int systemd_timer_enable_unit(int enable, > > + enum schedule_priority schedule, > > + const char *cmd) > > The cmd argument is pointless, it will always be "systemctl" and you > have even hard coded that value into the error message below. The reason that `cmd` is passed around everywhere is that the actual command can be overridden by GIT_TEST_MAINT_SCHEDULER which allows the test script to mock up a scheduler command rather than running the real scheduler command. I haven't read the new version of the patch closely yet, but after a quick scan, I'm pretty confident that this is still the case (despite the aggressive changes the patch makes to the areas around GIT_TEST_MAINT_SCHEDULER). As for hardcoding the command name in the error message, that seems perfectly fine since, under normal circumstances, it _will_ be that command (it's only different when testing).
Hi Lénaïc, On Sun, 9 May 2021 at 23:37, Lénaïc Huard <lenaic@lhuard.fr> wrote: > The default value is `auto` which chooses a suitable scheduler for the > system. > On Linux, if user systemd timers are available, they will be used as git > maintenance scheduler. If not, `cron` will be used if it is available. > If none is available, it will fail. I understand your reasoning for going with systemd-timer over cron, especially the part about knowing that the thing is actually running. > +--scheduler=auto|crontab|systemd-timer|launchctl|schtasks:: This says "systemd-timer"... > + By default or when `auto` is specified, the most appropriate scheduler > + for the system is used. On MacOS, `launchctl` is used. On Windows, > + `schtasks` is used. On Linux, `systemd-timers` is used if user systemd ... this says "systemd-timers". Should those two be the same? (Which?) > + timers are available, otherwise, `crontab` is used. On all other systems, > + `crontab` is used. So to be clear, I don't have a horse in this race. A few years ago I would have foreseen all kinds of reactions to the implication that systemd-timers would be "the most appropriate scheduler [...] on Linux". Maybe those times are behind us now. In the commit message, you say "a suitable", which reads a little bit less opinionated (to me). That's just a minor point; feel free to disregard. > +For more details, see systemd.timer(5) Missing trailing ".". A cursory grepping of our docs suggests this should be monospace (`systemd.timer(5)`). There aren't that many places where we refer to non-git manpages, thanks for doing so. That's the only nit I found to make about the markup in the documentation. Thanks for your attention to details. :-) Martin
Hi Eric On 10/05/2021 19:25, Eric Sunshine wrote: > On Mon, May 10, 2021 at 2:04 PM Phillip Wood <phillip.wood123@gmail.com> wrote: >> On 09/05/2021 22:32, Lénaïc Huard wrote: >>> +static int systemd_timer_enable_unit(int enable, >>> + enum schedule_priority schedule, >>> + const char *cmd) >> >> The cmd argument is pointless, it will always be "systemctl" and you >> have even hard coded that value into the error message below. > > The reason that `cmd` is passed around everywhere is that the actual > command can be overridden by GIT_TEST_MAINT_SCHEDULER which allows the > test script to mock up a scheduler command rather than running the > real scheduler command. I haven't read the new version of the patch > closely yet, but after a quick scan, I'm pretty confident that this is > still the case (despite the aggressive changes the patch makes to the > areas around GIT_TEST_MAINT_SCHEDULER). Thanks for pointing that out I'd somehow glossed over the GIT_TEST_MAINT_SCHEDULER code, I agree it looks like the patch takes care to keep it working. It is outside the scope of this patch but a possibly nicer pattern would be to have a function get_command_name(const char *default) that checks GIT_TEST_MAINT_SCHEDULER and returns the command name from that or the default if it is not set. We would then call that function to get the command name when we want to run a command. That way all the extra complexity is localized around the command call (and consists of a single function call), the usual command name is visible in the function calling the command and we'd avoid littering all the function signatures with a argument that is only relevant for testing. > As for hardcoding the command name in the error message, that seems > perfectly fine since, under normal circumstances, it _will_ be that > command (it's only different when testing). I agree, thanks Phillip
On Mon, May 10, 2021 at 4:09 PM Phillip Wood <phillip.wood123@gmail.com> wrote: > It is outside the scope of this patch but a possibly nicer pattern would > be to have a function get_command_name(const char *default) that checks > GIT_TEST_MAINT_SCHEDULER and returns the command name from that or the > default if it is not set. We would then call that function to get the > command name when we want to run a command. That way all the extra > complexity is localized around the command call (and consists of a > single function call), the usual command name is visible in the function > calling the command and we'd avoid littering all the function signatures > with a argument that is only relevant for testing. Yup, that would be a nice eventual cleanup. I agree that it is outside the scope of this submission.
Hi Lénaïc I've added some comments about testing On 09/05/2021 22:32, Lénaïc Huard wrote: >[...] > +struct maintenance_start_opts { > + enum scheduler scheduler; > +}; > + > +static void resolve_auto_scheduler(enum scheduler *scheduler) > +{ > + if (*scheduler != SCHEDULER_AUTO) > + return; > + > #if defined(__APPLE__) > -static const char platform_scheduler[] = "launchctl"; > + *scheduler = SCHEDULER_LAUNCHCTL; > + return; > + > #elif defined(GIT_WINDOWS_NATIVE) > -static const char platform_scheduler[] = "schtasks"; > + *scheduler = SCHEDULER_SCHTASKS; > + return; > + > +#elif defined(__linux__) > + if (is_systemd_timer_available("systemctl")) > + *scheduler = SCHEDULER_SYSTEMD; > + else if (is_crontab_available("crontab")) > + *scheduler = SCHEDULER_CRON; > + else > + die(_("neither systemd timers nor crontab are available")); > + return; > + > #else > -static const char platform_scheduler[] = "crontab"; > + *scheduler = SCHEDULER_CRON; > + return; > #endif > +} As it stands this function is untested and there is no way to test it with the current setup. There are two difficulties with testing it (i) it uses conditional compilation and (ii) there is no way to fake crontab and systemctl with the current test setup. I think we can address the latter (see below) and handle the condition compilation issues using test prerequisites if necessary. > -static int update_background_schedule(int enable) > +static void validate_scheduler(enum scheduler scheduler) > { > - int result; > - const char *scheduler = platform_scheduler; > - const char *cmd = scheduler; > + const char *cmd; > + > + if (scheduler == SCHEDULER_INVALID) > + BUG("invalid scheduler"); > + if (scheduler == SCHEDULER_AUTO) > + BUG("resolve_auto_scheduler should have been called before"); > + > + cmd = scheduler_fn[scheduler].cmd; > + if (!scheduler_fn[scheduler].is_available(cmd)) > + die(_("%s scheduler is not available"), cmd); > +} > + > +static int update_background_schedule(const struct maintenance_start_opts *opts, > + int enable) > +{ > + unsigned int i; > + int res, result = 0; > + enum scheduler scheduler; > + const char *cmd = NULL; > char *testing; > struct lock_file lk; > char *lock_path = xstrfmt("%s/schedule", the_repository->objects->odb->path); > > + if (hold_lock_file_for_update(&lk, lock_path, LOCK_NO_DEREF) < 0) > + return error(_("another process is scheduling background maintenance")); > + > testing = xstrdup_or_null(getenv("GIT_TEST_MAINT_SCHEDULER")); > if (testing) { > char *sep = strchr(testing, ':'); > if (!sep) > die("GIT_TEST_MAINT_SCHEDULER unparseable: %s", testing); > *sep = '\0'; > - scheduler = testing; > + scheduler = parse_scheduler(testing); > cmd = sep + 1; > + result = scheduler_fn[scheduler].update_schedule( > + enable, get_lock_file_fd(&lk), cmd); > + goto done; > } > > - if (hold_lock_file_for_update(&lk, lock_path, LOCK_NO_DEREF) < 0) > - return error(_("another process is scheduling background maintenance")); > - > - if (!strcmp(scheduler, "launchctl")) > - result = launchctl_update_schedule(enable, get_lock_file_fd(&lk), cmd); > - else if (!strcmp(scheduler, "schtasks")) > - result = schtasks_update_schedule(enable, get_lock_file_fd(&lk), cmd); > - else if (!strcmp(scheduler, "crontab")) > - result = crontab_update_schedule(enable, get_lock_file_fd(&lk), cmd); > - else > - die("unknown background scheduler: %s", scheduler); > + for (i = 1; i < ARRAY_SIZE(scheduler_fn); i++) { > + int enable_scheduler = enable && (opts->scheduler == i); > + cmd = scheduler_fn[i].cmd; > + if (!scheduler_fn[i].is_available(cmd)) > + continue; > + res = scheduler_fn[i].update_schedule( > + enable_scheduler, get_lock_file_fd(&lk), cmd); > + if (enable_scheduler) > + result = res; > + } This loop which is responsible for disabling the existing scheduler and enabling a new one is completely untested. I think that before this patch special casing the testing above still ran the important code, however now we fail to test an important aspect of the business logic. As we can only fake one command name the current test setup is insufficient to fix this. I think the best solution would be to mock systemctl, crontab, and the other commands in the test environment. mkdir bin && PATH="$(pwd)/bin:$PATH" && test_write_script systemctl <<-\EOF && # Mock systemctl, set FAKE_SYSTEMD=0 in the # environment to fake systemctl missing case "$*" in "--user list-timers") test ${FAKE_SYSTEMD:-1} = 1; exit $?;; *) printf "%s\n" "$*";; esac EOF # and so on for crontab etc Then it would be possible to test the various values --scheduler=<scheduler> including 'auto' (by setting FAKE_SYSTEMD=0 or FAKE_CRONTAB=0) and that we disable cron when enabling systemd and vice versa. Mocking the commands would also allow us to cleanup the code in gc.c as it would no longer need to pass command names around. > +done: > rollback_lock_file(&lk); > free(testing); > return result; > } > > -static int maintenance_start(void) > +static const char *const builtin_maintenance_start_usage[] = { > + N_("git maintenance start [--scheduler=<scheduler>]"), NULL > +}; > + > +static int maintenance_start(int argc, const char **argv, const char *prefix) > { > + struct maintenance_start_opts opts; > + struct option builtin_maintenance_start_options[] = { > + OPT_CALLBACK( > + 0, "scheduler", &opts.scheduler, N_("scheduler"), > + N_("scheduler to use to trigger git maintenance run"), > + maintenance_opt_scheduler), > + OPT_END() > + }; > + memset(&opts, 0, sizeof(opts)); > + > + argc = parse_options(argc, argv, prefix, > + builtin_maintenance_start_options, > + builtin_maintenance_start_usage, 0); This new command line option is completely untested Best Wishes Phillip > + > + resolve_auto_scheduler(&opts.scheduler); > + validate_scheduler(opts.scheduler); > + > + if (argc > 0) > + usage_with_options(builtin_maintenance_start_usage, > + builtin_maintenance_start_options); > + > if (maintenance_register()) > warning(_("failed to add repo to global config")); > - > - return update_background_schedule(1); > + return update_background_schedule(&opts, 1); > } > > static int maintenance_stop(void) > { > - return update_background_schedule(0); > + return update_background_schedule(NULL, 0); > } > > static const char builtin_maintenance_usage[] = N_("git maintenance <subcommand> [<options>]"); > @@ -2027,7 +2354,7 @@ int cmd_maintenance(int argc, const char **argv, const char *prefix) > if (!strcmp(argv[1], "run")) > return maintenance_run(argc - 1, argv + 1, prefix); > if (!strcmp(argv[1], "start")) > - return maintenance_start(); > + return maintenance_start(argc - 1, argv + 1, prefix); > if (!strcmp(argv[1], "stop")) > return maintenance_stop(); > if (!strcmp(argv[1], "register")) > diff --git a/t/t7900-maintenance.sh b/t/t7900-maintenance.sh > index 2412d8c5c0..6e6316cd90 100755 > --- a/t/t7900-maintenance.sh > +++ b/t/t7900-maintenance.sh > @@ -20,6 +20,20 @@ test_xmllint () { > fi > } > > +test_lazy_prereq SYSTEMD_ANALYZE ' > + systemd-analyze --help >out && > + grep verify out > +' > + > +test_systemd_analyze_verify () { > + if test_have_prereq SYSTEMD_ANALYZE > + then > + systemd-analyze verify "$@" > + else > + true > + fi > +} > + > test_expect_success 'help text' ' > test_expect_code 129 git maintenance -h 2>err && > test_i18ngrep "usage: git maintenance <subcommand>" err && > @@ -615,6 +629,43 @@ test_expect_success 'start and stop Windows maintenance' ' > test_cmp expect args > ' > > +test_expect_success 'start and stop Linux/systemd maintenance' ' > + write_script print-args <<-\EOF && > + echo $* >>args > + EOF > + > + rm -f args && > + GIT_TEST_MAINT_SCHEDULER="systemd:./print-args" git maintenance start && > + > + # start registers the repo > + git config --get --global --fixed-value maintenance.repo "$(pwd)" && > + > + test_systemd_analyze_verify "$HOME/.config/systemd/user/git-maintenance@.service" && > + > + rm -f expect && > + for frequency in hourly daily weekly > + do > + echo "--user enable --now git-maintenance@${frequency}.timer" >>expect || return 1 > + done && > + test_cmp expect args && > + > + rm -f args && > + GIT_TEST_MAINT_SCHEDULER="systemd:./print-args" git maintenance stop && > + > + # stop does not unregister the repo > + git config --get --global --fixed-value maintenance.repo "$(pwd)" && > + > + test_path_is_missing "$HOME/.config/systemd/user/git-maintenance@.timer" && > + test_path_is_missing "$HOME/.config/systemd/user/git-maintenance@.service" && > + > + rm -f expect && > + for frequency in hourly daily weekly > + do > + echo "--user disable --now git-maintenance@${frequency}.timer" >>expect || return 1 > + done && > + test_cmp expect args > +' > + > test_expect_success 'register preserves existing strategy' ' > git config maintenance.strategy none && > git maintenance register && >
On 5/9/2021 5:32 PM, Lénaïc Huard wrote: > The existing mechanism for scheduling background maintenance is done > through cron. On Linux systems managed by systemd, systemd provides an > alternative to schedule recurring tasks: systemd timers. Thank you for working so hard on this systemd integration. I see you have already received significant feedback on that portion, so I wanted to focus my review on the other piece that exists in this patch. > In order to choose which scheduler to use between `cron` and user > systemd timers, a new option > `--scheduler=auto|cron|systemd|launchctl|schtasks` has been added to > `git maintenance start`. > When `git maintenance start --scheduler=XXX` is run, it not only > registers `git maintenance run` tasks in the scheduler XXX, it also > removes the `git maintenance run` tasks from all the other schedulers to > ensure we cannot have two schedulers launching concurrent identical > tasks. > > The default value is `auto` which chooses a suitable scheduler for the > system. This addition of the --scheduler option should be split into a patch on its own. It requires significant refactoring of the existing code in a way that distracts from your systemd work. I'll highlight the portions of the diff that you could include in a preliminary patch and save the systemd stuff for an addition on top of that. > diff --git a/Documentation/git-maintenance.txt b/Documentation/git-maintenance.txt > index 80ddd33ceb..f012923333 100644 > --- a/Documentation/git-maintenance.txt > +++ b/Documentation/git-maintenance.txt > @@ -181,6 +181,20 @@ OPTIONS > `maintenance.<task>.enabled` configured as `true` are considered. > See the 'TASKS' section for the list of accepted `<task>` values. > > +--scheduler=auto|crontab|systemd-timer|launchctl|schtasks:: > + When combined with the `start` subcommand, specify the scheduler > + to use to run the hourly, daily and weekly executions of > + `git maintenance run`. > + The possible values for `<scheduler>` depend on the system: `crontab` > + is available on POSIX systems, `systemd-timer` is available on Linux > + systems, `launchctl` is available on MacOS and `schtasks` is available > + on Windows. > + By default or when `auto` is specified, the most appropriate scheduler > + for the system is used. On MacOS, `launchctl` is used. On Windows, > + `schtasks` is used. On Linux, `systemd-timers` is used if user systemd > + timers are available, otherwise, `crontab` is used. On all other systems, > + `crontab` is used. > + This portion of the docs can be updated on its own (minus the systemd bits). > diff --git a/builtin/gc.c b/builtin/gc.c > index ef7226d7bc..7c72aa3b99 100644 > --- a/builtin/gc.c > +++ b/builtin/gc.c > @@ -1544,6 +1544,15 @@ static const char *get_frequency(enum schedule_priority schedule) > } > } > > +static int is_launchctl_available(const char *cmd) > +{ > +#ifdef __APPLE__ > + return 1; > +#else > + return 0; > +#endif > +} > + > static char *launchctl_service_name(const char *frequency) > { > struct strbuf label = STRBUF_INIT; > @@ -1710,6 +1719,15 @@ static int launchctl_update_schedule(int run_maintenance, int fd, const char *cm > return launchctl_remove_plists(cmd); > } > > +static int is_schtasks_available(const char *cmd) > +{ > +#ifdef GIT_WINDOWS_NATIVE > + return 1; > +#else > + return 0; > +#endif > +} > + > static char *schtasks_task_name(const char *frequency) > { > struct strbuf label = STRBUF_INIT; > @@ -1872,6 +1890,28 @@ static int schtasks_update_schedule(int run_maintenance, int fd, const char *cmd > return schtasks_remove_tasks(cmd); > } > > +static int is_crontab_available(const char *cmd) > +{ > + static int cached_result = -1; > + struct child_process child = CHILD_PROCESS_INIT; > + > + if (cached_result != -1) > + return cached_result; > + > + strvec_split(&child.args, cmd); > + strvec_push(&child.args, "-l"); > + child.no_stdin = 1; > + child.no_stdout = 1; > + child.no_stderr = 1; > + child.silent_exec_failure = 1; > + > + if (start_command(&child)) > + return cached_result = 0; > + /* Ignore exit code, as an empty crontab will return error. */ > + finish_command(&child); > + return cached_result = 1; > +} > + These is_X_available() methods are valuable helpers. Adding is_systemd_timer_available() in the second patch will be simpler with this framework in place. > +enum scheduler { > + SCHEDULER_INVALID = -1, > + SCHEDULER_AUTO = 0, > + SCHEDULER_CRON = 1, > + SCHEDULER_SYSTEMD = 2, > + SCHEDULER_LAUNCHCTL = 3, > + SCHEDULER_SCHTASKS = 4, > +}; > + > +static const struct { > + int (*is_available)(const char *cmd); > + int (*update_schedule)(int run_maintenance, int fd, const char *cmd); > + const char *cmd; > +} scheduler_fn[] = { > + [SCHEDULER_CRON] = { is_crontab_available, crontab_update_schedule, > + "crontab" }, > + [SCHEDULER_SYSTEMD] = { is_systemd_timer_available, > + systemd_timer_update_schedule, "systemctl" }, > + [SCHEDULER_LAUNCHCTL] = { is_launchctl_available, > + launchctl_update_schedule, "launchctl" }, > + [SCHEDULER_SCHTASKS] = { is_schtasks_available, > + schtasks_update_schedule, "schtasks" }, > +}; This is also good to include, minus the systemd lines. I would also like to see this declaration reformatted. Something like this would be good: static const struct { int (*is_available)(const char *cmd); int (*update_schedule)(int run_maintenance, int fd, const char *cmd); const char *cmd; } scheduler_fn[] = { [SCHEDULER_CRON] = { .is_available = is_crontab_available, .update_schedule = crontab_update_schedule, .cmd = "crontab", }, [SCHEDULER_LAUNCHCTL] = { .is_available = is_launchctl_available, .update_schedule = launchctl_update_schedule, .cmd = "launchctl", }, [SCHEDULER_SCHTASKS] = { .is_available = is_schtasks_available, .update_schedule = schtasks_update_schedule, .cmd = "schtasks", }, }; The use of member names can help if we need to augment this struct later, and the use of commas after the final terms of each block helps the future diff if we add items to the end. > + > +static enum scheduler parse_scheduler(const char *value) > +{ > + if (!value) > + return SCHEDULER_INVALID; > + else if (!strcasecmp(value, "auto")) > + return SCHEDULER_AUTO; > + else if (!strcasecmp(value, "cron") || !strcasecmp(value, "crontab")) > + return SCHEDULER_CRON; > + else if (!strcasecmp(value, "systemd") || > + !strcasecmp(value, "systemd-timer")) > + return SCHEDULER_SYSTEMD; > + else if (!strcasecmp(value, "launchctl")) > + return SCHEDULER_LAUNCHCTL; > + else if (!strcasecmp(value, "schtasks")) > + return SCHEDULER_SCHTASKS; > + else > + return SCHEDULER_INVALID; > +} Good. The systemd stuff can be added in the second patch, making a clear integration point. > +static int maintenance_opt_scheduler(const struct option *opt, const char *arg, > + int unset) > +{ > + enum scheduler *scheduler = opt->value; > + > + if (unset) > + die(_("--no-scheduler is not allowed")); > + > + *scheduler = parse_scheduler(arg); > + > + if (*scheduler == SCHEDULER_INVALID) > + die(_("unrecognized --scheduler argument '%s'"), arg); > + > + return 0; > +} > + > +struct maintenance_start_opts { > + enum scheduler scheduler; > +}; This struct that contains only the enum seems confusing to me. Maybe it will make sense later. > +static void resolve_auto_scheduler(enum scheduler *scheduler) > +{ > + if (*scheduler != SCHEDULER_AUTO) > + return; > + > #if defined(__APPLE__) > -static const char platform_scheduler[] = "launchctl"; > + *scheduler = SCHEDULER_LAUNCHCTL; > + return; > + > #elif defined(GIT_WINDOWS_NATIVE) > -static const char platform_scheduler[] = "schtasks"; > + *scheduler = SCHEDULER_SCHTASKS; > + return; > + > +#elif defined(__linux__) > + if (is_systemd_timer_available("systemctl")) > + *scheduler = SCHEDULER_SYSTEMD; > + else if (is_crontab_available("crontab")) > + *scheduler = SCHEDULER_CRON; > + else > + die(_("neither systemd timers nor crontab are available")); > + return; > + > #else > -static const char platform_scheduler[] = "crontab"; > + *scheduler = SCHEDULER_CRON; > + return; > #endif > +} This diff looks pretty rough. I see that you are making systemctl the default for Linux. Ok. This also seems like it will not be testable in the test suite. > > -static int update_background_schedule(int enable) > +static void validate_scheduler(enum scheduler scheduler) > { > - int result; > - const char *scheduler = platform_scheduler; > - const char *cmd = scheduler; > + const char *cmd; > + > + if (scheduler == SCHEDULER_INVALID) > + BUG("invalid scheduler"); > + if (scheduler == SCHEDULER_AUTO) > + BUG("resolve_auto_scheduler should have been called before"); > + > + cmd = scheduler_fn[scheduler].cmd; > + if (!scheduler_fn[scheduler].is_available(cmd)) > + die(_("%s scheduler is not available"), cmd); > +} > + > +static int update_background_schedule(const struct maintenance_start_opts *opts, > + int enable) > +{ > + unsigned int i; > + int res, result = 0; > + enum scheduler scheduler; > + const char *cmd = NULL; > char *testing; > struct lock_file lk; > char *lock_path = xstrfmt("%s/schedule", the_repository->objects->odb->path); > > + if (hold_lock_file_for_update(&lk, lock_path, LOCK_NO_DEREF) < 0) > + return error(_("another process is scheduling background maintenance")); > + > testing = xstrdup_or_null(getenv("GIT_TEST_MAINT_SCHEDULER")); > if (testing) { > char *sep = strchr(testing, ':'); > if (!sep) > die("GIT_TEST_MAINT_SCHEDULER unparseable: %s", testing); > *sep = '\0'; > - scheduler = testing; > + scheduler = parse_scheduler(testing); > cmd = sep + 1; > + result = scheduler_fn[scheduler].update_schedule( > + enable, get_lock_file_fd(&lk), cmd); > + goto done; I see this 'goto done' is the reason we need to take the lock earlier. The other option would be to put the 'goto done' after the rollback_lock_file(), but this is fine, too. > } > > - if (hold_lock_file_for_update(&lk, lock_path, LOCK_NO_DEREF) < 0) > - return error(_("another process is scheduling background maintenance")); > - > - if (!strcmp(scheduler, "launchctl")) > - result = launchctl_update_schedule(enable, get_lock_file_fd(&lk), cmd); > - else if (!strcmp(scheduler, "schtasks")) > - result = schtasks_update_schedule(enable, get_lock_file_fd(&lk), cmd); > - else if (!strcmp(scheduler, "crontab")) > - result = crontab_update_schedule(enable, get_lock_file_fd(&lk), cmd); > - else > - die("unknown background scheduler: %s", scheduler); > + for (i = 1; i < ARRAY_SIZE(scheduler_fn); i++) { > + int enable_scheduler = enable && (opts->scheduler == i); > + cmd = scheduler_fn[i].cmd; > + if (!scheduler_fn[i].is_available(cmd)) > + continue; > + res = scheduler_fn[i].update_schedule( > + enable_scheduler, get_lock_file_fd(&lk), cmd); > + if (enable_scheduler) > + result = res; > + } This loop is cleaner than the list of else-ifs. > > +done: > rollback_lock_file(&lk); > free(testing); > return result; > } > > -static int maintenance_start(void) > +static const char *const builtin_maintenance_start_usage[] = { > + N_("git maintenance start [--scheduler=<scheduler>]"), NULL > +}; > + > +static int maintenance_start(int argc, const char **argv, const char *prefix) > { > + struct maintenance_start_opts opts; I see you using the struct now and in the helper methods above. While the creation of the struct looks a little strange now, this use matches other patterns in this file and is more flexible to additional options in the future. Thanks. > + struct option builtin_maintenance_start_options[] = { > + OPT_CALLBACK( > + 0, "scheduler", &opts.scheduler, N_("scheduler"), > + N_("scheduler to use to trigger git maintenance run"), > + maintenance_opt_scheduler), nit: these would typically be aligned with the end of the OPT_CALLBACK( opener, with the first set of parameters being on the same line: OPT_CALLBACK(0, "scheduler", &opts.scheduler, N_("scheduler"), N_("scheduler to use to trigger 'git maintenance run'"), maintenance_opt_scheduler), These options frequently run a little long on the line width, which might have been your motivation in adding an extra line. > + OPT_END() > + }; > + memset(&opts, 0, sizeof(opts)); > + > + argc = parse_options(argc, argv, prefix, > + builtin_maintenance_start_options, > + builtin_maintenance_start_usage, 0); > + > + resolve_auto_scheduler(&opts.scheduler); > + validate_scheduler(opts.scheduler); > + > + if (argc > 0) > + usage_with_options(builtin_maintenance_start_usage, > + builtin_maintenance_start_options); nit: "if (argc)" is the more typical pattern in the Git codebase. Also, this check should come right after parse_options(). > if (maintenance_register()) > warning(_("failed to add repo to global config")); > - > - return update_background_schedule(1); > + return update_background_schedule(&opts, 1); > } > > static int maintenance_stop(void) > { > - return update_background_schedule(0); > + return update_background_schedule(NULL, 0); > } > > static const char builtin_maintenance_usage[] = N_("git maintenance <subcommand> [<options>]"); > @@ -2027,7 +2354,7 @@ int cmd_maintenance(int argc, const char **argv, const char *prefix) > if (!strcmp(argv[1], "run")) > return maintenance_run(argc - 1, argv + 1, prefix); > if (!strcmp(argv[1], "start")) > - return maintenance_start(); > + return maintenance_start(argc - 1, argv + 1, prefix); > if (!strcmp(argv[1], "stop")) > return maintenance_stop(); > if (!strcmp(argv[1], "register")) > diff --git a/t/t7900-maintenance.sh b/t/t7900-maintenance.sh > index 2412d8c5c0..6e6316cd90 100755 > --- a/t/t7900-maintenance.sh > +++ b/t/t7900-maintenance.sh I'm not sure how we could achieve it, but it might be good to demonstrate a use of the --scheduler option here in the test script. Thanks, -Stolee
On 2021-05-10 15:25:07+0900, Junio C Hamano <gitster@pobox.com> wrote: > Eric Sunshine <sunshine@sunshineco.com> writes: > > >> I think others have strong opinion on not using "%1$s", > >> and prefer simple "%s" and using "exec_path" twice instead. > > > > I brought it up only because I hadn't seen it in Git sources, and > > wasn't sure if we'd want to start using it. Aside from Ævar, who > > seemed reasonably in favor of it, nobody else chimed in, so it could > > go either way, I suppose. > > If this were a piece of code that _everybody_ would use on _all_ the > supported platforms, I would suggest declaring that this is a > weather-balloon to see if some platforms have trouble using it. But > unfortunately this is not such a piece of code. Dependence on > systemd should strictly be opt-in. Yes, dependence on systemd should be strictly opt-in. Although, I don't use systemd-based distro, so it is irrelevant to me. I think it's none of Git (the project) business to decide which scheduler should be given higher priority. It's crontab when maintenance was introduced, it should be crontab, now. Another point for eternal bikeshedding: why do we limit ourselves in crontab and systemd, how about other homebrew schedulers? What should we do if another scheduler raise to be the big star in the scheduler world? I guess we should take some templates for running on {,un}register instead? However, I think such design may open another can of worms. So, I don't know.
Đoàn Trần Công Danh wrote: > Yes, dependence on systemd should be strictly opt-in. > Although, I don't use systemd-based distro, so it is irrelevant to me. > I think it's none of Git (the project) business to decide which > scheduler should be given higher priority. It's crontab when > maintenance was introduced, it should be crontab, now. I do use a systemd-based distro, and I like the option to use systemd units, but let's be honest... 100% of systems with systemd have cron... So...
On 12/05/2021 07:59, Felipe Contreras wrote: > Đoàn Trần Công Danh wrote: >> Yes, dependence on systemd should be strictly opt-in. >> Although, I don't use systemd-based distro, so it is irrelevant to me. >> I think it's none of Git (the project) business to decide which >> scheduler should be given higher priority. It's crontab when >> maintenance was introduced, it should be crontab, now. > > I do use a systemd-based distro, and I like the option to use systemd > units, but let's be honest... > > 100% of systems with systemd have cron... This is untrue, as the commit message points out cron is optional on systems running systemd and there are distributions such as Arch Linux that do not install a cron daemon without explicit user intervention. So... >
Hi Đoàn On 12/05/2021 01:29, Đoàn Trần Công Danh wrote: > On 2021-05-10 15:25:07+0900, Junio C Hamano <gitster@pobox.com> wrote: >> Eric Sunshine <sunshine@sunshineco.com> writes: >> >>>> I think others have strong opinion on not using "%1$s", >>>> and prefer simple "%s" and using "exec_path" twice instead. >>> >>> I brought it up only because I hadn't seen it in Git sources, and >>> wasn't sure if we'd want to start using it. Aside from Ævar, who >>> seemed reasonably in favor of it, nobody else chimed in, so it could >>> go either way, I suppose. >> >> If this were a piece of code that _everybody_ would use on _all_ the >> supported platforms, I would suggest declaring that this is a >> weather-balloon to see if some platforms have trouble using it. But >> unfortunately this is not such a piece of code. Dependence on >> systemd should strictly be opt-in. > > Yes, dependence on systemd should be strictly opt-in. > Although, I don't use systemd-based distro, so it is irrelevant to me. > I think it's none of Git (the project) business to decide which > scheduler should be given higher priority. It's crontab when > maintenance was introduced, it should be crontab, now. You seem to be simultaneously arguing that git should be neutral on the choice of scheduler while saying it should prioritize crontab. The commit message and cover letter list a number of difficulties with the strategy of prioritizing crontab over systemd when both are installed. I think we should aim for the solution that has the most chance of working without user intervention. > Another point for eternal bikeshedding: why do we limit ourselves in > crontab and systemd, how about other homebrew schedulers? What should > we do if another scheduler raise to be the big star in the scheduler > world? We should support the default scheduler on each platform - that was the rod we made for our own back when we decided to use the platform's scheduler rather than having a cross platform git maintenance daemon. It just happens that there are two possible default schedulers on linux so we need to support both of them. Best Wishes Phillip > I guess we should take some templates for running on {,un}register > instead? However, I think such design may open another can of worms. > So, I don't know. > >
On 2021-05-12 14:38:26+0100, Phillip Wood <phillip.wood123@gmail.com> wrote: > > Yes, dependence on systemd should be strictly opt-in. > > Although, I don't use systemd-based distro, so it is irrelevant to me. > > I think it's none of Git (the project) business to decide which > > scheduler should be given higher priority. It's crontab when > > maintenance was introduced, it should be crontab, now. > > You seem to be simultaneously arguing that git should be neutral on the > choice of scheduler while saying it should prioritize crontab. Yes, I'm arguing for git should be neutral on the choice of scheduler. No, I'm not arguing for git should be prioritize crontab, I'm arguing for "princible of least surprise" for no known break-through advantage. FWIW, whatever default scheduler chosen won't affect me, since I don't have systemd-timers to begin with. So ... In addition, I was one of those people pointed out that beside crontab, Linux users nowaday employed different schedulers [1], and the consensus, some how, settled on crontab. I think we shouldn't switch away from crontab if we don't have any compelling reasons. > The commit > message and cover letter list a number of difficulties with the strategy of > prioritizing crontab over systemd when both are installed. I think we should > aim for the solution that has the most chance of working without user > intervention. The solution that has the most chance of working without user intervention is the solution that is the status quo. Promoting systemd-timers to higher priority is a solution requires either user intervention or our supports (which will be carried over our lifetime). > > Another point for eternal bikeshedding: why do we limit ourselves in > > crontab and systemd, how about other homebrew schedulers? What should > > we do if another scheduler raise to be the big star in the scheduler > > world? > > We should support the default scheduler on each platform - that was the rod > we made for our own back when we decided to use the platform's scheduler > rather than having a cross platform git maintenance daemon. It just happens > that there are two possible default schedulers on linux so we need to > support both of them. As noted in [1], some home-brew solutions are very popular solutions among those some community. I'm not arguing that crontab or systemd-timers aren't popular. In fact, I think they're *very* popular, I listed systemd-timers as *first* alternative in the linked email. I'm not against supporting both of them, I was arguing about a generic solution. 1: https://lore.kernel.org/git/20200407005828.GC2568@danh.dev/
Hello Phillip, Le lundi 10 mai 2021, 20:03:58 CEST Phillip Wood a écrit : > > + unit = "# This file was created and is maintained by Git.\n" > > + "# Any edits made in this file might be replaced in the future\n" > > + "# by a Git command.\n" > > + "\n" > > + "[Unit]\n" > > + "Description=Optimize Git repositories data\n" > > + "\n" > > + "[Service]\n" > > + "Type=oneshot\n" > > + "ExecStart=\"%1$s/git\" --exec-path=\"%1$s\" for-each-repo > > --config=maintenance.repo maintenance run --schedule=%%i\n" + > > "LockPersonality=yes\n" > > + "MemoryDenyWriteExecute=yes\n" > > + "NoNewPrivileges=yes\n" > > + "RestrictAddressFamilies=AF_UNIX AF_INET AF_INET6\n" > > + "RestrictNamespaces=yes\n" > > + "RestrictRealtime=yes\n" > > + "RestrictSUIDSGID=yes\n" > > After a quick read of the systemd.exec man page it is unclear to me if > these Restrict... lines are needed as we already have > NoNewPrivileges=yes - maybe they have some effect if `git maintence` is > run as root? I think that the only thing that `NoNewPrivileges=yes` do is to set the no new privileges flag described in [1] on the process. The `Restrict…` options are enabling some other sandboxing features by blocking some syscalls through a seccomp profile. My understanding of the systemd.exec man page is the other way round, i.e.: as soon as there’s a `Restrict…` option, the `NoNewPrivileges=yes` is implied. So, I would say that strictly speaking `NoNewPrivileges=yes` isn’t needed. But `NoNewPrivileges=yes` doesn’t imply the `Restrict…` options. But I thought that, from a security point of view, it’s better to set as many sandboxing options as possible and be as explicit as possible. [1] https://www.kernel.org/doc/html/latest/userspace-api/no_new_privs.html
diff --git a/Documentation/git-maintenance.txt b/Documentation/git-maintenance.txt index 80ddd33ceb..f012923333 100644 --- a/Documentation/git-maintenance.txt +++ b/Documentation/git-maintenance.txt @@ -181,6 +181,20 @@ OPTIONS `maintenance.<task>.enabled` configured as `true` are considered. See the 'TASKS' section for the list of accepted `<task>` values. +--scheduler=auto|crontab|systemd-timer|launchctl|schtasks:: + When combined with the `start` subcommand, specify the scheduler + to use to run the hourly, daily and weekly executions of + `git maintenance run`. + The possible values for `<scheduler>` depend on the system: `crontab` + is available on POSIX systems, `systemd-timer` is available on Linux + systems, `launchctl` is available on MacOS and `schtasks` is available + on Windows. + By default or when `auto` is specified, the most appropriate scheduler + for the system is used. On MacOS, `launchctl` is used. On Windows, + `schtasks` is used. On Linux, `systemd-timers` is used if user systemd + timers are available, otherwise, `crontab` is used. On all other systems, + `crontab` is used. + TROUBLESHOOTING --------------- @@ -279,6 +293,52 @@ schedule to ensure you are executing the correct binaries in your schedule. +BACKGROUND MAINTENANCE ON LINUX SYSTEMD SYSTEMS +----------------------------------------------- + +While Linux supports `cron`, depending on the distribution, `cron` may +be an optional package not necessarily installed. On modern Linux +distributions, systemd timers are superseding it. + +If user systemd timers are available, they will be used as a replacement +of `cron`. + +In this case, `git maintenance start` will create user systemd timer units +and start the timers. The current list of user-scheduled tasks can be found +by running `systemctl --user list-timers`. The timers written by `git +maintenance start` are similar to this: + +----------------------------------------------------------------------- +$ systemctl --user list-timers +NEXT LEFT LAST PASSED UNIT ACTIVATES +Thu 2021-04-29 19:00:00 CEST 42min left Thu 2021-04-29 18:00:11 CEST 17min ago git-maintenance@hourly.timer git-maintenance@hourly.service +Fri 2021-04-30 00:00:00 CEST 5h 42min left Thu 2021-04-29 00:00:11 CEST 18h ago git-maintenance@daily.timer git-maintenance@daily.service +Mon 2021-05-03 00:00:00 CEST 3 days left Mon 2021-04-26 00:00:11 CEST 3 days ago git-maintenance@weekly.timer git-maintenance@weekly.service +----------------------------------------------------------------------- + +One timer is registered for each `--schedule=<frequency>` option. + +The definition of the systemd units can be inspected in the following files: + +----------------------------------------------------------------------- +~/.config/systemd/user/git-maintenance@.timer +~/.config/systemd/user/git-maintenance@.service +~/.config/systemd/user/timers.target.wants/git-maintenance@hourly.timer +~/.config/systemd/user/timers.target.wants/git-maintenance@daily.timer +~/.config/systemd/user/timers.target.wants/git-maintenance@weekly.timer +----------------------------------------------------------------------- + +`git maintenance start` will overwrite these files and start the timer +again with `systemctl --user`, so any customization should be done by +creating a drop-in file, i.e. a `.conf` suffixed file in the +`~/.config/systemd/user/git-maintenance@.service.d` directory. + +`git maintenance stop` will stop the user systemd timers and delete +the above mentioned files. + +For more details, see systemd.timer(5) + + BACKGROUND MAINTENANCE ON MACOS SYSTEMS --------------------------------------- diff --git a/builtin/gc.c b/builtin/gc.c index ef7226d7bc..7c72aa3b99 100644 --- a/builtin/gc.c +++ b/builtin/gc.c @@ -1544,6 +1544,15 @@ static const char *get_frequency(enum schedule_priority schedule) } } +static int is_launchctl_available(const char *cmd) +{ +#ifdef __APPLE__ + return 1; +#else + return 0; +#endif +} + static char *launchctl_service_name(const char *frequency) { struct strbuf label = STRBUF_INIT; @@ -1710,6 +1719,15 @@ static int launchctl_update_schedule(int run_maintenance, int fd, const char *cm return launchctl_remove_plists(cmd); } +static int is_schtasks_available(const char *cmd) +{ +#ifdef GIT_WINDOWS_NATIVE + return 1; +#else + return 0; +#endif +} + static char *schtasks_task_name(const char *frequency) { struct strbuf label = STRBUF_INIT; @@ -1872,6 +1890,28 @@ static int schtasks_update_schedule(int run_maintenance, int fd, const char *cmd return schtasks_remove_tasks(cmd); } +static int is_crontab_available(const char *cmd) +{ + static int cached_result = -1; + struct child_process child = CHILD_PROCESS_INIT; + + if (cached_result != -1) + return cached_result; + + strvec_split(&child.args, cmd); + strvec_push(&child.args, "-l"); + child.no_stdin = 1; + child.no_stdout = 1; + child.no_stderr = 1; + child.silent_exec_failure = 1; + + if (start_command(&child)) + return cached_result = 0; + /* Ignore exit code, as an empty crontab will return error. */ + finish_command(&child); + return cached_result = 1; +} + #define BEGIN_LINE "# BEGIN GIT MAINTENANCE SCHEDULE" #define END_LINE "# END GIT MAINTENANCE SCHEDULE" @@ -1959,61 +1999,348 @@ static int crontab_update_schedule(int run_maintenance, int fd, const char *cmd) return result; } +static int is_systemd_timer_available(const char *cmd) +{ +#ifdef __linux__ + static int cached_result = -1; + struct child_process child = CHILD_PROCESS_INIT; + + if (cached_result != -1) + return cached_result; + + strvec_split(&child.args, cmd); + strvec_pushl(&child.args, "--user", "list-timers", NULL); + child.no_stdin = 1; + child.no_stdout = 1; + child.no_stderr = 1; + child.silent_exec_failure = 1; + + if (start_command(&child)) + return cached_result = 0; + if (finish_command(&child)) + return cached_result = 0; + return cached_result = 1; +#else + return 0; +#endif +} + +static char *xdg_config_home_systemd(const char *filename) +{ + const char *home, *config_home; + + assert(filename); + config_home = getenv("XDG_CONFIG_HOME"); + if (config_home && *config_home) + return mkpathdup("%s/systemd/user/%s", config_home, filename); + + home = getenv("HOME"); + if (home) + return mkpathdup("%s/.config/systemd/user/%s", home, filename); + + die(_("failed to get $XDG_CONFIG_HOME and $HOME")); +} + +static int systemd_timer_enable_unit(int enable, + enum schedule_priority schedule, + const char *cmd) +{ + struct child_process child = CHILD_PROCESS_INIT; + const char *frequency = get_frequency(schedule); + + strvec_split(&child.args, cmd); + strvec_pushl(&child.args, "--user", enable ? "enable" : "disable", + "--now", NULL); + strvec_pushf(&child.args, "git-maintenance@%s.timer", frequency); + + if (start_command(&child)) + die(_("failed to run systemctl")); + return finish_command(&child); +} + +static int systemd_timer_delete_unit_templates(void) +{ + char *filename = xdg_config_home_systemd("git-maintenance@.timer"); + unlink(filename); + free(filename); + + filename = xdg_config_home_systemd("git-maintenance@.service"); + unlink(filename); + free(filename); + + return 0; +} + +static int systemd_timer_delete_units(const char *cmd) +{ + return systemd_timer_enable_unit(0, SCHEDULE_HOURLY, cmd) || + systemd_timer_enable_unit(0, SCHEDULE_DAILY, cmd) || + systemd_timer_enable_unit(0, SCHEDULE_WEEKLY, cmd) || + systemd_timer_delete_unit_templates(); +} + +static int systemd_timer_write_unit_templates(const char *exec_path) +{ + char *filename; + FILE *file; + const char *unit; + + filename = xdg_config_home_systemd("git-maintenance@.timer"); + if (safe_create_leading_directories(filename)) + die(_("failed to create directories for '%s'"), filename); + file = xfopen(filename, "w"); + free(filename); + + unit = "# This file was created and is maintained by Git.\n" + "# Any edits made in this file might be replaced in the future\n" + "# by a Git command.\n" + "\n" + "[Unit]\n" + "Description=Optimize Git repositories data\n" + "\n" + "[Timer]\n" + "OnCalendar=%i\n" + "Persistent=true\n" + "\n" + "[Install]\n" + "WantedBy=timers.target\n"; + fputs(unit, file); + fclose(file); + + filename = xdg_config_home_systemd("git-maintenance@.service"); + if (safe_create_leading_directories(filename)) + die(_("failed to create directories for '%s'"), filename); + file = xfopen(filename, "w"); + free(filename); + + unit = "# This file was created and is maintained by Git.\n" + "# Any edits made in this file might be replaced in the future\n" + "# by a Git command.\n" + "\n" + "[Unit]\n" + "Description=Optimize Git repositories data\n" + "\n" + "[Service]\n" + "Type=oneshot\n" + "ExecStart=\"%1$s/git\" --exec-path=\"%1$s\" for-each-repo --config=maintenance.repo maintenance run --schedule=%%i\n" + "LockPersonality=yes\n" + "MemoryDenyWriteExecute=yes\n" + "NoNewPrivileges=yes\n" + "RestrictAddressFamilies=AF_UNIX AF_INET AF_INET6\n" + "RestrictNamespaces=yes\n" + "RestrictRealtime=yes\n" + "RestrictSUIDSGID=yes\n" + "SystemCallArchitectures=native\n" + "SystemCallFilter=@system-service\n"; + fprintf(file, unit, exec_path); + fclose(file); + + return 0; +} + +static int systemd_timer_setup_units(const char *cmd) +{ + const char *exec_path = git_exec_path(); + + return systemd_timer_write_unit_templates(exec_path) || + systemd_timer_enable_unit(1, SCHEDULE_HOURLY, cmd) || + systemd_timer_enable_unit(1, SCHEDULE_DAILY, cmd) || + systemd_timer_enable_unit(1, SCHEDULE_WEEKLY, cmd); +} + +static int systemd_timer_update_schedule(int run_maintenance, int fd, + const char *cmd) +{ + if (run_maintenance) + return systemd_timer_setup_units(cmd); + else + return systemd_timer_delete_units(cmd); +} + +enum scheduler { + SCHEDULER_INVALID = -1, + SCHEDULER_AUTO = 0, + SCHEDULER_CRON = 1, + SCHEDULER_SYSTEMD = 2, + SCHEDULER_LAUNCHCTL = 3, + SCHEDULER_SCHTASKS = 4, +}; + +static const struct { + int (*is_available)(const char *cmd); + int (*update_schedule)(int run_maintenance, int fd, const char *cmd); + const char *cmd; +} scheduler_fn[] = { + [SCHEDULER_CRON] = { is_crontab_available, crontab_update_schedule, + "crontab" }, + [SCHEDULER_SYSTEMD] = { is_systemd_timer_available, + systemd_timer_update_schedule, "systemctl" }, + [SCHEDULER_LAUNCHCTL] = { is_launchctl_available, + launchctl_update_schedule, "launchctl" }, + [SCHEDULER_SCHTASKS] = { is_schtasks_available, + schtasks_update_schedule, "schtasks" }, +}; + +static enum scheduler parse_scheduler(const char *value) +{ + if (!value) + return SCHEDULER_INVALID; + else if (!strcasecmp(value, "auto")) + return SCHEDULER_AUTO; + else if (!strcasecmp(value, "cron") || !strcasecmp(value, "crontab")) + return SCHEDULER_CRON; + else if (!strcasecmp(value, "systemd") || + !strcasecmp(value, "systemd-timer")) + return SCHEDULER_SYSTEMD; + else if (!strcasecmp(value, "launchctl")) + return SCHEDULER_LAUNCHCTL; + else if (!strcasecmp(value, "schtasks")) + return SCHEDULER_SCHTASKS; + else + return SCHEDULER_INVALID; +} + +static int maintenance_opt_scheduler(const struct option *opt, const char *arg, + int unset) +{ + enum scheduler *scheduler = opt->value; + + if (unset) + die(_("--no-scheduler is not allowed")); + + *scheduler = parse_scheduler(arg); + + if (*scheduler == SCHEDULER_INVALID) + die(_("unrecognized --scheduler argument '%s'"), arg); + + return 0; +} + +struct maintenance_start_opts { + enum scheduler scheduler; +}; + +static void resolve_auto_scheduler(enum scheduler *scheduler) +{ + if (*scheduler != SCHEDULER_AUTO) + return; + #if defined(__APPLE__) -static const char platform_scheduler[] = "launchctl"; + *scheduler = SCHEDULER_LAUNCHCTL; + return; + #elif defined(GIT_WINDOWS_NATIVE) -static const char platform_scheduler[] = "schtasks"; + *scheduler = SCHEDULER_SCHTASKS; + return; + +#elif defined(__linux__) + if (is_systemd_timer_available("systemctl")) + *scheduler = SCHEDULER_SYSTEMD; + else if (is_crontab_available("crontab")) + *scheduler = SCHEDULER_CRON; + else + die(_("neither systemd timers nor crontab are available")); + return; + #else -static const char platform_scheduler[] = "crontab"; + *scheduler = SCHEDULER_CRON; + return; #endif +} -static int update_background_schedule(int enable) +static void validate_scheduler(enum scheduler scheduler) { - int result; - const char *scheduler = platform_scheduler; - const char *cmd = scheduler; + const char *cmd; + + if (scheduler == SCHEDULER_INVALID) + BUG("invalid scheduler"); + if (scheduler == SCHEDULER_AUTO) + BUG("resolve_auto_scheduler should have been called before"); + + cmd = scheduler_fn[scheduler].cmd; + if (!scheduler_fn[scheduler].is_available(cmd)) + die(_("%s scheduler is not available"), cmd); +} + +static int update_background_schedule(const struct maintenance_start_opts *opts, + int enable) +{ + unsigned int i; + int res, result = 0; + enum scheduler scheduler; + const char *cmd = NULL; char *testing; struct lock_file lk; char *lock_path = xstrfmt("%s/schedule", the_repository->objects->odb->path); + if (hold_lock_file_for_update(&lk, lock_path, LOCK_NO_DEREF) < 0) + return error(_("another process is scheduling background maintenance")); + testing = xstrdup_or_null(getenv("GIT_TEST_MAINT_SCHEDULER")); if (testing) { char *sep = strchr(testing, ':'); if (!sep) die("GIT_TEST_MAINT_SCHEDULER unparseable: %s", testing); *sep = '\0'; - scheduler = testing; + scheduler = parse_scheduler(testing); cmd = sep + 1; + result = scheduler_fn[scheduler].update_schedule( + enable, get_lock_file_fd(&lk), cmd); + goto done; } - if (hold_lock_file_for_update(&lk, lock_path, LOCK_NO_DEREF) < 0) - return error(_("another process is scheduling background maintenance")); - - if (!strcmp(scheduler, "launchctl")) - result = launchctl_update_schedule(enable, get_lock_file_fd(&lk), cmd); - else if (!strcmp(scheduler, "schtasks")) - result = schtasks_update_schedule(enable, get_lock_file_fd(&lk), cmd); - else if (!strcmp(scheduler, "crontab")) - result = crontab_update_schedule(enable, get_lock_file_fd(&lk), cmd); - else - die("unknown background scheduler: %s", scheduler); + for (i = 1; i < ARRAY_SIZE(scheduler_fn); i++) { + int enable_scheduler = enable && (opts->scheduler == i); + cmd = scheduler_fn[i].cmd; + if (!scheduler_fn[i].is_available(cmd)) + continue; + res = scheduler_fn[i].update_schedule( + enable_scheduler, get_lock_file_fd(&lk), cmd); + if (enable_scheduler) + result = res; + } +done: rollback_lock_file(&lk); free(testing); return result; } -static int maintenance_start(void) +static const char *const builtin_maintenance_start_usage[] = { + N_("git maintenance start [--scheduler=<scheduler>]"), NULL +}; + +static int maintenance_start(int argc, const char **argv, const char *prefix) { + struct maintenance_start_opts opts; + struct option builtin_maintenance_start_options[] = { + OPT_CALLBACK( + 0, "scheduler", &opts.scheduler, N_("scheduler"), + N_("scheduler to use to trigger git maintenance run"), + maintenance_opt_scheduler), + OPT_END() + }; + memset(&opts, 0, sizeof(opts)); + + argc = parse_options(argc, argv, prefix, + builtin_maintenance_start_options, + builtin_maintenance_start_usage, 0); + + resolve_auto_scheduler(&opts.scheduler); + validate_scheduler(opts.scheduler); + + if (argc > 0) + usage_with_options(builtin_maintenance_start_usage, + builtin_maintenance_start_options); + if (maintenance_register()) warning(_("failed to add repo to global config")); - - return update_background_schedule(1); + return update_background_schedule(&opts, 1); } static int maintenance_stop(void) { - return update_background_schedule(0); + return update_background_schedule(NULL, 0); } static const char builtin_maintenance_usage[] = N_("git maintenance <subcommand> [<options>]"); @@ -2027,7 +2354,7 @@ int cmd_maintenance(int argc, const char **argv, const char *prefix) if (!strcmp(argv[1], "run")) return maintenance_run(argc - 1, argv + 1, prefix); if (!strcmp(argv[1], "start")) - return maintenance_start(); + return maintenance_start(argc - 1, argv + 1, prefix); if (!strcmp(argv[1], "stop")) return maintenance_stop(); if (!strcmp(argv[1], "register")) diff --git a/t/t7900-maintenance.sh b/t/t7900-maintenance.sh index 2412d8c5c0..6e6316cd90 100755 --- a/t/t7900-maintenance.sh +++ b/t/t7900-maintenance.sh @@ -20,6 +20,20 @@ test_xmllint () { fi } +test_lazy_prereq SYSTEMD_ANALYZE ' + systemd-analyze --help >out && + grep verify out +' + +test_systemd_analyze_verify () { + if test_have_prereq SYSTEMD_ANALYZE + then + systemd-analyze verify "$@" + else + true + fi +} + test_expect_success 'help text' ' test_expect_code 129 git maintenance -h 2>err && test_i18ngrep "usage: git maintenance <subcommand>" err && @@ -615,6 +629,43 @@ test_expect_success 'start and stop Windows maintenance' ' test_cmp expect args ' +test_expect_success 'start and stop Linux/systemd maintenance' ' + write_script print-args <<-\EOF && + echo $* >>args + EOF + + rm -f args && + GIT_TEST_MAINT_SCHEDULER="systemd:./print-args" git maintenance start && + + # start registers the repo + git config --get --global --fixed-value maintenance.repo "$(pwd)" && + + test_systemd_analyze_verify "$HOME/.config/systemd/user/git-maintenance@.service" && + + rm -f expect && + for frequency in hourly daily weekly + do + echo "--user enable --now git-maintenance@${frequency}.timer" >>expect || return 1 + done && + test_cmp expect args && + + rm -f args && + GIT_TEST_MAINT_SCHEDULER="systemd:./print-args" git maintenance stop && + + # stop does not unregister the repo + git config --get --global --fixed-value maintenance.repo "$(pwd)" && + + test_path_is_missing "$HOME/.config/systemd/user/git-maintenance@.timer" && + test_path_is_missing "$HOME/.config/systemd/user/git-maintenance@.service" && + + rm -f expect && + for frequency in hourly daily weekly + do + echo "--user disable --now git-maintenance@${frequency}.timer" >>expect || return 1 + done && + test_cmp expect args +' + test_expect_success 'register preserves existing strategy' ' git config maintenance.strategy none && git maintenance register &&
The existing mechanism for scheduling background maintenance is done through cron. On Linux systems managed by systemd, systemd provides an alternative to schedule recurring tasks: systemd timers. The main motivations to implement systemd timers in addition to cron are: * cron is optional and Linux systems running systemd might not have it installed. * The execution of `crontab -l` can tell us if cron is installed but not if the daemon is actually running. * With systemd, each service is run in its own cgroup and its logs are tagged by the service inside journald. With cron, all scheduled tasks are running in the cron daemon cgroup and all the logs of the user-scheduled tasks are pretended to belong to the system cron service. Concretely, a user that doesn’t have access to the system logs won’t have access to the log of its own tasks scheduled by cron whereas he will have access to the log of its own tasks scheduled by systemd timer. Although `cron` attempts to send email, that email may go unseen by the user because these days, local mailboxes are not heavily used anymore. In order to choose which scheduler to use between `cron` and user systemd timers, a new option `--scheduler=auto|cron|systemd|launchctl|schtasks` has been added to `git maintenance start`. When `git maintenance start --scheduler=XXX` is run, it not only registers `git maintenance run` tasks in the scheduler XXX, it also removes the `git maintenance run` tasks from all the other schedulers to ensure we cannot have two schedulers launching concurrent identical tasks. The default value is `auto` which chooses a suitable scheduler for the system. On Linux, if user systemd timers are available, they will be used as git maintenance scheduler. If not, `cron` will be used if it is available. If none is available, it will fail. `git maintenance stop` doesn't have any `--scheduler` parameter because this command will try to remove the `git maintenance run` tasks from all the available schedulers. In order to schedule git maintenance, we need two unit template files: * ~/.config/systemd/user/git-maintenance@.service to define the command to be started by systemd and * ~/.config/systemd/user/git-maintenance@.timer to define the schedule at which the command should be run. Those units are templates that are parametrized by the frequency. Based on those templates, 3 timers are started: * git-maintenance@hourly.timer * git-maintenance@daily.timer * git-maintenance@weekly.timer The command launched by those three timers are the same than with the other scheduling methods: git for-each-repo --config=maintenance.repo maintenance run --schedule=%i with the full path for git to ensure that the version of git launched for the scheduled maintenance is the same as the one used to run `maintenance start`. The timer unit contains `Persistent=true` so that, if the computer is powered down when a maintenance task should run, the task will be run when the computer is back powered on. Signed-off-by: Lénaïc Huard <lenaic@lhuard.fr> --- Documentation/git-maintenance.txt | 60 +++++ builtin/gc.c | 375 ++++++++++++++++++++++++++++-- t/t7900-maintenance.sh | 51 ++++ 3 files changed, 462 insertions(+), 24 deletions(-)