Fix sparse warnings
Fix warnings from 'make check'.
- These files don't include 'builtin.h' causing sparse to complain that
cmd_* isn't declared:
builtin/clone.c:364, builtin/fetch-pack.c:797,
builtin/fmt-merge-msg.c:34, builtin/hash-object.c:78,
builtin/merge-index.c:69, builtin/merge-recursive.c:22
builtin/merge-tree.c:341, builtin/mktag.c:156, builtin/notes.c:426
builtin/notes.c:822, builtin/pack-redundant.c:596,
builtin/pack-refs.c:10, builtin/patch-id.c:60, builtin/patch-id.c:149,
builtin/remote.c:1512, builtin/remote-ext.c:240,
builtin/remote-fd.c:53, builtin/reset.c:236, builtin/send-pack.c:384,
builtin/unpack-file.c:25, builtin/var.c:75
- These files have symbols which should be marked static since they're
only file scope:
submodule.c:12, diff.c:631, replace_object.c:92, submodule.c:13,
submodule.c:14, trace.c:78, transport.c:195, transport-helper.c:79,
unpack-trees.c:19, url.c:3, url.c:18, url.c:104, url.c:117, url.c:123,
url.c:129, url.c:136, thread-utils.c:21, thread-utils.c:48
- These files redeclare symbols to be different types:
builtin/index-pack.c:210, parse-options.c:564, parse-options.c:571,
usage.c:49, usage.c:58, usage.c:63, usage.c:72
- These files use a literal integer 0 when they really should use a NULL
pointer:
daemon.c:663, fast-import.c:2942, imap-send.c:1072, notes-merge.c:362
While we're in the area, clean up some unused #includes in builtin files
(mostly exec_cmd.h).
Signed-off-by: Stephen Boyd <bebarino@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2011-03-22 07:51:05 +00:00
|
|
|
#include "builtin.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"
|
2011-03-11 19:53:52 +00:00
|
|
|
#include "transport.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;
|
2011-10-05 19:36:20 +00:00
|
|
|
static int no_done;
|
2011-09-04 19:37:45 +00:00
|
|
|
static int fetch_fsck_objects = -1;
|
|
|
|
static int transfer_fsck_objects = -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[] =
|
fetch-pack: new --stdin option to read refs from stdin
If a remote repo has too many tags (or branches), cloning it over the
smart HTTP transport can fail because remote-curl.c puts all the refs
from the remote repo on the fetch-pack command line. This can make the
command line longer than the global OS command line limit, causing
fetch-pack to fail.
This is especially a problem on Windows where the command line limit is
orders of magnitude shorter than Linux. There are already real repos out
there that msysGit cannot clone over smart HTTP due to this problem.
Here is an easy way to trigger this problem:
git init too-many-refs
cd too-many-refs
echo bla > bla.txt
git add .
git commit -m test
sha=$(git rev-parse HEAD)
tag=$(perl -e 'print "bla" x 30')
for i in `seq 50000`; do
echo $sha refs/tags/$tag-$i >> .git/packed-refs
done
Then share this repo over the smart HTTP protocol and try cloning it:
$ git clone http://localhost/.../too-many-refs/.git
Cloning into 'too-many-refs'...
fatal: cannot exec 'fetch-pack': Argument list too long
50k tags is obviously an absurd number, but it is required to
demonstrate the problem on Linux because it has a much more generous
command line limit. On Windows the clone fails with as little as 500
tags in the above loop, which is getting uncomfortably close to the
number of tags you might see in real long lived repos.
This is not just theoretical, msysGit is already failing to clone our
company repo due to this. It's a large repo converted from CVS, nearly
10 years of history.
Four possible solutions were discussed on the Git mailing list (in no
particular order):
1) Call fetch-pack multiple times with smaller batches of refs.
This was dismissed as inefficient and inelegant.
2) Add option --refs-fd=$n to pass a an fd from where to read the refs.
This was rejected because inheriting descriptors other than
stdin/stdout/stderr through exec() is apparently problematic on Windows,
plus it would require changes to the run-command API to open extra
pipes.
3) Add option --refs-from=$tmpfile to pass the refs using a temp file.
This was not favored because of the temp file requirement.
4) Add option --stdin to pass the refs on stdin, one per line.
In the end this option was chosen as the most efficient and most
desirable from scripting perspective.
There was however a small complication when using stdin to pass refs to
fetch-pack. The --stateless-rpc option to fetch-pack also uses stdin for
communication with the remote server.
If we are going to sneak refs on stdin line by line, it would have to be
done very carefully in the presence of --stateless-rpc, because when
reading refs line by line we might read ahead too much data into our
buffer and eat some of the remote protocol data which is also coming on
stdin.
One way to solve this would be to refactor get_remote_heads() in
fetch-pack.c to accept a residual buffer from our stdin line parsing
above, but this function is used in several places so other callers
would be burdened by this residual buffer interface even when most of
them don't need it.
In the end we settled on the following solution:
If --stdin is specified without --stateless-rpc, fetch-pack would read
the refs from stdin one per line, in a script friendly format.
However if --stdin is specified together with --stateless-rpc,
fetch-pack would read the refs from stdin in packetized format
(pkt-line) with a flush packet terminating the list of refs. This way we
can read the exact number of bytes that we need from stdin, and then
get_remote_heads() can continue reading from the same fd without losing
a single byte of remote protocol data.
This way the --stdin option only loses generality and scriptability when
used together with --stateless-rpc, which is not easily scriptable
anyway because it also uses pkt-line when talking to the remote server.
Signed-off-by: Ivan Todoroski <grnch@gmx.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2012-04-02 15:13:48 +00:00
|
|
|
"git fetch-pack [--all] [--stdin] [--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
|
|
|
|
2010-11-27 01:58:14 +00:00
|
|
|
commit_list_insert_by_date(commit, &rev_list);
|
2005-10-28 02:46:27 +00:00
|
|
|
|
|
|
|
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
|
|
|
|
};
|
|
|
|
|
2009-10-31 00:47:42 +00:00
|
|
|
static void consume_shallow_list(int fd)
|
|
|
|
{
|
|
|
|
if (args.stateless_rpc && args.depth > 0) {
|
|
|
|
/* If we sent a depth we will get back "duplicate"
|
|
|
|
* shallow and unshallow commands every time there
|
|
|
|
* is a block of have lines exchanged.
|
|
|
|
*/
|
|
|
|
char line[1000];
|
|
|
|
while (packet_read_line(fd, line, sizeof(line))) {
|
|
|
|
if (!prefixcmp(line, "shallow "))
|
|
|
|
continue;
|
|
|
|
if (!prefixcmp(line, "unshallow "))
|
|
|
|
continue;
|
|
|
|
die("git fetch-pack: expected shallow list");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-08-18 12:29:36 +00:00
|
|
|
struct write_shallow_data {
|
|
|
|
struct strbuf *out;
|
|
|
|
int use_pack_protocol;
|
|
|
|
int count;
|
|
|
|
};
|
|
|
|
|
|
|
|
static int write_one_shallow(const struct commit_graft *graft, void *cb_data)
|
|
|
|
{
|
|
|
|
struct write_shallow_data *data = cb_data;
|
|
|
|
const char *hex = sha1_to_hex(graft->sha1);
|
|
|
|
data->count++;
|
|
|
|
if (data->use_pack_protocol)
|
|
|
|
packet_buf_write(data->out, "shallow %s", hex);
|
|
|
|
else {
|
|
|
|
strbuf_addstr(data->out, hex);
|
|
|
|
strbuf_addch(data->out, '\n');
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int write_shallow_commits(struct strbuf *out, int use_pack_protocol)
|
|
|
|
{
|
|
|
|
struct write_shallow_data data;
|
|
|
|
data.out = out;
|
|
|
|
data.use_pack_protocol = use_pack_protocol;
|
|
|
|
data.count = 0;
|
|
|
|
for_each_commit_graft(write_one_shallow, &data);
|
|
|
|
return data.count;
|
|
|
|
}
|
|
|
|
|
2009-10-31 00:47:25 +00:00
|
|
|
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);
|
|
|
|
}
|
|
|
|
|
2009-10-31 00:47:42 +00:00
|
|
|
static void send_request(int fd, struct strbuf *buf)
|
|
|
|
{
|
|
|
|
if (args.stateless_rpc) {
|
|
|
|
send_sideband(fd, -1, buf->buf, buf->len, LARGE_PACKET_MAX);
|
|
|
|
packet_flush(fd);
|
|
|
|
} else
|
|
|
|
safe_write(fd, buf->buf, buf->len);
|
|
|
|
}
|
|
|
|
|
2011-03-11 19:53:52 +00:00
|
|
|
static void insert_one_alternate_ref(const struct ref *ref, void *unused)
|
|
|
|
{
|
|
|
|
rev_list_insert_ref(NULL, ref->old_sha1, 0, NULL);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void insert_alternate_refs(void)
|
|
|
|
{
|
refactor refs_from_alternate_cb to allow passing extra data
The foreach_alt_odb function triggers a callback for each
alternate object db we have, with room for a single void
pointer as data. Currently, we always call refs_from_alternate_cb
as the callback function, and then pass another callback (to
receive each ref individually) as the void pointer.
This has two problems:
1. C technically forbids stuffing a function pointer into
a "void *". In practice, this probably doesn't matter
on any architectures git runs on, but it never hurts to
follow the letter of the law.
2. There is no room for an extra data pointer. Indeed, the
alternate_ref_fn that refs_from_alternate_cb calls
takes a void* for data, but we always pass it NULL.
Instead, let's properly stuff our function pointer into a
data struct, which also leaves room for an extra
caller-supplied data pointer. And to keep things simple for
existing callers, let's make a for_each_alternate_ref
function that takes care of creating the extra struct.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2011-05-19 21:33:17 +00:00
|
|
|
for_each_alternate_ref(insert_one_alternate_ref, NULL);
|
2011-03-11 19:53:52 +00:00
|
|
|
}
|
|
|
|
|
2011-03-21 04:52:45 +00:00
|
|
|
#define INITIAL_FLUSH 16
|
2011-03-29 17:06:19 +00:00
|
|
|
#define PIPESAFE_FLUSH 32
|
2011-03-21 04:52:44 +00:00
|
|
|
#define LARGE_FLUSH 1024
|
2011-03-21 04:52:40 +00:00
|
|
|
|
|
|
|
static int next_flush(int count)
|
|
|
|
{
|
2011-03-29 17:06:19 +00:00
|
|
|
int flush_limit = args.stateless_rpc ? LARGE_FLUSH : PIPESAFE_FLUSH;
|
|
|
|
|
|
|
|
if (count < flush_limit)
|
2011-03-21 04:52:44 +00:00
|
|
|
count <<= 1;
|
|
|
|
else
|
2011-03-29 17:06:19 +00:00
|
|
|
count += flush_limit;
|
2011-03-21 04:52:44 +00:00
|
|
|
return count;
|
2011-03-21 04:52:40 +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;
|
2011-03-21 04:52:40 +00:00
|
|
|
int count = 0, flushes = 0, flush_at = INITIAL_FLUSH, retval;
|
2005-10-28 02:46:27 +00:00
|
|
|
const unsigned char *sha1;
|
2006-05-25 04:48:34 +00:00
|
|
|
unsigned in_vain = 0;
|
|
|
|
int got_continue = 0;
|
2011-03-29 19:29:10 +00:00
|
|
|
int got_ready = 0;
|
2009-10-31 00:47:23 +00:00
|
|
|
struct strbuf req_buf = STRBUF_INIT;
|
2009-10-31 00:47:42 +00:00
|
|
|
size_t state_len = 0;
|
2005-10-28 02:46:27 +00:00
|
|
|
|
2009-10-31 00:47:42 +00:00
|
|
|
if (args.stateless_rpc && multi_ack == 1)
|
|
|
|
die("--stateless-rpc requires multi_ack_detailed");
|
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);
|
2011-03-11 19:53:52 +00:00
|
|
|
insert_alternate_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
|
|
|
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");
|
2011-03-29 19:29:10 +00:00
|
|
|
if (no_done) strbuf_addstr(&c, " no-done");
|
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);
|
2009-10-31 00:47:42 +00:00
|
|
|
state_len = 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-10-31 00:47:42 +00:00
|
|
|
send_request(fd[1], &req_buf);
|
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
|
|
|
}
|
2009-10-31 00:47:42 +00:00
|
|
|
} else if (!args.stateless_rpc)
|
|
|
|
send_request(fd[1], &req_buf);
|
|
|
|
|
|
|
|
if (!args.stateless_rpc) {
|
|
|
|
/* If we aren't using the stateless-rpc interface
|
|
|
|
* we don't need to retain the headers.
|
|
|
|
*/
|
|
|
|
strbuf_setlen(&req_buf, 0);
|
|
|
|
state_len = 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
|
|
|
}
|
|
|
|
|
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())) {
|
2009-10-31 00:47:42 +00:00
|
|
|
packet_buf_write(&req_buf, "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++;
|
2011-03-21 04:52:40 +00:00
|
|
|
if (flush_at <= ++count) {
|
2005-10-28 02:50:26 +00:00
|
|
|
int ack;
|
|
|
|
|
2009-10-31 00:47:42 +00:00
|
|
|
packet_buf_flush(&req_buf);
|
|
|
|
send_request(fd[1], &req_buf);
|
|
|
|
strbuf_setlen(&req_buf, state_len);
|
2005-07-04 20:26:53 +00:00
|
|
|
flushes++;
|
2011-03-21 04:52:40 +00:00
|
|
|
flush_at = next_flush(count);
|
2005-07-04 20:26:53 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* We keep one window "ahead" of the other side, and
|
|
|
|
* will wait for an ACK only on the next one
|
|
|
|
*/
|
2011-03-21 04:52:40 +00:00
|
|
|
if (!args.stateless_rpc && count == INITIAL_FLUSH)
|
2005-07-04 20:26:53 +00:00
|
|
|
continue;
|
2005-10-28 02:50:26 +00:00
|
|
|
|
2009-10-31 00:47:42 +00:00
|
|
|
consume_shallow_list(fd[0]);
|
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);
|
2011-08-18 13:36:03 +00:00
|
|
|
if (!commit)
|
|
|
|
die("invalid commit %s", sha1_to_hex(result_sha1));
|
2009-10-31 00:47:42 +00:00
|
|
|
if (args.stateless_rpc
|
|
|
|
&& ack == ACK_common
|
|
|
|
&& !(commit->object.flags & COMMON)) {
|
|
|
|
/* We need to replay the have for this object
|
|
|
|
* on the next RPC request so the peer knows
|
|
|
|
* it is in common with us.
|
|
|
|
*/
|
|
|
|
const char *hex = sha1_to_hex(result_sha1);
|
|
|
|
packet_buf_write(&req_buf, "have %s\n", hex);
|
|
|
|
state_len = req_buf.len;
|
|
|
|
}
|
2005-10-28 02:50:26 +00:00
|
|
|
mark_common(commit, 0, 1);
|
|
|
|
retval = 0;
|
2006-05-25 04:48:34 +00:00
|
|
|
in_vain = 0;
|
|
|
|
got_continue = 1;
|
2011-03-29 19:29:10 +00:00
|
|
|
if (ack == ACK_ready) {
|
fetch-pack: Finish negotation if remote replies "ACK %s ready"
If multi_ack_detailed was selected in the protocol capabilities
(both client and server are >= Git 1.6.6) the upload-pack side will
send "ACK %s ready" when it knows how to safely cut the graph and
produce a reasonable pack for the want list that was already sent
on the connection.
Upon receiving "ACK %s ready" there is no point in looking at
the remaining commits inside of rev_list. Sending additional
"have %s" lines to the remote will not construct a smaller pack.
It is unlikely a commit older than the current cut point will have
a better delta base than the cut point itself has.
The original design of this code had fetch-pack empty rev_list by
marking a commit and its transitive ancestors COMMON whenever the
remote side said "ACK %s {continue,common}" and skipping over any
already COMMON commits during get_rev(). This approach does not
work when most of rev_list is actually COMMON_REF, commits that
are pointed to by a reference on the remote, which exist locally,
and which have not yet been sent to the remote as a "have %s" line.
Most of the common references are tags in the ref/tags namespace,
using points in the commit graph that are more than 1 commit apart.
In git.git itself, this is currently 340 tags, 339 of which point to
commits in the commit graph. fetch-pack pushes all of these into
rev_list, but is unable to mark them COMMON and discard during a
remote's "ACK %s {continue,common}" because it does not parse through
the entire parent chain. Not parsing the entire parent chain is
an optimization to avoid walking back to the roots of the repository.
Assuming the client is only following the remote (and does not make
its own local commits), the client needs 11 rounds to spin through
the entire list of tags (32 commits per round, ceil(339/32) == 11).
Unfortunately the server knows on the first "have %s" line that
it can produce a good pack, and does not need to see the remaining
320 tags in the other 10 rounds.
Over git:// and ssh:// this isn't as bad as it sounds, the client is
only transmitting an extra 16,000 bytes that it doesn't need to send.
Over smart HTTP, the client must do an additional 10 HTTP POST
requests, each of which incurs round-trip latency, and must upload
the entire state vector of all known common objects. On the final
POST request, this is 16 KiB worth of data.
Fix all of this by clearing rev_list as soon as the remote side
says it can construct a pack.
Signed-off-by: Shawn O. Pearce <spearce@spearce.org>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2011-03-14 23:48:38 +00:00
|
|
|
rev_list = NULL;
|
2011-03-29 19:29:10 +00:00
|
|
|
got_ready = 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:
|
2011-03-29 19:29:10 +00:00
|
|
|
if (!got_ready || !no_done) {
|
|
|
|
packet_buf_write(&req_buf, "done\n");
|
|
|
|
send_request(fd[1], &req_buf);
|
|
|
|
}
|
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);
|
|
|
|
|
2009-10-31 00:47:42 +00:00
|
|
|
consume_shallow_list(fd[0]);
|
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;
|
fetch: avoid repeated commits in mark_complete
We add every local ref to a list so that we can mark them
and all of their ancestors back to a certain cutoff point.
However, if some refs point to the same commit, we will end
up adding them to the list many times.
Furthermore, since commit_lists are stored as linked lists,
we must do an O(n) traversal of the list in order to find
the right place to insert each commit. This makes building
the list O(n^2) in the number of refs.
For normal repositories, this isn't a big deal. We have a
few hundreds refs at most, and most of them are unique. But
consider an "alternates" repo that serves as an object
database for many other similar repos. For reachability, it
needs to keep a copy of the refs in each child repo. This
means it may have a large number of refs, many of which
point to the same commits.
By noting commits we have already added to the list, we can
shrink the size of "n" in such a repo to the number of
unique commits, which is on the order of what a normal repo
would contain (it's actually more than a normal repo, since child repos
may have branches at different states, but in practice it tends
to be much smaller than the list with duplicates).
Here are the results on one particular giant repo
(containing objects for all Rails forks on GitHub):
$ git for-each-ref | wc -l
112514
[before]
$ git fetch --no-tags ../remote.git
63.52user 0.12system 1:03.68elapsed 99%CPU (0avgtext+0avgdata 137648maxresident)k
1856inputs+48outputs (11major+19603minor)pagefaults 0swaps
$ git fetch --no-tags ../remote.git
6.15user 0.08system 0:06.25elapsed 99%CPU (0avgtext+0avgdata 123856maxresident)k
0inputs+40outputs (0major+18872minor)pagefaults 0swaps
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2011-05-19 20:48:51 +00:00
|
|
|
if (!(commit->object.flags & COMPLETE)) {
|
|
|
|
commit->object.flags |= COMPLETE;
|
|
|
|
commit_list_insert_by_date(commit, &complete);
|
|
|
|
}
|
2005-10-19 21:27:02 +00:00
|
|
|
}
|
|
|
|
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) &&
|
2011-09-15 21:10:25 +00:00
|
|
|
check_refname_format(ref->name + 5, 0))
|
2006-05-11 22:28:44 +00:00
|
|
|
; /* 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 {
|
fetch-pack: match refs exactly
When we are determining the list of refs to fetch via
fetch-pack, we have two sets of refs to compare: those on
the remote side, and a "match" list of things we want to
fetch. We iterate through the remote refs alphabetically,
seeing if each one is wanted by the "match" list.
Since def88e9 (Commit first cut at "git-fetch-pack",
2005-07-04), we have used the "path_match" function to do a
suffix match, where a remote ref is considered wanted if
any of the "match" elements is a suffix of the remote
refname.
This enables callers of fetch-pack to specify unqualified
refs and have them matched up with remote refs (e.g., ask
for "A" and get remote's "refs/heads/A"). However, if you
provide a fully qualified ref, then there are corner cases
where we provide the wrong answer. For example, given a
remote with two refs:
refs/foo/refs/heads/master
refs/heads/master
asking for "refs/heads/master" will first match
"refs/foo/refs/heads/master" by the suffix rule, and we will
erroneously fetch it instead of refs/heads/master.
As it turns out, all callers of fetch_pack do provide
fully-qualified refs for the match list. There are two ways
fetch_pack can get match lists:
1. Through the transport code (i.e., via git-fetch)
2. On the command-line of git-fetch-pack
In the first case, we will always be providing the names of
fully-qualified refs from "struct ref" objects. We will have
pre-matched those ref objects already (since we have to
handle more advanced matching, like wildcard refspecs), and
are just providing a list of the refs whose objects we need.
In the second case, users could in theory be providing
non-qualified refs on the command-line. However, the
fetch-pack documentation claims that refs should be fully
qualified (and has always done so since it was written in
2005).
Let's change this path_match call to simply check for string
equality, matching what the callers of fetch_pack are
expecting.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2011-12-13 00:48:08 +00:00
|
|
|
int i;
|
|
|
|
for (i = 0; i < nr_match; i++) {
|
|
|
|
if (!strcmp(ref->name, match[i])) {
|
|
|
|
match[i][0] = '\0';
|
|
|
|
return_refs[i] = ref;
|
|
|
|
break;
|
|
|
|
}
|
2006-05-11 22:28:44 +00:00
|
|
|
}
|
fetch-pack: match refs exactly
When we are determining the list of refs to fetch via
fetch-pack, we have two sets of refs to compare: those on
the remote side, and a "match" list of things we want to
fetch. We iterate through the remote refs alphabetically,
seeing if each one is wanted by the "match" list.
Since def88e9 (Commit first cut at "git-fetch-pack",
2005-07-04), we have used the "path_match" function to do a
suffix match, where a remote ref is considered wanted if
any of the "match" elements is a suffix of the remote
refname.
This enables callers of fetch-pack to specify unqualified
refs and have them matched up with remote refs (e.g., ask
for "A" and get remote's "refs/heads/A"). However, if you
provide a fully qualified ref, then there are corner cases
where we provide the wrong answer. For example, given a
remote with two refs:
refs/foo/refs/heads/master
refs/heads/master
asking for "refs/heads/master" will first match
"refs/foo/refs/heads/master" by the suffix rule, and we will
erroneously fetch it instead of refs/heads/master.
As it turns out, all callers of fetch_pack do provide
fully-qualified refs for the match list. There are two ways
fetch_pack can get match lists:
1. Through the transport code (i.e., via git-fetch)
2. On the command-line of git-fetch-pack
In the first case, we will always be providing the names of
fully-qualified refs from "struct ref" objects. We will have
pre-matched those ref objects already (since we have to
handle more advanced matching, like wildcard refspecs), and
are just providing a list of the refs whose objects we need.
In the second case, users could in theory be providing
non-qualified refs on the command-line. However, the
fetch-pack documentation claims that refs should be fully
qualified (and has always done so since it was written in
2005).
Let's change this path_match call to simply check for string
equality, matching what the callers of fetch_pack are
expecting.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2011-12-13 00:48:08 +00:00
|
|
|
if (i < nr_match)
|
|
|
|
continue; /* we will link it later */
|
2006-05-11 22:28:44 +00:00
|
|
|
}
|
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2010-02-05 20:57:38 +00:00
|
|
|
static int sideband_demux(int in, int out, 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
|
|
|
|
2010-02-05 20:57:38 +00:00
|
|
|
int ret = recv_sideband("fetch-pack", xd[0], out);
|
|
|
|
close(out);
|
2009-06-08 08:51:22 +00:00
|
|
|
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;
|
2010-02-05 20:57:38 +00:00
|
|
|
demux.out = -1;
|
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 (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;
|
2011-09-04 19:37:45 +00:00
|
|
|
if (fetch_fsck_objects >= 0
|
|
|
|
? fetch_fsck_objects
|
|
|
|
: transfer_fsck_objects >= 0
|
|
|
|
? transfer_fsck_objects
|
|
|
|
: 0)
|
2011-09-04 19:26:14 +00:00
|
|
|
*av++ = "--strict";
|
2007-01-23 06:37:33 +00:00
|
|
|
*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;
|
2011-03-29 19:29:10 +00:00
|
|
|
if (server_supports("no-done")) {
|
|
|
|
if (args.verbose)
|
|
|
|
fprintf(stderr, "Server supports no-done\n");
|
2011-03-29 17:16:29 +00:00
|
|
|
if (args.stateless_rpc)
|
|
|
|
no_done = 1;
|
2011-03-29 19:29:10 +00:00
|
|
|
}
|
2009-10-31 00:47:25 +00:00
|
|
|
}
|
|
|
|
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
|
|
|
|
2009-10-31 00:47:42 +00:00
|
|
|
if (args.stateless_rpc)
|
|
|
|
packet_flush(fd[1]);
|
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;
|
|
|
|
}
|
|
|
|
|
2011-09-04 19:26:14 +00:00
|
|
|
if (!strcmp(var, "fetch.fsckobjects")) {
|
|
|
|
fetch_fsck_objects = git_config_bool(var, value);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2011-09-04 19:37:45 +00:00
|
|
|
if (!strcmp(var, "transfer.fsckobjects")) {
|
|
|
|
transfer_fsck_objects = 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;
|
2012-05-21 07:59:56 +00:00
|
|
|
const char *dest = NULL;
|
|
|
|
char **heads;
|
2008-02-04 18:26:23 +00:00
|
|
|
int fd[2];
|
2009-10-31 00:47:42 +00:00
|
|
|
char *pack_lockfile = NULL;
|
|
|
|
char **pack_lockfile_ptr = NULL;
|
2008-02-04 18:26:23 +00:00
|
|
|
struct child_process *conn;
|
2007-01-25 01:02:15 +00:00
|
|
|
|
2011-02-24 14:30:19 +00:00
|
|
|
packet_trace_identity("fetch-pack");
|
|
|
|
|
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;
|
|
|
|
}
|
fetch-pack: new --stdin option to read refs from stdin
If a remote repo has too many tags (or branches), cloning it over the
smart HTTP transport can fail because remote-curl.c puts all the refs
from the remote repo on the fetch-pack command line. This can make the
command line longer than the global OS command line limit, causing
fetch-pack to fail.
This is especially a problem on Windows where the command line limit is
orders of magnitude shorter than Linux. There are already real repos out
there that msysGit cannot clone over smart HTTP due to this problem.
Here is an easy way to trigger this problem:
git init too-many-refs
cd too-many-refs
echo bla > bla.txt
git add .
git commit -m test
sha=$(git rev-parse HEAD)
tag=$(perl -e 'print "bla" x 30')
for i in `seq 50000`; do
echo $sha refs/tags/$tag-$i >> .git/packed-refs
done
Then share this repo over the smart HTTP protocol and try cloning it:
$ git clone http://localhost/.../too-many-refs/.git
Cloning into 'too-many-refs'...
fatal: cannot exec 'fetch-pack': Argument list too long
50k tags is obviously an absurd number, but it is required to
demonstrate the problem on Linux because it has a much more generous
command line limit. On Windows the clone fails with as little as 500
tags in the above loop, which is getting uncomfortably close to the
number of tags you might see in real long lived repos.
This is not just theoretical, msysGit is already failing to clone our
company repo due to this. It's a large repo converted from CVS, nearly
10 years of history.
Four possible solutions were discussed on the Git mailing list (in no
particular order):
1) Call fetch-pack multiple times with smaller batches of refs.
This was dismissed as inefficient and inelegant.
2) Add option --refs-fd=$n to pass a an fd from where to read the refs.
This was rejected because inheriting descriptors other than
stdin/stdout/stderr through exec() is apparently problematic on Windows,
plus it would require changes to the run-command API to open extra
pipes.
3) Add option --refs-from=$tmpfile to pass the refs using a temp file.
This was not favored because of the temp file requirement.
4) Add option --stdin to pass the refs on stdin, one per line.
In the end this option was chosen as the most efficient and most
desirable from scripting perspective.
There was however a small complication when using stdin to pass refs to
fetch-pack. The --stateless-rpc option to fetch-pack also uses stdin for
communication with the remote server.
If we are going to sneak refs on stdin line by line, it would have to be
done very carefully in the presence of --stateless-rpc, because when
reading refs line by line we might read ahead too much data into our
buffer and eat some of the remote protocol data which is also coming on
stdin.
One way to solve this would be to refactor get_remote_heads() in
fetch-pack.c to accept a residual buffer from our stdin line parsing
above, but this function is used in several places so other callers
would be burdened by this residual buffer interface even when most of
them don't need it.
In the end we settled on the following solution:
If --stdin is specified without --stateless-rpc, fetch-pack would read
the refs from stdin one per line, in a script friendly format.
However if --stdin is specified together with --stateless-rpc,
fetch-pack would read the refs from stdin in packetized format
(pkt-line) with a flush packet terminating the list of refs. This way we
can read the exact number of bytes that we need from stdin, and then
get_remote_heads() can continue reading from the same fd without losing
a single byte of remote protocol data.
This way the --stdin option only loses generality and scriptability when
used together with --stateless-rpc, which is not easily scriptable
anyway because it also uses pkt-line when talking to the remote server.
Signed-off-by: Ivan Todoroski <grnch@gmx.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2012-04-02 15:13:48 +00:00
|
|
|
if (!strcmp("--stdin", arg)) {
|
|
|
|
args.stdin_refs = 1;
|
|
|
|
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;
|
|
|
|
}
|
2009-10-31 00:47:42 +00:00
|
|
|
if (!strcmp("--stateless-rpc", arg)) {
|
|
|
|
args.stateless_rpc = 1;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
if (!strcmp("--lock-pack", arg)) {
|
|
|
|
args.lock_pack = 1;
|
|
|
|
pack_lockfile_ptr = &pack_lockfile;
|
|
|
|
continue;
|
|
|
|
}
|
2005-07-04 20:26:53 +00:00
|
|
|
usage(fetch_pack_usage);
|
|
|
|
}
|
2012-05-21 07:59:56 +00:00
|
|
|
dest = arg;
|
2007-09-11 03:03:00 +00:00
|
|
|
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
|
|
|
|
fetch-pack: new --stdin option to read refs from stdin
If a remote repo has too many tags (or branches), cloning it over the
smart HTTP transport can fail because remote-curl.c puts all the refs
from the remote repo on the fetch-pack command line. This can make the
command line longer than the global OS command line limit, causing
fetch-pack to fail.
This is especially a problem on Windows where the command line limit is
orders of magnitude shorter than Linux. There are already real repos out
there that msysGit cannot clone over smart HTTP due to this problem.
Here is an easy way to trigger this problem:
git init too-many-refs
cd too-many-refs
echo bla > bla.txt
git add .
git commit -m test
sha=$(git rev-parse HEAD)
tag=$(perl -e 'print "bla" x 30')
for i in `seq 50000`; do
echo $sha refs/tags/$tag-$i >> .git/packed-refs
done
Then share this repo over the smart HTTP protocol and try cloning it:
$ git clone http://localhost/.../too-many-refs/.git
Cloning into 'too-many-refs'...
fatal: cannot exec 'fetch-pack': Argument list too long
50k tags is obviously an absurd number, but it is required to
demonstrate the problem on Linux because it has a much more generous
command line limit. On Windows the clone fails with as little as 500
tags in the above loop, which is getting uncomfortably close to the
number of tags you might see in real long lived repos.
This is not just theoretical, msysGit is already failing to clone our
company repo due to this. It's a large repo converted from CVS, nearly
10 years of history.
Four possible solutions were discussed on the Git mailing list (in no
particular order):
1) Call fetch-pack multiple times with smaller batches of refs.
This was dismissed as inefficient and inelegant.
2) Add option --refs-fd=$n to pass a an fd from where to read the refs.
This was rejected because inheriting descriptors other than
stdin/stdout/stderr through exec() is apparently problematic on Windows,
plus it would require changes to the run-command API to open extra
pipes.
3) Add option --refs-from=$tmpfile to pass the refs using a temp file.
This was not favored because of the temp file requirement.
4) Add option --stdin to pass the refs on stdin, one per line.
In the end this option was chosen as the most efficient and most
desirable from scripting perspective.
There was however a small complication when using stdin to pass refs to
fetch-pack. The --stateless-rpc option to fetch-pack also uses stdin for
communication with the remote server.
If we are going to sneak refs on stdin line by line, it would have to be
done very carefully in the presence of --stateless-rpc, because when
reading refs line by line we might read ahead too much data into our
buffer and eat some of the remote protocol data which is also coming on
stdin.
One way to solve this would be to refactor get_remote_heads() in
fetch-pack.c to accept a residual buffer from our stdin line parsing
above, but this function is used in several places so other callers
would be burdened by this residual buffer interface even when most of
them don't need it.
In the end we settled on the following solution:
If --stdin is specified without --stateless-rpc, fetch-pack would read
the refs from stdin one per line, in a script friendly format.
However if --stdin is specified together with --stateless-rpc,
fetch-pack would read the refs from stdin in packetized format
(pkt-line) with a flush packet terminating the list of refs. This way we
can read the exact number of bytes that we need from stdin, and then
get_remote_heads() can continue reading from the same fd without losing
a single byte of remote protocol data.
This way the --stdin option only loses generality and scriptability when
used together with --stateless-rpc, which is not easily scriptable
anyway because it also uses pkt-line when talking to the remote server.
Signed-off-by: Ivan Todoroski <grnch@gmx.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2012-04-02 15:13:48 +00:00
|
|
|
if (args.stdin_refs) {
|
|
|
|
/*
|
|
|
|
* Copy refs from cmdline to new growable list, then
|
|
|
|
* append the refs from the standard input.
|
|
|
|
*/
|
|
|
|
int alloc_heads = nr_heads;
|
|
|
|
int size = nr_heads * sizeof(*heads);
|
|
|
|
heads = memcpy(xmalloc(size), heads, size);
|
|
|
|
if (args.stateless_rpc) {
|
|
|
|
/* in stateless RPC mode we use pkt-line to read
|
|
|
|
* from stdin, until we get a flush packet
|
|
|
|
*/
|
|
|
|
static char line[1000];
|
|
|
|
for (;;) {
|
|
|
|
int n = packet_read_line(0, line, sizeof(line));
|
|
|
|
if (!n)
|
|
|
|
break;
|
|
|
|
if (line[n-1] == '\n')
|
|
|
|
n--;
|
|
|
|
ALLOC_GROW(heads, nr_heads + 1, alloc_heads);
|
|
|
|
heads[nr_heads++] = xmemdupz(line, n);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
/* read from stdin one ref per line, until EOF */
|
|
|
|
struct strbuf line = STRBUF_INIT;
|
|
|
|
while (strbuf_getline(&line, stdin, '\n') != EOF) {
|
|
|
|
ALLOC_GROW(heads, nr_heads + 1, alloc_heads);
|
|
|
|
heads[nr_heads++] = strbuf_detach(&line, NULL);
|
|
|
|
}
|
|
|
|
strbuf_release(&line);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-10-31 00:47:42 +00:00
|
|
|
if (args.stateless_rpc) {
|
|
|
|
conn = NULL;
|
|
|
|
fd[0] = 0;
|
|
|
|
fd[1] = 1;
|
2008-02-04 18:26:23 +00:00
|
|
|
} else {
|
2012-05-21 07:59:56 +00:00
|
|
|
conn = git_connect(fd, dest, args.uploadpack,
|
2009-10-31 00:47:42 +00:00
|
|
|
args.verbose ? CONNECT_VERBOSE : 0);
|
|
|
|
}
|
|
|
|
|
2011-12-13 00:41:37 +00:00
|
|
|
get_remote_heads(fd[0], &ref, 0, NULL);
|
2009-10-31 00:47:42 +00:00
|
|
|
|
|
|
|
ref = fetch_pack(&args, fd, conn, ref, dest,
|
|
|
|
nr_heads, heads, pack_lockfile_ptr);
|
|
|
|
if (pack_lockfile) {
|
|
|
|
printf("lock %s\n", pack_lockfile);
|
|
|
|
fflush(stdout);
|
2008-02-04 18:26:23 +00:00
|
|
|
}
|
2009-10-31 00:47:42 +00:00
|
|
|
close(fd[0]);
|
|
|
|
close(fd[1]);
|
|
|
|
if (finish_connect(conn))
|
|
|
|
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
|
|
|
}
|