Start handling references internally as a sorted in-memory list
This also adds some very rudimentary support for the notion of packed
refs. HOWEVER! At this point it isn't used to actually look up a ref
yet, only for listing them (ie "for_each_ref()" and friends see the
packed refs, but none of the other single-ref lookup routines).
Note how we keep two separate lists: one for the loose refs, and one for
the packed refs we read. That's so that we can easily keep the two apart,
and read only one set or the other (and still always make sure that the
loose refs take precedence).
[ From this, it's not actually obvious why we'd keep the two separate
lists, but it's important to have the packed refs on their own list
later on, when I add support for looking up a single loose one.
For that case, we will want to read _just_ the packed refs in case the
single-ref lookup fails, yet we may end up needing the other list at
some point in the future, so keeping them separated is important ]
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-09-12 01:37:32 +02:00
|
|
|
#include "cache.h"
|
|
|
|
#include "refs.h"
|
|
|
|
|
2006-09-21 09:06:06 +02:00
|
|
|
static const char builtin_pack_refs_usage[] =
|
|
|
|
"git-pack-refs [--prune]";
|
|
|
|
|
|
|
|
struct ref_to_prune {
|
|
|
|
struct ref_to_prune *next;
|
|
|
|
unsigned char sha1[20];
|
|
|
|
char name[FLEX_ARRAY];
|
|
|
|
};
|
|
|
|
|
|
|
|
struct pack_refs_cb_data {
|
|
|
|
int prune;
|
|
|
|
struct ref_to_prune *ref_to_prune;
|
|
|
|
FILE *refs_file;
|
|
|
|
};
|
Start handling references internally as a sorted in-memory list
This also adds some very rudimentary support for the notion of packed
refs. HOWEVER! At this point it isn't used to actually look up a ref
yet, only for listing them (ie "for_each_ref()" and friends see the
packed refs, but none of the other single-ref lookup routines).
Note how we keep two separate lists: one for the loose refs, and one for
the packed refs we read. That's so that we can easily keep the two apart,
and read only one set or the other (and still always make sure that the
loose refs take precedence).
[ From this, it's not actually obvious why we'd keep the two separate
lists, but it's important to have the packed refs on their own list
later on, when I add support for looking up a single loose one.
For that case, we will want to read _just_ the packed refs in case the
single-ref lookup fails, yet we may end up needing the other list at
some point in the future, so keeping them separated is important ]
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-09-12 01:37:32 +02:00
|
|
|
|
2006-09-21 09:06:06 +02:00
|
|
|
static int do_not_prune(int flags)
|
|
|
|
{
|
|
|
|
/* If it is already packed or if it is a symref,
|
|
|
|
* do not prune it.
|
|
|
|
*/
|
|
|
|
return (flags & (REF_ISSYMREF|REF_ISPACKED));
|
|
|
|
}
|
|
|
|
|
2006-09-21 07:02:01 +02:00
|
|
|
static int handle_one_ref(const char *path, const unsigned char *sha1,
|
|
|
|
int flags, void *cb_data)
|
Start handling references internally as a sorted in-memory list
This also adds some very rudimentary support for the notion of packed
refs. HOWEVER! At this point it isn't used to actually look up a ref
yet, only for listing them (ie "for_each_ref()" and friends see the
packed refs, but none of the other single-ref lookup routines).
Note how we keep two separate lists: one for the loose refs, and one for
the packed refs we read. That's so that we can easily keep the two apart,
and read only one set or the other (and still always make sure that the
loose refs take precedence).
[ From this, it's not actually obvious why we'd keep the two separate
lists, but it's important to have the packed refs on their own list
later on, when I add support for looking up a single loose one.
For that case, we will want to read _just_ the packed refs in case the
single-ref lookup fails, yet we may end up needing the other list at
some point in the future, so keeping them separated is important ]
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-09-12 01:37:32 +02:00
|
|
|
{
|
2006-09-21 09:06:06 +02:00
|
|
|
struct pack_refs_cb_data *cb = cb_data;
|
2006-09-21 06:47:42 +02:00
|
|
|
|
2006-09-21 09:06:05 +02:00
|
|
|
/* Do not pack the symbolic refs */
|
|
|
|
if (!(flags & REF_ISSYMREF))
|
2006-09-21 09:06:06 +02:00
|
|
|
fprintf(cb->refs_file, "%s %s\n", sha1_to_hex(sha1), path);
|
|
|
|
if (cb->prune && !do_not_prune(flags)) {
|
|
|
|
int namelen = strlen(path) + 1;
|
|
|
|
struct ref_to_prune *n = xcalloc(1, sizeof(*n) + namelen);
|
|
|
|
hashcpy(n->sha1, sha1);
|
|
|
|
strcpy(n->name, path);
|
|
|
|
n->next = cb->ref_to_prune;
|
|
|
|
cb->ref_to_prune = n;
|
|
|
|
}
|
Start handling references internally as a sorted in-memory list
This also adds some very rudimentary support for the notion of packed
refs. HOWEVER! At this point it isn't used to actually look up a ref
yet, only for listing them (ie "for_each_ref()" and friends see the
packed refs, but none of the other single-ref lookup routines).
Note how we keep two separate lists: one for the loose refs, and one for
the packed refs we read. That's so that we can easily keep the two apart,
and read only one set or the other (and still always make sure that the
loose refs take precedence).
[ From this, it's not actually obvious why we'd keep the two separate
lists, but it's important to have the packed refs on their own list
later on, when I add support for looking up a single loose one.
For that case, we will want to read _just_ the packed refs in case the
single-ref lookup fails, yet we may end up needing the other list at
some point in the future, so keeping them separated is important ]
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-09-12 01:37:32 +02:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2006-09-21 09:06:06 +02:00
|
|
|
/* make sure nobody touched the ref, and unlink */
|
|
|
|
static void prune_ref(struct ref_to_prune *r)
|
|
|
|
{
|
2006-09-27 10:09:18 +02:00
|
|
|
struct ref_lock *lock = lock_ref_sha1(r->name + 5, r->sha1);
|
2006-09-21 09:06:06 +02:00
|
|
|
|
|
|
|
if (lock) {
|
2006-09-23 06:31:40 +02:00
|
|
|
unlink(git_path("%s", r->name));
|
2006-09-21 09:06:06 +02:00
|
|
|
unlock_ref(lock);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void prune_refs(struct ref_to_prune *r)
|
|
|
|
{
|
|
|
|
while (r) {
|
|
|
|
prune_ref(r);
|
|
|
|
r = r->next;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2006-10-03 11:15:18 +02:00
|
|
|
static struct lock_file packed;
|
|
|
|
|
Start handling references internally as a sorted in-memory list
This also adds some very rudimentary support for the notion of packed
refs. HOWEVER! At this point it isn't used to actually look up a ref
yet, only for listing them (ie "for_each_ref()" and friends see the
packed refs, but none of the other single-ref lookup routines).
Note how we keep two separate lists: one for the loose refs, and one for
the packed refs we read. That's so that we can easily keep the two apart,
and read only one set or the other (and still always make sure that the
loose refs take precedence).
[ From this, it's not actually obvious why we'd keep the two separate
lists, but it's important to have the packed refs on their own list
later on, when I add support for looking up a single loose one.
For that case, we will want to read _just_ the packed refs in case the
single-ref lookup fails, yet we may end up needing the other list at
some point in the future, so keeping them separated is important ]
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-09-12 01:37:32 +02:00
|
|
|
int cmd_pack_refs(int argc, const char **argv, const char *prefix)
|
|
|
|
{
|
2006-09-21 09:06:06 +02:00
|
|
|
int fd, i;
|
|
|
|
struct pack_refs_cb_data cbdata;
|
|
|
|
|
|
|
|
memset(&cbdata, 0, sizeof(cbdata));
|
|
|
|
|
|
|
|
for (i = 1; i < argc; i++) {
|
|
|
|
const char *arg = argv[i];
|
|
|
|
if (!strcmp(arg, "--prune")) {
|
|
|
|
cbdata.prune = 1;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
/* perhaps other parameters later... */
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (i != argc)
|
|
|
|
usage(builtin_pack_refs_usage);
|
Start handling references internally as a sorted in-memory list
This also adds some very rudimentary support for the notion of packed
refs. HOWEVER! At this point it isn't used to actually look up a ref
yet, only for listing them (ie "for_each_ref()" and friends see the
packed refs, but none of the other single-ref lookup routines).
Note how we keep two separate lists: one for the loose refs, and one for
the packed refs we read. That's so that we can easily keep the two apart,
and read only one set or the other (and still always make sure that the
loose refs take precedence).
[ From this, it's not actually obvious why we'd keep the two separate
lists, but it's important to have the packed refs on their own list
later on, when I add support for looking up a single loose one.
For that case, we will want to read _just_ the packed refs in case the
single-ref lookup fails, yet we may end up needing the other list at
some point in the future, so keeping them separated is important ]
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-09-12 01:37:32 +02:00
|
|
|
|
2006-10-03 11:15:18 +02:00
|
|
|
fd = hold_lock_file_for_update(&packed, git_path("packed-refs"), 1);
|
2006-09-21 09:06:06 +02:00
|
|
|
cbdata.refs_file = fdopen(fd, "w");
|
|
|
|
if (!cbdata.refs_file)
|
|
|
|
die("unable to create ref-pack file structure (%s)",
|
|
|
|
strerror(errno));
|
|
|
|
for_each_ref(handle_one_ref, &cbdata);
|
2006-10-05 06:37:15 +02:00
|
|
|
fflush(cbdata.refs_file);
|
Start handling references internally as a sorted in-memory list
This also adds some very rudimentary support for the notion of packed
refs. HOWEVER! At this point it isn't used to actually look up a ref
yet, only for listing them (ie "for_each_ref()" and friends see the
packed refs, but none of the other single-ref lookup routines).
Note how we keep two separate lists: one for the loose refs, and one for
the packed refs we read. That's so that we can easily keep the two apart,
and read only one set or the other (and still always make sure that the
loose refs take precedence).
[ From this, it's not actually obvious why we'd keep the two separate
lists, but it's important to have the packed refs on their own list
later on, when I add support for looking up a single loose one.
For that case, we will want to read _just_ the packed refs in case the
single-ref lookup fails, yet we may end up needing the other list at
some point in the future, so keeping them separated is important ]
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-09-12 01:37:32 +02:00
|
|
|
fsync(fd);
|
2006-09-21 09:06:06 +02:00
|
|
|
fclose(cbdata.refs_file);
|
2006-10-03 11:15:18 +02:00
|
|
|
if (commit_lock_file(&packed) < 0)
|
Start handling references internally as a sorted in-memory list
This also adds some very rudimentary support for the notion of packed
refs. HOWEVER! At this point it isn't used to actually look up a ref
yet, only for listing them (ie "for_each_ref()" and friends see the
packed refs, but none of the other single-ref lookup routines).
Note how we keep two separate lists: one for the loose refs, and one for
the packed refs we read. That's so that we can easily keep the two apart,
and read only one set or the other (and still always make sure that the
loose refs take precedence).
[ From this, it's not actually obvious why we'd keep the two separate
lists, but it's important to have the packed refs on their own list
later on, when I add support for looking up a single loose one.
For that case, we will want to read _just_ the packed refs in case the
single-ref lookup fails, yet we may end up needing the other list at
some point in the future, so keeping them separated is important ]
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-09-12 01:37:32 +02:00
|
|
|
die("unable to overwrite old ref-pack file (%s)", strerror(errno));
|
2006-09-21 09:06:06 +02:00
|
|
|
if (cbdata.prune)
|
|
|
|
prune_refs(cbdata.ref_to_prune);
|
Start handling references internally as a sorted in-memory list
This also adds some very rudimentary support for the notion of packed
refs. HOWEVER! At this point it isn't used to actually look up a ref
yet, only for listing them (ie "for_each_ref()" and friends see the
packed refs, but none of the other single-ref lookup routines).
Note how we keep two separate lists: one for the loose refs, and one for
the packed refs we read. That's so that we can easily keep the two apart,
and read only one set or the other (and still always make sure that the
loose refs take precedence).
[ From this, it's not actually obvious why we'd keep the two separate
lists, but it's important to have the packed refs on their own list
later on, when I add support for looking up a single loose one.
For that case, we will want to read _just_ the packed refs in case the
single-ref lookup fails, yet we may end up needing the other list at
some point in the future, so keeping them separated is important ]
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-09-12 01:37:32 +02:00
|
|
|
return 0;
|
|
|
|
}
|