2007-03-14 01:58:22 +00:00
|
|
|
/*
|
|
|
|
* git gc builtin command
|
|
|
|
*
|
|
|
|
* Cleanup unreachable files and optimize the repository.
|
|
|
|
*
|
|
|
|
* Copyright (c) 2007 James Bowes
|
|
|
|
*
|
|
|
|
* Based on git-gc.sh, which is
|
|
|
|
*
|
|
|
|
* Copyright (c) 2006 Shawn O. Pearce
|
|
|
|
*/
|
|
|
|
|
2007-07-14 23:14:45 +00:00
|
|
|
#include "builtin.h"
|
2007-03-14 01:58:22 +00:00
|
|
|
#include "cache.h"
|
2007-11-02 01:02:27 +00:00
|
|
|
#include "parse-options.h"
|
2007-03-14 01:58:22 +00:00
|
|
|
#include "run-command.h"
|
|
|
|
|
|
|
|
#define FAILED_RUN "failed to run %s"
|
|
|
|
|
2007-11-02 01:02:27 +00:00
|
|
|
static const char * const builtin_gc_usage[] = {
|
|
|
|
"git-gc [options]",
|
|
|
|
NULL
|
|
|
|
};
|
2007-03-14 01:58:22 +00:00
|
|
|
|
Make "git gc" pack all refs by default
I've taught myself to use "git gc" instead of doing the repack explicitly,
but it doesn't actually do what I think it should do.
We've had packed refs for a long time now, and I think it just makes sense
to pack normal branches too. So I end up having to do
git pack-refs --all --prune
in order to get a nice git repo that doesn't have any unnecessary files.
So why not just do that in "git gc"? It's not as if there really is any
downside to packing branches, even if they end up changing later. Quite
often they don't, and even if they do, so what?
Also, make the default for refs packing just be an unambiguous "do it",
rather than "do it by default only for non-bare repositories". If you want
that behaviour, you can always just add a
[gc]
packrefs = notbare
in your ~/.gitconfig file, but I don't actually see why bare would be any
different (except for the broken reason that http-fetching used to be
totally broken, and not doing it just meant that it didn't even get
fixed in a timely manner!).
So here's a trivial patch to make "git gc" do a better job. Hmm?
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2007-05-24 18:41:39 +00:00
|
|
|
static int pack_refs = 1;
|
2007-05-09 19:48:39 +00:00
|
|
|
static int aggressive_window = -1;
|
2007-09-05 20:01:37 +00:00
|
|
|
static int gc_auto_threshold = 6700;
|
2007-09-17 07:55:13 +00:00
|
|
|
static int gc_auto_pack_limit = 20;
|
gc: call "prune --expire 2.weeks.ago" by default
The only reason we did not call "prune" in git-gc was that it is an
inherently dangerous operation: if there is a commit going on, you will
prune loose objects that were just created, and are, in fact, needed by the
commit object just about to be created.
Since it is dangerous, we told users so. That led to many users not even
daring to run it when it was actually safe. Besides, they are users, and
should not have to remember such details as when to call git-gc with
--prune, or to call git-prune directly.
Of course, the consequence was that "git gc --auto" gets triggered much
more often than we would like, since unreferenced loose objects (such as
left-overs from a rebase or a reset --hard) were never pruned.
Alas, git-prune recently learnt the option --expire <minimum-age>, which
makes it a much safer operation. This allows us to call prune from git-gc,
with a grace period of 2 weeks for the unreferenced loose objects (this
value was determined in a discussion on the git list as a safe one).
If you want to override this grace period, just set the config variable
gc.pruneExpire to a different value; an example would be
[gc]
pruneExpire = 6.months.ago
or even "never", if you feel really paranoid.
Note that this new behaviour makes "--prune" be a no-op.
While adding a test to t5304-prune.sh (since it really tests the implicit
call to "prune"), also the original test for "prune --expire" was moved
there from t1410-reflog.sh, where it did not belong.
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
2008-03-12 20:55:47 +00:00
|
|
|
static char *prune_expire = "2.weeks.ago";
|
2007-03-14 01:58:22 +00:00
|
|
|
|
2007-05-09 19:48:39 +00:00
|
|
|
#define MAX_ADD 10
|
Make "git gc" pack all refs by default
I've taught myself to use "git gc" instead of doing the repack explicitly,
but it doesn't actually do what I think it should do.
We've had packed refs for a long time now, and I think it just makes sense
to pack normal branches too. So I end up having to do
git pack-refs --all --prune
in order to get a nice git repo that doesn't have any unnecessary files.
So why not just do that in "git gc"? It's not as if there really is any
downside to packing branches, even if they end up changing later. Quite
often they don't, and even if they do, so what?
Also, make the default for refs packing just be an unambiguous "do it",
rather than "do it by default only for non-bare repositories". If you want
that behaviour, you can always just add a
[gc]
packrefs = notbare
in your ~/.gitconfig file, but I don't actually see why bare would be any
different (except for the broken reason that http-fetching used to be
totally broken, and not doing it just meant that it didn't even get
fixed in a timely manner!).
So here's a trivial patch to make "git gc" do a better job. Hmm?
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2007-05-24 18:41:39 +00:00
|
|
|
static const char *argv_pack_refs[] = {"pack-refs", "--all", "--prune", NULL};
|
2007-03-14 01:58:22 +00:00
|
|
|
static const char *argv_reflog[] = {"reflog", "expire", "--all", NULL};
|
2007-10-11 00:59:19 +00:00
|
|
|
static const char *argv_repack[MAX_ADD] = {"repack", "-d", "-l", NULL};
|
gc: call "prune --expire 2.weeks.ago" by default
The only reason we did not call "prune" in git-gc was that it is an
inherently dangerous operation: if there is a commit going on, you will
prune loose objects that were just created, and are, in fact, needed by the
commit object just about to be created.
Since it is dangerous, we told users so. That led to many users not even
daring to run it when it was actually safe. Besides, they are users, and
should not have to remember such details as when to call git-gc with
--prune, or to call git-prune directly.
Of course, the consequence was that "git gc --auto" gets triggered much
more often than we would like, since unreferenced loose objects (such as
left-overs from a rebase or a reset --hard) were never pruned.
Alas, git-prune recently learnt the option --expire <minimum-age>, which
makes it a much safer operation. This allows us to call prune from git-gc,
with a grace period of 2 weeks for the unreferenced loose objects (this
value was determined in a discussion on the git list as a safe one).
If you want to override this grace period, just set the config variable
gc.pruneExpire to a different value; an example would be
[gc]
pruneExpire = 6.months.ago
or even "never", if you feel really paranoid.
Note that this new behaviour makes "--prune" be a no-op.
While adding a test to t5304-prune.sh (since it really tests the implicit
call to "prune"), also the original test for "prune --expire" was moved
there from t1410-reflog.sh, where it did not belong.
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
2008-03-12 20:55:47 +00:00
|
|
|
static const char *argv_prune[] = {"prune", "--expire", NULL, NULL};
|
2007-03-14 01:58:22 +00:00
|
|
|
static const char *argv_rerere[] = {"rerere", "gc", NULL};
|
|
|
|
|
|
|
|
static int gc_config(const char *var, const char *value)
|
|
|
|
{
|
|
|
|
if (!strcmp(var, "gc.packrefs")) {
|
2008-02-08 14:26:18 +00:00
|
|
|
if (value && !strcmp(value, "notbare"))
|
2007-03-14 01:58:22 +00:00
|
|
|
pack_refs = -1;
|
|
|
|
else
|
|
|
|
pack_refs = git_config_bool(var, value);
|
|
|
|
return 0;
|
|
|
|
}
|
2007-05-09 19:48:39 +00:00
|
|
|
if (!strcmp(var, "gc.aggressivewindow")) {
|
|
|
|
aggressive_window = git_config_int(var, value);
|
|
|
|
return 0;
|
|
|
|
}
|
2007-09-05 20:01:37 +00:00
|
|
|
if (!strcmp(var, "gc.auto")) {
|
|
|
|
gc_auto_threshold = git_config_int(var, value);
|
|
|
|
return 0;
|
|
|
|
}
|
2007-09-17 07:55:13 +00:00
|
|
|
if (!strcmp(var, "gc.autopacklimit")) {
|
|
|
|
gc_auto_pack_limit = git_config_int(var, value);
|
|
|
|
return 0;
|
|
|
|
}
|
gc: call "prune --expire 2.weeks.ago" by default
The only reason we did not call "prune" in git-gc was that it is an
inherently dangerous operation: if there is a commit going on, you will
prune loose objects that were just created, and are, in fact, needed by the
commit object just about to be created.
Since it is dangerous, we told users so. That led to many users not even
daring to run it when it was actually safe. Besides, they are users, and
should not have to remember such details as when to call git-gc with
--prune, or to call git-prune directly.
Of course, the consequence was that "git gc --auto" gets triggered much
more often than we would like, since unreferenced loose objects (such as
left-overs from a rebase or a reset --hard) were never pruned.
Alas, git-prune recently learnt the option --expire <minimum-age>, which
makes it a much safer operation. This allows us to call prune from git-gc,
with a grace period of 2 weeks for the unreferenced loose objects (this
value was determined in a discussion on the git list as a safe one).
If you want to override this grace period, just set the config variable
gc.pruneExpire to a different value; an example would be
[gc]
pruneExpire = 6.months.ago
or even "never", if you feel really paranoid.
Note that this new behaviour makes "--prune" be a no-op.
While adding a test to t5304-prune.sh (since it really tests the implicit
call to "prune"), also the original test for "prune --expire" was moved
there from t1410-reflog.sh, where it did not belong.
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
2008-03-12 20:55:47 +00:00
|
|
|
if (!strcmp(var, "gc.pruneexpire")) {
|
|
|
|
if (!value)
|
|
|
|
return config_error_nonbool(var);
|
|
|
|
if (strcmp(value, "now")) {
|
|
|
|
unsigned long now = approxidate("now");
|
|
|
|
if (approxidate(value) >= now)
|
|
|
|
return error("Invalid %s: '%s'", var, value);
|
|
|
|
}
|
|
|
|
prune_expire = xstrdup(value);
|
|
|
|
return 0;
|
|
|
|
}
|
2007-03-14 01:58:22 +00:00
|
|
|
return git_default_config(var, value);
|
|
|
|
}
|
|
|
|
|
2007-05-09 19:48:39 +00:00
|
|
|
static void append_option(const char **cmd, const char *opt, int max_length)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i = 0; cmd[i]; i++)
|
|
|
|
;
|
|
|
|
|
|
|
|
if (i + 2 >= max_length)
|
|
|
|
die("Too many options specified");
|
|
|
|
cmd[i++] = opt;
|
|
|
|
cmd[i] = NULL;
|
|
|
|
}
|
|
|
|
|
2007-09-17 07:44:17 +00:00
|
|
|
static int too_many_loose_objects(void)
|
2007-09-05 20:01:37 +00:00
|
|
|
{
|
|
|
|
/*
|
|
|
|
* Quickly check if a "gc" is needed, by estimating how
|
|
|
|
* many loose objects there are. Because SHA-1 is evenly
|
|
|
|
* distributed, we can check only one and get a reasonable
|
|
|
|
* estimate.
|
|
|
|
*/
|
|
|
|
char path[PATH_MAX];
|
|
|
|
const char *objdir = get_object_directory();
|
|
|
|
DIR *dir;
|
|
|
|
struct dirent *ent;
|
|
|
|
int auto_threshold;
|
|
|
|
int num_loose = 0;
|
|
|
|
int needed = 0;
|
|
|
|
|
2007-09-17 07:55:13 +00:00
|
|
|
if (gc_auto_threshold <= 0)
|
|
|
|
return 0;
|
|
|
|
|
2007-09-05 20:01:37 +00:00
|
|
|
if (sizeof(path) <= snprintf(path, sizeof(path), "%s/17", objdir)) {
|
|
|
|
warning("insanely long object directory %.*s", 50, objdir);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
dir = opendir(path);
|
|
|
|
if (!dir)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
auto_threshold = (gc_auto_threshold + 255) / 256;
|
|
|
|
while ((ent = readdir(dir)) != NULL) {
|
|
|
|
if (strspn(ent->d_name, "0123456789abcdef") != 38 ||
|
|
|
|
ent->d_name[38] != '\0')
|
|
|
|
continue;
|
|
|
|
if (++num_loose > auto_threshold) {
|
|
|
|
needed = 1;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
closedir(dir);
|
|
|
|
return needed;
|
|
|
|
}
|
|
|
|
|
2007-09-17 07:55:13 +00:00
|
|
|
static int too_many_packs(void)
|
|
|
|
{
|
|
|
|
struct packed_git *p;
|
|
|
|
int cnt;
|
|
|
|
|
|
|
|
if (gc_auto_pack_limit <= 0)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
prepare_packed_git();
|
|
|
|
for (cnt = 0, p = packed_git; p; p = p->next) {
|
|
|
|
char path[PATH_MAX];
|
|
|
|
size_t len;
|
|
|
|
int keep;
|
|
|
|
|
|
|
|
if (!p->pack_local)
|
|
|
|
continue;
|
|
|
|
len = strlen(p->pack_name);
|
|
|
|
if (PATH_MAX <= len + 1)
|
|
|
|
continue; /* oops, give up */
|
|
|
|
memcpy(path, p->pack_name, len-5);
|
|
|
|
memcpy(path + len - 5, ".keep", 6);
|
|
|
|
keep = access(p->pack_name, F_OK) && (errno == ENOENT);
|
|
|
|
if (keep)
|
|
|
|
continue;
|
|
|
|
/*
|
|
|
|
* Perhaps check the size of the pack and count only
|
|
|
|
* very small ones here?
|
|
|
|
*/
|
|
|
|
cnt++;
|
|
|
|
}
|
|
|
|
return gc_auto_pack_limit <= cnt;
|
|
|
|
}
|
|
|
|
|
2007-09-17 07:44:17 +00:00
|
|
|
static int need_to_gc(void)
|
|
|
|
{
|
|
|
|
/*
|
2007-09-17 07:55:13 +00:00
|
|
|
* Setting gc.auto and gc.autopacklimit to 0 or negative can
|
|
|
|
* disable the automatic gc.
|
2007-09-17 07:44:17 +00:00
|
|
|
*/
|
2007-09-17 07:55:13 +00:00
|
|
|
if (gc_auto_threshold <= 0 && gc_auto_pack_limit <= 0)
|
2007-09-17 07:48:39 +00:00
|
|
|
return 0;
|
|
|
|
|
2007-09-17 07:55:13 +00:00
|
|
|
/*
|
|
|
|
* If there are too many loose objects, but not too many
|
|
|
|
* packs, we run "repack -d -l". If there are too many packs,
|
|
|
|
* we run "repack -A -d -l". Otherwise we tell the caller
|
|
|
|
* there is no need.
|
|
|
|
*/
|
|
|
|
if (too_many_packs())
|
2007-10-11 01:00:27 +00:00
|
|
|
append_option(argv_repack, "-A", MAX_ADD);
|
2007-09-17 07:55:13 +00:00
|
|
|
else if (!too_many_loose_objects())
|
|
|
|
return 0;
|
2007-09-17 07:48:39 +00:00
|
|
|
return 1;
|
2007-09-17 07:44:17 +00:00
|
|
|
}
|
|
|
|
|
2007-03-14 01:58:22 +00:00
|
|
|
int cmd_gc(int argc, const char **argv, const char *prefix)
|
|
|
|
{
|
|
|
|
int prune = 0;
|
2007-11-02 01:02:27 +00:00
|
|
|
int aggressive = 0;
|
2007-09-05 20:01:37 +00:00
|
|
|
int auto_gc = 0;
|
2008-02-29 21:53:39 +00:00
|
|
|
int quiet = 0;
|
2007-05-09 19:48:39 +00:00
|
|
|
char buf[80];
|
2007-03-14 01:58:22 +00:00
|
|
|
|
2007-11-02 01:02:27 +00:00
|
|
|
struct option builtin_gc_options[] = {
|
2007-11-06 00:39:00 +00:00
|
|
|
OPT_BOOLEAN(0, "prune", &prune, "prune unreferenced objects"),
|
2007-11-02 01:02:27 +00:00
|
|
|
OPT_BOOLEAN(0, "aggressive", &aggressive, "be more thorough (increased runtime)"),
|
|
|
|
OPT_BOOLEAN(0, "auto", &auto_gc, "enable auto-gc mode"),
|
2008-02-29 21:53:39 +00:00
|
|
|
OPT_BOOLEAN('q', "quiet", &quiet, "suppress progress reports"),
|
2007-11-02 01:02:27 +00:00
|
|
|
OPT_END()
|
|
|
|
};
|
|
|
|
|
2007-03-14 01:58:22 +00:00
|
|
|
git_config(gc_config);
|
|
|
|
|
|
|
|
if (pack_refs < 0)
|
|
|
|
pack_refs = !is_bare_repository();
|
|
|
|
|
2007-11-02 01:02:27 +00:00
|
|
|
argc = parse_options(argc, argv, builtin_gc_options, builtin_gc_usage, 0);
|
|
|
|
if (argc > 0)
|
|
|
|
usage_with_options(builtin_gc_usage, builtin_gc_options);
|
|
|
|
|
|
|
|
if (aggressive) {
|
|
|
|
append_option(argv_repack, "-f", MAX_ADD);
|
|
|
|
if (aggressive_window > 0) {
|
|
|
|
sprintf(buf, "--window=%d", aggressive_window);
|
|
|
|
append_option(argv_repack, buf, MAX_ADD);
|
2007-09-05 20:01:37 +00:00
|
|
|
}
|
2007-03-14 01:58:22 +00:00
|
|
|
}
|
2008-02-29 21:53:39 +00:00
|
|
|
if (quiet)
|
|
|
|
append_option(argv_repack, "-q", MAX_ADD);
|
2007-03-14 01:58:22 +00:00
|
|
|
|
2007-09-05 20:01:37 +00:00
|
|
|
if (auto_gc) {
|
|
|
|
/*
|
|
|
|
* Auto-gc should be least intrusive as possible.
|
|
|
|
*/
|
|
|
|
prune = 0;
|
|
|
|
if (!need_to_gc())
|
|
|
|
return 0;
|
2008-01-07 21:05:22 +00:00
|
|
|
fprintf(stderr, "Auto packing your repository for optimum "
|
2007-10-19 01:12:11 +00:00
|
|
|
"performance. You may also\n"
|
|
|
|
"run \"git gc\" manually. See "
|
|
|
|
"\"git help gc\" for more information.\n");
|
2007-10-11 00:59:19 +00:00
|
|
|
} else {
|
|
|
|
/*
|
|
|
|
* Use safer (for shared repos) "-A" option to
|
|
|
|
* repack when not pruning. Auto-gc makes its
|
|
|
|
* own decision.
|
|
|
|
*/
|
|
|
|
if (prune)
|
|
|
|
append_option(argv_repack, "-a", MAX_ADD);
|
|
|
|
else
|
|
|
|
append_option(argv_repack, "-A", MAX_ADD);
|
2007-09-05 20:01:37 +00:00
|
|
|
}
|
|
|
|
|
2007-03-14 01:58:22 +00:00
|
|
|
if (pack_refs && run_command_v_opt(argv_pack_refs, RUN_GIT_CMD))
|
|
|
|
return error(FAILED_RUN, argv_pack_refs[0]);
|
|
|
|
|
|
|
|
if (run_command_v_opt(argv_reflog, RUN_GIT_CMD))
|
|
|
|
return error(FAILED_RUN, argv_reflog[0]);
|
|
|
|
|
|
|
|
if (run_command_v_opt(argv_repack, RUN_GIT_CMD))
|
|
|
|
return error(FAILED_RUN, argv_repack[0]);
|
|
|
|
|
gc: call "prune --expire 2.weeks.ago" by default
The only reason we did not call "prune" in git-gc was that it is an
inherently dangerous operation: if there is a commit going on, you will
prune loose objects that were just created, and are, in fact, needed by the
commit object just about to be created.
Since it is dangerous, we told users so. That led to many users not even
daring to run it when it was actually safe. Besides, they are users, and
should not have to remember such details as when to call git-gc with
--prune, or to call git-prune directly.
Of course, the consequence was that "git gc --auto" gets triggered much
more often than we would like, since unreferenced loose objects (such as
left-overs from a rebase or a reset --hard) were never pruned.
Alas, git-prune recently learnt the option --expire <minimum-age>, which
makes it a much safer operation. This allows us to call prune from git-gc,
with a grace period of 2 weeks for the unreferenced loose objects (this
value was determined in a discussion on the git list as a safe one).
If you want to override this grace period, just set the config variable
gc.pruneExpire to a different value; an example would be
[gc]
pruneExpire = 6.months.ago
or even "never", if you feel really paranoid.
Note that this new behaviour makes "--prune" be a no-op.
While adding a test to t5304-prune.sh (since it really tests the implicit
call to "prune"), also the original test for "prune --expire" was moved
there from t1410-reflog.sh, where it did not belong.
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
2008-03-12 20:55:47 +00:00
|
|
|
argv_prune[2] = prune_expire;
|
|
|
|
if (run_command_v_opt(argv_prune, RUN_GIT_CMD))
|
2007-03-14 01:58:22 +00:00
|
|
|
return error(FAILED_RUN, argv_prune[0]);
|
|
|
|
|
|
|
|
if (run_command_v_opt(argv_rerere, RUN_GIT_CMD))
|
|
|
|
return error(FAILED_RUN, argv_rerere[0]);
|
|
|
|
|
2007-09-17 07:44:17 +00:00
|
|
|
if (auto_gc && too_many_loose_objects())
|
|
|
|
warning("There are too many unreachable loose objects; "
|
|
|
|
"run 'git prune' to remove them.");
|
|
|
|
|
2007-03-14 01:58:22 +00:00
|
|
|
return 0;
|
|
|
|
}
|