2005-07-04 20:26:53 +00:00
|
|
|
#include "cache.h"
|
2005-07-04 22:29:17 +00:00
|
|
|
#include "refs.h"
|
2005-07-04 20:26:53 +00:00
|
|
|
#include "pkt-line.h"
|
2005-10-19 21:27:02 +00:00
|
|
|
#include "commit.h"
|
|
|
|
#include "tag.h"
|
2005-07-04 20:26:53 +00:00
|
|
|
|
2005-12-15 06:17:38 +00:00
|
|
|
static int keep_pack;
|
2005-07-14 07:08:37 +00:00
|
|
|
static int quiet;
|
2005-08-12 09:08:29 +00:00
|
|
|
static int verbose;
|
2006-03-20 08:21:10 +00:00
|
|
|
static int fetch_all;
|
2005-08-12 09:08:29 +00:00
|
|
|
static const char fetch_pack_usage[] =
|
2006-03-20 08:21:10 +00:00
|
|
|
"git-fetch-pack [--all] [-q] [-v] [-k] [--thin] [--exec=upload-pack] [host:]directory <refs>...";
|
2005-07-04 20:26:53 +00:00
|
|
|
static const char *exec = "git-upload-pack";
|
|
|
|
|
2005-10-19 23:14:34 +00:00
|
|
|
#define COMPLETE (1U << 0)
|
2005-10-28 02:46:27 +00:00
|
|
|
#define COMMON (1U << 1)
|
|
|
|
#define COMMON_REF (1U << 2)
|
|
|
|
#define SEEN (1U << 3)
|
|
|
|
#define POPPED (1U << 4)
|
|
|
|
|
2006-05-25 04:48:34 +00:00
|
|
|
/*
|
|
|
|
* After sending this many "have"s if we do not get any new ACK , we
|
|
|
|
* give up traversing our history.
|
|
|
|
*/
|
|
|
|
#define MAX_IN_VAIN 256
|
|
|
|
|
2005-10-28 02:46:27 +00:00
|
|
|
static struct commit_list *rev_list = NULL;
|
2006-02-20 08:38:39 +00:00
|
|
|
static int non_common_revs = 0, multi_ack = 0, use_thin_pack = 0;
|
2005-10-28 02:46:27 +00:00
|
|
|
|
|
|
|
static void rev_list_push(struct commit *commit, int mark)
|
|
|
|
{
|
|
|
|
if (!(commit->object.flags & mark)) {
|
|
|
|
commit->object.flags |= mark;
|
|
|
|
|
|
|
|
if (!(commit->object.parsed))
|
|
|
|
parse_commit(commit);
|
|
|
|
|
|
|
|
insert_by_date(commit, &rev_list);
|
|
|
|
|
|
|
|
if (!(commit->object.flags & COMMON))
|
|
|
|
non_common_revs++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static int rev_list_insert_ref(const char *path, const unsigned char *sha1)
|
|
|
|
{
|
2005-11-02 23:19:13 +00:00
|
|
|
struct object *o = deref_tag(parse_object(sha1), path, 0);
|
2005-10-28 02:46:27 +00:00
|
|
|
|
2005-11-02 23:19:13 +00:00
|
|
|
if (o && o->type == commit_type)
|
2005-10-28 02:46:27 +00:00
|
|
|
rev_list_push((struct commit *)o, SEEN);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
This function marks a rev and its ancestors as common.
|
|
|
|
In some cases, it is desirable to mark only the ancestors (for example
|
|
|
|
when only the server does not yet know that they are common).
|
|
|
|
*/
|
|
|
|
|
|
|
|
static void mark_common(struct commit *commit,
|
|
|
|
int ancestors_only, int dont_parse)
|
|
|
|
{
|
|
|
|
if (commit != NULL && !(commit->object.flags & COMMON)) {
|
|
|
|
struct object *o = (struct object *)commit;
|
|
|
|
|
|
|
|
if (!ancestors_only)
|
|
|
|
o->flags |= COMMON;
|
|
|
|
|
|
|
|
if (!(o->flags & SEEN))
|
|
|
|
rev_list_push(commit, SEEN);
|
|
|
|
else {
|
|
|
|
struct commit_list *parents;
|
|
|
|
|
|
|
|
if (!ancestors_only && !(o->flags & POPPED))
|
|
|
|
non_common_revs--;
|
|
|
|
if (!o->parsed && !dont_parse)
|
|
|
|
parse_commit(commit);
|
|
|
|
|
|
|
|
for (parents = commit->parents;
|
|
|
|
parents;
|
|
|
|
parents = parents->next)
|
|
|
|
mark_common(parents->item, 0, dont_parse);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
Get the next rev to send, ignoring the common.
|
|
|
|
*/
|
|
|
|
|
2006-02-26 15:13:46 +00:00
|
|
|
static const unsigned char* get_rev(void)
|
2005-10-28 02:46:27 +00:00
|
|
|
{
|
|
|
|
struct commit *commit = NULL;
|
|
|
|
|
|
|
|
while (commit == NULL) {
|
|
|
|
unsigned int mark;
|
|
|
|
struct commit_list* parents;
|
|
|
|
|
|
|
|
if (rev_list == NULL || non_common_revs == 0)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
commit = rev_list->item;
|
|
|
|
if (!(commit->object.parsed))
|
|
|
|
parse_commit(commit);
|
|
|
|
commit->object.flags |= POPPED;
|
|
|
|
if (!(commit->object.flags & COMMON))
|
|
|
|
non_common_revs--;
|
|
|
|
|
|
|
|
parents = commit->parents;
|
|
|
|
|
|
|
|
if (commit->object.flags & COMMON) {
|
|
|
|
/* do not send "have", and ignore ancestors */
|
|
|
|
commit = NULL;
|
|
|
|
mark = COMMON | SEEN;
|
|
|
|
} else if (commit->object.flags & COMMON_REF)
|
|
|
|
/* send "have", and ignore ancestors */
|
|
|
|
mark = COMMON | SEEN;
|
|
|
|
else
|
|
|
|
/* send "have", also for its ancestors */
|
|
|
|
mark = SEEN;
|
|
|
|
|
|
|
|
while (parents) {
|
|
|
|
if (!(parents->item->object.flags & SEEN))
|
|
|
|
rev_list_push(parents->item, mark);
|
|
|
|
if (mark & COMMON)
|
|
|
|
mark_common(parents->item, 1, 0);
|
|
|
|
parents = parents->next;
|
|
|
|
}
|
|
|
|
|
|
|
|
rev_list = rev_list->next;
|
|
|
|
}
|
|
|
|
|
|
|
|
return commit->object.sha1;
|
|
|
|
}
|
2005-10-19 23:14:34 +00:00
|
|
|
|
2005-08-12 09:08:29 +00:00
|
|
|
static int find_common(int fd[2], unsigned char *result_sha1,
|
|
|
|
struct ref *refs)
|
2005-07-04 20:26:53 +00:00
|
|
|
{
|
git-fetch-pack: avoid unnecessary zero packing
If everything is up-to-date locally, we don't need to even ask for a
pack-file from the remote, or try to unpack it.
This is especially important for tags - since the pack-file common commit
logic is based purely on the commit history, it will never be able to find
a common tag, and will thus always end up re-fetching them.
Especially notably, if the tag points to a non-commit (eg a tagged tree),
the pack-file would be unnecessarily big, just because it cannot any most
recent common point between commits for pruning.
Short-circuiting the case where we already have that reference means that
we avoid a lot of these in the common case.
NOTE! This only matches remote ref names against the same local name,
which works well for tags, but is not as generic as it could be. If we
ever need to, we could match against _any_ local ref (if we have it, we
have it), but this "match against same name" is simpler and more
efficient, and covers the common case.
Renaming of refs is common for branch heads, but since those are always
commits, the pack-file generation can optimize that case.
In some cases we might still end up fetching pack-files unnecessarily, but
this at least avoids the re-fetching of tags over and over if you use a
regular
git fetch --tags ...
which was the main reason behind the change.
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2005-10-18 18:35:17 +00:00
|
|
|
int fetching;
|
2005-10-28 02:46:27 +00:00
|
|
|
int count = 0, flushes = 0, retval;
|
|
|
|
const unsigned char *sha1;
|
2006-05-25 04:48:34 +00:00
|
|
|
unsigned in_vain = 0;
|
|
|
|
int got_continue = 0;
|
2005-10-28 02:46:27 +00:00
|
|
|
|
|
|
|
for_each_ref(rev_list_insert_ref);
|
2005-07-04 20:26:53 +00:00
|
|
|
|
git-fetch-pack: avoid unnecessary zero packing
If everything is up-to-date locally, we don't need to even ask for a
pack-file from the remote, or try to unpack it.
This is especially important for tags - since the pack-file common commit
logic is based purely on the commit history, it will never be able to find
a common tag, and will thus always end up re-fetching them.
Especially notably, if the tag points to a non-commit (eg a tagged tree),
the pack-file would be unnecessarily big, just because it cannot any most
recent common point between commits for pruning.
Short-circuiting the case where we already have that reference means that
we avoid a lot of these in the common case.
NOTE! This only matches remote ref names against the same local name,
which works well for tags, but is not as generic as it could be. If we
ever need to, we could match against _any_ local ref (if we have it, we
have it), but this "match against same name" is simpler and more
efficient, and covers the common case.
Renaming of refs is common for branch heads, but since those are always
commits, the pack-file generation can optimize that case.
In some cases we might still end up fetching pack-files unnecessarily, but
this at least avoids the re-fetching of tags over and over if you use a
regular
git fetch --tags ...
which was the main reason behind the change.
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2005-10-18 18:35:17 +00:00
|
|
|
fetching = 0;
|
|
|
|
for ( ; refs ; refs = refs->next) {
|
2005-08-12 09:08:29 +00:00
|
|
|
unsigned char *remote = refs->old_sha1;
|
2005-10-20 01:28:17 +00:00
|
|
|
struct object *o;
|
git-fetch-pack: avoid unnecessary zero packing
If everything is up-to-date locally, we don't need to even ask for a
pack-file from the remote, or try to unpack it.
This is especially important for tags - since the pack-file common commit
logic is based purely on the commit history, it will never be able to find
a common tag, and will thus always end up re-fetching them.
Especially notably, if the tag points to a non-commit (eg a tagged tree),
the pack-file would be unnecessarily big, just because it cannot any most
recent common point between commits for pruning.
Short-circuiting the case where we already have that reference means that
we avoid a lot of these in the common case.
NOTE! This only matches remote ref names against the same local name,
which works well for tags, but is not as generic as it could be. If we
ever need to, we could match against _any_ local ref (if we have it, we
have it), but this "match against same name" is simpler and more
efficient, and covers the common case.
Renaming of refs is common for branch heads, but since those are always
commits, the pack-file generation can optimize that case.
In some cases we might still end up fetching pack-files unnecessarily, but
this at least avoids the re-fetching of tags over and over if you use a
regular
git fetch --tags ...
which was the main reason behind the change.
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2005-10-18 18:35:17 +00:00
|
|
|
|
2005-10-19 23:14:34 +00:00
|
|
|
/*
|
2005-10-20 01:28:17 +00:00
|
|
|
* If that object is complete (i.e. it is an ancestor of a
|
|
|
|
* local ref), we tell them we have it but do not have to
|
|
|
|
* tell them about its ancestors, which they already know
|
|
|
|
* about.
|
2005-10-20 04:55:49 +00:00
|
|
|
*
|
|
|
|
* We use lookup_object here because we are only
|
|
|
|
* interested in the case we *know* the object is
|
|
|
|
* reachable and we have already scanned it.
|
2005-10-20 01:28:17 +00:00
|
|
|
*/
|
2005-10-20 04:55:49 +00:00
|
|
|
if (((o = lookup_object(remote)) != NULL) &&
|
2005-10-28 02:47:07 +00:00
|
|
|
(o->flags & COMPLETE)) {
|
git-fetch-pack: avoid unnecessary zero packing
If everything is up-to-date locally, we don't need to even ask for a
pack-file from the remote, or try to unpack it.
This is especially important for tags - since the pack-file common commit
logic is based purely on the commit history, it will never be able to find
a common tag, and will thus always end up re-fetching them.
Especially notably, if the tag points to a non-commit (eg a tagged tree),
the pack-file would be unnecessarily big, just because it cannot any most
recent common point between commits for pruning.
Short-circuiting the case where we already have that reference means that
we avoid a lot of these in the common case.
NOTE! This only matches remote ref names against the same local name,
which works well for tags, but is not as generic as it could be. If we
ever need to, we could match against _any_ local ref (if we have it, we
have it), but this "match against same name" is simpler and more
efficient, and covers the common case.
Renaming of refs is common for branch heads, but since those are always
commits, the pack-file generation can optimize that case.
In some cases we might still end up fetching pack-files unnecessarily, but
this at least avoids the re-fetching of tags over and over if you use a
regular
git fetch --tags ...
which was the main reason behind the change.
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2005-10-18 18:35:17 +00:00
|
|
|
continue;
|
2005-10-19 23:14:34 +00:00
|
|
|
}
|
2005-10-28 02:46:27 +00:00
|
|
|
|
2006-02-20 08:38:39 +00:00
|
|
|
packet_write(fd[1], "want %s%s%s\n", sha1_to_hex(remote),
|
|
|
|
(multi_ack ? " multi_ack" : ""),
|
|
|
|
(use_thin_pack ? " thin-pack" : ""));
|
git-fetch-pack: avoid unnecessary zero packing
If everything is up-to-date locally, we don't need to even ask for a
pack-file from the remote, or try to unpack it.
This is especially important for tags - since the pack-file common commit
logic is based purely on the commit history, it will never be able to find
a common tag, and will thus always end up re-fetching them.
Especially notably, if the tag points to a non-commit (eg a tagged tree),
the pack-file would be unnecessarily big, just because it cannot any most
recent common point between commits for pruning.
Short-circuiting the case where we already have that reference means that
we avoid a lot of these in the common case.
NOTE! This only matches remote ref names against the same local name,
which works well for tags, but is not as generic as it could be. If we
ever need to, we could match against _any_ local ref (if we have it, we
have it), but this "match against same name" is simpler and more
efficient, and covers the common case.
Renaming of refs is common for branch heads, but since those are always
commits, the pack-file generation can optimize that case.
In some cases we might still end up fetching pack-files unnecessarily, but
this at least avoids the re-fetching of tags over and over if you use a
regular
git fetch --tags ...
which was the main reason behind the change.
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2005-10-18 18:35:17 +00:00
|
|
|
fetching++;
|
2005-08-12 09:08:29 +00:00
|
|
|
}
|
2005-07-04 22:29:17 +00:00
|
|
|
packet_flush(fd[1]);
|
git-fetch-pack: avoid unnecessary zero packing
If everything is up-to-date locally, we don't need to even ask for a
pack-file from the remote, or try to unpack it.
This is especially important for tags - since the pack-file common commit
logic is based purely on the commit history, it will never be able to find
a common tag, and will thus always end up re-fetching them.
Especially notably, if the tag points to a non-commit (eg a tagged tree),
the pack-file would be unnecessarily big, just because it cannot any most
recent common point between commits for pruning.
Short-circuiting the case where we already have that reference means that
we avoid a lot of these in the common case.
NOTE! This only matches remote ref names against the same local name,
which works well for tags, but is not as generic as it could be. If we
ever need to, we could match against _any_ local ref (if we have it, we
have it), but this "match against same name" is simpler and more
efficient, and covers the common case.
Renaming of refs is common for branch heads, but since those are always
commits, the pack-file generation can optimize that case.
In some cases we might still end up fetching pack-files unnecessarily, but
this at least avoids the re-fetching of tags over and over if you use a
regular
git fetch --tags ...
which was the main reason behind the change.
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2005-10-18 18:35:17 +00:00
|
|
|
if (!fetching)
|
|
|
|
return 1;
|
2005-10-19 23:14:34 +00:00
|
|
|
|
2005-10-28 02:46:27 +00:00
|
|
|
flushes = 0;
|
2005-07-04 23:35:13 +00:00
|
|
|
retval = -1;
|
2005-10-28 02:46:27 +00:00
|
|
|
while ((sha1 = get_rev())) {
|
2005-07-04 20:26:53 +00:00
|
|
|
packet_write(fd[1], "have %s\n", sha1_to_hex(sha1));
|
2005-08-12 09:08:29 +00:00
|
|
|
if (verbose)
|
|
|
|
fprintf(stderr, "have %s\n", sha1_to_hex(sha1));
|
2006-05-25 04:48:34 +00:00
|
|
|
in_vain++;
|
2005-07-04 20:26:53 +00:00
|
|
|
if (!(31 & ++count)) {
|
2005-10-28 02:50:26 +00:00
|
|
|
int ack;
|
|
|
|
|
2005-07-04 20:26:53 +00:00
|
|
|
packet_flush(fd[1]);
|
|
|
|
flushes++;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* We keep one window "ahead" of the other side, and
|
|
|
|
* will wait for an ACK only on the next one
|
|
|
|
*/
|
|
|
|
if (count == 32)
|
|
|
|
continue;
|
2005-10-28 02:50:26 +00:00
|
|
|
|
|
|
|
do {
|
|
|
|
ack = get_ack(fd[0], result_sha1);
|
|
|
|
if (verbose && ack)
|
|
|
|
fprintf(stderr, "got ack %d %s\n", ack,
|
|
|
|
sha1_to_hex(result_sha1));
|
|
|
|
if (ack == 1) {
|
|
|
|
flushes = 0;
|
|
|
|
multi_ack = 0;
|
|
|
|
retval = 0;
|
|
|
|
goto done;
|
|
|
|
} else if (ack == 2) {
|
|
|
|
struct commit *commit =
|
|
|
|
lookup_commit(result_sha1);
|
|
|
|
mark_common(commit, 0, 1);
|
|
|
|
retval = 0;
|
2006-05-25 04:48:34 +00:00
|
|
|
in_vain = 0;
|
|
|
|
got_continue = 1;
|
2005-10-28 02:50:26 +00:00
|
|
|
}
|
|
|
|
} while (ack);
|
2005-07-04 20:26:53 +00:00
|
|
|
flushes--;
|
2006-05-25 04:48:34 +00:00
|
|
|
if (got_continue && MAX_IN_VAIN < in_vain) {
|
|
|
|
if (verbose)
|
|
|
|
fprintf(stderr, "giving up\n");
|
|
|
|
break; /* give up */
|
|
|
|
}
|
2005-07-04 20:26:53 +00:00
|
|
|
}
|
|
|
|
}
|
2005-10-28 02:50:26 +00:00
|
|
|
done:
|
2005-07-04 23:35:13 +00:00
|
|
|
packet_write(fd[1], "done\n");
|
2005-08-12 09:08:29 +00:00
|
|
|
if (verbose)
|
|
|
|
fprintf(stderr, "done\n");
|
2005-10-28 02:50:26 +00:00
|
|
|
if (retval != 0) {
|
|
|
|
multi_ack = 0;
|
2005-10-28 02:46:27 +00:00
|
|
|
flushes++;
|
2005-10-28 02:50:26 +00:00
|
|
|
}
|
|
|
|
while (flushes || multi_ack) {
|
|
|
|
int ack = get_ack(fd[0], result_sha1);
|
|
|
|
if (ack) {
|
2005-08-12 09:08:29 +00:00
|
|
|
if (verbose)
|
2005-10-28 02:50:26 +00:00
|
|
|
fprintf(stderr, "got ack (%d) %s\n", ack,
|
|
|
|
sha1_to_hex(result_sha1));
|
|
|
|
if (ack == 1)
|
|
|
|
return 0;
|
|
|
|
multi_ack = 1;
|
|
|
|
continue;
|
2005-08-12 09:08:29 +00:00
|
|
|
}
|
2005-10-28 02:50:26 +00:00
|
|
|
flushes--;
|
2005-07-04 20:26:53 +00:00
|
|
|
}
|
2005-07-04 23:35:13 +00:00
|
|
|
return retval;
|
2005-07-04 20:26:53 +00:00
|
|
|
}
|
|
|
|
|
2005-10-19 21:27:02 +00:00
|
|
|
static struct commit_list *complete = NULL;
|
|
|
|
|
|
|
|
static int mark_complete(const char *path, const unsigned char *sha1)
|
|
|
|
{
|
|
|
|
struct object *o = parse_object(sha1);
|
|
|
|
|
|
|
|
while (o && o->type == tag_type) {
|
2005-10-20 04:55:49 +00:00
|
|
|
struct tag *t = (struct tag *) o;
|
|
|
|
if (!t->tagged)
|
|
|
|
break; /* broken repository */
|
2005-10-19 21:27:02 +00:00
|
|
|
o->flags |= COMPLETE;
|
2005-10-20 04:55:49 +00:00
|
|
|
o = parse_object(t->tagged->sha1);
|
2005-10-19 21:27:02 +00:00
|
|
|
}
|
2005-10-20 04:55:49 +00:00
|
|
|
if (o && o->type == commit_type) {
|
2005-10-19 21:27:02 +00:00
|
|
|
struct commit *commit = (struct commit *)o;
|
|
|
|
commit->object.flags |= COMPLETE;
|
|
|
|
insert_by_date(commit, &complete);
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void mark_recent_complete_commits(unsigned long cutoff)
|
|
|
|
{
|
|
|
|
while (complete && cutoff <= complete->item->date) {
|
|
|
|
if (verbose)
|
|
|
|
fprintf(stderr, "Marking %s as complete\n",
|
|
|
|
sha1_to_hex(complete->item->object.sha1));
|
|
|
|
pop_most_recent_commit(&complete, COMPLETE);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2005-10-28 02:47:07 +00:00
|
|
|
static void filter_refs(struct ref **refs, int nr_match, char **match)
|
|
|
|
{
|
2006-05-11 22:28:44 +00:00
|
|
|
struct ref **return_refs;
|
|
|
|
struct ref *newlist = NULL;
|
|
|
|
struct ref **newtail = &newlist;
|
|
|
|
struct ref *ref, *next;
|
|
|
|
struct ref *fastarray[32];
|
|
|
|
|
|
|
|
if (nr_match && !fetch_all) {
|
|
|
|
if (ARRAY_SIZE(fastarray) < nr_match)
|
|
|
|
return_refs = xcalloc(nr_match, sizeof(struct ref *));
|
|
|
|
else {
|
|
|
|
return_refs = fastarray;
|
|
|
|
memset(return_refs, 0, sizeof(struct ref *) * nr_match);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
return_refs = NULL;
|
|
|
|
|
|
|
|
for (ref = *refs; ref; ref = next) {
|
|
|
|
next = ref->next;
|
|
|
|
if (!memcmp(ref->name, "refs/", 5) &&
|
|
|
|
check_ref_format(ref->name + 5))
|
|
|
|
; /* trash */
|
|
|
|
else if (fetch_all) {
|
|
|
|
*newtail = ref;
|
|
|
|
ref->next = NULL;
|
|
|
|
newtail = &ref->next;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
int order = path_match(ref->name, nr_match, match);
|
|
|
|
if (order) {
|
|
|
|
return_refs[order-1] = ref;
|
|
|
|
continue; /* we will link it later */
|
|
|
|
}
|
|
|
|
}
|
|
|
|
free(ref);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!fetch_all) {
|
|
|
|
int i;
|
|
|
|
for (i = 0; i < nr_match; i++) {
|
|
|
|
ref = return_refs[i];
|
|
|
|
if (ref) {
|
|
|
|
*newtail = ref;
|
|
|
|
ref->next = NULL;
|
|
|
|
newtail = &ref->next;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (return_refs != fastarray)
|
|
|
|
free(return_refs);
|
2005-10-28 02:47:07 +00:00
|
|
|
}
|
2006-05-11 22:28:44 +00:00
|
|
|
*refs = newlist;
|
2005-10-28 02:47:07 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static int everything_local(struct ref **refs, int nr_match, char **match)
|
git-fetch-pack: avoid unnecessary zero packing
If everything is up-to-date locally, we don't need to even ask for a
pack-file from the remote, or try to unpack it.
This is especially important for tags - since the pack-file common commit
logic is based purely on the commit history, it will never be able to find
a common tag, and will thus always end up re-fetching them.
Especially notably, if the tag points to a non-commit (eg a tagged tree),
the pack-file would be unnecessarily big, just because it cannot any most
recent common point between commits for pruning.
Short-circuiting the case where we already have that reference means that
we avoid a lot of these in the common case.
NOTE! This only matches remote ref names against the same local name,
which works well for tags, but is not as generic as it could be. If we
ever need to, we could match against _any_ local ref (if we have it, we
have it), but this "match against same name" is simpler and more
efficient, and covers the common case.
Renaming of refs is common for branch heads, but since those are always
commits, the pack-file generation can optimize that case.
In some cases we might still end up fetching pack-files unnecessarily, but
this at least avoids the re-fetching of tags over and over if you use a
regular
git fetch --tags ...
which was the main reason behind the change.
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2005-10-18 18:35:17 +00:00
|
|
|
{
|
2005-10-19 21:27:02 +00:00
|
|
|
struct ref *ref;
|
git-fetch-pack: avoid unnecessary zero packing
If everything is up-to-date locally, we don't need to even ask for a
pack-file from the remote, or try to unpack it.
This is especially important for tags - since the pack-file common commit
logic is based purely on the commit history, it will never be able to find
a common tag, and will thus always end up re-fetching them.
Especially notably, if the tag points to a non-commit (eg a tagged tree),
the pack-file would be unnecessarily big, just because it cannot any most
recent common point between commits for pruning.
Short-circuiting the case where we already have that reference means that
we avoid a lot of these in the common case.
NOTE! This only matches remote ref names against the same local name,
which works well for tags, but is not as generic as it could be. If we
ever need to, we could match against _any_ local ref (if we have it, we
have it), but this "match against same name" is simpler and more
efficient, and covers the common case.
Renaming of refs is common for branch heads, but since those are always
commits, the pack-file generation can optimize that case.
In some cases we might still end up fetching pack-files unnecessarily, but
this at least avoids the re-fetching of tags over and over if you use a
regular
git fetch --tags ...
which was the main reason behind the change.
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2005-10-18 18:35:17 +00:00
|
|
|
int retval;
|
2005-10-19 21:27:02 +00:00
|
|
|
unsigned long cutoff = 0;
|
|
|
|
|
|
|
|
track_object_refs = 0;
|
|
|
|
save_commit_buffer = 0;
|
|
|
|
|
2005-10-28 02:47:07 +00:00
|
|
|
for (ref = *refs; ref; ref = ref->next) {
|
2005-10-19 21:27:02 +00:00
|
|
|
struct object *o;
|
|
|
|
|
|
|
|
o = parse_object(ref->old_sha1);
|
|
|
|
if (!o)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
/* We already have it -- which may mean that we were
|
|
|
|
* in sync with the other side at some time after
|
|
|
|
* that (it is OK if we guess wrong here).
|
|
|
|
*/
|
|
|
|
if (o->type == commit_type) {
|
|
|
|
struct commit *commit = (struct commit *)o;
|
|
|
|
if (!cutoff || cutoff < commit->date)
|
|
|
|
cutoff = commit->date;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
for_each_ref(mark_complete);
|
|
|
|
if (cutoff)
|
|
|
|
mark_recent_complete_commits(cutoff);
|
git-fetch-pack: avoid unnecessary zero packing
If everything is up-to-date locally, we don't need to even ask for a
pack-file from the remote, or try to unpack it.
This is especially important for tags - since the pack-file common commit
logic is based purely on the commit history, it will never be able to find
a common tag, and will thus always end up re-fetching them.
Especially notably, if the tag points to a non-commit (eg a tagged tree),
the pack-file would be unnecessarily big, just because it cannot any most
recent common point between commits for pruning.
Short-circuiting the case where we already have that reference means that
we avoid a lot of these in the common case.
NOTE! This only matches remote ref names against the same local name,
which works well for tags, but is not as generic as it could be. If we
ever need to, we could match against _any_ local ref (if we have it, we
have it), but this "match against same name" is simpler and more
efficient, and covers the common case.
Renaming of refs is common for branch heads, but since those are always
commits, the pack-file generation can optimize that case.
In some cases we might still end up fetching pack-files unnecessarily, but
this at least avoids the re-fetching of tags over and over if you use a
regular
git fetch --tags ...
which was the main reason behind the change.
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2005-10-18 18:35:17 +00:00
|
|
|
|
2005-10-28 02:47:07 +00:00
|
|
|
/*
|
|
|
|
* Mark all complete remote refs as common refs.
|
|
|
|
* Don't mark them common yet; the server has to be told so first.
|
|
|
|
*/
|
|
|
|
for (ref = *refs; ref; ref = ref->next) {
|
2005-11-02 23:19:13 +00:00
|
|
|
struct object *o = deref_tag(lookup_object(ref->old_sha1),
|
|
|
|
NULL, 0);
|
2005-10-28 02:47:07 +00:00
|
|
|
|
|
|
|
if (!o || o->type != commit_type || !(o->flags & COMPLETE))
|
|
|
|
continue;
|
|
|
|
|
|
|
|
if (!(o->flags & SEEN)) {
|
|
|
|
rev_list_push((struct commit *)o, COMMON_REF | SEEN);
|
|
|
|
|
|
|
|
mark_common((struct commit *)o, 1, 1);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
filter_refs(refs, nr_match, match);
|
|
|
|
|
|
|
|
for (retval = 1, ref = *refs; ref ; ref = ref->next) {
|
|
|
|
const unsigned char *remote = ref->old_sha1;
|
git-fetch-pack: avoid unnecessary zero packing
If everything is up-to-date locally, we don't need to even ask for a
pack-file from the remote, or try to unpack it.
This is especially important for tags - since the pack-file common commit
logic is based purely on the commit history, it will never be able to find
a common tag, and will thus always end up re-fetching them.
Especially notably, if the tag points to a non-commit (eg a tagged tree),
the pack-file would be unnecessarily big, just because it cannot any most
recent common point between commits for pruning.
Short-circuiting the case where we already have that reference means that
we avoid a lot of these in the common case.
NOTE! This only matches remote ref names against the same local name,
which works well for tags, but is not as generic as it could be. If we
ever need to, we could match against _any_ local ref (if we have it, we
have it), but this "match against same name" is simpler and more
efficient, and covers the common case.
Renaming of refs is common for branch heads, but since those are always
commits, the pack-file generation can optimize that case.
In some cases we might still end up fetching pack-files unnecessarily, but
this at least avoids the re-fetching of tags over and over if you use a
regular
git fetch --tags ...
which was the main reason behind the change.
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2005-10-18 18:35:17 +00:00
|
|
|
unsigned char local[20];
|
2005-10-19 21:27:02 +00:00
|
|
|
struct object *o;
|
git-fetch-pack: avoid unnecessary zero packing
If everything is up-to-date locally, we don't need to even ask for a
pack-file from the remote, or try to unpack it.
This is especially important for tags - since the pack-file common commit
logic is based purely on the commit history, it will never be able to find
a common tag, and will thus always end up re-fetching them.
Especially notably, if the tag points to a non-commit (eg a tagged tree),
the pack-file would be unnecessarily big, just because it cannot any most
recent common point between commits for pruning.
Short-circuiting the case where we already have that reference means that
we avoid a lot of these in the common case.
NOTE! This only matches remote ref names against the same local name,
which works well for tags, but is not as generic as it could be. If we
ever need to, we could match against _any_ local ref (if we have it, we
have it), but this "match against same name" is simpler and more
efficient, and covers the common case.
Renaming of refs is common for branch heads, but since those are always
commits, the pack-file generation can optimize that case.
In some cases we might still end up fetching pack-files unnecessarily, but
this at least avoids the re-fetching of tags over and over if you use a
regular
git fetch --tags ...
which was the main reason behind the change.
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2005-10-18 18:35:17 +00:00
|
|
|
|
2005-10-28 02:47:07 +00:00
|
|
|
o = lookup_object(remote);
|
2005-10-19 21:27:02 +00:00
|
|
|
if (!o || !(o->flags & COMPLETE)) {
|
git-fetch-pack: avoid unnecessary zero packing
If everything is up-to-date locally, we don't need to even ask for a
pack-file from the remote, or try to unpack it.
This is especially important for tags - since the pack-file common commit
logic is based purely on the commit history, it will never be able to find
a common tag, and will thus always end up re-fetching them.
Especially notably, if the tag points to a non-commit (eg a tagged tree),
the pack-file would be unnecessarily big, just because it cannot any most
recent common point between commits for pruning.
Short-circuiting the case where we already have that reference means that
we avoid a lot of these in the common case.
NOTE! This only matches remote ref names against the same local name,
which works well for tags, but is not as generic as it could be. If we
ever need to, we could match against _any_ local ref (if we have it, we
have it), but this "match against same name" is simpler and more
efficient, and covers the common case.
Renaming of refs is common for branch heads, but since those are always
commits, the pack-file generation can optimize that case.
In some cases we might still end up fetching pack-files unnecessarily, but
this at least avoids the re-fetching of tags over and over if you use a
regular
git fetch --tags ...
which was the main reason behind the change.
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2005-10-18 18:35:17 +00:00
|
|
|
retval = 0;
|
|
|
|
if (!verbose)
|
|
|
|
continue;
|
|
|
|
fprintf(stderr,
|
|
|
|
"want %s (%s)\n", sha1_to_hex(remote),
|
2005-10-28 02:47:07 +00:00
|
|
|
ref->name);
|
git-fetch-pack: avoid unnecessary zero packing
If everything is up-to-date locally, we don't need to even ask for a
pack-file from the remote, or try to unpack it.
This is especially important for tags - since the pack-file common commit
logic is based purely on the commit history, it will never be able to find
a common tag, and will thus always end up re-fetching them.
Especially notably, if the tag points to a non-commit (eg a tagged tree),
the pack-file would be unnecessarily big, just because it cannot any most
recent common point between commits for pruning.
Short-circuiting the case where we already have that reference means that
we avoid a lot of these in the common case.
NOTE! This only matches remote ref names against the same local name,
which works well for tags, but is not as generic as it could be. If we
ever need to, we could match against _any_ local ref (if we have it, we
have it), but this "match against same name" is simpler and more
efficient, and covers the common case.
Renaming of refs is common for branch heads, but since those are always
commits, the pack-file generation can optimize that case.
In some cases we might still end up fetching pack-files unnecessarily, but
this at least avoids the re-fetching of tags over and over if you use a
regular
git fetch --tags ...
which was the main reason behind the change.
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2005-10-18 18:35:17 +00:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2005-10-28 02:47:07 +00:00
|
|
|
memcpy(ref->new_sha1, local, 20);
|
git-fetch-pack: avoid unnecessary zero packing
If everything is up-to-date locally, we don't need to even ask for a
pack-file from the remote, or try to unpack it.
This is especially important for tags - since the pack-file common commit
logic is based purely on the commit history, it will never be able to find
a common tag, and will thus always end up re-fetching them.
Especially notably, if the tag points to a non-commit (eg a tagged tree),
the pack-file would be unnecessarily big, just because it cannot any most
recent common point between commits for pruning.
Short-circuiting the case where we already have that reference means that
we avoid a lot of these in the common case.
NOTE! This only matches remote ref names against the same local name,
which works well for tags, but is not as generic as it could be. If we
ever need to, we could match against _any_ local ref (if we have it, we
have it), but this "match against same name" is simpler and more
efficient, and covers the common case.
Renaming of refs is common for branch heads, but since those are always
commits, the pack-file generation can optimize that case.
In some cases we might still end up fetching pack-files unnecessarily, but
this at least avoids the re-fetching of tags over and over if you use a
regular
git fetch --tags ...
which was the main reason behind the change.
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2005-10-18 18:35:17 +00:00
|
|
|
if (!verbose)
|
|
|
|
continue;
|
|
|
|
fprintf(stderr,
|
|
|
|
"already have %s (%s)\n", sha1_to_hex(remote),
|
2005-10-28 02:47:07 +00:00
|
|
|
ref->name);
|
git-fetch-pack: avoid unnecessary zero packing
If everything is up-to-date locally, we don't need to even ask for a
pack-file from the remote, or try to unpack it.
This is especially important for tags - since the pack-file common commit
logic is based purely on the commit history, it will never be able to find
a common tag, and will thus always end up re-fetching them.
Especially notably, if the tag points to a non-commit (eg a tagged tree),
the pack-file would be unnecessarily big, just because it cannot any most
recent common point between commits for pruning.
Short-circuiting the case where we already have that reference means that
we avoid a lot of these in the common case.
NOTE! This only matches remote ref names against the same local name,
which works well for tags, but is not as generic as it could be. If we
ever need to, we could match against _any_ local ref (if we have it, we
have it), but this "match against same name" is simpler and more
efficient, and covers the common case.
Renaming of refs is common for branch heads, but since those are always
commits, the pack-file generation can optimize that case.
In some cases we might still end up fetching pack-files unnecessarily, but
this at least avoids the re-fetching of tags over and over if you use a
regular
git fetch --tags ...
which was the main reason behind the change.
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2005-10-18 18:35:17 +00:00
|
|
|
}
|
|
|
|
return retval;
|
|
|
|
}
|
|
|
|
|
2005-07-04 20:26:53 +00:00
|
|
|
static int fetch_pack(int fd[2], int nr_match, char **match)
|
|
|
|
{
|
2005-07-16 20:55:50 +00:00
|
|
|
struct ref *ref;
|
|
|
|
unsigned char sha1[20];
|
|
|
|
int status;
|
2005-07-04 20:26:53 +00:00
|
|
|
|
2005-10-28 02:47:07 +00:00
|
|
|
get_remote_heads(fd[0], &ref, 0, NULL, 0);
|
2005-10-28 02:50:26 +00:00
|
|
|
if (server_supports("multi_ack")) {
|
|
|
|
if (verbose)
|
|
|
|
fprintf(stderr, "Server supports multi_ack\n");
|
|
|
|
multi_ack = 1;
|
|
|
|
}
|
2005-07-16 20:55:50 +00:00
|
|
|
if (!ref) {
|
|
|
|
packet_flush(fd[1]);
|
|
|
|
die("no matching remote head");
|
|
|
|
}
|
2005-10-28 02:47:07 +00:00
|
|
|
if (everything_local(&ref, nr_match, match)) {
|
git-fetch-pack: avoid unnecessary zero packing
If everything is up-to-date locally, we don't need to even ask for a
pack-file from the remote, or try to unpack it.
This is especially important for tags - since the pack-file common commit
logic is based purely on the commit history, it will never be able to find
a common tag, and will thus always end up re-fetching them.
Especially notably, if the tag points to a non-commit (eg a tagged tree),
the pack-file would be unnecessarily big, just because it cannot any most
recent common point between commits for pruning.
Short-circuiting the case where we already have that reference means that
we avoid a lot of these in the common case.
NOTE! This only matches remote ref names against the same local name,
which works well for tags, but is not as generic as it could be. If we
ever need to, we could match against _any_ local ref (if we have it, we
have it), but this "match against same name" is simpler and more
efficient, and covers the common case.
Renaming of refs is common for branch heads, but since those are always
commits, the pack-file generation can optimize that case.
In some cases we might still end up fetching pack-files unnecessarily, but
this at least avoids the re-fetching of tags over and over if you use a
regular
git fetch --tags ...
which was the main reason behind the change.
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2005-10-18 18:35:17 +00:00
|
|
|
packet_flush(fd[1]);
|
|
|
|
goto all_done;
|
|
|
|
}
|
2005-08-12 09:08:29 +00:00
|
|
|
if (find_common(fd, sha1, ref) < 0)
|
2006-03-20 08:21:10 +00:00
|
|
|
if (!keep_pack)
|
|
|
|
/* When cloning, it is not unusual to have
|
|
|
|
* no common commit.
|
|
|
|
*/
|
|
|
|
fprintf(stderr, "warning: no common commits\n");
|
2005-12-15 06:17:38 +00:00
|
|
|
|
|
|
|
if (keep_pack)
|
Make "git clone" less of a deathly quiet experience
It used to be that "git-unpack-objects" would give nice percentages, but
now that we don't unpack the initial clone pack any more, it doesn't. And
I'd love to do that nice percentage view in the pack objects downloader
too, but the thing doesn't even read the pack header, much less know how
much it's going to get, so I was lazy and didn't.
Instead, it at least prints out how much data it's gotten, and what the
packing speed is. Which makes the user realize that it's actually doing
something useful instead of sitting there silently (and if the recipient
knows how large the final result is, he can at least make a guess about
when it migt be done).
So with this patch, I get something like this on my DSL line:
[torvalds@g5 ~]$ time git clone master.kernel.org:/pub/scm/linux/kernel/git/torvalds/linux-2.6 clone-test
Packing 188543 objects
48.398MB (154 kB/s)
where even the speed approximation seems to be roughtly correct (even
though my algorithm is a truly stupid one, and only really gives "speed in
the last half second or so").
Anyway, _something_ like this is definitely needed. It could certainly be
better (if it showed the same kind of thing that git-unpack-objects did,
that would be much nicer, but would require parsing the object stream as
it comes in). But this is big step forward, I think.
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-02-11 04:31:09 +00:00
|
|
|
status = receive_keep_pack(fd, "git-fetch-pack", quiet);
|
2005-12-15 06:17:38 +00:00
|
|
|
else
|
|
|
|
status = receive_unpack_pack(fd, "git-fetch-pack", quiet);
|
|
|
|
|
|
|
|
if (status)
|
|
|
|
die("git-fetch-pack: fetch failed.");
|
|
|
|
|
|
|
|
all_done:
|
|
|
|
while (ref) {
|
|
|
|
printf("%s %s\n",
|
|
|
|
sha1_to_hex(ref->old_sha1), ref->name);
|
|
|
|
ref = ref->next;
|
2005-07-04 23:35:13 +00:00
|
|
|
}
|
2005-12-15 06:17:38 +00:00
|
|
|
return 0;
|
2005-07-04 20:26:53 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
int main(int argc, char **argv)
|
|
|
|
{
|
|
|
|
int i, ret, nr_heads;
|
|
|
|
char *dest = NULL, **heads;
|
|
|
|
int fd[2];
|
|
|
|
pid_t pid;
|
|
|
|
|
2005-11-26 08:47:59 +00:00
|
|
|
setup_git_directory();
|
|
|
|
|
2005-07-04 20:26:53 +00:00
|
|
|
nr_heads = 0;
|
|
|
|
heads = NULL;
|
|
|
|
for (i = 1; i < argc; i++) {
|
|
|
|
char *arg = argv[i];
|
|
|
|
|
|
|
|
if (*arg == '-') {
|
2005-07-14 07:08:37 +00:00
|
|
|
if (!strncmp("--exec=", arg, 7)) {
|
|
|
|
exec = arg + 7;
|
|
|
|
continue;
|
|
|
|
}
|
2005-12-18 09:55:29 +00:00
|
|
|
if (!strcmp("--quiet", arg) || !strcmp("-q", arg)) {
|
2005-08-12 09:08:29 +00:00
|
|
|
quiet = 1;
|
|
|
|
continue;
|
|
|
|
}
|
2005-12-18 09:55:29 +00:00
|
|
|
if (!strcmp("--keep", arg) || !strcmp("-k", arg)) {
|
2005-12-15 06:17:38 +00:00
|
|
|
keep_pack = 1;
|
|
|
|
continue;
|
|
|
|
}
|
2006-02-20 08:38:39 +00:00
|
|
|
if (!strcmp("--thin", arg)) {
|
|
|
|
use_thin_pack = 1;
|
|
|
|
continue;
|
|
|
|
}
|
2006-03-20 08:21:10 +00:00
|
|
|
if (!strcmp("--all", arg)) {
|
|
|
|
fetch_all = 1;
|
|
|
|
continue;
|
|
|
|
}
|
2005-08-12 09:08:29 +00:00
|
|
|
if (!strcmp("-v", arg)) {
|
|
|
|
verbose = 1;
|
|
|
|
continue;
|
|
|
|
}
|
2005-07-04 20:26:53 +00:00
|
|
|
usage(fetch_pack_usage);
|
|
|
|
}
|
|
|
|
dest = arg;
|
|
|
|
heads = argv + i + 1;
|
|
|
|
nr_heads = argc - i - 1;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (!dest)
|
|
|
|
usage(fetch_pack_usage);
|
2006-02-20 08:38:39 +00:00
|
|
|
if (keep_pack)
|
|
|
|
use_thin_pack = 0;
|
2005-07-04 20:26:53 +00:00
|
|
|
pid = git_connect(fd, dest, exec);
|
|
|
|
if (pid < 0)
|
|
|
|
return 1;
|
|
|
|
ret = fetch_pack(fd, nr_heads, heads);
|
|
|
|
close(fd[0]);
|
|
|
|
close(fd[1]);
|
|
|
|
finish_connect(pid);
|
2005-11-06 08:09:59 +00:00
|
|
|
|
|
|
|
if (!ret && nr_heads) {
|
|
|
|
/* If the heads to pull were given, we should have
|
|
|
|
* consumed all of them by matching the remote.
|
|
|
|
* Otherwise, 'git-fetch remote no-such-ref' would
|
|
|
|
* silently succeed without issuing an error.
|
|
|
|
*/
|
|
|
|
for (i = 0; i < nr_heads; i++)
|
|
|
|
if (heads[i] && heads[i][0]) {
|
|
|
|
error("no such remote ref %s", heads[i]);
|
|
|
|
ret = 1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2005-07-04 20:26:53 +00:00
|
|
|
return ret;
|
|
|
|
}
|