kernel
/
git
mirror of https://git.kernel.org/pub/scm/git/git.git
1
0
Fork 0
Code Releases Activity
Browse Source

Merge branch 'lh/systemd-timers' 

"git maintenance" scheduler learned to use systemd timers as a
possible backend.

* lh/systemd-timers:
  maintenance: add support for systemd timers on Linux
  maintenance: `git maintenance run` learned `--scheduler=<scheduler>`
  cache.h: Introduce a generic "xdg_config_home_for(…)" function
maint
Junio C Hamano 4 years ago
parent
76f5fdc203 b681b191f9
commit
ed8794ef7a
5 changed files with 694 additions and 80 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 57
      Documentation/git-maintenance.txt
  2. 583
      builtin/gc.c
  3. 7
      cache.h
  4. 13
      path.c
  5. 114
      t/t7900-maintenance.sh

57
Documentation/git-maintenance.txt
Unescape View File

@ -179,6 +179,17 @@ OPTIONS @@ -179,6 +179,17 @@ 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
for running the hourly, daily and weekly executions of
`git maintenance run`.
Possible values for `<scheduler>` are `auto`, `crontab`
(POSIX), `systemd-timer` (Linux), `launchctl` (macOS), and
`schtasks` (Windows). When `auto` is specified, the
appropriate platform-specific scheduler is used; on Linux,
`systemd-timer` is used if available, otherwise
`crontab`. Default is `auto`.


TROUBLESHOOTING
---------------
@ -277,6 +288,52 @@ schedule to ensure you are executing the correct binaries in your @@ -277,6 +288,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
---------------------------------------


583
builtin/gc.c
Unescape View File

@ -1529,6 +1529,93 @@ static const char *get_frequency(enum schedule_priority schedule) @@ -1529,6 +1529,93 @@ static const char *get_frequency(enum schedule_priority schedule)
}
}

/*
* get_schedule_cmd` reads the GIT_TEST_MAINT_SCHEDULER environment variable
* to mock the schedulers that `git maintenance start` rely on.
*
* For test purpose, GIT_TEST_MAINT_SCHEDULER can be set to a comma-separated
* list of colon-separated key/value pairs where each pair contains a scheduler
* and its corresponding mock.
*
* * If $GIT_TEST_MAINT_SCHEDULER is not set, return false and leave the
* arguments unmodified.
*
* * If $GIT_TEST_MAINT_SCHEDULER is set, return true.
* In this case, the *cmd value is read as input.
*
* * if the input value *cmd is the key of one of the comma-separated list
* item, then *is_available is set to true and *cmd is modified and becomes
* the mock command.
*
* * if the input value *cmd isn’t the key of any of the comma-separated list
* item, then *is_available is set to false.
*
* Ex.:
* GIT_TEST_MAINT_SCHEDULER not set
* +-------+-------------------------------------------------+
* | Input | Output |
* | *cmd | return code | *cmd | *is_available |
* +-------+-------------+-------------------+---------------+
* | "foo" | false | "foo" (unchanged) | (unchanged) |
* +-------+-------------+-------------------+---------------+
*
* GIT_TEST_MAINT_SCHEDULER set to “foo:./mock_foo.sh,bar:./mock_bar.sh”
* +-------+-------------------------------------------------+
* | Input | Output |
* | *cmd | return code | *cmd | *is_available |
* +-------+-------------+-------------------+---------------+
* | "foo" | true | "./mock.foo.sh" | true |
* | "qux" | true | "qux" (unchanged) | false |
* +-------+-------------+-------------------+---------------+
*/
static int get_schedule_cmd(const char **cmd, int *is_available)
{
char *testing = xstrdup_or_null(getenv("GIT_TEST_MAINT_SCHEDULER"));
struct string_list_item *item;
struct string_list list = STRING_LIST_INIT_NODUP;

if (!testing)
return 0;

if (is_available)
*is_available = 0;

string_list_split_in_place(&list, testing, ',', -1);
for_each_string_list_item(item, &list) {
struct string_list pair = STRING_LIST_INIT_NODUP;

if (string_list_split_in_place(&pair, item->string, ':', 2) != 2)
continue;

if (!strcmp(*cmd, pair.items[0].string)) {
*cmd = pair.items[1].string;
if (is_available)
*is_available = 1;
string_list_clear(&list, 0);
UNLEAK(testing);
return 1;
}
}

string_list_clear(&list, 0);
free(testing);
return 1;
}

