2013-09-15 15:33:20 +00:00
|
|
|
#include "builtin.h"
|
|
|
|
#include "cache.h"
|
2017-06-14 18:07:36 +00:00
|
|
|
#include "config.h"
|
2013-09-15 15:33:20 +00:00
|
|
|
#include "dir.h"
|
|
|
|
#include "parse-options.h"
|
|
|
|
#include "run-command.h"
|
|
|
|
#include "sigchain.h"
|
|
|
|
#include "strbuf.h"
|
|
|
|
#include "string-list.h"
|
|
|
|
#include "argv-array.h"
|
2018-07-12 19:39:40 +00:00
|
|
|
#include "midx.h"
|
2018-08-08 22:34:06 +00:00
|
|
|
#include "packfile.h"
|
2018-08-20 18:33:55 +00:00
|
|
|
#include "object-store.h"
|
2013-09-15 15:33:20 +00:00
|
|
|
|
|
|
|
static int delta_base_offset = 1;
|
repack: add `repack.packKeptObjects` config var
The git-repack command always passes `--honor-pack-keep`
to pack-objects. This has traditionally been a good thing,
as we do not want to duplicate those objects in a new pack,
and we are not going to delete the old pack.
However, when bitmaps are in use, it is important for a full
repack to include all reachable objects, even if they may be
duplicated in a .keep pack. Otherwise, we cannot generate
the bitmaps, as the on-disk format requires the set of
objects in the pack to be fully closed.
Even if the repository does not generally have .keep files,
a simultaneous push could cause a race condition in which a
.keep file exists at the moment of a repack. The repack may
try to include those objects in one of two situations:
1. The pushed .keep pack contains objects that were
already in the repository (e.g., blobs due to a revert of
an old commit).
2. Receive-pack updates the refs, making the objects
reachable, but before it removes the .keep file, the
repack runs.
In either case, we may prefer to duplicate some objects in
the new, full pack, and let the next repack (after the .keep
file is cleaned up) take care of removing them.
This patch introduces both a command-line and config option
to disable the `--honor-pack-keep` option. By default, it
is triggered when pack.writeBitmaps (or `--write-bitmap-index`
is turned on), but specifying it explicitly can override the
behavior (e.g., in cases where you prefer .keep files to
bitmaps, but only when they are present).
Note that this option just disables the pack-objects
behavior. We still leave packs with a .keep in place, as we
do not necessarily know that we have duplicated all of their
objects.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2014-03-03 20:04:20 +00:00
|
|
|
static int pack_kept_objects = -1;
|
2014-06-10 20:19:38 +00:00
|
|
|
static int write_bitmaps;
|
2018-08-16 06:13:10 +00:00
|
|
|
static int use_delta_islands;
|
2013-09-15 15:33:20 +00:00
|
|
|
static char *packdir, *packtmp;
|
|
|
|
|
|
|
|
static const char *const git_repack_usage[] = {
|
2015-01-13 07:44:47 +00:00
|
|
|
N_("git repack [<options>]"),
|
2013-09-15 15:33:20 +00:00
|
|
|
NULL
|
|
|
|
};
|
|
|
|
|
2016-12-28 22:45:42 +00:00
|
|
|
static const char incremental_bitmap_conflict_error[] = N_(
|
|
|
|
"Incremental repacks are incompatible with bitmap indexes. Use\n"
|
|
|
|
"--no-write-bitmap-index or disable the pack.writebitmaps configuration."
|
|
|
|
);
|
|
|
|
|
|
|
|
|
2013-09-15 15:33:20 +00:00
|
|
|
static int repack_config(const char *var, const char *value, void *cb)
|
|
|
|
{
|
|
|
|
if (!strcmp(var, "repack.usedeltabaseoffset")) {
|
|
|
|
delta_base_offset = git_config_bool(var, value);
|
|
|
|
return 0;
|
|
|
|
}
|
repack: add `repack.packKeptObjects` config var
The git-repack command always passes `--honor-pack-keep`
to pack-objects. This has traditionally been a good thing,
as we do not want to duplicate those objects in a new pack,
and we are not going to delete the old pack.
However, when bitmaps are in use, it is important for a full
repack to include all reachable objects, even if they may be
duplicated in a .keep pack. Otherwise, we cannot generate
the bitmaps, as the on-disk format requires the set of
objects in the pack to be fully closed.
Even if the repository does not generally have .keep files,
a simultaneous push could cause a race condition in which a
.keep file exists at the moment of a repack. The repack may
try to include those objects in one of two situations:
1. The pushed .keep pack contains objects that were
already in the repository (e.g., blobs due to a revert of
an old commit).
2. Receive-pack updates the refs, making the objects
reachable, but before it removes the .keep file, the
repack runs.
In either case, we may prefer to duplicate some objects in
the new, full pack, and let the next repack (after the .keep
file is cleaned up) take care of removing them.
This patch introduces both a command-line and config option
to disable the `--honor-pack-keep` option. By default, it
is triggered when pack.writeBitmaps (or `--write-bitmap-index`
is turned on), but specifying it explicitly can override the
behavior (e.g., in cases where you prefer .keep files to
bitmaps, but only when they are present).
Note that this option just disables the pack-objects
behavior. We still leave packs with a .keep in place, as we
do not necessarily know that we have duplicated all of their
objects.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2014-03-03 20:04:20 +00:00
|
|
|
if (!strcmp(var, "repack.packkeptobjects")) {
|
|
|
|
pack_kept_objects = git_config_bool(var, value);
|
|
|
|
return 0;
|
|
|
|
}
|
2014-06-10 20:20:30 +00:00
|
|
|
if (!strcmp(var, "repack.writebitmaps") ||
|
|
|
|
!strcmp(var, "pack.writebitmaps")) {
|
2014-06-10 20:10:07 +00:00
|
|
|
write_bitmaps = git_config_bool(var, value);
|
2014-06-10 20:09:23 +00:00
|
|
|
return 0;
|
|
|
|
}
|
2018-08-16 06:13:10 +00:00
|
|
|
if (!strcmp(var, "repack.usedeltaislands")) {
|
|
|
|
use_delta_islands = git_config_bool(var, value);
|
|
|
|
return 0;
|
|
|
|
}
|
2013-09-15 15:33:20 +00:00
|
|
|
return git_default_config(var, value, cb);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Remove temporary $GIT_OBJECT_DIRECTORY/pack/.tmp-$$-pack-* files.
|
|
|
|
*/
|
|
|
|
static void remove_temporary_files(void)
|
|
|
|
{
|
|
|
|
struct strbuf buf = STRBUF_INIT;
|
|
|
|
size_t dirlen, prefixlen;
|
|
|
|
DIR *dir;
|
|
|
|
struct dirent *e;
|
|
|
|
|
|
|
|
dir = opendir(packdir);
|
|
|
|
if (!dir)
|
|
|
|
return;
|
|
|
|
|
|
|
|
/* Point at the slash at the end of ".../objects/pack/" */
|
|
|
|
dirlen = strlen(packdir) + 1;
|
|
|
|
strbuf_addstr(&buf, packtmp);
|
|
|
|
/* Hold the length of ".tmp-%d-pack-" */
|
|
|
|
prefixlen = buf.len - dirlen;
|
|
|
|
|
|
|
|
while ((e = readdir(dir))) {
|
|
|
|
if (strncmp(e->d_name, buf.buf + dirlen, prefixlen))
|
|
|
|
continue;
|
|
|
|
strbuf_setlen(&buf, dirlen);
|
|
|
|
strbuf_addstr(&buf, e->d_name);
|
|
|
|
unlink(buf.buf);
|
|
|
|
}
|
|
|
|
closedir(dir);
|
|
|
|
strbuf_release(&buf);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void remove_pack_on_signal(int signo)
|
|
|
|
{
|
|
|
|
remove_temporary_files();
|
|
|
|
sigchain_pop(signo);
|
|
|
|
raise(signo);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Adds all packs hex strings to the fname list, which do not
|
2018-08-08 22:34:06 +00:00
|
|
|
* have a corresponding .keep file. These packs are not to
|
2017-12-08 15:27:16 +00:00
|
|
|
* be kept if we are going to pack everything into one file.
|
2013-09-15 15:33:20 +00:00
|
|
|
*/
|
2018-04-15 15:36:13 +00:00
|
|
|
static void get_non_kept_pack_filenames(struct string_list *fname_list,
|
|
|
|
const struct string_list *extra_keep)
|
2013-09-15 15:33:20 +00:00
|
|
|
{
|
|
|
|
DIR *dir;
|
|
|
|
struct dirent *e;
|
|
|
|
char *fname;
|
|
|
|
|
|
|
|
if (!(dir = opendir(packdir)))
|
|
|
|
return;
|
|
|
|
|
|
|
|
while ((e = readdir(dir)) != NULL) {
|
2014-06-30 16:58:51 +00:00
|
|
|
size_t len;
|
2018-04-15 15:36:13 +00:00
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i = 0; i < extra_keep->nr; i++)
|
|
|
|
if (!fspathcmp(e->d_name, extra_keep->items[i].string))
|
|
|
|
break;
|
|
|
|
if (extra_keep->nr > 0 && i < extra_keep->nr)
|
|
|
|
continue;
|
|
|
|
|
2014-06-30 16:58:51 +00:00
|
|
|
if (!strip_suffix(e->d_name, ".pack", &len))
|
2013-09-15 15:33:20 +00:00
|
|
|
continue;
|
|
|
|
|
|
|
|
fname = xmemdupz(e->d_name, len);
|
|
|
|
|
2018-08-08 22:34:06 +00:00
|
|
|
if (!file_exists(mkpath("%s/%s.keep", packdir, fname)))
|
2013-09-15 15:33:20 +00:00
|
|
|
string_list_append_nodup(fname_list, fname);
|
|
|
|
else
|
|
|
|
free(fname);
|
|
|
|
}
|
|
|
|
closedir(dir);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void remove_redundant_pack(const char *dir_name, const char *base_name)
|
|
|
|
{
|
2018-08-08 22:34:06 +00:00
|
|
|
const char *exts[] = {".pack", ".idx", ".keep", ".bitmap", ".promisor"};
|
2013-09-15 15:33:20 +00:00
|
|
|
int i;
|
|
|
|
struct strbuf buf = STRBUF_INIT;
|
|
|
|
size_t plen;
|
|
|
|
|
|
|
|
strbuf_addf(&buf, "%s/%s", dir_name, base_name);
|
|
|
|
plen = buf.len;
|
|
|
|
|
|
|
|
for (i = 0; i < ARRAY_SIZE(exts); i++) {
|
|
|
|
strbuf_setlen(&buf, plen);
|
|
|
|
strbuf_addstr(&buf, exts[i]);
|
|
|
|
unlink(buf.buf);
|
|
|
|
}
|
|
|
|
strbuf_release(&buf);
|
|
|
|
}
|
|
|
|
|
2018-08-08 22:34:05 +00:00
|
|
|
struct pack_objects_args {
|
|
|
|
const char *window;
|
|
|
|
const char *window_memory;
|
|
|
|
const char *depth;
|
|
|
|
const char *threads;
|
|
|
|
const char *max_pack_size;
|
|
|
|
int no_reuse_delta;
|
|
|
|
int no_reuse_object;
|
|
|
|
int quiet;
|
|
|
|
int local;
|
|
|
|
};
|
|
|
|
|
|
|
|
static void prepare_pack_objects(struct child_process *cmd,
|
|
|
|
const struct pack_objects_args *args)
|
|
|
|
{
|
|
|
|
argv_array_push(&cmd->args, "pack-objects");
|
|
|
|
if (args->window)
|
|
|
|
argv_array_pushf(&cmd->args, "--window=%s", args->window);
|
|
|
|
if (args->window_memory)
|
|
|
|
argv_array_pushf(&cmd->args, "--window-memory=%s", args->window_memory);
|
|
|
|
if (args->depth)
|
|
|
|
argv_array_pushf(&cmd->args, "--depth=%s", args->depth);
|
|
|
|
if (args->threads)
|
|
|
|
argv_array_pushf(&cmd->args, "--threads=%s", args->threads);
|
|
|
|
if (args->max_pack_size)
|
|
|
|
argv_array_pushf(&cmd->args, "--max-pack-size=%s", args->max_pack_size);
|
|
|
|
if (args->no_reuse_delta)
|
|
|
|
argv_array_pushf(&cmd->args, "--no-reuse-delta");
|
|
|
|
if (args->no_reuse_object)
|
|
|
|
argv_array_pushf(&cmd->args, "--no-reuse-object");
|
|
|
|
if (args->local)
|
|
|
|
argv_array_push(&cmd->args, "--local");
|
|
|
|
if (args->quiet)
|
|
|
|
argv_array_push(&cmd->args, "--quiet");
|
|
|
|
if (delta_base_offset)
|
|
|
|
argv_array_push(&cmd->args, "--delta-base-offset");
|
|
|
|
argv_array_push(&cmd->args, packtmp);
|
|
|
|
cmd->git_cmd = 1;
|
|
|
|
cmd->out = -1;
|
|
|
|
}
|
|
|
|
|
2018-08-08 22:34:06 +00:00
|
|
|
/*
|
|
|
|
* Write oid to the given struct child_process's stdin, starting it first if
|
|
|
|
* necessary.
|
|
|
|
*/
|
|
|
|
static int write_oid(const struct object_id *oid, struct packed_git *pack,
|
|
|
|
uint32_t pos, void *data)
|
|
|
|
{
|
|
|
|
struct child_process *cmd = data;
|
|
|
|
|
|
|
|
if (cmd->in == -1) {
|
|
|
|
if (start_command(cmd))
|
|
|
|
die("Could not start pack-objects to repack promisor objects");
|
|
|
|
}
|
|
|
|
|
|
|
|
xwrite(cmd->in, oid_to_hex(oid), GIT_SHA1_HEXSZ);
|
|
|
|
xwrite(cmd->in, "\n", 1);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void repack_promisor_objects(const struct pack_objects_args *args,
|
|
|
|
struct string_list *names)
|
|
|
|
{
|
|
|
|
struct child_process cmd = CHILD_PROCESS_INIT;
|
|
|
|
FILE *out;
|
|
|
|
struct strbuf line = STRBUF_INIT;
|
|
|
|
|
|
|
|
prepare_pack_objects(&cmd, args);
|
|
|
|
cmd.in = -1;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* NEEDSWORK: Giving pack-objects only the OIDs without any ordering
|
|
|
|
* hints may result in suboptimal deltas in the resulting pack. See if
|
|
|
|
* the OIDs can be sent with fake paths such that pack-objects can use a
|
|
|
|
* {type -> existing pack order} ordering when computing deltas instead
|
|
|
|
* of a {type -> size} ordering, which may produce better deltas.
|
|
|
|
*/
|
|
|
|
for_each_packed_object(write_oid, &cmd,
|
|
|
|
FOR_EACH_OBJECT_PROMISOR_ONLY);
|
|
|
|
|
|
|
|
if (cmd.in == -1)
|
|
|
|
/* No packed objects; cmd was never started */
|
|
|
|
return;
|
|
|
|
|
|
|
|
close(cmd.in);
|
|
|
|
|
|
|
|
out = xfdopen(cmd.out, "r");
|
|
|
|
while (strbuf_getline_lf(&line, out) != EOF) {
|
|
|
|
char *promisor_name;
|
|
|
|
int fd;
|
2018-10-15 00:01:50 +00:00
|
|
|
if (line.len != the_hash_algo->hexsz)
|
|
|
|
die("repack: Expecting full hex object ID lines only from pack-objects.");
|
2018-08-08 22:34:06 +00:00
|
|
|
string_list_append(names, line.buf);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* pack-objects creates the .pack and .idx files, but not the
|
|
|
|
* .promisor file. Create the .promisor file, which is empty.
|
|
|
|
*/
|
|
|
|
promisor_name = mkpathdup("%s-%s.promisor", packtmp,
|
|
|
|
line.buf);
|
|
|
|
fd = open(promisor_name, O_CREAT|O_EXCL|O_WRONLY, 0600);
|
|
|
|
if (fd < 0)
|
|
|
|
die_errno("unable to create '%s'", promisor_name);
|
|
|
|
close(fd);
|
|
|
|
free(promisor_name);
|
|
|
|
}
|
|
|
|
fclose(out);
|
|
|
|
if (finish_command(&cmd))
|
|
|
|
die("Could not finish pack-objects to repack promisor objects");
|
|
|
|
}
|
|
|
|
|
2013-09-15 15:33:20 +00:00
|
|
|
#define ALL_INTO_ONE 1
|
|
|
|
#define LOOSEN_UNREACHABLE 2
|
|
|
|
|
|
|
|
int cmd_repack(int argc, const char **argv, const char *prefix)
|
|
|
|
{
|
2013-12-21 14:00:23 +00:00
|
|
|
struct {
|
|
|
|
const char *name;
|
2013-12-21 14:00:27 +00:00
|
|
|
unsigned optional:1;
|
2013-12-21 14:00:23 +00:00
|
|
|
} exts[] = {
|
|
|
|
{".pack"},
|
|
|
|
{".idx"},
|
2013-12-21 14:00:31 +00:00
|
|
|
{".bitmap", 1},
|
2018-08-08 22:34:06 +00:00
|
|
|
{".promisor", 1},
|
2013-12-21 14:00:23 +00:00
|
|
|
};
|
2014-08-19 19:09:35 +00:00
|
|
|
struct child_process cmd = CHILD_PROCESS_INIT;
|
2013-09-15 15:33:20 +00:00
|
|
|
struct string_list_item *item;
|
|
|
|
struct string_list names = STRING_LIST_INIT_DUP;
|
|
|
|
struct string_list rollback = STRING_LIST_INIT_NODUP;
|
|
|
|
struct string_list existing_packs = STRING_LIST_INIT_DUP;
|
|
|
|
struct strbuf line = STRBUF_INIT;
|
2018-04-15 15:36:13 +00:00
|
|
|
int i, ext, ret, failed;
|
2013-09-15 15:33:20 +00:00
|
|
|
FILE *out;
|
|
|
|
|
|
|
|
/* variables to be filled by option parsing */
|
|
|
|
int pack_everything = 0;
|
|
|
|
int delete_redundant = 0;
|
2014-01-23 01:28:30 +00:00
|
|
|
const char *unpack_unreachable = NULL;
|
repack: add --keep-unreachable option
The usual way to do a full repack (and what is done by
git-gc) is to run "repack -Ad --unpack-unreachable=<when>",
which will loosen any unreachable objects newer than
"<when>", and drop any older ones.
This is a safer alternative to "repack -ad", because
"<when>" becomes a grace period during which we will not
drop any new objects that are about to be referenced.
However, it isn't perfectly safe. It's always possible that
a process is about to reference an old object. Even if that
process were to take care to update the timestamp on the
object, there is no atomicity with a simultaneously running
"repack" process.
So while unlikely, there is a small race wherein we may drop
an object that is in the process of being referenced. If you
do automated repacking on a large number of active
repositories, you may hit it eventually, and the result is a
corrupted repository.
It would be nice to fix that race in the long run, but it's
complicated. In the meantime, there is a much simpler
strategy for automated repository maintenance: do not drop
objects at all. We already have a "--keep-unreachable"
option in pack-objects; we just need to plumb it through
from git-repack.
Note that this _isn't_ plumbed through from git-gc, so at
this point it's strictly a tool for people doing their own
advanced repository maintenance strategy.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2016-06-13 04:36:28 +00:00
|
|
|
int keep_unreachable = 0;
|
2018-04-15 15:36:13 +00:00
|
|
|
struct string_list keep_pack_list = STRING_LIST_INIT_NODUP;
|
2013-09-15 15:33:20 +00:00
|
|
|
int no_update_server_info = 0;
|
2018-07-12 19:39:40 +00:00
|
|
|
int midx_cleared = 0;
|
2018-08-08 22:34:05 +00:00
|
|
|
struct pack_objects_args po_args = {NULL};
|
2013-09-15 15:33:20 +00:00
|
|
|
|
|
|
|
struct option builtin_repack_options[] = {
|
|
|
|
OPT_BIT('a', NULL, &pack_everything,
|
|
|
|
N_("pack everything in a single pack"), ALL_INTO_ONE),
|
|
|
|
OPT_BIT('A', NULL, &pack_everything,
|
|
|
|
N_("same as -a, and turn unreachable objects loose"),
|
|
|
|
LOOSEN_UNREACHABLE | ALL_INTO_ONE),
|
|
|
|
OPT_BOOL('d', NULL, &delete_redundant,
|
|
|
|
N_("remove redundant packs, and run git-prune-packed")),
|
2018-08-08 22:34:05 +00:00
|
|
|
OPT_BOOL('f', NULL, &po_args.no_reuse_delta,
|
2013-09-15 15:33:20 +00:00
|
|
|
N_("pass --no-reuse-delta to git-pack-objects")),
|
2018-08-08 22:34:05 +00:00
|
|
|
OPT_BOOL('F', NULL, &po_args.no_reuse_object,
|
2013-09-15 15:33:20 +00:00
|
|
|
N_("pass --no-reuse-object to git-pack-objects")),
|
|
|
|
OPT_BOOL('n', NULL, &no_update_server_info,
|
|
|
|
N_("do not run git-update-server-info")),
|
2018-08-08 22:34:05 +00:00
|
|
|
OPT__QUIET(&po_args.quiet, N_("be quiet")),
|
|
|
|
OPT_BOOL('l', "local", &po_args.local,
|
2013-09-15 15:33:20 +00:00
|
|
|
N_("pass --local to git-pack-objects")),
|
2014-06-10 20:10:07 +00:00
|
|
|
OPT_BOOL('b', "write-bitmap-index", &write_bitmaps,
|
2013-12-21 14:00:31 +00:00
|
|
|
N_("write bitmap index")),
|
2018-08-16 06:13:10 +00:00
|
|
|
OPT_BOOL('i', "delta-islands", &use_delta_islands,
|
|
|
|
N_("pass --delta-islands to git-pack-objects")),
|
2013-09-15 15:33:20 +00:00
|
|
|
OPT_STRING(0, "unpack-unreachable", &unpack_unreachable, N_("approxidate"),
|
|
|
|
N_("with -A, do not loosen objects older than this")),
|
repack: add --keep-unreachable option
The usual way to do a full repack (and what is done by
git-gc) is to run "repack -Ad --unpack-unreachable=<when>",
which will loosen any unreachable objects newer than
"<when>", and drop any older ones.
This is a safer alternative to "repack -ad", because
"<when>" becomes a grace period during which we will not
drop any new objects that are about to be referenced.
However, it isn't perfectly safe. It's always possible that
a process is about to reference an old object. Even if that
process were to take care to update the timestamp on the
object, there is no atomicity with a simultaneously running
"repack" process.
So while unlikely, there is a small race wherein we may drop
an object that is in the process of being referenced. If you
do automated repacking on a large number of active
repositories, you may hit it eventually, and the result is a
corrupted repository.
It would be nice to fix that race in the long run, but it's
complicated. In the meantime, there is a much simpler
strategy for automated repository maintenance: do not drop
objects at all. We already have a "--keep-unreachable"
option in pack-objects; we just need to plumb it through
from git-repack.
Note that this _isn't_ plumbed through from git-gc, so at
this point it's strictly a tool for people doing their own
advanced repository maintenance strategy.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2016-06-13 04:36:28 +00:00
|
|
|
OPT_BOOL('k', "keep-unreachable", &keep_unreachable,
|
|
|
|
N_("with -a, repack unreachable objects")),
|
2018-08-08 22:34:05 +00:00
|
|
|
OPT_STRING(0, "window", &po_args.window, N_("n"),
|
2013-09-15 15:33:20 +00:00
|
|
|
N_("size of the window used for delta compression")),
|
2018-08-08 22:34:05 +00:00
|
|
|
OPT_STRING(0, "window-memory", &po_args.window_memory, N_("bytes"),
|
2013-09-15 15:33:20 +00:00
|
|
|
N_("same as the above, but limit memory size instead of entries count")),
|
2018-08-08 22:34:05 +00:00
|
|
|
OPT_STRING(0, "depth", &po_args.depth, N_("n"),
|
2013-09-15 15:33:20 +00:00
|
|
|
N_("limits the maximum delta depth")),
|
2018-08-08 22:34:05 +00:00
|
|
|
OPT_STRING(0, "threads", &po_args.threads, N_("n"),
|
2017-04-26 23:09:25 +00:00
|
|
|
N_("limits the maximum number of threads")),
|
2018-08-08 22:34:05 +00:00
|
|
|
OPT_STRING(0, "max-pack-size", &po_args.max_pack_size, N_("bytes"),
|
2013-09-15 15:33:20 +00:00
|
|
|
N_("maximum size of each packfile")),
|
repack: add `repack.packKeptObjects` config var
The git-repack command always passes `--honor-pack-keep`
to pack-objects. This has traditionally been a good thing,
as we do not want to duplicate those objects in a new pack,
and we are not going to delete the old pack.
However, when bitmaps are in use, it is important for a full
repack to include all reachable objects, even if they may be
duplicated in a .keep pack. Otherwise, we cannot generate
the bitmaps, as the on-disk format requires the set of
objects in the pack to be fully closed.
Even if the repository does not generally have .keep files,
a simultaneous push could cause a race condition in which a
.keep file exists at the moment of a repack. The repack may
try to include those objects in one of two situations:
1. The pushed .keep pack contains objects that were
already in the repository (e.g., blobs due to a revert of
an old commit).
2. Receive-pack updates the refs, making the objects
reachable, but before it removes the .keep file, the
repack runs.
In either case, we may prefer to duplicate some objects in
the new, full pack, and let the next repack (after the .keep
file is cleaned up) take care of removing them.
This patch introduces both a command-line and config option
to disable the `--honor-pack-keep` option. By default, it
is triggered when pack.writeBitmaps (or `--write-bitmap-index`
is turned on), but specifying it explicitly can override the
behavior (e.g., in cases where you prefer .keep files to
bitmaps, but only when they are present).
Note that this option just disables the pack-objects
behavior. We still leave packs with a .keep in place, as we
do not necessarily know that we have duplicated all of their
objects.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2014-03-03 20:04:20 +00:00
|
|
|
OPT_BOOL(0, "pack-kept-objects", &pack_kept_objects,
|
|
|
|
N_("repack objects in packs marked with .keep")),
|
2018-04-15 15:36:13 +00:00
|
|
|
OPT_STRING_LIST(0, "keep-pack", &keep_pack_list, N_("name"),
|
|
|
|
N_("do not repack this pack")),
|
2013-09-15 15:33:20 +00:00
|
|
|
OPT_END()
|
|
|
|
};
|
|
|
|
|
|
|
|
git_config(repack_config, NULL);
|
|
|
|
|
|
|
|
argc = parse_options(argc, argv, prefix, builtin_repack_options,
|
|
|
|
git_repack_usage, 0);
|
|
|
|
|
2015-06-23 10:54:11 +00:00
|
|
|
if (delete_redundant && repository_format_precious_objects)
|
|
|
|
die(_("cannot delete packs in a precious-objects repo"));
|
|
|
|
|
repack: add --keep-unreachable option
The usual way to do a full repack (and what is done by
git-gc) is to run "repack -Ad --unpack-unreachable=<when>",
which will loosen any unreachable objects newer than
"<when>", and drop any older ones.
This is a safer alternative to "repack -ad", because
"<when>" becomes a grace period during which we will not
drop any new objects that are about to be referenced.
However, it isn't perfectly safe. It's always possible that
a process is about to reference an old object. Even if that
process were to take care to update the timestamp on the
object, there is no atomicity with a simultaneously running
"repack" process.
So while unlikely, there is a small race wherein we may drop
an object that is in the process of being referenced. If you
do automated repacking on a large number of active
repositories, you may hit it eventually, and the result is a
corrupted repository.
It would be nice to fix that race in the long run, but it's
complicated. In the meantime, there is a much simpler
strategy for automated repository maintenance: do not drop
objects at all. We already have a "--keep-unreachable"
option in pack-objects; we just need to plumb it through
from git-repack.
Note that this _isn't_ plumbed through from git-gc, so at
this point it's strictly a tool for people doing their own
advanced repository maintenance strategy.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2016-06-13 04:36:28 +00:00
|
|
|
if (keep_unreachable &&
|
|
|
|
(unpack_unreachable || (pack_everything & LOOSEN_UNREACHABLE)))
|
|
|
|
die(_("--keep-unreachable and -A are incompatible"));
|
|
|
|
|
repack: add `repack.packKeptObjects` config var
The git-repack command always passes `--honor-pack-keep`
to pack-objects. This has traditionally been a good thing,
as we do not want to duplicate those objects in a new pack,
and we are not going to delete the old pack.
However, when bitmaps are in use, it is important for a full
repack to include all reachable objects, even if they may be
duplicated in a .keep pack. Otherwise, we cannot generate
the bitmaps, as the on-disk format requires the set of
objects in the pack to be fully closed.
Even if the repository does not generally have .keep files,
a simultaneous push could cause a race condition in which a
.keep file exists at the moment of a repack. The repack may
try to include those objects in one of two situations:
1. The pushed .keep pack contains objects that were
already in the repository (e.g., blobs due to a revert of
an old commit).
2. Receive-pack updates the refs, making the objects
reachable, but before it removes the .keep file, the
repack runs.
In either case, we may prefer to duplicate some objects in
the new, full pack, and let the next repack (after the .keep
file is cleaned up) take care of removing them.
This patch introduces both a command-line and config option
to disable the `--honor-pack-keep` option. By default, it
is triggered when pack.writeBitmaps (or `--write-bitmap-index`
is turned on), but specifying it explicitly can override the
behavior (e.g., in cases where you prefer .keep files to
bitmaps, but only when they are present).
Note that this option just disables the pack-objects
behavior. We still leave packs with a .keep in place, as we
do not necessarily know that we have duplicated all of their
objects.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2014-03-03 20:04:20 +00:00
|
|
|
if (pack_kept_objects < 0)
|
2014-06-10 20:19:38 +00:00
|
|
|
pack_kept_objects = write_bitmaps;
|
repack: add `repack.packKeptObjects` config var
The git-repack command always passes `--honor-pack-keep`
to pack-objects. This has traditionally been a good thing,
as we do not want to duplicate those objects in a new pack,
and we are not going to delete the old pack.
However, when bitmaps are in use, it is important for a full
repack to include all reachable objects, even if they may be
duplicated in a .keep pack. Otherwise, we cannot generate
the bitmaps, as the on-disk format requires the set of
objects in the pack to be fully closed.
Even if the repository does not generally have .keep files,
a simultaneous push could cause a race condition in which a
.keep file exists at the moment of a repack. The repack may
try to include those objects in one of two situations:
1. The pushed .keep pack contains objects that were
already in the repository (e.g., blobs due to a revert of
an old commit).
2. Receive-pack updates the refs, making the objects
reachable, but before it removes the .keep file, the
repack runs.
In either case, we may prefer to duplicate some objects in
the new, full pack, and let the next repack (after the .keep
file is cleaned up) take care of removing them.
This patch introduces both a command-line and config option
to disable the `--honor-pack-keep` option. By default, it
is triggered when pack.writeBitmaps (or `--write-bitmap-index`
is turned on), but specifying it explicitly can override the
behavior (e.g., in cases where you prefer .keep files to
bitmaps, but only when they are present).
Note that this option just disables the pack-objects
behavior. We still leave packs with a .keep in place, as we
do not necessarily know that we have duplicated all of their
objects.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2014-03-03 20:04:20 +00:00
|
|
|
|
2016-12-28 22:45:42 +00:00
|
|
|
if (write_bitmaps && !(pack_everything & ALL_INTO_ONE))
|
|
|
|
die(_(incremental_bitmap_conflict_error));
|
|
|
|
|
2013-09-15 15:33:20 +00:00
|
|
|
packdir = mkpathdup("%s/pack", get_object_directory());
|
|
|
|
packtmp = mkpathdup("%s/.tmp-%d-pack", packdir, (int)getpid());
|
|
|
|
|
|
|
|
sigchain_push_common(remove_pack_on_signal);
|
|
|
|
|
2018-08-08 22:34:05 +00:00
|
|
|
prepare_pack_objects(&cmd, &po_args);
|
|
|
|
|
2014-11-09 13:49:54 +00:00
|
|
|
argv_array_push(&cmd.args, "--keep-true-parents");
|
repack: add `repack.packKeptObjects` config var
The git-repack command always passes `--honor-pack-keep`
to pack-objects. This has traditionally been a good thing,
as we do not want to duplicate those objects in a new pack,
and we are not going to delete the old pack.
However, when bitmaps are in use, it is important for a full
repack to include all reachable objects, even if they may be
duplicated in a .keep pack. Otherwise, we cannot generate
the bitmaps, as the on-disk format requires the set of
objects in the pack to be fully closed.
Even if the repository does not generally have .keep files,
a simultaneous push could cause a race condition in which a
.keep file exists at the moment of a repack. The repack may
try to include those objects in one of two situations:
1. The pushed .keep pack contains objects that were
already in the repository (e.g., blobs due to a revert of
an old commit).
2. Receive-pack updates the refs, making the objects
reachable, but before it removes the .keep file, the
repack runs.
In either case, we may prefer to duplicate some objects in
the new, full pack, and let the next repack (after the .keep
file is cleaned up) take care of removing them.
This patch introduces both a command-line and config option
to disable the `--honor-pack-keep` option. By default, it
is triggered when pack.writeBitmaps (or `--write-bitmap-index`
is turned on), but specifying it explicitly can override the
behavior (e.g., in cases where you prefer .keep files to
bitmaps, but only when they are present).
Note that this option just disables the pack-objects
behavior. We still leave packs with a .keep in place, as we
do not necessarily know that we have duplicated all of their
objects.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2014-03-03 20:04:20 +00:00
|
|
|
if (!pack_kept_objects)
|
2014-11-09 13:49:54 +00:00
|
|
|
argv_array_push(&cmd.args, "--honor-pack-keep");
|
2018-04-15 15:36:13 +00:00
|
|
|
for (i = 0; i < keep_pack_list.nr; i++)
|
|
|
|
argv_array_pushf(&cmd.args, "--keep-pack=%s",
|
|
|
|
keep_pack_list.items[i].string);
|
2014-11-09 13:49:54 +00:00
|
|
|
argv_array_push(&cmd.args, "--non-empty");
|
|
|
|
argv_array_push(&cmd.args, "--all");
|
|
|
|
argv_array_push(&cmd.args, "--reflog");
|
|
|
|
argv_array_push(&cmd.args, "--indexed-objects");
|
2017-12-08 15:27:16 +00:00
|
|
|
if (repository_format_partial_clone)
|
|
|
|
argv_array_push(&cmd.args, "--exclude-promisor-objects");
|
2014-06-10 20:19:38 +00:00
|
|
|
if (write_bitmaps)
|
2014-11-09 13:49:54 +00:00
|
|
|
argv_array_push(&cmd.args, "--write-bitmap-index");
|
2018-08-16 06:13:10 +00:00
|
|
|
if (use_delta_islands)
|
|
|
|
argv_array_push(&cmd.args, "--delta-islands");
|
2013-09-15 15:33:20 +00:00
|
|
|
|
|
|
|
if (pack_everything & ALL_INTO_ONE) {
|
2018-04-15 15:36:13 +00:00
|
|
|
get_non_kept_pack_filenames(&existing_packs, &keep_pack_list);
|
2013-09-15 15:33:20 +00:00
|
|
|
|
2018-08-08 22:34:06 +00:00
|
|
|
repack_promisor_objects(&po_args, &names);
|
|
|
|
|
2013-09-15 15:33:20 +00:00
|
|
|
if (existing_packs.nr && delete_redundant) {
|
2015-03-20 18:43:13 +00:00
|
|
|
if (unpack_unreachable) {
|
2014-11-09 13:49:54 +00:00
|
|
|
argv_array_pushf(&cmd.args,
|
2013-09-15 15:33:20 +00:00
|
|
|
"--unpack-unreachable=%s",
|
|
|
|
unpack_unreachable);
|
2015-03-20 18:43:13 +00:00
|
|
|
argv_array_push(&cmd.env_array, "GIT_REF_PARANOIA=1");
|
|
|
|
} else if (pack_everything & LOOSEN_UNREACHABLE) {
|
2014-11-09 13:49:54 +00:00
|
|
|
argv_array_push(&cmd.args,
|
2013-09-15 15:33:20 +00:00
|
|
|
"--unpack-unreachable");
|
repack: add --keep-unreachable option
The usual way to do a full repack (and what is done by
git-gc) is to run "repack -Ad --unpack-unreachable=<when>",
which will loosen any unreachable objects newer than
"<when>", and drop any older ones.
This is a safer alternative to "repack -ad", because
"<when>" becomes a grace period during which we will not
drop any new objects that are about to be referenced.
However, it isn't perfectly safe. It's always possible that
a process is about to reference an old object. Even if that
process were to take care to update the timestamp on the
object, there is no atomicity with a simultaneously running
"repack" process.
So while unlikely, there is a small race wherein we may drop
an object that is in the process of being referenced. If you
do automated repacking on a large number of active
repositories, you may hit it eventually, and the result is a
corrupted repository.
It would be nice to fix that race in the long run, but it's
complicated. In the meantime, there is a much simpler
strategy for automated repository maintenance: do not drop
objects at all. We already have a "--keep-unreachable"
option in pack-objects; we just need to plumb it through
from git-repack.
Note that this _isn't_ plumbed through from git-gc, so at
this point it's strictly a tool for people doing their own
advanced repository maintenance strategy.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2016-06-13 04:36:28 +00:00
|
|
|
} else if (keep_unreachable) {
|
|
|
|
argv_array_push(&cmd.args, "--keep-unreachable");
|
repack: extend --keep-unreachable to loose objects
If you use "repack -adk" currently, we will pack all objects
that are already packed into the new pack, and then drop the
old packs. However, loose unreachable objects will be left
as-is. In theory these are meant to expire eventually with
"git prune". But if you are using "repack -k", you probably
want to keep things forever and therefore do not run "git
prune" at all. Meaning those loose objects may build up over
time and end up fooling any object-count heuristics (such as
the one done by "gc --auto", though since git-gc does not
support "repack -k", this really applies to whatever custom
scripts people might have driving "repack -k").
With this patch, we instead stuff any loose unreachable
objects into the pack along with the already-packed
unreachable objects. This may seem wasteful, but it is
really no more so than using "repack -k" in the first place.
We are at a slight disadvantage, in that we have no useful
ordering for the result, or names to hand to the delta code.
However, this is again no worse than what "repack -k" is
already doing for the packed objects. The packing of these
objects doesn't matter much because they should not be
accessed frequently (unless they actually _do_ become
referenced, but then they would get moved to a different
part of the packfile during the next repack).
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2016-06-13 04:38:04 +00:00
|
|
|
argv_array_push(&cmd.args, "--pack-loose-unreachable");
|
2015-03-20 18:43:13 +00:00
|
|
|
} else {
|
|
|
|
argv_array_push(&cmd.env_array, "GIT_REF_PARANOIA=1");
|
|
|
|
}
|
2013-09-15 15:33:20 +00:00
|
|
|
}
|
|
|
|
} else {
|
2014-11-09 13:49:54 +00:00
|
|
|
argv_array_push(&cmd.args, "--unpacked");
|
|
|
|
argv_array_push(&cmd.args, "--incremental");
|
2013-09-15 15:33:20 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
cmd.no_stdin = 1;
|
|
|
|
|
|
|
|
ret = start_command(&cmd);
|
|
|
|
if (ret)
|
2013-09-15 15:33:21 +00:00
|
|
|
return ret;
|
2013-09-15 15:33:20 +00:00
|
|
|
|
|
|
|
out = xfdopen(cmd.out, "r");
|
2016-01-13 23:31:17 +00:00
|
|
|
while (strbuf_getline_lf(&line, out) != EOF) {
|
2018-10-15 00:01:50 +00:00
|
|
|
if (line.len != the_hash_algo->hexsz)
|
|
|
|
die("repack: Expecting full hex object ID lines only from pack-objects.");
|
2013-09-15 15:33:20 +00:00
|
|
|
string_list_append(&names, line.buf);
|
|
|
|
}
|
|
|
|
fclose(out);
|
|
|
|
ret = finish_command(&cmd);
|
|
|
|
if (ret)
|
2013-09-15 15:33:21 +00:00
|
|
|
return ret;
|
2013-09-15 15:33:20 +00:00
|
|
|
|
2018-08-08 22:34:05 +00:00
|
|
|
if (!names.nr && !po_args.quiet)
|
2013-09-15 15:33:20 +00:00
|
|
|
printf("Nothing new to pack.\n");
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Ok we have prepared all new packfiles.
|
|
|
|
* First see if there are packs of the same name and if so
|
|
|
|
* if we can move them out of the way (this can happen if we
|
|
|
|
* repacked immediately after packing fully.
|
|
|
|
*/
|
|
|
|
failed = 0;
|
|
|
|
for_each_string_list_item(item, &names) {
|
2013-12-21 14:00:19 +00:00
|
|
|
for (ext = 0; ext < ARRAY_SIZE(exts); ext++) {
|
2015-08-10 09:35:38 +00:00
|
|
|
char *fname, *fname_old;
|
2018-07-12 19:39:40 +00:00
|
|
|
|
|
|
|
if (!midx_cleared) {
|
2018-10-12 17:34:19 +00:00
|
|
|
clear_midx_file(the_repository);
|
2018-07-12 19:39:40 +00:00
|
|
|
midx_cleared = 1;
|
|
|
|
}
|
|
|
|
|
2014-02-02 15:09:56 +00:00
|
|
|
fname = mkpathdup("%s/pack-%s%s", packdir,
|
2013-12-21 14:00:23 +00:00
|
|
|
item->string, exts[ext].name);
|
2013-09-15 15:33:20 +00:00
|
|
|
if (!file_exists(fname)) {
|
|
|
|
free(fname);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2015-08-10 09:35:38 +00:00
|
|
|
fname_old = mkpathdup("%s/old-%s%s", packdir,
|
2013-12-21 14:00:23 +00:00
|
|
|
item->string, exts[ext].name);
|
2013-09-15 15:33:20 +00:00
|
|
|
if (file_exists(fname_old))
|
|
|
|
if (unlink(fname_old))
|
|
|
|
failed = 1;
|
|
|
|
|
|
|
|
if (!failed && rename(fname, fname_old)) {
|
|
|
|
free(fname);
|
2015-08-10 09:35:38 +00:00
|
|
|
free(fname_old);
|
2013-09-15 15:33:20 +00:00
|
|
|
failed = 1;
|
|
|
|
break;
|
|
|
|
} else {
|
|
|
|
string_list_append(&rollback, fname);
|
2015-08-10 09:35:38 +00:00
|
|
|
free(fname_old);
|
2013-09-15 15:33:20 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
if (failed)
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (failed) {
|
|
|
|
struct string_list rollback_failure = STRING_LIST_INIT_DUP;
|
|
|
|
for_each_string_list_item(item, &rollback) {
|
2015-08-10 09:35:38 +00:00
|
|
|
char *fname, *fname_old;
|
2013-09-15 15:33:20 +00:00
|
|
|
fname = mkpathdup("%s/%s", packdir, item->string);
|
2015-08-10 09:35:38 +00:00
|
|
|
fname_old = mkpathdup("%s/old-%s", packdir, item->string);
|
2013-09-15 15:33:20 +00:00
|
|
|
if (rename(fname_old, fname))
|
|
|
|
string_list_append(&rollback_failure, fname);
|
|
|
|
free(fname);
|
2015-08-10 09:35:38 +00:00
|
|
|
free(fname_old);
|
2013-09-15 15:33:20 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if (rollback_failure.nr) {
|
|
|
|
int i;
|
|
|
|
fprintf(stderr,
|
|
|
|
"WARNING: Some packs in use have been renamed by\n"
|
|
|
|
"WARNING: prefixing old- to their name, in order to\n"
|
|
|
|
"WARNING: replace them with the new version of the\n"
|
|
|
|
"WARNING: file. But the operation failed, and the\n"
|
|
|
|
"WARNING: attempt to rename them back to their\n"
|
|
|
|
"WARNING: original names also failed.\n"
|
|
|
|
"WARNING: Please rename them in %s manually:\n", packdir);
|
|
|
|
for (i = 0; i < rollback_failure.nr; i++)
|
|
|
|
fprintf(stderr, "WARNING: old-%s -> %s\n",
|
|
|
|
rollback_failure.items[i].string,
|
|
|
|
rollback_failure.items[i].string);
|
|
|
|
}
|
|
|
|
exit(1);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Now the ones with the same name are out of the way... */
|
|
|
|
for_each_string_list_item(item, &names) {
|
2013-12-21 14:00:19 +00:00
|
|
|
for (ext = 0; ext < ARRAY_SIZE(exts); ext++) {
|
2013-09-15 15:33:20 +00:00
|
|
|
char *fname, *fname_old;
|
|
|
|
struct stat statbuffer;
|
2013-12-21 14:00:27 +00:00
|
|
|
int exists = 0;
|
2013-09-15 15:33:20 +00:00
|
|
|
fname = mkpathdup("%s/pack-%s%s",
|
2013-12-21 14:00:23 +00:00
|
|
|
packdir, item->string, exts[ext].name);
|
2013-09-15 15:33:20 +00:00
|
|
|
fname_old = mkpathdup("%s-%s%s",
|
2013-12-21 14:00:23 +00:00
|
|
|
packtmp, item->string, exts[ext].name);
|
2013-09-15 15:33:20 +00:00
|
|
|
if (!stat(fname_old, &statbuffer)) {
|
|
|
|
statbuffer.st_mode &= ~(S_IWUSR | S_IWGRP | S_IWOTH);
|
|
|
|
chmod(fname_old, statbuffer.st_mode);
|
2013-12-21 14:00:27 +00:00
|
|
|
exists = 1;
|
|
|
|
}
|
|
|
|
if (exists || !exts[ext].optional) {
|
|
|
|
if (rename(fname_old, fname))
|
|
|
|
die_errno(_("renaming '%s' failed"), fname_old);
|
2013-09-15 15:33:20 +00:00
|
|
|
}
|
|
|
|
free(fname);
|
|
|
|
free(fname_old);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Remove the "old-" files */
|
|
|
|
for_each_string_list_item(item, &names) {
|
2013-12-21 14:00:19 +00:00
|
|
|
for (ext = 0; ext < ARRAY_SIZE(exts); ext++) {
|
2015-08-10 09:35:38 +00:00
|
|
|
char *fname;
|
|
|
|
fname = mkpathdup("%s/old-%s%s",
|
|
|
|
packdir,
|
|
|
|
item->string,
|
|
|
|
exts[ext].name);
|
2013-09-15 15:33:22 +00:00
|
|
|
if (remove_path(fname))
|
2016-06-17 20:21:20 +00:00
|
|
|
warning(_("failed to remove '%s'"), fname);
|
2015-08-10 09:35:38 +00:00
|
|
|
free(fname);
|
2013-09-15 15:33:20 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* End of pack replacement. */
|
|
|
|
|
2018-08-08 22:34:06 +00:00
|
|
|
reprepare_packed_git(the_repository);
|
|
|
|
|
2013-09-15 15:33:20 +00:00
|
|
|
if (delete_redundant) {
|
2018-10-15 00:01:50 +00:00
|
|
|
const int hexsz = the_hash_algo->hexsz;
|
2014-09-13 07:28:01 +00:00
|
|
|
int opts = 0;
|
2014-11-25 08:02:35 +00:00
|
|
|
string_list_sort(&names);
|
2013-09-15 15:33:20 +00:00
|
|
|
for_each_string_list_item(item, &existing_packs) {
|
|
|
|
char *sha1;
|
|
|
|
size_t len = strlen(item->string);
|
2018-10-15 00:01:50 +00:00
|
|
|
if (len < hexsz)
|
2013-09-15 15:33:20 +00:00
|
|
|
continue;
|
2018-10-15 00:01:50 +00:00
|
|
|
sha1 = item->string + len - hexsz;
|
2013-09-15 15:33:20 +00:00
|
|
|
if (!string_list_has_string(&names, sha1))
|
|
|
|
remove_redundant_pack(packdir, item->string);
|
|
|
|
}
|
2018-08-08 22:34:05 +00:00
|
|
|
if (!po_args.quiet && isatty(2))
|
2014-09-13 07:28:01 +00:00
|
|
|
opts |= PRUNE_PACKED_VERBOSE;
|
|
|
|
prune_packed_objects(opts);
|
repack -ad: prune the list of shallow commits
`git repack` can drop unreachable commits without further warning,
making the corresponding entries in `.git/shallow` invalid, which causes
serious problems when deepening the branches.
One scenario where unreachable commits are dropped by `git repack` is
when a `git fetch --prune` (or even a `git fetch` when a ref was
force-pushed in the meantime) can make a commit unreachable that was
reachable before.
Therefore it is not safe to assume that a `git repack -adlf` will keep
unreachable commits alone (under the assumption that they had not been
packed in the first place, which is an assumption at least some of Git's
code seems to make).
This is particularly important to keep in mind when looking at the
`.git/shallow` file: if any commits listed in that file become
unreachable, it is not a problem, but if they go missing, it *is* a
problem. One symptom of this problem is that a deepening fetch may now
fail with
fatal: error in object: unshallow <commit-hash>
To avoid this problem, let's prune the shallow list in `git repack` when
the `-d` option is passed, unless `-A` is passed, too (which would force
the now-unreachable objects to be turned into loose objects instead of
being deleted). Additionally, we also need to take `--keep-reachable`
and `--unpack-unreachable=<date>` into account.
Note: an alternative solution discussed during the review of this patch
was to teach `git fetch` to simply ignore entries in .git/shallow if the
corresponding commits do not exist locally. A quick test, however,
revealed that the .git/shallow file is written during a shallow *clone*,
in which case the commits do not exist, either, but the "shallow" line
*does* need to be sent. Therefore, this approach would be a lot more
finicky than the approach presented by the this patch.
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2018-10-24 15:56:13 +00:00
|
|
|
|
|
|
|
if (!keep_unreachable &&
|
|
|
|
(!(pack_everything & LOOSEN_UNREACHABLE) ||
|
|
|
|
unpack_unreachable) &&
|
|
|
|
is_repository_shallow(the_repository))
|
|
|
|
prune_shallow(PRUNE_QUICK);
|
2013-09-15 15:33:20 +00:00
|
|
|
}
|
|
|
|
|
2014-09-13 07:28:01 +00:00
|
|
|
if (!no_update_server_info)
|
|
|
|
update_server_info(0);
|
2013-09-15 15:33:20 +00:00
|
|
|
remove_temporary_files();
|
2018-10-12 17:34:20 +00:00
|
|
|
|
|
|
|
if (git_env_bool(GIT_TEST_MULTI_PACK_INDEX, 0))
|
|
|
|
write_midx_file(get_object_directory());
|
|
|
|
|
2013-09-15 15:33:20 +00:00
|
|
|
string_list_clear(&names, 0);
|
|
|
|
string_list_clear(&rollback, 0);
|
|
|
|
string_list_clear(&existing_packs, 0);
|
|
|
|
strbuf_release(&line);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|