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"
|
2006-11-01 22:06:23 +00:00
|
|
|
#include "exec_cmd.h"
|
2007-01-23 06:37:33 +00:00
|
|
|
#include "pack.h"
|
2006-11-01 22:06:23 +00:00
|
|
|
#include "sideband.h"
|
2007-09-11 03:03:00 +00:00
|
|
|
#include "fetch-pack.h"
|
2008-02-04 18:26:23 +00:00
|
|
|
#include "remote.h"
|
2007-10-19 19:47:57 +00:00
|
|
|
#include "run-command.h"
|
2005-07-04 20:26:53 +00:00
|
|
|
|
2007-01-25 01:02:15 +00:00
|
|
|
static int transfer_unpack_limit = -1;
|
|
|
|
static int fetch_unpack_limit = -1;
|
2007-01-25 00:47:24 +00:00
|
|
|
static int unpack_limit = 100;
|
2009-05-02 00:18:02 +00:00
|
|
|
static int prefer_ofs_delta = 1;
|
2007-10-30 02:35:08 +00:00
|
|
|
static struct fetch_pack_args args = {
|
|
|
|
/* .uploadpack = */ "git-upload-pack",
|
|
|
|
};
|
2007-09-19 04:49:35 +00:00
|
|
|
|
2005-08-12 09:08:29 +00:00
|
|
|
static const char fetch_pack_usage[] =
|
2008-07-13 13:36:15 +00:00
|
|
|
"git fetch-pack [--all] [--quiet|-q] [--keep|-k] [--thin] [--include-tag] [--upload-pack=<git-upload-pack>] [--depth=<n>] [--no-progress] [-v] [<host>:]<directory> [<refs>...]";
|
2005-07-04 20:26:53 +00:00
|
|
|
|
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)
|
|
|
|
|
2008-03-18 02:15:02 +00:00
|
|
|
static int marked;
|
|
|
|
|
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
|
|
|
|
|
2006-08-15 17:23:48 +00:00
|
|
|
static struct commit_list *rev_list;
|
2007-11-07 22:20:22 +00:00
|
|
|
static int non_common_revs, multi_ack, use_sideband;
|
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))
|
2008-03-03 06:31:23 +00:00
|
|
|
if (parse_commit(commit))
|
|
|
|
return;
|
2005-10-28 02:46:27 +00:00
|
|
|
|
|
|
|
insert_by_date(commit, &rev_list);
|
|
|
|
|
|
|
|
if (!(commit->object.flags & COMMON))
|
|
|
|
non_common_revs++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2006-09-21 05:02:01 +00:00
|
|
|
static int rev_list_insert_ref(const char *path, const unsigned char *sha1, int flag, void *cb_data)
|
2005-10-28 02:46:27 +00:00
|
|
|
{
|
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
|
|
|
|
2006-07-12 03:45:31 +00:00
|
|
|
if (o && o->type == OBJ_COMMIT)
|
2005-10-28 02:46:27 +00:00
|
|
|
rev_list_push((struct commit *)o, SEEN);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2008-03-18 02:15:02 +00:00
|
|
|
static int clear_marks(const char *path, const unsigned char *sha1, int flag, void *cb_data)
|
|
|
|
{
|
|
|
|
struct object *o = deref_tag(parse_object(sha1), path, 0);
|
|
|
|
|
|
|
|
if (o && o->type == OBJ_COMMIT)
|
|
|
|
clear_commit_marks((struct commit *)o,
|
|
|
|
COMMON | COMMON_REF | SEEN | POPPED);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2005-10-28 02:46:27 +00:00
|
|
|
/*
|
|
|
|
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)
|
2008-03-03 06:31:23 +00:00
|
|
|
if (parse_commit(commit))
|
|
|
|
return;
|
2005-10-28 02:46:27 +00:00
|
|
|
|
|
|
|
for (parents = commit->parents;
|
|
|
|
parents;
|
|
|
|
parents = parents->next)
|
|
|
|
mark_common(parents->item, 0, dont_parse);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
Get the next rev to send, ignoring the common.
|
|
|
|
*/
|
|
|
|
|
2009-05-01 09:06:36 +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;
|
2008-04-28 23:27:49 +00:00
|
|
|
struct commit_list *parents;
|
2005-10-28 02:46:27 +00:00
|
|
|
|
|
|
|
if (rev_list == NULL || non_common_revs == 0)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
commit = rev_list->item;
|
2008-04-30 18:42:05 +00:00
|
|
|
if (!commit->object.parsed)
|
2008-04-28 23:27:49 +00:00
|
|
|
parse_commit(commit);
|
|
|
|
parents = commit->parents;
|
2008-03-03 06:31:23 +00:00
|
|
|
|
2005-10-28 02:46:27 +00:00
|
|
|
commit->object.flags |= POPPED;
|
|
|
|
if (!(commit->object.flags & COMMON))
|
|
|
|
non_common_revs--;
|
2007-06-07 07:04:01 +00:00
|
|
|
|
2005-10-28 02:46:27 +00:00
|
|
|
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
|
|
|
|
2009-10-31 00:47:25 +00:00
|
|
|
enum ack_type {
|
|
|
|
NAK = 0,
|
|
|
|
ACK,
|
|
|
|
ACK_continue,
|
|
|
|
ACK_common,
|
|
|
|
ACK_ready
|
|
|
|
};
|
|
|
|
|
|
|
|
static enum ack_type get_ack(int fd, unsigned char *result_sha1)
|
2009-10-31 00:47:24 +00:00
|
|
|
{
|
|
|
|
static char line[1000];
|
|
|
|
int len = packet_read_line(fd, line, sizeof(line));
|
|
|
|
|
|
|
|
if (!len)
|
|
|
|
die("git fetch-pack: expected ACK/NAK, got EOF");
|
|
|
|
if (line[len-1] == '\n')
|
|
|
|
line[--len] = 0;
|
|
|
|
if (!strcmp(line, "NAK"))
|
2009-10-31 00:47:25 +00:00
|
|
|
return NAK;
|
2009-10-31 00:47:24 +00:00
|
|
|
if (!prefixcmp(line, "ACK ")) {
|
|
|
|
if (!get_sha1_hex(line+4, result_sha1)) {
|
|
|
|
if (strstr(line+45, "continue"))
|
2009-10-31 00:47:25 +00:00
|
|
|
return ACK_continue;
|
|
|
|
if (strstr(line+45, "common"))
|
|
|
|
return ACK_common;
|
|
|
|
if (strstr(line+45, "ready"))
|
|
|
|
return ACK_ready;
|
|
|
|
return ACK;
|
2009-10-31 00:47:24 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
die("git fetch_pack: expected ACK/NAK, got '%s'", line);
|
|
|
|
}
|
|
|
|
|
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;
|
2009-10-31 00:47:23 +00:00
|
|
|
struct strbuf req_buf = STRBUF_INIT;
|
2005-10-28 02:46:27 +00:00
|
|
|
|
2008-03-18 02:15:02 +00:00
|
|
|
if (marked)
|
|
|
|
for_each_ref(clear_marks, NULL);
|
|
|
|
marked = 1;
|
|
|
|
|
2006-09-21 04:47:42 +00:00
|
|
|
for_each_ref(rev_list_insert_ref, NULL);
|
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;
|
2009-10-31 00:47:23 +00:00
|
|
|
const char *remote_hex;
|
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
|
|
|
|
2009-10-31 00:47:23 +00:00
|
|
|
remote_hex = sha1_to_hex(remote);
|
|
|
|
if (!fetching) {
|
|
|
|
struct strbuf c = STRBUF_INIT;
|
2009-10-31 00:47:25 +00:00
|
|
|
if (multi_ack == 2) strbuf_addstr(&c, " multi_ack_detailed");
|
|
|
|
if (multi_ack == 1) strbuf_addstr(&c, " multi_ack");
|
2009-10-31 00:47:23 +00:00
|
|
|
if (use_sideband == 2) strbuf_addstr(&c, " side-band-64k");
|
|
|
|
if (use_sideband == 1) strbuf_addstr(&c, " side-band");
|
|
|
|
if (args.use_thin_pack) strbuf_addstr(&c, " thin-pack");
|
|
|
|
if (args.no_progress) strbuf_addstr(&c, " no-progress");
|
|
|
|
if (args.include_tag) strbuf_addstr(&c, " include-tag");
|
|
|
|
if (prefer_ofs_delta) strbuf_addstr(&c, " ofs-delta");
|
|
|
|
packet_buf_write(&req_buf, "want %s%s\n", remote_hex, c.buf);
|
|
|
|
strbuf_release(&c);
|
|
|
|
} else
|
|
|
|
packet_buf_write(&req_buf, "want %s\n", remote_hex);
|
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
|
|
|
}
|
2009-10-31 00:47:23 +00:00
|
|
|
|
|
|
|
if (!fetching) {
|
|
|
|
strbuf_release(&req_buf);
|
|
|
|
packet_flush(fd[1]);
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2006-10-30 19:09:06 +00:00
|
|
|
if (is_repository_shallow())
|
2009-10-31 00:47:23 +00:00
|
|
|
write_shallow_commits(&req_buf, 1);
|
2007-09-19 04:49:35 +00:00
|
|
|
if (args.depth > 0)
|
2009-10-31 00:47:23 +00:00
|
|
|
packet_buf_write(&req_buf, "deepen %d", args.depth);
|
|
|
|
packet_buf_flush(&req_buf);
|
|
|
|
|
|
|
|
safe_write(fd[1], req_buf.buf, req_buf.len);
|
2005-10-19 23:14:34 +00:00
|
|
|
|
2007-09-19 04:49:35 +00:00
|
|
|
if (args.depth > 0) {
|
allow cloning a repository "shallowly"
By specifying a depth, you can now clone a repository such that
all fetched ancestor-chains' length is at most "depth". For example,
if the upstream repository has only 2 branches ("A" and "B"), which
are linear, and you specify depth 3, you will get A, A~1, A~2, A~3,
B, B~1, B~2, and B~3. The ends are automatically made shallow
commits.
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-10-30 19:09:29 +00:00
|
|
|
char line[1024];
|
|
|
|
unsigned char sha1[20];
|
|
|
|
|
2009-03-07 20:02:10 +00:00
|
|
|
while (packet_read_line(fd[0], line, sizeof(line))) {
|
2007-02-20 09:54:00 +00:00
|
|
|
if (!prefixcmp(line, "shallow ")) {
|
allow cloning a repository "shallowly"
By specifying a depth, you can now clone a repository such that
all fetched ancestor-chains' length is at most "depth". For example,
if the upstream repository has only 2 branches ("A" and "B"), which
are linear, and you specify depth 3, you will get A, A~1, A~2, A~3,
B, B~1, B~2, and B~3. The ends are automatically made shallow
commits.
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-10-30 19:09:29 +00:00
|
|
|
if (get_sha1_hex(line + 8, sha1))
|
|
|
|
die("invalid shallow line: %s", line);
|
|
|
|
register_shallow(sha1);
|
2006-11-14 06:04:56 +00:00
|
|
|
continue;
|
|
|
|
}
|
2007-02-20 09:54:00 +00:00
|
|
|
if (!prefixcmp(line, "unshallow ")) {
|
2006-10-30 19:09:53 +00:00
|
|
|
if (get_sha1_hex(line + 10, sha1))
|
|
|
|
die("invalid unshallow line: %s", line);
|
|
|
|
if (!lookup_object(sha1))
|
|
|
|
die("object not found: %s", line);
|
|
|
|
/* make sure that it is parsed as shallow */
|
2008-03-03 06:31:23 +00:00
|
|
|
if (!parse_object(sha1))
|
|
|
|
die("error in object: %s", line);
|
2006-10-30 19:09:53 +00:00
|
|
|
if (unregister_shallow(sha1))
|
|
|
|
die("no shallow found: %s", line);
|
2006-11-14 06:04:56 +00:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
die("expected shallow/unshallow, got %s", line);
|
allow cloning a repository "shallowly"
By specifying a depth, you can now clone a repository such that
all fetched ancestor-chains' length is at most "depth". For example,
if the upstream repository has only 2 branches ("A" and "B"), which
are linear, and you specify depth 3, you will get A, A~1, A~2, A~3,
B, B~1, B~2, and B~3. The ends are automatically made shallow
commits.
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-10-30 19:09:29 +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));
|
2007-09-19 04:49:35 +00:00
|
|
|
if (args.verbose)
|
2005-08-12 09:08:29 +00:00
|
|
|
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);
|
2007-09-19 04:49:35 +00:00
|
|
|
if (args.verbose && ack)
|
2005-10-28 02:50:26 +00:00
|
|
|
fprintf(stderr, "got ack %d %s\n", ack,
|
|
|
|
sha1_to_hex(result_sha1));
|
2009-10-31 00:47:25 +00:00
|
|
|
switch (ack) {
|
|
|
|
case ACK:
|
2005-10-28 02:50:26 +00:00
|
|
|
flushes = 0;
|
|
|
|
multi_ack = 0;
|
|
|
|
retval = 0;
|
|
|
|
goto done;
|
2009-10-31 00:47:25 +00:00
|
|
|
case ACK_common:
|
|
|
|
case ACK_ready:
|
|
|
|
case ACK_continue: {
|
2005-10-28 02:50:26 +00:00
|
|
|
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;
|
2009-10-31 00:47:25 +00:00
|
|
|
break;
|
|
|
|
}
|
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) {
|
2007-09-19 04:49:35 +00:00
|
|
|
if (args.verbose)
|
2006-05-25 04:48:34 +00:00
|
|
|
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");
|
2007-09-19 04:49:35 +00:00
|
|
|
if (args.verbose)
|
2005-08-12 09:08:29 +00:00
|
|
|
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
|
|
|
}
|
2009-10-31 00:47:23 +00:00
|
|
|
strbuf_release(&req_buf);
|
|
|
|
|
2005-10-28 02:50:26 +00:00
|
|
|
while (flushes || multi_ack) {
|
|
|
|
int ack = get_ack(fd[0], result_sha1);
|
|
|
|
if (ack) {
|
2007-09-19 04:49:35 +00:00
|
|
|
if (args.verbose)
|
2005-10-28 02:50:26 +00:00
|
|
|
fprintf(stderr, "got ack (%d) %s\n", ack,
|
|
|
|
sha1_to_hex(result_sha1));
|
2009-10-31 00:47:25 +00:00
|
|
|
if (ack == ACK)
|
2005-10-28 02:50:26 +00:00
|
|
|
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
|
|
|
}
|
2008-07-02 17:06:56 +00:00
|
|
|
/* it is no error to fetch into a completely empty repo */
|
|
|
|
return count ? retval : 0;
|
2005-07-04 20:26:53 +00:00
|
|
|
}
|
|
|
|
|
2006-08-15 17:23:48 +00:00
|
|
|
static struct commit_list *complete;
|
2005-10-19 21:27:02 +00:00
|
|
|
|
2006-09-21 05:02:01 +00:00
|
|
|
static int mark_complete(const char *path, const unsigned char *sha1, int flag, void *cb_data)
|
2005-10-19 21:27:02 +00:00
|
|
|
{
|
|
|
|
struct object *o = parse_object(sha1);
|
|
|
|
|
2006-07-12 03:45:31 +00:00
|
|
|
while (o && o->type == OBJ_TAG) {
|
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
|
|
|
}
|
2006-07-12 03:45:31 +00:00
|
|
|
if (o && o->type == OBJ_COMMIT) {
|
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) {
|
2007-09-19 04:49:35 +00:00
|
|
|
if (args.verbose)
|
2005-10-19 21:27:02 +00:00
|
|
|
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];
|
|
|
|
|
2007-09-19 04:49:35 +00:00
|
|
|
if (nr_match && !args.fetch_all) {
|
2006-05-11 22:28:44 +00:00
|
|
|
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 */
|
2007-09-19 04:49:35 +00:00
|
|
|
else if (args.fetch_all &&
|
|
|
|
(!args.depth || prefixcmp(ref->name, "refs/tags/") )) {
|
2006-05-11 22:28:44 +00:00
|
|
|
*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);
|
|
|
|
}
|
|
|
|
|
2007-09-19 04:49:35 +00:00
|
|
|
if (!args.fetch_all) {
|
2006-05-11 22:28:44 +00:00
|
|
|
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;
|
|
|
|
|
|
|
|
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).
|
|
|
|
*/
|
2006-07-12 03:45:31 +00:00
|
|
|
if (o->type == OBJ_COMMIT) {
|
2005-10-19 21:27:02 +00:00
|
|
|
struct commit *commit = (struct commit *)o;
|
|
|
|
if (!cutoff || cutoff < commit->date)
|
|
|
|
cutoff = commit->date;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2007-09-19 04:49:35 +00:00
|
|
|
if (!args.depth) {
|
2006-10-30 19:09:53 +00:00
|
|
|
for_each_ref(mark_complete, NULL);
|
|
|
|
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
|
|
|
|
2006-07-12 03:45:31 +00:00
|
|
|
if (!o || o->type != OBJ_COMMIT || !(o->flags & COMPLETE))
|
2005-10-28 02:47:07 +00:00
|
|
|
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;
|
2007-09-19 04:49:35 +00:00
|
|
|
if (!args.verbose)
|
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;
|
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2006-08-23 06:49:00 +00:00
|
|
|
hashcpy(ref->new_sha1, local);
|
2007-09-19 04:49:35 +00:00
|
|
|
if (!args.verbose)
|
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;
|
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2007-10-19 19:48:01 +00:00
|
|
|
static int sideband_demux(int fd, void *data)
|
2006-11-01 22:06:23 +00:00
|
|
|
{
|
2007-10-19 19:48:01 +00:00
|
|
|
int *xd = data;
|
2006-11-01 22:06:23 +00:00
|
|
|
|
2009-06-08 08:51:22 +00:00
|
|
|
int ret = recv_sideband("fetch-pack", xd[0], fd);
|
|
|
|
close(fd);
|
|
|
|
return ret;
|
2007-10-19 19:48:01 +00:00
|
|
|
}
|
|
|
|
|
2007-09-14 07:31:23 +00:00
|
|
|
static int get_pack(int xd[2], char **pack_lockfile)
|
2006-11-01 22:06:23 +00:00
|
|
|
{
|
2007-10-19 19:48:01 +00:00
|
|
|
struct async demux;
|
2007-01-23 06:37:33 +00:00
|
|
|
const char *argv[20];
|
|
|
|
char keep_arg[256];
|
|
|
|
char hdr_arg[256];
|
|
|
|
const char **av;
|
2007-09-19 04:49:35 +00:00
|
|
|
int do_keep = args.keep_pack;
|
2007-10-19 19:47:57 +00:00
|
|
|
struct child_process cmd;
|
2006-11-01 22:06:23 +00:00
|
|
|
|
fetch-pack: Prepare for a side-band demultiplexer in a thread.
get_pack() receives a pair of file descriptors that communicate with
upload-pack at the remote end. In order to support the case where the
side-band demultiplexer runs in a thread, and, hence, in the same process
as the main routine, we must not close the readable file descriptor early.
The handling of the readable fd is changed in the case where upload-pack
supports side-band communication: The old code closed the fd after it was
inherited to the side-band demultiplexer process. Now we do not close it.
The caller (do_fetch_pack) will close it later anyway. The demultiplexer
is the only reader, it does not matter that the fd remains open in the
main process as well as in unpack-objects/index-pack, which inherits it.
The writable fd is not needed in get_pack(), hence, the old code closed
the fd. For symmetry with the readable fd, we now do not close it; the
caller (do_fetch_pack) will close it later anyway. Therefore, the new
behavior is that the channel now remains open during the entire
conversation, but this has no ill effects because upload-pack does not read
from it once it has begun to send the pack data. For the same reason it
does not matter that the writable fd is now inherited to the demultiplexer
and unpack-objects/index-pack processes.
Signed-off-by: Johannes Sixt <johannes.sixt@telecom.at>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2007-11-17 22:09:28 +00:00
|
|
|
memset(&demux, 0, sizeof(demux));
|
|
|
|
if (use_sideband) {
|
|
|
|
/* xd[] is talking with upload-pack; subprocess reads from
|
|
|
|
* xd[0], spits out band#2 to stderr, and feeds us band#1
|
|
|
|
* through demux->out.
|
|
|
|
*/
|
|
|
|
demux.proc = sideband_demux;
|
|
|
|
demux.data = xd;
|
|
|
|
if (start_async(&demux))
|
|
|
|
die("fetch-pack: unable to fork off sideband"
|
|
|
|
" demultiplexer");
|
|
|
|
}
|
|
|
|
else
|
|
|
|
demux.out = xd[0];
|
2007-01-23 06:37:33 +00:00
|
|
|
|
2007-10-19 19:47:57 +00:00
|
|
|
memset(&cmd, 0, sizeof(cmd));
|
|
|
|
cmd.argv = argv;
|
2007-01-23 06:37:33 +00:00
|
|
|
av = argv;
|
|
|
|
*hdr_arg = 0;
|
2007-09-19 04:49:35 +00:00
|
|
|
if (!args.keep_pack && unpack_limit) {
|
2007-01-23 06:37:33 +00:00
|
|
|
struct pack_header header;
|
|
|
|
|
fetch-pack: Prepare for a side-band demultiplexer in a thread.
get_pack() receives a pair of file descriptors that communicate with
upload-pack at the remote end. In order to support the case where the
side-band demultiplexer runs in a thread, and, hence, in the same process
as the main routine, we must not close the readable file descriptor early.
The handling of the readable fd is changed in the case where upload-pack
supports side-band communication: The old code closed the fd after it was
inherited to the side-band demultiplexer process. Now we do not close it.
The caller (do_fetch_pack) will close it later anyway. The demultiplexer
is the only reader, it does not matter that the fd remains open in the
main process as well as in unpack-objects/index-pack, which inherits it.
The writable fd is not needed in get_pack(), hence, the old code closed
the fd. For symmetry with the readable fd, we now do not close it; the
caller (do_fetch_pack) will close it later anyway. Therefore, the new
behavior is that the channel now remains open during the entire
conversation, but this has no ill effects because upload-pack does not read
from it once it has begun to send the pack data. For the same reason it
does not matter that the writable fd is now inherited to the demultiplexer
and unpack-objects/index-pack processes.
Signed-off-by: Johannes Sixt <johannes.sixt@telecom.at>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2007-11-17 22:09:28 +00:00
|
|
|
if (read_pack_header(demux.out, &header))
|
2007-01-23 06:37:33 +00:00
|
|
|
die("protocol error: bad pack header");
|
2008-07-03 15:52:09 +00:00
|
|
|
snprintf(hdr_arg, sizeof(hdr_arg),
|
|
|
|
"--pack_header=%"PRIu32",%"PRIu32,
|
2007-01-23 06:37:33 +00:00
|
|
|
ntohl(header.hdr_version), ntohl(header.hdr_entries));
|
2007-01-25 00:47:24 +00:00
|
|
|
if (ntohl(header.hdr_entries) < unpack_limit)
|
2007-01-23 06:37:33 +00:00
|
|
|
do_keep = 0;
|
|
|
|
else
|
|
|
|
do_keep = 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (do_keep) {
|
2007-10-19 19:47:57 +00:00
|
|
|
if (pack_lockfile)
|
|
|
|
cmd.out = -1;
|
2007-01-23 06:37:33 +00:00
|
|
|
*av++ = "index-pack";
|
|
|
|
*av++ = "--stdin";
|
2007-09-19 04:49:35 +00:00
|
|
|
if (!args.quiet && !args.no_progress)
|
2007-01-23 06:37:33 +00:00
|
|
|
*av++ = "-v";
|
2007-09-19 04:49:35 +00:00
|
|
|
if (args.use_thin_pack)
|
2007-01-23 06:37:33 +00:00
|
|
|
*av++ = "--fix-thin";
|
2007-09-19 04:49:35 +00:00
|
|
|
if (args.lock_pack || unpack_limit) {
|
2007-01-23 06:37:33 +00:00
|
|
|
int s = sprintf(keep_arg,
|
2008-08-31 12:09:39 +00:00
|
|
|
"--keep=fetch-pack %"PRIuMAX " on ", (uintmax_t) getpid());
|
2007-01-23 06:37:33 +00:00
|
|
|
if (gethostname(keep_arg + s, sizeof(keep_arg) - s))
|
|
|
|
strcpy(keep_arg + s, "localhost");
|
|
|
|
*av++ = keep_arg;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
*av++ = "unpack-objects";
|
2007-09-19 04:49:35 +00:00
|
|
|
if (args.quiet)
|
2007-01-23 06:37:33 +00:00
|
|
|
*av++ = "-q";
|
|
|
|
}
|
|
|
|
if (*hdr_arg)
|
|
|
|
*av++ = hdr_arg;
|
|
|
|
*av++ = NULL;
|
|
|
|
|
fetch-pack: Prepare for a side-band demultiplexer in a thread.
get_pack() receives a pair of file descriptors that communicate with
upload-pack at the remote end. In order to support the case where the
side-band demultiplexer runs in a thread, and, hence, in the same process
as the main routine, we must not close the readable file descriptor early.
The handling of the readable fd is changed in the case where upload-pack
supports side-band communication: The old code closed the fd after it was
inherited to the side-band demultiplexer process. Now we do not close it.
The caller (do_fetch_pack) will close it later anyway. The demultiplexer
is the only reader, it does not matter that the fd remains open in the
main process as well as in unpack-objects/index-pack, which inherits it.
The writable fd is not needed in get_pack(), hence, the old code closed
the fd. For symmetry with the readable fd, we now do not close it; the
caller (do_fetch_pack) will close it later anyway. Therefore, the new
behavior is that the channel now remains open during the entire
conversation, but this has no ill effects because upload-pack does not read
from it once it has begun to send the pack data. For the same reason it
does not matter that the writable fd is now inherited to the demultiplexer
and unpack-objects/index-pack processes.
Signed-off-by: Johannes Sixt <johannes.sixt@telecom.at>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2007-11-17 22:09:28 +00:00
|
|
|
cmd.in = demux.out;
|
2007-10-19 19:47:57 +00:00
|
|
|
cmd.git_cmd = 1;
|
|
|
|
if (start_command(&cmd))
|
2006-11-01 22:06:23 +00:00
|
|
|
die("fetch-pack: unable to fork off %s", argv[0]);
|
2008-02-16 17:36:38 +00:00
|
|
|
if (do_keep && pack_lockfile) {
|
2007-10-19 19:47:57 +00:00
|
|
|
*pack_lockfile = index_pack_lockfile(cmd.out);
|
2008-02-16 17:36:38 +00:00
|
|
|
close(cmd.out);
|
|
|
|
}
|
2007-10-19 19:47:57 +00:00
|
|
|
|
|
|
|
if (finish_command(&cmd))
|
|
|
|
die("%s failed", argv[0]);
|
2007-10-19 19:48:01 +00:00
|
|
|
if (use_sideband && finish_async(&demux))
|
|
|
|
die("error in sideband demultiplexer");
|
2007-10-19 19:47:57 +00:00
|
|
|
return 0;
|
2006-11-01 22:06:23 +00:00
|
|
|
}
|
|
|
|
|
2007-09-14 07:31:23 +00:00
|
|
|
static struct ref *do_fetch_pack(int fd[2],
|
2008-02-04 18:26:23 +00:00
|
|
|
const struct ref *orig_ref,
|
2007-09-14 07:31:23 +00:00
|
|
|
int nr_match,
|
|
|
|
char **match,
|
|
|
|
char **pack_lockfile)
|
2005-07-04 20:26:53 +00:00
|
|
|
{
|
2008-02-04 18:26:23 +00:00
|
|
|
struct ref *ref = copy_ref_list(orig_ref);
|
2005-07-16 20:55:50 +00:00
|
|
|
unsigned char sha1[20];
|
2005-07-04 20:26:53 +00:00
|
|
|
|
2006-10-30 19:09:06 +00:00
|
|
|
if (is_repository_shallow() && !server_supports("shallow"))
|
|
|
|
die("Server does not support shallow clients");
|
2009-10-31 00:47:25 +00:00
|
|
|
if (server_supports("multi_ack_detailed")) {
|
|
|
|
if (args.verbose)
|
|
|
|
fprintf(stderr, "Server supports multi_ack_detailed\n");
|
|
|
|
multi_ack = 2;
|
|
|
|
}
|
|
|
|
else if (server_supports("multi_ack")) {
|
2007-09-19 04:49:35 +00:00
|
|
|
if (args.verbose)
|
2005-10-28 02:50:26 +00:00
|
|
|
fprintf(stderr, "Server supports multi_ack\n");
|
|
|
|
multi_ack = 1;
|
|
|
|
}
|
2006-09-10 23:27:08 +00:00
|
|
|
if (server_supports("side-band-64k")) {
|
2007-09-19 04:49:35 +00:00
|
|
|
if (args.verbose)
|
2006-09-10 23:27:08 +00:00
|
|
|
fprintf(stderr, "Server supports side-band-64k\n");
|
|
|
|
use_sideband = 2;
|
|
|
|
}
|
|
|
|
else if (server_supports("side-band")) {
|
2007-09-19 04:49:35 +00:00
|
|
|
if (args.verbose)
|
2006-06-21 07:30:21 +00:00
|
|
|
fprintf(stderr, "Server supports side-band\n");
|
|
|
|
use_sideband = 1;
|
|
|
|
}
|
2009-05-02 00:18:02 +00:00
|
|
|
if (server_supports("ofs-delta")) {
|
|
|
|
if (args.verbose)
|
|
|
|
fprintf(stderr, "Server supports ofs-delta\n");
|
|
|
|
} else
|
|
|
|
prefer_ofs_delta = 0;
|
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)
|
2007-09-19 04:49:35 +00:00
|
|
|
if (!args.keep_pack)
|
2006-03-20 08:21:10 +00:00
|
|
|
/* When cloning, it is not unusual to have
|
|
|
|
* no common commit.
|
|
|
|
*/
|
2009-03-24 01:09:12 +00:00
|
|
|
warning("no common commits");
|
2005-12-15 06:17:38 +00:00
|
|
|
|
2007-09-14 07:31:23 +00:00
|
|
|
if (get_pack(fd, pack_lockfile))
|
2008-08-31 16:39:19 +00:00
|
|
|
die("git fetch-pack: fetch failed.");
|
2005-12-15 06:17:38 +00:00
|
|
|
|
|
|
|
all_done:
|
2007-09-11 03:03:00 +00:00
|
|
|
return ref;
|
2005-07-04 20:26:53 +00:00
|
|
|
}
|
|
|
|
|
2006-11-25 09:33:06 +00:00
|
|
|
static int remove_duplicates(int nr_heads, char **heads)
|
|
|
|
{
|
|
|
|
int src, dst;
|
|
|
|
|
|
|
|
for (src = dst = 0; src < nr_heads; src++) {
|
|
|
|
/* If heads[src] is different from any of
|
|
|
|
* heads[0..dst], push it in.
|
|
|
|
*/
|
|
|
|
int i;
|
|
|
|
for (i = 0; i < dst; i++) {
|
|
|
|
if (!strcmp(heads[i], heads[src]))
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (i < dst)
|
|
|
|
continue;
|
|
|
|
if (src != dst)
|
|
|
|
heads[dst] = heads[src];
|
|
|
|
dst++;
|
|
|
|
}
|
|
|
|
return dst;
|
|
|
|
}
|
|
|
|
|
2008-05-14 17:46:53 +00:00
|
|
|
static int fetch_pack_config(const char *var, const char *value, void *cb)
|
2007-01-25 00:47:24 +00:00
|
|
|
{
|
|
|
|
if (strcmp(var, "fetch.unpacklimit") == 0) {
|
2007-01-25 01:02:15 +00:00
|
|
|
fetch_unpack_limit = git_config_int(var, value);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (strcmp(var, "transfer.unpacklimit") == 0) {
|
|
|
|
transfer_unpack_limit = git_config_int(var, value);
|
2007-01-25 00:47:24 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2009-05-02 00:18:02 +00:00
|
|
|
if (strcmp(var, "repack.usedeltabaseoffset") == 0) {
|
|
|
|
prefer_ofs_delta = git_config_bool(var, value);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2008-05-14 17:46:53 +00:00
|
|
|
return git_default_config(var, value, cb);
|
2007-01-25 00:47:24 +00:00
|
|
|
}
|
|
|
|
|
2007-01-02 19:22:08 +00:00
|
|
|
static struct lock_file lock;
|
|
|
|
|
2007-09-19 04:49:39 +00:00
|
|
|
static void fetch_pack_setup(void)
|
2005-07-04 20:26:53 +00:00
|
|
|
{
|
2007-09-19 04:49:39 +00:00
|
|
|
static int did_setup;
|
|
|
|
if (did_setup)
|
|
|
|
return;
|
2008-05-14 17:46:53 +00:00
|
|
|
git_config(fetch_pack_config, NULL);
|
2007-01-25 01:02:15 +00:00
|
|
|
if (0 <= transfer_unpack_limit)
|
|
|
|
unpack_limit = transfer_unpack_limit;
|
|
|
|
else if (0 <= fetch_unpack_limit)
|
|
|
|
unpack_limit = fetch_unpack_limit;
|
2007-09-19 04:49:39 +00:00
|
|
|
did_setup = 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
int cmd_fetch_pack(int argc, const char **argv, const char *prefix)
|
|
|
|
{
|
|
|
|
int i, ret, nr_heads;
|
2008-02-04 18:26:23 +00:00
|
|
|
struct ref *ref = NULL;
|
2007-09-19 04:49:39 +00:00
|
|
|
char *dest = NULL, **heads;
|
2008-02-04 18:26:23 +00:00
|
|
|
int fd[2];
|
|
|
|
struct child_process *conn;
|
2007-01-25 01:02:15 +00:00
|
|
|
|
2005-07-04 20:26:53 +00:00
|
|
|
nr_heads = 0;
|
|
|
|
heads = NULL;
|
|
|
|
for (i = 1; i < argc; i++) {
|
2007-09-11 03:03:00 +00:00
|
|
|
const char *arg = argv[i];
|
2005-07-04 20:26:53 +00:00
|
|
|
|
|
|
|
if (*arg == '-') {
|
2007-02-20 09:54:00 +00:00
|
|
|
if (!prefixcmp(arg, "--upload-pack=")) {
|
2007-09-19 04:49:35 +00:00
|
|
|
args.uploadpack = arg + 14;
|
2007-01-23 08:20:17 +00:00
|
|
|
continue;
|
|
|
|
}
|
2007-02-20 09:54:00 +00:00
|
|
|
if (!prefixcmp(arg, "--exec=")) {
|
2007-09-19 04:49:35 +00:00
|
|
|
args.uploadpack = arg + 7;
|
2005-07-14 07:08:37 +00:00
|
|
|
continue;
|
|
|
|
}
|
2005-12-18 09:55:29 +00:00
|
|
|
if (!strcmp("--quiet", arg) || !strcmp("-q", arg)) {
|
2007-09-19 04:49:35 +00:00
|
|
|
args.quiet = 1;
|
2005-08-12 09:08:29 +00:00
|
|
|
continue;
|
|
|
|
}
|
2005-12-18 09:55:29 +00:00
|
|
|
if (!strcmp("--keep", arg) || !strcmp("-k", arg)) {
|
2007-09-19 04:49:35 +00:00
|
|
|
args.lock_pack = args.keep_pack;
|
|
|
|
args.keep_pack = 1;
|
2007-01-23 06:37:33 +00:00
|
|
|
continue;
|
|
|
|
}
|
2006-02-20 08:38:39 +00:00
|
|
|
if (!strcmp("--thin", arg)) {
|
2007-09-19 04:49:35 +00:00
|
|
|
args.use_thin_pack = 1;
|
2006-02-20 08:38:39 +00:00
|
|
|
continue;
|
|
|
|
}
|
2008-03-04 03:27:33 +00:00
|
|
|
if (!strcmp("--include-tag", arg)) {
|
|
|
|
args.include_tag = 1;
|
|
|
|
continue;
|
|
|
|
}
|
2006-03-20 08:21:10 +00:00
|
|
|
if (!strcmp("--all", arg)) {
|
2007-09-19 04:49:35 +00:00
|
|
|
args.fetch_all = 1;
|
2006-03-20 08:21:10 +00:00
|
|
|
continue;
|
|
|
|
}
|
2005-08-12 09:08:29 +00:00
|
|
|
if (!strcmp("-v", arg)) {
|
2007-09-19 04:49:35 +00:00
|
|
|
args.verbose = 1;
|
2005-08-12 09:08:29 +00:00
|
|
|
continue;
|
|
|
|
}
|
2007-02-20 09:54:00 +00:00
|
|
|
if (!prefixcmp(arg, "--depth=")) {
|
2007-09-19 04:49:35 +00:00
|
|
|
args.depth = strtol(arg + 8, NULL, 0);
|
allow cloning a repository "shallowly"
By specifying a depth, you can now clone a repository such that
all fetched ancestor-chains' length is at most "depth". For example,
if the upstream repository has only 2 branches ("A" and "B"), which
are linear, and you specify depth 3, you will get A, A~1, A~2, A~3,
B, B~1, B~2, and B~3. The ends are automatically made shallow
commits.
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-10-30 19:09:29 +00:00
|
|
|
continue;
|
|
|
|
}
|
2007-02-20 02:01:44 +00:00
|
|
|
if (!strcmp("--no-progress", arg)) {
|
2007-09-19 04:49:35 +00:00
|
|
|
args.no_progress = 1;
|
2007-02-20 02:01:44 +00:00
|
|
|
continue;
|
|
|
|
}
|
2005-07-04 20:26:53 +00:00
|
|
|
usage(fetch_pack_usage);
|
|
|
|
}
|
2007-09-11 03:03:00 +00:00
|
|
|
dest = (char *)arg;
|
|
|
|
heads = (char **)(argv + i + 1);
|
2005-07-04 20:26:53 +00:00
|
|
|
nr_heads = argc - i - 1;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (!dest)
|
|
|
|
usage(fetch_pack_usage);
|
2007-09-11 03:03:00 +00:00
|
|
|
|
2008-02-04 18:26:23 +00:00
|
|
|
conn = git_connect(fd, (char *)dest, args.uploadpack,
|
|
|
|
args.verbose ? CONNECT_VERBOSE : 0);
|
|
|
|
if (conn) {
|
2008-09-09 08:27:09 +00:00
|
|
|
get_remote_heads(fd[0], &ref, 0, NULL, 0, NULL);
|
2008-02-04 18:26:23 +00:00
|
|
|
|
|
|
|
ref = fetch_pack(&args, fd, conn, ref, dest, nr_heads, heads, NULL);
|
|
|
|
close(fd[0]);
|
|
|
|
close(fd[1]);
|
|
|
|
if (finish_connect(conn))
|
|
|
|
ref = NULL;
|
|
|
|
} else {
|
|
|
|
ref = NULL;
|
|
|
|
}
|
2007-09-11 03:03:00 +00:00
|
|
|
ret = !ref;
|
|
|
|
|
2008-02-04 18:26:23 +00:00
|
|
|
if (!ret && nr_heads) {
|
|
|
|
/* If the heads to pull were given, we should have
|
|
|
|
* consumed all of them by matching the remote.
|
2008-09-09 10:28:30 +00:00
|
|
|
* Otherwise, 'git fetch remote no-such-ref' would
|
2008-02-04 18:26:23 +00:00
|
|
|
* 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;
|
|
|
|
}
|
|
|
|
}
|
2007-09-11 03:03:00 +00:00
|
|
|
while (ref) {
|
|
|
|
printf("%s %s\n",
|
|
|
|
sha1_to_hex(ref->old_sha1), ref->name);
|
|
|
|
ref = ref->next;
|
|
|
|
}
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2007-09-19 04:49:35 +00:00
|
|
|
struct ref *fetch_pack(struct fetch_pack_args *my_args,
|
2008-02-04 18:26:23 +00:00
|
|
|
int fd[], struct child_process *conn,
|
|
|
|
const struct ref *ref,
|
2007-09-19 04:49:35 +00:00
|
|
|
const char *dest,
|
2007-09-14 07:31:23 +00:00
|
|
|
int nr_heads,
|
|
|
|
char **heads,
|
|
|
|
char **pack_lockfile)
|
2007-09-11 03:03:00 +00:00
|
|
|
{
|
|
|
|
struct stat st;
|
2008-02-04 18:26:23 +00:00
|
|
|
struct ref *ref_cpy;
|
2007-09-11 03:03:00 +00:00
|
|
|
|
2007-09-19 04:49:39 +00:00
|
|
|
fetch_pack_setup();
|
2008-12-06 20:50:09 +00:00
|
|
|
if (&args != my_args)
|
|
|
|
memcpy(&args, my_args, sizeof(args));
|
2007-09-19 04:49:35 +00:00
|
|
|
if (args.depth > 0) {
|
2007-09-11 03:03:00 +00:00
|
|
|
if (stat(git_path("shallow"), &st))
|
|
|
|
st.st_mtime = 0;
|
|
|
|
}
|
|
|
|
|
2006-11-25 09:33:06 +00:00
|
|
|
if (heads && nr_heads)
|
|
|
|
nr_heads = remove_duplicates(nr_heads, heads);
|
2008-02-04 18:26:23 +00:00
|
|
|
if (!ref) {
|
|
|
|
packet_flush(fd[1]);
|
|
|
|
die("no matching remote head");
|
2005-11-06 08:09:59 +00:00
|
|
|
}
|
2008-02-04 18:26:23 +00:00
|
|
|
ref_cpy = do_fetch_pack(fd, ref, nr_heads, heads, pack_lockfile);
|
2005-11-06 08:09:59 +00:00
|
|
|
|
2008-02-04 18:26:23 +00:00
|
|
|
if (args.depth > 0) {
|
allow cloning a repository "shallowly"
By specifying a depth, you can now clone a repository such that
all fetched ancestor-chains' length is at most "depth". For example,
if the upstream repository has only 2 branches ("A" and "B"), which
are linear, and you specify depth 3, you will get A, A~1, A~2, A~3,
B, B~1, B~2, and B~3. The ends are automatically made shallow
commits.
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-10-30 19:09:29 +00:00
|
|
|
struct cache_time mtime;
|
2009-10-31 00:47:23 +00:00
|
|
|
struct strbuf sb = STRBUF_INIT;
|
allow cloning a repository "shallowly"
By specifying a depth, you can now clone a repository such that
all fetched ancestor-chains' length is at most "depth". For example,
if the upstream repository has only 2 branches ("A" and "B"), which
are linear, and you specify depth 3, you will get A, A~1, A~2, A~3,
B, B~1, B~2, and B~3. The ends are automatically made shallow
commits.
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-10-30 19:09:29 +00:00
|
|
|
char *shallow = git_path("shallow");
|
|
|
|
int fd;
|
|
|
|
|
|
|
|
mtime.sec = st.st_mtime;
|
2009-03-04 17:47:40 +00:00
|
|
|
mtime.nsec = ST_MTIME_NSEC(st);
|
allow cloning a repository "shallowly"
By specifying a depth, you can now clone a repository such that
all fetched ancestor-chains' length is at most "depth". For example,
if the upstream repository has only 2 branches ("A" and "B"), which
are linear, and you specify depth 3, you will get A, A~1, A~2, A~3,
B, B~1, B~2, and B~3. The ends are automatically made shallow
commits.
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-10-30 19:09:29 +00:00
|
|
|
if (stat(shallow, &st)) {
|
|
|
|
if (mtime.sec)
|
|
|
|
die("shallow file was removed during fetch");
|
|
|
|
} else if (st.st_mtime != mtime.sec
|
|
|
|
#ifdef USE_NSEC
|
2009-03-15 11:38:55 +00:00
|
|
|
|| ST_MTIME_NSEC(st) != mtime.nsec
|
allow cloning a repository "shallowly"
By specifying a depth, you can now clone a repository such that
all fetched ancestor-chains' length is at most "depth". For example,
if the upstream repository has only 2 branches ("A" and "B"), which
are linear, and you specify depth 3, you will get A, A~1, A~2, A~3,
B, B~1, B~2, and B~3. The ends are automatically made shallow
commits.
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-10-30 19:09:29 +00:00
|
|
|
#endif
|
|
|
|
)
|
|
|
|
die("shallow file was changed during fetch");
|
|
|
|
|
2008-10-17 22:44:39 +00:00
|
|
|
fd = hold_lock_file_for_update(&lock, shallow,
|
|
|
|
LOCK_DIE_ON_ERROR);
|
2009-10-31 00:47:23 +00:00
|
|
|
if (!write_shallow_commits(&sb, 0)
|
|
|
|
|| write_in_full(fd, sb.buf, sb.len) != sb.len) {
|
2009-04-29 21:22:56 +00:00
|
|
|
unlink_or_warn(shallow);
|
allow cloning a repository "shallowly"
By specifying a depth, you can now clone a repository such that
all fetched ancestor-chains' length is at most "depth". For example,
if the upstream repository has only 2 branches ("A" and "B"), which
are linear, and you specify depth 3, you will get A, A~1, A~2, A~3,
B, B~1, B~2, and B~3. The ends are automatically made shallow
commits.
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-10-30 19:09:29 +00:00
|
|
|
rollback_lock_file(&lock);
|
|
|
|
} else {
|
|
|
|
commit_lock_file(&lock);
|
|
|
|
}
|
2009-10-31 00:47:23 +00:00
|
|
|
strbuf_release(&sb);
|
allow cloning a repository "shallowly"
By specifying a depth, you can now clone a repository such that
all fetched ancestor-chains' length is at most "depth". For example,
if the upstream repository has only 2 branches ("A" and "B"), which
are linear, and you specify depth 3, you will get A, A~1, A~2, A~3,
B, B~1, B~2, and B~3. The ends are automatically made shallow
commits.
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-10-30 19:09:29 +00:00
|
|
|
}
|
|
|
|
|
2008-06-15 14:04:20 +00:00
|
|
|
reprepare_packed_git();
|
2008-02-04 18:26:23 +00:00
|
|
|
return ref_cpy;
|
2005-07-04 20:26:53 +00:00
|
|
|
}
|