static int is_launchctl_available(void)
{
const char *cmd = "launchctl";
int is_available;
if (get_schedule_cmd(&cmd, &is_available))
return is_available;

#ifdef __APPLE__
return 1;
#else
return 0;
#endif
}

static char *launchctl_service_name(const char *frequency)
{
struct strbuf label = STRBUF_INIT;
@ -1555,19 +1642,17 @@ static char *launchctl_get_uid(void) @@ -1555,19 +1642,17 @@ static char *launchctl_get_uid(void)
return xstrfmt("gui/%d", getuid());
}

static int launchctl_boot_plist(int enable, const char *filename, const char *cmd)
static int launchctl_boot_plist(int enable, const char *filename)
{
const char *cmd = "launchctl";
int result;
struct child_process child = CHILD_PROCESS_INIT;
char *uid = launchctl_get_uid();

get_schedule_cmd(&cmd, NULL);
strvec_split(&child.args, cmd);
if (enable)
strvec_push(&child.args, "bootstrap");
else
strvec_push(&child.args, "bootout");
strvec_push(&child.args, uid);
strvec_push(&child.args, filename);
strvec_pushl(&child.args, enable ? "bootstrap" : "bootout", uid,
filename, NULL);

child.no_stderr = 1;
child.no_stdout = 1;
@ -1581,23 +1666,23 @@ static int launchctl_boot_plist(int enable, const char *filename, const char *cm @@ -1581,23 +1666,23 @@ static int launchctl_boot_plist(int enable, const char *filename, const char *cm
return result;
}

static int launchctl_remove_plist(enum schedule_priority schedule, const char *cmd)
static int launchctl_remove_plist(enum schedule_priority schedule)
{
const char *frequency = get_frequency(schedule);
char *name = launchctl_service_name(frequency);
char *filename = launchctl_service_filename(name);
int result = launchctl_boot_plist(0, filename, cmd);
int result = launchctl_boot_plist(0, filename);
unlink(filename);
free(filename);
free(name);
return result;
}

static int launchctl_remove_plists(const char *cmd)
static int launchctl_remove_plists(void)
{
return launchctl_remove_plist(SCHEDULE_HOURLY, cmd) ||
launchctl_remove_plist(SCHEDULE_DAILY, cmd) ||
launchctl_remove_plist(SCHEDULE_WEEKLY, cmd);
return launchctl_remove_plist(SCHEDULE_HOURLY) ||
launchctl_remove_plist(SCHEDULE_DAILY) ||
launchctl_remove_plist(SCHEDULE_WEEKLY);
}

static int launchctl_list_contains_plist(const char *name, const char *cmd)
@ -1623,7 +1708,7 @@ static int launchctl_list_contains_plist(const char *name, const char *cmd) @@ -1623,7 +1708,7 @@ static int launchctl_list_contains_plist(const char *name, const char *cmd)
return !result;
}

static int launchctl_schedule_plist(const char *exec_path, enum schedule_priority schedule, const char *cmd)
static int launchctl_schedule_plist(const char *exec_path, enum schedule_priority schedule)
{
int i, fd;
const char *preamble, *repeat;
@ -1634,7 +1719,9 @@ static int launchctl_schedule_plist(const char *exec_path, enum schedule_priorit @@ -1634,7 +1719,9 @@ static int launchctl_schedule_plist(const char *exec_path, enum schedule_priorit
static unsigned long lock_file_timeout_ms = ULONG_MAX;
struct strbuf plist = STRBUF_INIT, plist2 = STRBUF_INIT;
struct stat st;
const char *cmd = "launchctl";

get_schedule_cmd(&cmd, NULL);
preamble = "<?xml version=\"1.0\"?>\n"
"<!DOCTYPE plist PUBLIC \"-//Apple//DTD PLIST 1.0//EN\" \"http://www.apple.com/DTDs/PropertyList-1.0.dtd\">\n"
"<plist version=\"1.0\">"
@ -1715,8 +1802,8 @@ static int launchctl_schedule_plist(const char *exec_path, enum schedule_priorit @@ -1715,8 +1802,8 @@ static int launchctl_schedule_plist(const char *exec_path, enum schedule_priorit
die_errno(_("could not write '%s'"), filename);

/* bootout might fail if not already running, so ignore */
launchctl_boot_plist(0, filename, cmd);
if (launchctl_boot_plist(1, filename, cmd))
launchctl_boot_plist(0, filename);
if (launchctl_boot_plist(1, filename))
die(_("failed to bootstrap service %s"), filename);
}

@ -1727,21 +1814,35 @@ static int launchctl_schedule_plist(const char *exec_path, enum schedule_priorit @@ -1727,21 +1814,35 @@ static int launchctl_schedule_plist(const char *exec_path, enum schedule_priorit
return 0;
}

static int launchctl_add_plists(const char *cmd)
static int launchctl_add_plists(void)
{
const char *exec_path = git_exec_path();

return launchctl_schedule_plist(exec_path, SCHEDULE_HOURLY, cmd) ||
launchctl_schedule_plist(exec_path, SCHEDULE_DAILY, cmd) ||
launchctl_schedule_plist(exec_path, SCHEDULE_WEEKLY, cmd);
return launchctl_schedule_plist(exec_path, SCHEDULE_HOURLY) ||
launchctl_schedule_plist(exec_path, SCHEDULE_DAILY) ||
launchctl_schedule_plist(exec_path, SCHEDULE_WEEKLY);
}

static int launchctl_update_schedule(int run_maintenance, int fd, const char *cmd)
static int launchctl_update_schedule(int run_maintenance, int fd)
{
if (run_maintenance)
return launchctl_add_plists(cmd);
return launchctl_add_plists();
else
return launchctl_remove_plists(cmd);
return launchctl_remove_plists();
}

static int is_schtasks_available(void)
{
const char *cmd = "schtasks";
int is_available;
if (get_schedule_cmd(&cmd, &is_available))
return is_available;

#ifdef GIT_WINDOWS_NATIVE
return 1;
#else
return 0;
#endif
}

static char *schtasks_task_name(const char *frequency)
@ -1751,13 +1852,15 @@ static char *schtasks_task_name(const char *frequency) @@ -1751,13 +1852,15 @@ static char *schtasks_task_name(const char *frequency)
return strbuf_detach(&label, NULL);
}

static int schtasks_remove_task(enum schedule_priority schedule, const char *cmd)
static int schtasks_remove_task(enum schedule_priority schedule)
{
const char *cmd = "schtasks";
int result;
struct strvec args = STRVEC_INIT;
const char *frequency = get_frequency(schedule);
char *name = schtasks_task_name(frequency);

get_schedule_cmd(&cmd, NULL);
strvec_split(&args, cmd);
strvec_pushl(&args, "/delete", "/tn", name, "/f", NULL);

@ -1768,15 +1871,16 @@ static int schtasks_remove_task(enum schedule_priority schedule, const char *cmd @@ -1768,15 +1871,16 @@ static int schtasks_remove_task(enum schedule_priority schedule, const char *cmd
return result;
}

static int schtasks_remove_tasks(const char *cmd)
static int schtasks_remove_tasks(void)
{
return schtasks_remove_task(SCHEDULE_HOURLY, cmd) ||
schtasks_remove_task(SCHEDULE_DAILY, cmd) ||
schtasks_remove_task(SCHEDULE_WEEKLY, cmd);
return schtasks_remove_task(SCHEDULE_HOURLY) ||
schtasks_remove_task(SCHEDULE_DAILY) ||
schtasks_remove_task(SCHEDULE_WEEKLY);
}

static int schtasks_schedule_task(const char *exec_path, enum schedule_priority schedule, const char *cmd)
static int schtasks_schedule_task(const char *exec_path, enum schedule_priority schedule)
{
const char *cmd = "schtasks";
int result;
struct child_process child = CHILD_PROCESS_INIT;
const char *xml;
@ -1785,6 +1889,8 @@ static int schtasks_schedule_task(const char *exec_path, enum schedule_priority @@ -1785,6 +1889,8 @@ static int schtasks_schedule_task(const char *exec_path, enum schedule_priority
char *name = schtasks_task_name(frequency);
struct strbuf tfilename = STRBUF_INIT;

get_schedule_cmd(&cmd, NULL);

strbuf_addf(&tfilename, "%s/schedule_%s_XXXXXX",
get_git_common_dir(), frequency);
tfile = xmks_tempfile(tfilename.buf);
@ -1889,28 +1995,52 @@ static int schtasks_schedule_task(const char *exec_path, enum schedule_priority @@ -1889,28 +1995,52 @@ static int schtasks_schedule_task(const char *exec_path, enum schedule_priority
return result;
}

static int schtasks_schedule_tasks(const char *cmd)
static int schtasks_schedule_tasks(void)
{
const char *exec_path = git_exec_path();

return schtasks_schedule_task(exec_path, SCHEDULE_HOURLY, cmd) ||
schtasks_schedule_task(exec_path, SCHEDULE_DAILY, cmd) ||
schtasks_schedule_task(exec_path, SCHEDULE_WEEKLY, cmd);
return schtasks_schedule_task(exec_path, SCHEDULE_HOURLY) ||
schtasks_schedule_task(exec_path, SCHEDULE_DAILY) ||
schtasks_schedule_task(exec_path, SCHEDULE_WEEKLY);
}

static int schtasks_update_schedule(int run_maintenance, int fd, const char *cmd)
static int schtasks_update_schedule(int run_maintenance, int fd)
{
if (run_maintenance)
return schtasks_schedule_tasks(cmd);
return schtasks_schedule_tasks();
else
return schtasks_remove_tasks(cmd);
return schtasks_remove_tasks();
}

static int is_crontab_available(void)
{
const char *cmd = "crontab";
int is_available;
struct child_process child = CHILD_PROCESS_INIT;

if (get_schedule_cmd(&cmd, &is_available))
return is_available;

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 0;
/* Ignore exit code, as an empty crontab will return error. */
finish_command(&child);
return 1;
}

#define BEGIN_LINE "# BEGIN GIT MAINTENANCE SCHEDULE"
#define END_LINE "# END GIT MAINTENANCE SCHEDULE"

static int crontab_update_schedule(int run_maintenance, int fd, const char *cmd)
static int crontab_update_schedule(int run_maintenance, int fd)
{
const char *cmd = "crontab";
int result = 0;
int in_old_region = 0;
struct child_process crontab_list = CHILD_PROCESS_INIT;
@ -1918,6 +2048,7 @@ static int crontab_update_schedule(int run_maintenance, int fd, const char *cmd) @@ -1918,6 +2048,7 @@ static int crontab_update_schedule(int run_maintenance, int fd, const char *cmd)
FILE *cron_list, *cron_in;
struct strbuf line = STRBUF_INIT;

get_schedule_cmd(&cmd, NULL);
strvec_split(&crontab_list.args, cmd);
strvec_push(&crontab_list.args, "-l");
crontab_list.in = -1;
@ -1994,66 +2125,376 @@ done_editing: @@ -1994,66 +2125,376 @@ done_editing:
return result;
}

static int real_is_systemd_timer_available(void)
{
struct child_process child = CHILD_PROCESS_INIT;

strvec_pushl(&child.args, "systemctl", "--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 0;
if (finish_command(&child))
return 0;
return 1;
}

static int is_systemd_timer_available(void)
{
const char *cmd = "systemctl";
int is_available;

if (get_schedule_cmd(&cmd, &is_available))
return is_available;

return real_is_systemd_timer_available();
}

static char *xdg_config_home_systemd(const char *filename)
{
return xdg_config_home_for("systemd/user", filename);
}

static int systemd_timer_enable_unit(int enable,
enum schedule_priority schedule)
{
const char *cmd = "systemctl";
struct child_process child = CHILD_PROCESS_INIT;
const char *frequency = get_frequency(schedule);

/*
* Disabling the systemd unit while it is already disabled makes
* systemctl print an error.
* Let's ignore it since it means we already are in the expected state:
* the unit is disabled.
*
* On the other hand, enabling a systemd unit which is already enabled
* produces no error.
*/
if (!enable)
child.no_stderr = 1;

get_schedule_cmd(&cmd, NULL);
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))
return error(_("failed to start systemctl"));
if (finish_command(&child))
/*
* Disabling an already disabled systemd unit makes
* systemctl fail.
* Let's ignore this failure.
*
* Enabling an enabled systemd unit doesn't fail.
*/
if (enable)
return error(_("failed to run systemctl"));
return 0;
}

static int systemd_timer_delete_unit_templates(void)
{
int ret = 0;
char *filename = xdg_config_home_systemd("git-maintenance@.timer");
if (unlink(filename) && !is_missing_file_error(errno))
ret = error_errno(_("failed to delete '%s'"), filename);
FREE_AND_NULL(filename);

filename = xdg_config_home_systemd("git-maintenance@.service");
if (unlink(filename) && !is_missing_file_error(errno))
ret = error_errno(_("failed to delete '%s'"), filename);

free(filename);
return ret;
}

static int systemd_timer_delete_units(void)
{
return systemd_timer_enable_unit(0, SCHEDULE_HOURLY) ||
systemd_timer_enable_unit(0, SCHEDULE_DAILY) ||
systemd_timer_enable_unit(0, SCHEDULE_WEEKLY) ||
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)) {
error(_("failed to create directories for '%s'"), filename);
goto error;
}
file = fopen_or_warn(filename, "w");
if (file == NULL)
goto error;

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";
if (fputs(unit, file) == EOF) {
error(_("failed to write to '%s'"), filename);
fclose(file);
goto error;
}
if (fclose(file) == EOF) {
error_errno(_("failed to flush '%s'"), filename);
goto error;
}
free(filename);

filename = xdg_config_home_systemd("git-maintenance@.service");
file = fopen_or_warn(filename, "w");
if (file == NULL)
goto error;

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=\"%s/git\" --exec-path=\"%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";
if (fprintf(file, unit, exec_path, exec_path) < 0) {
error(_("failed to write to '%s'"), filename);
fclose(file);
goto error;
}
if (fclose(file) == EOF) {
error_errno(_("failed to flush '%s'"), filename);
goto error;
}
free(filename);
return 0;

error:
free(filename);
systemd_timer_delete_unit_templates();
return -1;
}

static int systemd_timer_setup_units(void)
{
const char *exec_path = git_exec_path();

int ret = systemd_timer_write_unit_templates(exec_path) ||
systemd_timer_enable_unit(1, SCHEDULE_HOURLY) ||
systemd_timer_enable_unit(1, SCHEDULE_DAILY) ||
systemd_timer_enable_unit(1, SCHEDULE_WEEKLY);
if (ret)
systemd_timer_delete_units();
return ret;
}

static int systemd_timer_update_schedule(int run_maintenance, int fd)
{
if (run_maintenance)
return systemd_timer_setup_units();
else
return systemd_timer_delete_units();
}

enum scheduler {
SCHEDULER_INVALID = -1,
SCHEDULER_AUTO,
SCHEDULER_CRON,
SCHEDULER_SYSTEMD,
SCHEDULER_LAUNCHCTL,
SCHEDULER_SCHTASKS,
};

static const struct {
const char *name;
int (*is_available)(void);
int (*update_schedule)(int run_maintenance, int fd);
} scheduler_fn[] = {
[SCHEDULER_CRON] = {
.name = "crontab",
.is_available = is_crontab_available,
.update_schedule = crontab_update_schedule,
},
[SCHEDULER_SYSTEMD] = {
.name = "systemctl",
.is_available = is_systemd_timer_available,
.update_schedule = systemd_timer_update_schedule,
},
[SCHEDULER_LAUNCHCTL] = {
.name = "launchctl",
.is_available = is_launchctl_available,
.update_schedule = launchctl_update_schedule,
},
[SCHEDULER_SCHTASKS] = {
.name = "schtasks",
.is_available = is_schtasks_available,
.update_schedule = schtasks_update_schedule,
},
};

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;

BUG_ON_OPT_NEG(unset);

*scheduler = parse_scheduler(arg);
if (*scheduler == SCHEDULER_INVALID)
return error(_("unrecognized --scheduler argument '%s'"), arg);
return 0;
}

struct maintenance_start_opts {
enum scheduler scheduler;
};

static enum scheduler resolve_scheduler(enum scheduler scheduler)
{
if (scheduler != SCHEDULER_AUTO)
return scheduler;

#if defined(__APPLE__)
static const char platform_scheduler[] = "launchctl";
return SCHEDULER_LAUNCHCTL;

#elif defined(GIT_WINDOWS_NATIVE)
static const char platform_scheduler[] = "schtasks";
return SCHEDULER_SCHTASKS;

#elif defined(__linux__)
if (is_systemd_timer_available())
return SCHEDULER_SYSTEMD;
else if (is_crontab_available())
return SCHEDULER_CRON;
else
die(_("neither systemd timers nor crontab are available"));

#else
static const char platform_scheduler[] = "crontab";
return SCHEDULER_CRON;
#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;
char *testing;
if (scheduler == SCHEDULER_INVALID)
BUG("invalid scheduler");
if (scheduler == SCHEDULER_AUTO)
BUG("resolve_scheduler should have been called before");

if (!scheduler_fn[scheduler].is_available())
die(_("%s scheduler is not available"),
scheduler_fn[scheduler].name);
}

static int update_background_schedule(const struct maintenance_start_opts *opts,
int enable)
{
unsigned int i;
int result = 0;
struct lock_file lk;
char *lock_path = xstrfmt("%s/schedule", the_repository->objects->odb->path);

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;
cmd = sep + 1;
if (hold_lock_file_for_update(&lk, lock_path, LOCK_NO_DEREF) < 0) {
free(lock_path);
return error(_("another process is scheduling background maintenance"));
}

if (hold_lock_file_for_update(&lk, lock_path, LOCK_NO_DEREF) < 0) {
result = error(_("another process is scheduling background maintenance"));
goto cleanup;
for (i = 1; i < ARRAY_SIZE(scheduler_fn); i++) {
if (enable && opts->scheduler == i)
continue;
if (!scheduler_fn[i].is_available())
continue;
scheduler_fn[i].update_schedule(0, get_lock_file_fd(&lk));
}

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);
if (enable)
result = scheduler_fn[opts->scheduler].update_schedule(
1, get_lock_file_fd(&lk));

rollback_lock_file(&lk);

cleanup:
free(lock_path);
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 = { 0 };
struct option options[] = {
OPT_CALLBACK_F(
0, "scheduler", &opts.scheduler, N_("scheduler"),
N_("scheduler to trigger git maintenance run"),
PARSE_OPT_NONEG, maintenance_opt_scheduler),
OPT_END()
};

argc = parse_options(argc, argv, prefix, options,
builtin_maintenance_start_usage, 0);
if (argc)
usage_with_options(builtin_maintenance_start_usage, options);

opts.scheduler = resolve_scheduler(opts.scheduler);
validate_scheduler(opts.scheduler);

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>]");
@ -2067,7 +2508,7 @@ int cmd_maintenance(int argc, const char **argv, const char *prefix) @@ -2067,7 +2508,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"))

7
cache.h
Unescape View File

@ -1297,6 +1297,13 @@ int is_ntfs_dotmailmap(const char *name); @@ -1297,6 +1297,13 @@ int is_ntfs_dotmailmap(const char *name);
*/
int looks_like_command_line_option(const char *str);

/**
* Return a newly allocated string with the evaluation of
* "$XDG_CONFIG_HOME/$subdir/$filename" if $XDG_CONFIG_HOME is non-empty, otherwise
* "$HOME/.config/$subdir/$filename". Return NULL upon error.
*/
char *xdg_config_home_for(const char *subdir, const char *filename);

/**
* Return a newly allocated string with the evaluation of
* "$XDG_CONFIG_HOME/git/$filename" if $XDG_CONFIG_HOME is non-empty, otherwise

13
path.c
Unescape View File

@ -1510,21 +1510,28 @@ int looks_like_command_line_option(const char *str) @@ -1510,21 +1510,28 @@ int looks_like_command_line_option(const char *str)
return str && str[0] == '-';
}

char *xdg_config_home(const char *filename)
char *xdg_config_home_for(const char *subdir, const char *filename)
{
const char *home, *config_home;

assert(subdir);
assert(filename);
config_home = getenv("XDG_CONFIG_HOME");
if (config_home && *config_home)
return mkpathdup("%s/git/%s", config_home, filename);
return mkpathdup("%s/%s/%s", config_home, subdir, filename);

home = getenv("HOME");
if (home)
return mkpathdup("%s/.config/git/%s", home, filename);
return mkpathdup("%s/.config/%s/%s", home, subdir, filename);

return NULL;
}

char *xdg_config_home(const char *filename)
{
return xdg_config_home_for("git", filename);
}

char *xdg_cache_home(const char *filename)
{
const char *home, *cache_home;

114
t/t7900-maintenance.sh
Unescape View File

@ -20,6 +20,18 @@ test_xmllint () { @@ -20,6 +20,18 @@ 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 "$@"
fi
}

test_expect_success 'help text' '
test_expect_code 129 git maintenance -h 2>err &&
test_i18ngrep "usage: git maintenance <subcommand>" err &&
@ -492,8 +504,21 @@ test_expect_success !MINGW 'register and unregister with regex metacharacters' ' @@ -492,8 +504,21 @@ test_expect_success !MINGW 'register and unregister with regex metacharacters' '
maintenance.repo "$(pwd)/$META"
'

test_expect_success 'start --scheduler=<scheduler>' '
test_expect_code 129 git maintenance start --scheduler=foo 2>err &&
test_i18ngrep "unrecognized --scheduler argument" err &&

test_expect_code 129 git maintenance start --no-scheduler 2>err &&
test_i18ngrep "unknown option" err &&

test_expect_code 128 \
env GIT_TEST_MAINT_SCHEDULER="launchctl:true,schtasks:true" \
git maintenance start --scheduler=crontab 2>err &&
test_i18ngrep "fatal: crontab scheduler is not available" err
'

test_expect_success 'start from empty cron table' '
GIT_TEST_MAINT_SCHEDULER="crontab:test-tool crontab cron.txt" git maintenance start &&
GIT_TEST_MAINT_SCHEDULER="crontab:test-tool crontab cron.txt" git maintenance start --scheduler=crontab &&

# start registers the repo
git config --get --global --fixed-value maintenance.repo "$(pwd)" &&
@ -516,7 +541,7 @@ test_expect_success 'stop from existing schedule' ' @@ -516,7 +541,7 @@ test_expect_success 'stop from existing schedule' '

test_expect_success 'start preserves existing schedule' '
echo "Important information!" >cron.txt &&
GIT_TEST_MAINT_SCHEDULER="crontab:test-tool crontab cron.txt" git maintenance start &&
GIT_TEST_MAINT_SCHEDULER="crontab:test-tool crontab cron.txt" git maintenance start --scheduler=crontab &&
grep "Important information!" cron.txt
'

@ -545,7 +570,7 @@ test_expect_success 'start and stop macOS maintenance' ' @@ -545,7 +570,7 @@ test_expect_success 'start and stop macOS maintenance' '
EOF

rm -f args &&
GIT_TEST_MAINT_SCHEDULER=launchctl:./print-args git maintenance start &&
GIT_TEST_MAINT_SCHEDULER=launchctl:./print-args git maintenance start --scheduler=launchctl &&

# start registers the repo
git config --get --global --fixed-value maintenance.repo "$(pwd)" &&
@ -584,11 +609,11 @@ test_expect_success 'start and stop macOS maintenance' ' @@ -584,11 +609,11 @@ test_expect_success 'start and stop macOS maintenance' '

test_expect_success 'use launchctl list to prevent extra work' '
# ensure we are registered
GIT_TEST_MAINT_SCHEDULER=launchctl:./print-args git maintenance start &&
GIT_TEST_MAINT_SCHEDULER=launchctl:./print-args git maintenance start --scheduler=launchctl &&

# do it again on a fresh args file
rm -f args &&
GIT_TEST_MAINT_SCHEDULER=launchctl:./print-args git maintenance start &&
GIT_TEST_MAINT_SCHEDULER=launchctl:./print-args git maintenance start --scheduler=launchctl &&

ls "$HOME/Library/LaunchAgents" >actual &&
cat >expect <<-\EOF &&
@ -613,7 +638,7 @@ test_expect_success 'start and stop Windows maintenance' ' @@ -613,7 +638,7 @@ test_expect_success 'start and stop Windows maintenance' '
EOF

rm -f args &&
GIT_TEST_MAINT_SCHEDULER="schtasks:./print-args" git maintenance start &&
GIT_TEST_MAINT_SCHEDULER="schtasks:./print-args" git maintenance start --scheduler=schtasks &&

# start registers the repo
git config --get --global --fixed-value maintenance.repo "$(pwd)" &&
@ -636,6 +661,83 @@ test_expect_success 'start and stop Windows maintenance' ' @@ -636,6 +661,83 @@ 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 &&
printf "%s\n" "$*" >>args
EOF

XDG_CONFIG_HOME="$PWD" &&
export XDG_CONFIG_HOME &&
rm -f args &&
GIT_TEST_MAINT_SCHEDULER="systemctl:./print-args" git maintenance start --scheduler=systemd-timer &&

# start registers the repo
git config --get --global --fixed-value maintenance.repo "$(pwd)" &&

test_systemd_analyze_verify "systemd/user/git-maintenance@.service" &&

printf -- "--user enable --now git-maintenance@%s.timer\n" hourly daily weekly >expect &&
test_cmp expect args &&

rm -f args &&
GIT_TEST_MAINT_SCHEDULER="systemctl:./print-args" git maintenance stop &&

# stop does not unregister the repo
git config --get --global --fixed-value maintenance.repo "$(pwd)" &&

test_path_is_missing "systemd/user/git-maintenance@.timer" &&
test_path_is_missing "systemd/user/git-maintenance@.service" &&

printf -- "--user disable --now git-maintenance@%s.timer\n" hourly daily weekly >expect &&
test_cmp expect args
'

test_expect_success 'start and stop when several schedulers are available' '
write_script print-args <<-\EOF &&
printf "%s\n" "$*" | sed "s:gui/[0-9][0-9]*:gui/[UID]:; s:\(schtasks /create .* /xml\).*:\1:;" >>args
EOF

rm -f args &&
GIT_TEST_MAINT_SCHEDULER="systemctl:./print-args systemctl,launchctl:./print-args launchctl,schtasks:./print-args schtasks" git maintenance start --scheduler=systemd-timer &&
printf "launchctl bootout gui/[UID] $pfx/Library/LaunchAgents/org.git-scm.git.%s.plist\n" \
hourly daily weekly >expect &&
printf "schtasks /delete /tn Git Maintenance (%s) /f\n" \
hourly daily weekly >>expect &&
printf -- "systemctl --user enable --now git-maintenance@%s.timer\n" hourly daily weekly >>expect &&
test_cmp expect args &&

rm -f args &&
GIT_TEST_MAINT_SCHEDULER="systemctl:./print-args systemctl,launchctl:./print-args launchctl,schtasks:./print-args schtasks" git maintenance start --scheduler=launchctl &&
printf -- "systemctl --user disable --now git-maintenance@%s.timer\n" hourly daily weekly >expect &&
printf "schtasks /delete /tn Git Maintenance (%s) /f\n" \
hourly daily weekly >>expect &&
for frequency in hourly daily weekly
do
PLIST="$pfx/Library/LaunchAgents/org.git-scm.git.$frequency.plist" &&
echo "launchctl bootout gui/[UID] $PLIST" >>expect &&
echo "launchctl bootstrap gui/[UID] $PLIST" >>expect || return 1
done &&
test_cmp expect args &&

rm -f args &&
GIT_TEST_MAINT_SCHEDULER="systemctl:./print-args systemctl,launchctl:./print-args launchctl,schtasks:./print-args schtasks" git maintenance start --scheduler=schtasks &&
printf -- "systemctl --user disable --now git-maintenance@%s.timer\n" hourly daily weekly >expect &&
printf "launchctl bootout gui/[UID] $pfx/Library/LaunchAgents/org.git-scm.git.%s.plist\n" \
hourly daily weekly >>expect &&
printf "schtasks /create /tn Git Maintenance (%s) /f /xml\n" \
hourly daily weekly >>expect &&
test_cmp expect args &&

rm -f args &&
GIT_TEST_MAINT_SCHEDULER="systemctl:./print-args systemctl,launchctl:./print-args launchctl,schtasks:./print-args schtasks" git maintenance stop &&
printf -- "systemctl --user disable --now git-maintenance@%s.timer\n" hourly daily weekly >expect &&
printf "launchctl bootout gui/[UID] $pfx/Library/LaunchAgents/org.git-scm.git.%s.plist\n" \
hourly daily weekly >>expect &&
printf "schtasks /delete /tn Git Maintenance (%s) /f\n" \
hourly daily weekly >>expect &&
test_cmp expect args
'

test_expect_success 'register preserves existing strategy' '
git config maintenance.strategy none &&
git maintenance register &&

Write Preview
Loading…
Cancel
Save