2007-09-11 03:03:25 +00:00
|
|
|
/*
|
|
|
|
* "git fetch"
|
|
|
|
*/
|
|
|
|
#include "cache.h"
|
|
|
|
#include "refs.h"
|
|
|
|
#include "commit.h"
|
|
|
|
#include "builtin.h"
|
2008-07-21 18:03:49 +00:00
|
|
|
#include "string-list.h"
|
2007-09-11 03:03:25 +00:00
|
|
|
#include "remote.h"
|
|
|
|
#include "transport.h"
|
2007-11-11 07:29:47 +00:00
|
|
|
#include "run-command.h"
|
2007-12-04 07:25:47 +00:00
|
|
|
#include "parse-options.h"
|
chain kill signals for cleanup functions
If a piece of code wanted to do some cleanup before exiting
(e.g., cleaning up a lockfile or a tempfile), our usual
strategy was to install a signal handler that did something
like this:
do_cleanup(); /* actual work */
signal(signo, SIG_DFL); /* restore previous behavior */
raise(signo); /* deliver signal, killing ourselves */
For a single handler, this works fine. However, if we want
to clean up two _different_ things, we run into a problem.
The most recently installed handler will run, but when it
removes itself as a handler, it doesn't put back the first
handler.
This patch introduces sigchain, a tiny library for handling
a stack of signal handlers. You sigchain_push each handler,
and use sigchain_pop to restore whoever was before you in
the stack.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2009-01-22 06:02:35 +00:00
|
|
|
#include "sigchain.h"
|
2015-08-18 00:22:00 +00:00
|
|
|
#include "submodule-config.h"
|
2010-11-12 12:54:52 +00:00
|
|
|
#include "submodule.h"
|
2011-09-02 23:33:22 +00:00
|
|
|
#include "connected.h"
|
2012-09-01 11:27:35 +00:00
|
|
|
#include "argv-array.h"
|
2016-07-01 16:03:30 +00:00
|
|
|
#include "utf8.h"
|
2007-09-11 03:03:25 +00:00
|
|
|
|
2007-12-04 07:25:47 +00:00
|
|
|
static const char * const builtin_fetch_usage[] = {
|
2012-08-20 12:32:09 +00:00
|
|
|
N_("git fetch [<options>] [<repository> [<refspec>...]]"),
|
|
|
|
N_("git fetch [<options>] <group>"),
|
|
|
|
N_("git fetch --multiple [<options>] [(<repository> | <group>)...]"),
|
|
|
|
N_("git fetch --all [<options>]"),
|
2007-12-04 07:25:47 +00:00
|
|
|
NULL
|
|
|
|
};
|
2007-09-11 03:03:25 +00:00
|
|
|
|
2007-12-04 07:25:47 +00:00
|
|
|
enum {
|
|
|
|
TAGS_UNSET = 0,
|
|
|
|
TAGS_DEFAULT = 1,
|
|
|
|
TAGS_SET = 2
|
|
|
|
};
|
|
|
|
|
2013-07-13 09:36:24 +00:00
|
|
|
static int fetch_prune_config = -1; /* unspecified */
|
|
|
|
static int prune = -1; /* unspecified */
|
|
|
|
#define PRUNE_BY_DEFAULT 0 /* do we prune by default? */
|
|
|
|
|
fetch, upload-pack: --deepen=N extends shallow boundary by N commits
In git-fetch, --depth argument is always relative with the latest
remote refs. This makes it a bit difficult to cover this use case,
where the user wants to make the shallow history, say 3 levels
deeper. It would work if remote refs have not moved yet, but nobody
can guarantee that, especially when that use case is performed a
couple months after the last clone or "git fetch --depth". Also,
modifying shallow boundary using --depth does not work well with
clones created by --since or --not.
This patch fixes that. A new argument --deepen=<N> will add <N> more (*)
parent commits to the current history regardless of where remote refs
are.
Have/Want negotiation is still respected. So if remote refs move, the
server will send two chunks: one between "have" and "want" and another
to extend shallow history. In theory, the client could send no "want"s
in order to get the second chunk only. But the protocol does not allow
that. Either you send no want lines, which means ls-remote; or you
have to send at least one want line that carries deep-relative to the
server..
The main work was done by Dongcan Jiang. I fixed it up here and there.
And of course all the bugs belong to me.
(*) We could even support --deepen=<N> where <N> is negative. In that
case we can cut some history from the shallow clone. This operation
(and --depth=<shorter depth>) does not require interaction with remote
side (and more complicated to implement as a result).
Helped-by: Duy Nguyen <pclouds@gmail.com>
Helped-by: Eric Sunshine <sunshine@sunshineco.com>
Helped-by: Junio C Hamano <gitster@pobox.com>
Signed-off-by: Dongcan Jiang <dongcan.jiang@gmail.com>
Signed-off-by: Nguyễn Thái Ngọc Duy <pclouds@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2016-06-12 10:54:09 +00:00
|
|
|
static int all, append, dry_run, force, keep, multiple, update_head_ok, verbosity, deepen_relative;
|
2012-02-13 20:17:15 +00:00
|
|
|
static int progress = -1, recurse_submodules = RECURSE_SUBMODULES_DEFAULT;
|
2016-06-12 10:53:59 +00:00
|
|
|
static int tags = TAGS_DEFAULT, unshallow, update_shallow, deepen;
|
2016-03-01 02:07:13 +00:00
|
|
|
static int max_children = -1;
|
2016-02-03 04:09:14 +00:00
|
|
|
static enum transport_family family;
|
2007-11-11 07:29:47 +00:00
|
|
|
static const char *depth;
|
2016-06-12 10:53:59 +00:00
|
|
|
static const char *deepen_since;
|
2007-12-04 07:25:47 +00:00
|
|
|
static const char *upload_pack;
|
2016-06-12 10:54:04 +00:00
|
|
|
static struct string_list deepen_not = STRING_LIST_INIT_NODUP;
|
2007-12-04 07:25:46 +00:00
|
|
|
static struct strbuf default_rla = STRBUF_INIT;
|
2013-08-07 22:38:45 +00:00
|
|
|
static struct transport *gtransport;
|
fetch: work around "transport-take-over" hack
A Git-aware "connect" transport allows the "transport_take_over" to
redirect generic transport requests like fetch(), push_refs() and
get_refs_list() to the native Git transport handling methods. The
take-over process replaces transport->data with a fake data that
these method implementations understand.
While this hack works OK for a single request, it breaks when the
transport needs to make more than one requests. transport->data
that used to hold necessary information for the specific helper to
work correctly is destroyed during the take-over process.
One codepath that this matters is "git fetch" in auto-follow mode;
when it does not get all the tags that ought to point at the history
it got (which can be determined by looking at the peeled tags in the
initial advertisement) from the primary transfer, it internally
makes a second request to complete the fetch. Because "take-over"
hack has already destroyed the data necessary to talk to the
transport helper by the time this happens, the second request cannot
make a request to the helper to make another connection to fetch
these additional tags.
Mark such a transport as "cannot_reuse", and use a separate
transport to perform the backfill fetch in order to work around
this breakage.
Note that this problem does not manifest itself when running t5802,
because our upload-pack gives you all the necessary auto-followed
tags during the primary transfer. You would need to step through
"git fetch" in a debugger, stop immediately after the primary
transfer finishes and writes these auto-followed tags, remove the
tag references and repack/prune the repository to convince the
"find-non-local-tags" procedure that the primary transfer failed to
give us all the necessary tags, and then let it continue, in order
to trigger the bug in the secondary transfer this patch fixes.
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2013-08-07 22:47:18 +00:00
|
|
|
static struct transport *gsecondary;
|
2010-11-12 12:54:52 +00:00
|
|
|
static const char *submodule_prefix = "";
|
2011-03-06 22:10:46 +00:00
|
|
|
static const char *recurse_submodules_default;
|
2014-01-03 02:28:51 +00:00
|
|
|
static int shown_url = 0;
|
2014-05-29 22:21:31 +00:00
|
|
|
static int refmap_alloc, refmap_nr;
|
|
|
|
static const char **refmap_array;
|
2007-09-14 07:31:25 +00:00
|
|
|
|
2011-03-06 22:11:21 +00:00
|
|
|
static int option_parse_recurse_submodules(const struct option *opt,
|
|
|
|
const char *arg, int unset)
|
|
|
|
{
|
|
|
|
if (unset) {
|
|
|
|
recurse_submodules = RECURSE_SUBMODULES_OFF;
|
|
|
|
} else {
|
|
|
|
if (arg)
|
|
|
|
recurse_submodules = parse_fetch_recurse_submodules_arg(opt->long_name, arg);
|
|
|
|
else
|
|
|
|
recurse_submodules = RECURSE_SUBMODULES_ON;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
2007-09-14 07:31:25 +00:00
|
|
|
|
2013-07-13 09:36:24 +00:00
|
|
|
static int git_fetch_config(const char *k, const char *v, void *cb)
|
|
|
|
{
|
|
|
|
if (!strcmp(k, "fetch.prune")) {
|
|
|
|
fetch_prune_config = git_config_bool(k, v);
|
|
|
|
return 0;
|
|
|
|
}
|
fetch: load all default config at startup
When we start the git-fetch program, we call git_config to
load all config, but our callback only processes the
fetch.prune option; we do not chain to git_default_config at
all.
This means that we may not load some core configuration
which will have an effect. For instance, we do not load
core.logAllRefUpdates, which impacts whether or not we
create reflogs in a bare repository.
Note that I said "may" above. It gets even more exciting. If
we have to transfer actual objects as part of the fetch,
then we call fetch_pack as part of the same process. That
function loads its own config, which does chain to
git_default_config, impacting global variables which are
used by the rest of fetch. But if the fetch is a pure ref
update (e.g., a new ref which is a copy of an old one), we
skip fetch_pack entirely. So we get inconsistent results
depending on whether or not we have actual objects to
transfer or not!
Let's just load the core config at the start of fetch, so we
know we have it (we may also load it again as part of
fetch_pack, but that's OK; it's designed to be idempotent).
Our tests check both cases (with and without a pack). We
also check similar behavior for push for good measure, but
it already works as expected.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2014-11-04 13:11:19 +00:00
|
|
|
return git_default_config(k, v, cb);
|
2013-07-13 09:36:24 +00:00
|
|
|
}
|
|
|
|
|
2014-05-29 22:21:31 +00:00
|
|
|
static int parse_refmap_arg(const struct option *opt, const char *arg, int unset)
|
|
|
|
{
|
|
|
|
ALLOC_GROW(refmap_array, refmap_nr + 1, refmap_alloc);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* "git fetch --refmap='' origin foo"
|
|
|
|
* can be used to tell the command not to store anywhere
|
|
|
|
*/
|
|
|
|
if (*arg)
|
|
|
|
refmap_array[refmap_nr++] = arg;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2007-12-04 07:25:47 +00:00
|
|
|
static struct option builtin_fetch_options[] = {
|
2008-11-15 00:14:24 +00:00
|
|
|
OPT__VERBOSITY(&verbosity),
|
2013-08-03 11:51:19 +00:00
|
|
|
OPT_BOOL(0, "all", &all,
|
|
|
|
N_("fetch from all remotes")),
|
|
|
|
OPT_BOOL('a', "append", &append,
|
|
|
|
N_("append to .git/FETCH_HEAD instead of overwriting")),
|
2012-08-20 12:32:09 +00:00
|
|
|
OPT_STRING(0, "upload-pack", &upload_pack, N_("path"),
|
|
|
|
N_("path to upload pack on remote end")),
|
|
|
|
OPT__FORCE(&force, N_("force overwrite of local branch")),
|
2013-08-03 11:51:19 +00:00
|
|
|
OPT_BOOL('m', "multiple", &multiple,
|
|
|
|
N_("fetch from multiple remotes")),
|
2007-12-04 07:25:47 +00:00
|
|
|
OPT_SET_INT('t', "tags", &tags,
|
2012-08-20 12:32:09 +00:00
|
|
|
N_("fetch all tags and associated objects"), TAGS_SET),
|
2008-03-13 07:13:15 +00:00
|
|
|
OPT_SET_INT('n', NULL, &tags,
|
2012-08-20 12:32:09 +00:00
|
|
|
N_("do not fetch all tags (--no-tags)"), TAGS_UNSET),
|
2015-12-16 00:04:12 +00:00
|
|
|
OPT_INTEGER('j', "jobs", &max_children,
|
|
|
|
N_("number of submodules fetched in parallel")),
|
2013-08-03 11:51:19 +00:00
|
|
|
OPT_BOOL('p', "prune", &prune,
|
|
|
|
N_("prune remote-tracking branches no longer on remote")),
|
2012-08-20 12:32:09 +00:00
|
|
|
{ OPTION_CALLBACK, 0, "recurse-submodules", NULL, N_("on-demand"),
|
|
|
|
N_("control recursive fetching of submodules"),
|
2011-03-06 22:11:21 +00:00
|
|
|
PARSE_OPT_OPTARG, option_parse_recurse_submodules },
|
2013-08-03 11:51:19 +00:00
|
|
|
OPT_BOOL(0, "dry-run", &dry_run,
|
|
|
|
N_("dry run")),
|
|
|
|
OPT_BOOL('k', "keep", &keep, N_("keep downloaded pack")),
|
|
|
|
OPT_BOOL('u', "update-head-ok", &update_head_ok,
|
2012-08-20 12:32:09 +00:00
|
|
|
N_("allow updating of HEAD ref")),
|
|
|
|
OPT_BOOL(0, "progress", &progress, N_("force progress reporting")),
|
|
|
|
OPT_STRING(0, "depth", &depth, N_("depth"),
|
|
|
|
N_("deepen history of shallow clone")),
|
2016-06-12 10:53:59 +00:00
|
|
|
OPT_STRING(0, "shallow-since", &deepen_since, N_("time"),
|
|
|
|
N_("deepen history of shallow repository based on time")),
|
2016-06-12 10:54:04 +00:00
|
|
|
OPT_STRING_LIST(0, "shallow-exclude", &deepen_not, N_("revision"),
|
2016-12-04 22:03:59 +00:00
|
|
|
N_("deepen history of shallow clone, excluding rev")),
|
fetch, upload-pack: --deepen=N extends shallow boundary by N commits
In git-fetch, --depth argument is always relative with the latest
remote refs. This makes it a bit difficult to cover this use case,
where the user wants to make the shallow history, say 3 levels
deeper. It would work if remote refs have not moved yet, but nobody
can guarantee that, especially when that use case is performed a
couple months after the last clone or "git fetch --depth". Also,
modifying shallow boundary using --depth does not work well with
clones created by --since or --not.
This patch fixes that. A new argument --deepen=<N> will add <N> more (*)
parent commits to the current history regardless of where remote refs
are.
Have/Want negotiation is still respected. So if remote refs move, the
server will send two chunks: one between "have" and "want" and another
to extend shallow history. In theory, the client could send no "want"s
in order to get the second chunk only. But the protocol does not allow
that. Either you send no want lines, which means ls-remote; or you
have to send at least one want line that carries deep-relative to the
server..
The main work was done by Dongcan Jiang. I fixed it up here and there.
And of course all the bugs belong to me.
(*) We could even support --deepen=<N> where <N> is negative. In that
case we can cut some history from the shallow clone. This operation
(and --depth=<shorter depth>) does not require interaction with remote
side (and more complicated to implement as a result).
Helped-by: Duy Nguyen <pclouds@gmail.com>
Helped-by: Eric Sunshine <sunshine@sunshineco.com>
Helped-by: Junio C Hamano <gitster@pobox.com>
Signed-off-by: Dongcan Jiang <dongcan.jiang@gmail.com>
Signed-off-by: Nguyễn Thái Ngọc Duy <pclouds@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2016-06-12 10:54:09 +00:00
|
|
|
OPT_INTEGER(0, "deepen", &deepen_relative,
|
|
|
|
N_("deepen history of shallow clone")),
|
2013-01-11 09:05:46 +00:00
|
|
|
{ OPTION_SET_INT, 0, "unshallow", &unshallow, NULL,
|
|
|
|
N_("convert to a complete repository"),
|
|
|
|
PARSE_OPT_NONEG | PARSE_OPT_NOARG, NULL, 1 },
|
2012-08-20 12:32:09 +00:00
|
|
|
{ OPTION_STRING, 0, "submodule-prefix", &submodule_prefix, N_("dir"),
|
|
|
|
N_("prepend this to submodule path output"), PARSE_OPT_HIDDEN },
|
2011-03-06 22:10:46 +00:00
|
|
|
{ OPTION_STRING, 0, "recurse-submodules-default",
|
|
|
|
&recurse_submodules_default, NULL,
|
2012-08-20 12:32:09 +00:00
|
|
|
N_("default mode for recursion"), PARSE_OPT_HIDDEN },
|
2013-12-05 13:02:42 +00:00
|
|
|
OPT_BOOL(0, "update-shallow", &update_shallow,
|
|
|
|
N_("accept refs that update .git/shallow")),
|
2014-05-29 22:21:31 +00:00
|
|
|
{ OPTION_CALLBACK, 0, "refmap", NULL, N_("refmap"),
|
|
|
|
N_("specify fetch refmap"), PARSE_OPT_NONEG, parse_refmap_arg },
|
2016-02-03 04:09:14 +00:00
|
|
|
OPT_SET_INT('4', "ipv4", &family, N_("use IPv4 addresses only"),
|
|
|
|
TRANSPORT_FAMILY_IPV4),
|
|
|
|
OPT_SET_INT('6', "ipv6", &family, N_("use IPv6 addresses only"),
|
|
|
|
TRANSPORT_FAMILY_IPV6),
|
2007-12-04 07:25:47 +00:00
|
|
|
OPT_END()
|
|
|
|
};
|
|
|
|
|
2007-09-14 07:31:25 +00:00
|
|
|
static void unlock_pack(void)
|
|
|
|
{
|
2013-08-07 22:38:45 +00:00
|
|
|
if (gtransport)
|
|
|
|
transport_unlock_pack(gtransport);
|
fetch: work around "transport-take-over" hack
A Git-aware "connect" transport allows the "transport_take_over" to
redirect generic transport requests like fetch(), push_refs() and
get_refs_list() to the native Git transport handling methods. The
take-over process replaces transport->data with a fake data that
these method implementations understand.
While this hack works OK for a single request, it breaks when the
transport needs to make more than one requests. transport->data
that used to hold necessary information for the specific helper to
work correctly is destroyed during the take-over process.
One codepath that this matters is "git fetch" in auto-follow mode;
when it does not get all the tags that ought to point at the history
it got (which can be determined by looking at the peeled tags in the
initial advertisement) from the primary transfer, it internally
makes a second request to complete the fetch. Because "take-over"
hack has already destroyed the data necessary to talk to the
transport helper by the time this happens, the second request cannot
make a request to the helper to make another connection to fetch
these additional tags.
Mark such a transport as "cannot_reuse", and use a separate
transport to perform the backfill fetch in order to work around
this breakage.
Note that this problem does not manifest itself when running t5802,
because our upload-pack gives you all the necessary auto-followed
tags during the primary transfer. You would need to step through
"git fetch" in a debugger, stop immediately after the primary
transfer finishes and writes these auto-followed tags, remove the
tag references and repack/prune the repository to convince the
"find-non-local-tags" procedure that the primary transfer failed to
give us all the necessary tags, and then let it continue, in order
to trigger the bug in the secondary transfer this patch fixes.
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2013-08-07 22:47:18 +00:00
|
|
|
if (gsecondary)
|
|
|
|
transport_unlock_pack(gsecondary);
|
2007-09-14 07:31:25 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static void unlock_pack_on_signal(int signo)
|
|
|
|
{
|
|
|
|
unlock_pack();
|
chain kill signals for cleanup functions
If a piece of code wanted to do some cleanup before exiting
(e.g., cleaning up a lockfile or a tempfile), our usual
strategy was to install a signal handler that did something
like this:
do_cleanup(); /* actual work */
signal(signo, SIG_DFL); /* restore previous behavior */
raise(signo); /* deliver signal, killing ourselves */
For a single handler, this works fine. However, if we want
to clean up two _different_ things, we run into a problem.
The most recently installed handler will run, but when it
removes itself as a handler, it doesn't put back the first
handler.
This patch introduces sigchain, a tiny library for handling
a stack of signal handlers. You sigchain_push each handler,
and use sigchain_pop to restore whoever was before you in
the stack.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2009-01-22 06:02:35 +00:00
|
|
|
sigchain_pop(signo);
|
2007-09-14 07:31:25 +00:00
|
|
|
raise(signo);
|
|
|
|
}
|
2007-09-11 03:03:25 +00:00
|
|
|
|
2007-09-18 08:54:53 +00:00
|
|
|
static void add_merge_config(struct ref **head,
|
2007-10-30 01:05:40 +00:00
|
|
|
const struct ref *remote_refs,
|
2007-09-18 08:54:53 +00:00
|
|
|
struct branch *branch,
|
|
|
|
struct ref ***tail)
|
2007-09-11 03:03:25 +00:00
|
|
|
{
|
2007-09-18 08:54:53 +00:00
|
|
|
int i;
|
2007-09-11 03:03:25 +00:00
|
|
|
|
2007-09-18 08:54:53 +00:00
|
|
|
for (i = 0; i < branch->merge_nr; i++) {
|
|
|
|
struct ref *rm, **old_tail = *tail;
|
|
|
|
struct refspec refspec;
|
|
|
|
|
|
|
|
for (rm = *head; rm; rm = rm->next) {
|
|
|
|
if (branch_merge_matches(branch, i, rm->name)) {
|
2013-05-11 16:15:59 +00:00
|
|
|
rm->fetch_head_status = FETCH_HEAD_MERGE;
|
2007-09-18 08:54:53 +00:00
|
|
|
break;
|
|
|
|
}
|
2007-09-11 03:03:25 +00:00
|
|
|
}
|
2007-09-18 08:54:53 +00:00
|
|
|
if (rm)
|
|
|
|
continue;
|
|
|
|
|
2007-10-27 06:09:48 +00:00
|
|
|
/*
|
2010-11-02 15:31:23 +00:00
|
|
|
* Not fetched to a remote-tracking branch? We need to fetch
|
2007-09-18 08:54:53 +00:00
|
|
|
* it anyway to allow this branch's "branch.$name.merge"
|
2008-09-09 10:28:30 +00:00
|
|
|
* to be honored by 'git pull', but we do not have to
|
2007-10-27 06:09:48 +00:00
|
|
|
* fail if branch.$name.merge is misconfigured to point
|
|
|
|
* at a nonexisting branch. If we were indeed called by
|
2008-09-09 10:28:30 +00:00
|
|
|
* 'git pull', it will notice the misconfiguration because
|
2007-10-27 06:09:48 +00:00
|
|
|
* there is no entry in the resulting FETCH_HEAD marked
|
|
|
|
* for merging.
|
2007-09-18 08:54:53 +00:00
|
|
|
*/
|
2010-03-12 22:27:33 +00:00
|
|
|
memset(&refspec, 0, sizeof(refspec));
|
2007-09-18 08:54:53 +00:00
|
|
|
refspec.src = branch->merge[i]->src;
|
2007-10-27 06:09:48 +00:00
|
|
|
get_fetch_map(remote_refs, &refspec, tail, 1);
|
2007-09-18 08:54:53 +00:00
|
|
|
for (rm = *old_tail; rm; rm = rm->next)
|
2013-05-11 16:15:59 +00:00
|
|
|
rm->fetch_head_status = FETCH_HEAD_MERGE;
|
2007-09-11 03:03:25 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-05-25 18:38:35 +00:00
|
|
|
static int add_existing(const char *refname, const struct object_id *oid,
|
2013-10-30 05:32:55 +00:00
|
|
|
int flag, void *cbdata)
|
|
|
|
{
|
|
|
|
struct string_list *list = (struct string_list *)cbdata;
|
|
|
|
struct string_list_item *item = string_list_insert(list, refname);
|
2015-05-25 18:38:35 +00:00
|
|
|
struct object_id *old_oid = xmalloc(sizeof(*old_oid));
|
|
|
|
|
|
|
|
oidcpy(old_oid, oid);
|
|
|
|
item->util = old_oid;
|
2013-10-30 05:32:55 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int will_fetch(struct ref **head, const unsigned char *sha1)
|
|
|
|
{
|
|
|
|
struct ref *rm = *head;
|
|
|
|
while (rm) {
|
2015-11-10 02:22:20 +00:00
|
|
|
if (!hashcmp(rm->old_oid.hash, sha1))
|
2013-10-30 05:32:55 +00:00
|
|
|
return 1;
|
|
|
|
rm = rm->next;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2008-03-03 02:35:25 +00:00
|
|
|
static void find_non_local_tags(struct transport *transport,
|
|
|
|
struct ref **head,
|
2013-10-30 05:32:55 +00:00
|
|
|
struct ref ***tail)
|
|
|
|
{
|
|
|
|
struct string_list existing_refs = STRING_LIST_INIT_DUP;
|
|
|
|
struct string_list remote_refs = STRING_LIST_INIT_NODUP;
|
|
|
|
const struct ref *ref;
|
|
|
|
struct string_list_item *item = NULL;
|
|
|
|
|
2015-05-25 18:38:35 +00:00
|
|
|
for_each_ref(add_existing, &existing_refs);
|
2013-10-30 05:32:55 +00:00
|
|
|
for (ref = transport_get_remote_refs(transport); ref; ref = ref->next) {
|
2013-12-17 19:47:35 +00:00
|
|
|
if (!starts_with(ref->name, "refs/tags/"))
|
2013-10-30 05:32:55 +00:00
|
|
|
continue;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* The peeled ref always follows the matching base
|
|
|
|
* ref, so if we see a peeled ref that we don't want
|
|
|
|
* to fetch then we can mark the ref entry in the list
|
|
|
|
* as one to ignore by setting util to NULL.
|
|
|
|
*/
|
2013-12-17 19:47:35 +00:00
|
|
|
if (ends_with(ref->name, "^{}")) {
|
fetch: use "quick" has_sha1_file for tag following
When we auto-follow tags in a fetch, we look at all of the
tags advertised by the remote and fetch ones where we don't
already have the tag, but we do have the object it peels to.
This involves a lot of calls to has_sha1_file(), some of
which we can reasonably expect to fail. Since 45e8a74
(has_sha1_file: re-check pack directory before giving up,
2013-08-30), this may cause many calls to
reprepare_packed_git(), which is potentially expensive.
This has gone unnoticed for several years because it
requires a fairly unique setup to matter:
1. You need to have a lot of packs on the client side to
make reprepare_packed_git() expensive (the most
expensive part is finding duplicates in an unsorted
list, which is currently quadratic).
2. You need a large number of tag refs on the server side
that are candidates for auto-following (i.e., that the
client doesn't have). Each one triggers a re-read of
the pack directory.
3. Under normal circumstances, the client would
auto-follow those tags and after one large fetch, (2)
would no longer be true. But if those tags point to
history which is disconnected from what the client
otherwise fetches, then it will never auto-follow, and
those candidates will impact it on every fetch.
So when all three are true, each fetch pays an extra
O(nr_tags * nr_packs^2) cost, mostly in string comparisons
on the pack names. This was exacerbated by 47bf4b0
(prepare_packed_git_one: refactor duplicate-pack check,
2014-06-30) which uses a slightly more expensive string
check, under the assumption that the duplicate check doesn't
happen very often (and it shouldn't; the real problem here
is how often we are calling reprepare_packed_git()).
This patch teaches fetch to use HAS_SHA1_QUICK to sacrifice
accuracy for speed, in cases where we might be racy with a
simultaneous repack. This is similar to the fix in 0eeb077
(index-pack: avoid excessive re-reading of pack directory,
2015-06-09). As with that case, it's OK for has_sha1_file()
occasionally say "no I don't have it" when we do, because
the worst case is not a corruption, but simply that we may
fail to auto-follow a tag that points to it.
Here are results from the included perf script, which sets
up a situation similar to the one described above:
Test HEAD^ HEAD
----------------------------------------------------------
5550.4: fetch 11.21(10.42+0.78) 0.08(0.04+0.02) -99.3%
Reported-by: Vegard Nossum <vegard.nossum@oracle.com>
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2016-10-13 16:53:44 +00:00
|
|
|
if (item &&
|
|
|
|
!has_object_file_with_flags(&ref->old_oid, HAS_SHA1_QUICK) &&
|
2015-11-10 02:22:20 +00:00
|
|
|
!will_fetch(head, ref->old_oid.hash) &&
|
fetch: use "quick" has_sha1_file for tag following
When we auto-follow tags in a fetch, we look at all of the
tags advertised by the remote and fetch ones where we don't
already have the tag, but we do have the object it peels to.
This involves a lot of calls to has_sha1_file(), some of
which we can reasonably expect to fail. Since 45e8a74
(has_sha1_file: re-check pack directory before giving up,
2013-08-30), this may cause many calls to
reprepare_packed_git(), which is potentially expensive.
This has gone unnoticed for several years because it
requires a fairly unique setup to matter:
1. You need to have a lot of packs on the client side to
make reprepare_packed_git() expensive (the most
expensive part is finding duplicates in an unsorted
list, which is currently quadratic).
2. You need a large number of tag refs on the server side
that are candidates for auto-following (i.e., that the
client doesn't have). Each one triggers a re-read of
the pack directory.
3. Under normal circumstances, the client would
auto-follow those tags and after one large fetch, (2)
would no longer be true. But if those tags point to
history which is disconnected from what the client
otherwise fetches, then it will never auto-follow, and
those candidates will impact it on every fetch.
So when all three are true, each fetch pays an extra
O(nr_tags * nr_packs^2) cost, mostly in string comparisons
on the pack names. This was exacerbated by 47bf4b0
(prepare_packed_git_one: refactor duplicate-pack check,
2014-06-30) which uses a slightly more expensive string
check, under the assumption that the duplicate check doesn't
happen very often (and it shouldn't; the real problem here
is how often we are calling reprepare_packed_git()).
This patch teaches fetch to use HAS_SHA1_QUICK to sacrifice
accuracy for speed, in cases where we might be racy with a
simultaneous repack. This is similar to the fix in 0eeb077
(index-pack: avoid excessive re-reading of pack directory,
2015-06-09). As with that case, it's OK for has_sha1_file()
occasionally say "no I don't have it" when we do, because
the worst case is not a corruption, but simply that we may
fail to auto-follow a tag that points to it.
Here are results from the included perf script, which sets
up a situation similar to the one described above:
Test HEAD^ HEAD
----------------------------------------------------------
5550.4: fetch 11.21(10.42+0.78) 0.08(0.04+0.02) -99.3%
Reported-by: Vegard Nossum <vegard.nossum@oracle.com>
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2016-10-13 16:53:44 +00:00
|
|
|
!has_sha1_file_with_flags(item->util, HAS_SHA1_QUICK) &&
|
2013-10-30 05:32:55 +00:00
|
|
|
!will_fetch(head, item->util))
|
|
|
|
item->util = NULL;
|
|
|
|
item = NULL;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If item is non-NULL here, then we previously saw a
|
|
|
|
* ref not followed by a peeled reference, so we need
|
|
|
|
* to check if it is a lightweight tag that we want to
|
|
|
|
* fetch.
|
|
|
|
*/
|
fetch: use "quick" has_sha1_file for tag following
When we auto-follow tags in a fetch, we look at all of the
tags advertised by the remote and fetch ones where we don't
already have the tag, but we do have the object it peels to.
This involves a lot of calls to has_sha1_file(), some of
which we can reasonably expect to fail. Since 45e8a74
(has_sha1_file: re-check pack directory before giving up,
2013-08-30), this may cause many calls to
reprepare_packed_git(), which is potentially expensive.
This has gone unnoticed for several years because it
requires a fairly unique setup to matter:
1. You need to have a lot of packs on the client side to
make reprepare_packed_git() expensive (the most
expensive part is finding duplicates in an unsorted
list, which is currently quadratic).
2. You need a large number of tag refs on the server side
that are candidates for auto-following (i.e., that the
client doesn't have). Each one triggers a re-read of
the pack directory.
3. Under normal circumstances, the client would
auto-follow those tags and after one large fetch, (2)
would no longer be true. But if those tags point to
history which is disconnected from what the client
otherwise fetches, then it will never auto-follow, and
those candidates will impact it on every fetch.
So when all three are true, each fetch pays an extra
O(nr_tags * nr_packs^2) cost, mostly in string comparisons
on the pack names. This was exacerbated by 47bf4b0
(prepare_packed_git_one: refactor duplicate-pack check,
2014-06-30) which uses a slightly more expensive string
check, under the assumption that the duplicate check doesn't
happen very often (and it shouldn't; the real problem here
is how often we are calling reprepare_packed_git()).
This patch teaches fetch to use HAS_SHA1_QUICK to sacrifice
accuracy for speed, in cases where we might be racy with a
simultaneous repack. This is similar to the fix in 0eeb077
(index-pack: avoid excessive re-reading of pack directory,
2015-06-09). As with that case, it's OK for has_sha1_file()
occasionally say "no I don't have it" when we do, because
the worst case is not a corruption, but simply that we may
fail to auto-follow a tag that points to it.
Here are results from the included perf script, which sets
up a situation similar to the one described above:
Test HEAD^ HEAD
----------------------------------------------------------
5550.4: fetch 11.21(10.42+0.78) 0.08(0.04+0.02) -99.3%
Reported-by: Vegard Nossum <vegard.nossum@oracle.com>
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2016-10-13 16:53:44 +00:00
|
|
|
if (item &&
|
|
|
|
!has_sha1_file_with_flags(item->util, HAS_SHA1_QUICK) &&
|
2013-10-30 05:32:55 +00:00
|
|
|
!will_fetch(head, item->util))
|
|
|
|
item->util = NULL;
|
|
|
|
|
|
|
|
item = NULL;
|
|
|
|
|
|
|
|
/* skip duplicates and refs that we already have */
|
|
|
|
if (string_list_has_string(&remote_refs, ref->name) ||
|
|
|
|
string_list_has_string(&existing_refs, ref->name))
|
|
|
|
continue;
|
|
|
|
|
|
|
|
item = string_list_insert(&remote_refs, ref->name);
|
2015-11-10 02:22:20 +00:00
|
|
|
item->util = (void *)&ref->old_oid;
|
2013-10-30 05:32:55 +00:00
|
|
|
}
|
|
|
|
string_list_clear(&existing_refs, 1);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* We may have a final lightweight tag that needs to be
|
|
|
|
* checked to see if it needs fetching.
|
|
|
|
*/
|
fetch: use "quick" has_sha1_file for tag following
When we auto-follow tags in a fetch, we look at all of the
tags advertised by the remote and fetch ones where we don't
already have the tag, but we do have the object it peels to.
This involves a lot of calls to has_sha1_file(), some of
which we can reasonably expect to fail. Since 45e8a74
(has_sha1_file: re-check pack directory before giving up,
2013-08-30), this may cause many calls to
reprepare_packed_git(), which is potentially expensive.
This has gone unnoticed for several years because it
requires a fairly unique setup to matter:
1. You need to have a lot of packs on the client side to
make reprepare_packed_git() expensive (the most
expensive part is finding duplicates in an unsorted
list, which is currently quadratic).
2. You need a large number of tag refs on the server side
that are candidates for auto-following (i.e., that the
client doesn't have). Each one triggers a re-read of
the pack directory.
3. Under normal circumstances, the client would
auto-follow those tags and after one large fetch, (2)
would no longer be true. But if those tags point to
history which is disconnected from what the client
otherwise fetches, then it will never auto-follow, and
those candidates will impact it on every fetch.
So when all three are true, each fetch pays an extra
O(nr_tags * nr_packs^2) cost, mostly in string comparisons
on the pack names. This was exacerbated by 47bf4b0
(prepare_packed_git_one: refactor duplicate-pack check,
2014-06-30) which uses a slightly more expensive string
check, under the assumption that the duplicate check doesn't
happen very often (and it shouldn't; the real problem here
is how often we are calling reprepare_packed_git()).
This patch teaches fetch to use HAS_SHA1_QUICK to sacrifice
accuracy for speed, in cases where we might be racy with a
simultaneous repack. This is similar to the fix in 0eeb077
(index-pack: avoid excessive re-reading of pack directory,
2015-06-09). As with that case, it's OK for has_sha1_file()
occasionally say "no I don't have it" when we do, because
the worst case is not a corruption, but simply that we may
fail to auto-follow a tag that points to it.
Here are results from the included perf script, which sets
up a situation similar to the one described above:
Test HEAD^ HEAD
----------------------------------------------------------
5550.4: fetch 11.21(10.42+0.78) 0.08(0.04+0.02) -99.3%
Reported-by: Vegard Nossum <vegard.nossum@oracle.com>
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2016-10-13 16:53:44 +00:00
|
|
|
if (item &&
|
|
|
|
!has_sha1_file_with_flags(item->util, HAS_SHA1_QUICK) &&
|
2013-10-30 05:32:55 +00:00
|
|
|
!will_fetch(head, item->util))
|
|
|
|
item->util = NULL;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* For all the tags in the remote_refs string list,
|
|
|
|
* add them to the list of refs to be fetched
|
|
|
|
*/
|
|
|
|
for_each_string_list_item(item, &remote_refs) {
|
|
|
|
/* Unless we have already decided to ignore this item... */
|
|
|
|
if (item->util)
|
|
|
|
{
|
|
|
|
struct ref *rm = alloc_ref(item->string);
|
|
|
|
rm->peer_ref = alloc_ref(item->string);
|
2015-11-10 02:22:20 +00:00
|
|
|
oidcpy(&rm->old_oid, item->util);
|
2013-10-30 05:32:55 +00:00
|
|
|
**tail = rm;
|
|
|
|
*tail = &rm->next;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
string_list_clear(&remote_refs, 0);
|
|
|
|
}
|
2008-03-03 02:35:25 +00:00
|
|
|
|
2007-09-11 03:03:25 +00:00
|
|
|
static struct ref *get_ref_map(struct transport *transport,
|
2013-10-23 15:50:38 +00:00
|
|
|
struct refspec *refspecs, int refspec_count,
|
|
|
|
int tags, int *autotags)
|
2007-09-11 03:03:25 +00:00
|
|
|
{
|
|
|
|
int i;
|
|
|
|
struct ref *rm;
|
|
|
|
struct ref *ref_map = NULL;
|
|
|
|
struct ref **tail = &ref_map;
|
|
|
|
|
2013-10-30 05:32:59 +00:00
|
|
|
/* opportunistically-updated references: */
|
|
|
|
struct ref *orefs = NULL, **oref_tail = &orefs;
|
2007-09-11 03:03:25 +00:00
|
|
|
|
2013-10-30 05:32:59 +00:00
|
|
|
const struct ref *remote_refs = transport_get_remote_refs(transport);
|
2013-05-11 16:16:52 +00:00
|
|
|
|
2013-10-30 05:32:59 +00:00
|
|
|
if (refspec_count) {
|
2014-05-29 22:21:31 +00:00
|
|
|
struct refspec *fetch_refspec;
|
|
|
|
int fetch_refspec_nr;
|
|
|
|
|
2013-10-23 15:50:38 +00:00
|
|
|
for (i = 0; i < refspec_count; i++) {
|
|
|
|
get_fetch_map(remote_refs, &refspecs[i], &tail, 0);
|
|
|
|
if (refspecs[i].dst && refspecs[i].dst[0])
|
2007-09-11 03:03:25 +00:00
|
|
|
*autotags = 1;
|
|
|
|
}
|
2013-10-30 05:32:58 +00:00
|
|
|
/* Merge everything on the command line (but not --tags) */
|
2007-09-11 03:03:25 +00:00
|
|
|
for (rm = ref_map; rm; rm = rm->next)
|
2013-05-11 16:15:59 +00:00
|
|
|
rm->fetch_head_status = FETCH_HEAD_MERGE;
|
2013-05-11 16:16:52 +00:00
|
|
|
|
|
|
|
/*
|
2013-10-30 05:32:58 +00:00
|
|
|
* For any refs that we happen to be fetching via
|
|
|
|
* command-line arguments, the destination ref might
|
|
|
|
* have been missing or have been different than the
|
|
|
|
* remote-tracking ref that would be derived from the
|
|
|
|
* configured refspec. In these cases, we want to
|
|
|
|
* take the opportunity to update their configured
|
|
|
|
* remote-tracking reference. However, we do not want
|
|
|
|
* to mention these entries in FETCH_HEAD at all, as
|
|
|
|
* they would simply be duplicates of existing
|
|
|
|
* entries, so we set them FETCH_HEAD_IGNORE below.
|
|
|
|
*
|
|
|
|
* We compute these entries now, based only on the
|
|
|
|
* refspecs specified on the command line. But we add
|
|
|
|
* them to the list following the refspecs resulting
|
|
|
|
* from the tags option so that one of the latter,
|
|
|
|
* which has FETCH_HEAD_NOT_FOR_MERGE, is not removed
|
|
|
|
* by ref_remove_duplicates() in favor of one of these
|
|
|
|
* opportunistic entries with FETCH_HEAD_IGNORE.
|
2013-05-11 16:16:52 +00:00
|
|
|
*/
|
2014-05-29 22:21:31 +00:00
|
|
|
if (refmap_array) {
|
|
|
|
fetch_refspec = parse_fetch_refspec(refmap_nr, refmap_array);
|
|
|
|
fetch_refspec_nr = refmap_nr;
|
|
|
|
} else {
|
|
|
|
fetch_refspec = transport->remote->fetch;
|
|
|
|
fetch_refspec_nr = transport->remote->fetch_refspec_nr;
|
|
|
|
}
|
|
|
|
|
|
|
|
for (i = 0; i < fetch_refspec_nr; i++)
|
|
|
|
get_fetch_map(ref_map, &fetch_refspec[i], &oref_tail, 1);
|
|
|
|
} else if (refmap_array) {
|
|
|
|
die("--refmap option is only meaningful with command-line refspec(s).");
|
2007-09-11 03:03:25 +00:00
|
|
|
} else {
|
|
|
|
/* Use the defaults */
|
|
|
|
struct remote *remote = transport->remote;
|
2007-09-18 08:54:53 +00:00
|
|
|
struct branch *branch = branch_get(NULL);
|
|
|
|
int has_merge = branch_has_merge_config(branch);
|
builtin/fetch.c: ignore merge config when not fetching from branch's remote
When 'git fetch' is supplied a single argument, it tries to match it
against a configured remote and then fetch the refs specified by the
named remote's fetchspec. Additionally, or alternatively, if the current
branch has a merge ref configured, and if the name of the remote supplied
to fetch matches the one in the branch's configuration, then git also adds
the merge ref to the list of refs to update.
If the argument to fetch does not specify a named remote, or if the name
supplied does not match the remote configured for the current branch, then
the current branch's merge configuration should not be considered.
git currently mishandles the case when the argument to fetch specifies a
GIT URL(i.e. not a named remote) and the current branch has a configured
merge ref. In this case, fetch should ignore the branch's merge ref and
attempt to fetch from the remote repository's HEAD branch. But, since
fetch only checks _whether_ the current branch has a merge ref configured,
and does _not_ check whether the branch's configured remote matches the
command line argument (until later), it will mistakenly enter the wrong
branch of an 'if' statement and will not fall back to fetch the HEAD branch.
The fetch ends up doing nothing and returns with a successful zero status.
Fix this by comparing the remote repository's name to the branch's remote
name, in addition to whether it has a configured merge ref, sooner, so that
fetch can correctly decide whether the branch's configuration is interesting
or not, and fall back to fetching from the remote's HEAD branch when
appropriate.
This fixes the test in t5510.
Signed-off-by: Brandon Casey <casey@nrlssc.navy.mil>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2010-08-25 17:52:56 +00:00
|
|
|
if (remote &&
|
|
|
|
(remote->fetch_refspec_nr ||
|
2010-09-09 18:56:36 +00:00
|
|
|
/* Note: has_merge implies non-NULL branch->remote_name */
|
builtin/fetch.c: ignore merge config when not fetching from branch's remote
When 'git fetch' is supplied a single argument, it tries to match it
against a configured remote and then fetch the refs specified by the
named remote's fetchspec. Additionally, or alternatively, if the current
branch has a merge ref configured, and if the name of the remote supplied
to fetch matches the one in the branch's configuration, then git also adds
the merge ref to the list of refs to update.
If the argument to fetch does not specify a named remote, or if the name
supplied does not match the remote configured for the current branch, then
the current branch's merge configuration should not be considered.
git currently mishandles the case when the argument to fetch specifies a
GIT URL(i.e. not a named remote) and the current branch has a configured
merge ref. In this case, fetch should ignore the branch's merge ref and
attempt to fetch from the remote repository's HEAD branch. But, since
fetch only checks _whether_ the current branch has a merge ref configured,
and does _not_ check whether the branch's configured remote matches the
command line argument (until later), it will mistakenly enter the wrong
branch of an 'if' statement and will not fall back to fetch the HEAD branch.
The fetch ends up doing nothing and returns with a successful zero status.
Fix this by comparing the remote repository's name to the branch's remote
name, in addition to whether it has a configured merge ref, sooner, so that
fetch can correctly decide whether the branch's configuration is interesting
or not, and fall back to fetching from the remote's HEAD branch when
appropriate.
This fixes the test in t5510.
Signed-off-by: Brandon Casey <casey@nrlssc.navy.mil>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2010-08-25 17:52:56 +00:00
|
|
|
(has_merge && !strcmp(branch->remote_name, remote->name)))) {
|
2007-09-11 03:03:25 +00:00
|
|
|
for (i = 0; i < remote->fetch_refspec_nr; i++) {
|
2007-10-27 06:09:48 +00:00
|
|
|
get_fetch_map(remote_refs, &remote->fetch[i], &tail, 0);
|
2007-09-11 03:03:25 +00:00
|
|
|
if (remote->fetch[i].dst &&
|
|
|
|
remote->fetch[i].dst[0])
|
|
|
|
*autotags = 1;
|
2007-09-18 08:54:53 +00:00
|
|
|
if (!i && !has_merge && ref_map &&
|
2007-09-28 23:34:17 +00:00
|
|
|
!remote->fetch[0].pattern)
|
2013-05-11 16:15:59 +00:00
|
|
|
ref_map->fetch_head_status = FETCH_HEAD_MERGE;
|
2007-09-11 03:03:25 +00:00
|
|
|
}
|
2007-10-11 00:47:55 +00:00
|
|
|
/*
|
|
|
|
* if the remote we're fetching from is the same
|
|
|
|
* as given in branch.<name>.remote, we add the
|
|
|
|
* ref given in branch.<name>.merge, too.
|
2010-09-09 18:56:36 +00:00
|
|
|
*
|
|
|
|
* Note: has_merge implies non-NULL branch->remote_name
|
2007-10-11 00:47:55 +00:00
|
|
|
*/
|
2007-10-27 06:09:48 +00:00
|
|
|
if (has_merge &&
|
|
|
|
!strcmp(branch->remote_name, remote->name))
|
2007-09-18 08:54:53 +00:00
|
|
|
add_merge_config(&ref_map, remote_refs, branch, &tail);
|
2007-09-11 03:03:25 +00:00
|
|
|
} else {
|
|
|
|
ref_map = get_remote_ref(remote_refs, "HEAD");
|
2007-10-27 06:09:48 +00:00
|
|
|
if (!ref_map)
|
2011-02-22 23:41:51 +00:00
|
|
|
die(_("Couldn't find remote ref HEAD"));
|
2013-05-11 16:15:59 +00:00
|
|
|
ref_map->fetch_head_status = FETCH_HEAD_MERGE;
|
2008-03-03 02:34:51 +00:00
|
|
|
tail = &ref_map->next;
|
2007-09-11 03:03:25 +00:00
|
|
|
}
|
|
|
|
}
|
2013-10-30 05:32:58 +00:00
|
|
|
|
2013-10-30 05:32:59 +00:00
|
|
|
if (tags == TAGS_SET)
|
|
|
|
/* also fetch all tags */
|
|
|
|
get_fetch_map(remote_refs, tag_refspec, &tail, 0);
|
|
|
|
else if (tags == TAGS_DEFAULT && *autotags)
|
2008-03-03 02:35:25 +00:00
|
|
|
find_non_local_tags(transport, &ref_map, &tail);
|
2013-10-30 05:32:58 +00:00
|
|
|
|
2013-10-30 05:32:59 +00:00
|
|
|
/* Now append any refs to be updated opportunistically: */
|
|
|
|
*tail = orefs;
|
|
|
|
for (rm = orefs; rm; rm = rm->next) {
|
|
|
|
rm->fetch_head_status = FETCH_HEAD_IGNORE;
|
|
|
|
tail = &rm->next;
|
|
|
|
}
|
|
|
|
|
2013-10-30 05:33:09 +00:00
|
|
|
return ref_remove_duplicates(ref_map);
|
2007-09-11 03:03:25 +00:00
|
|
|
}
|
|
|
|
|
2009-05-25 10:40:54 +00:00
|
|
|
#define STORE_REF_ERROR_OTHER 1
|
|
|
|
#define STORE_REF_ERROR_DF_CONFLICT 2
|
|
|
|
|
2007-09-11 03:03:25 +00:00
|
|
|
static int s_update_ref(const char *action,
|
|
|
|
struct ref *ref,
|
|
|
|
int check_old)
|
|
|
|
{
|
|
|
|
char msg[1024];
|
|
|
|
char *rla = getenv("GIT_REFLOG_ACTION");
|
2014-04-28 20:49:07 +00:00
|
|
|
struct ref_transaction *transaction;
|
|
|
|
struct strbuf err = STRBUF_INIT;
|
|
|
|
int ret, df_conflict = 0;
|
2007-09-11 03:03:25 +00:00
|
|
|
|
2009-11-10 08:19:43 +00:00
|
|
|
if (dry_run)
|
|
|
|
return 0;
|
2007-09-11 03:03:25 +00:00
|
|
|
if (!rla)
|
2007-12-04 07:25:46 +00:00
|
|
|
rla = default_rla.buf;
|
2007-09-11 03:03:25 +00:00
|
|
|
snprintf(msg, sizeof(msg), "%s: %s", rla, action);
|
2014-04-28 20:49:07 +00:00
|
|
|
|
|
|
|
transaction = ref_transaction_begin(&err);
|
|
|
|
if (!transaction ||
|
2015-02-17 17:00:15 +00:00
|
|
|
ref_transaction_update(transaction, ref->name,
|
2015-11-10 02:22:20 +00:00
|
|
|
ref->new_oid.hash,
|
|
|
|
check_old ? ref->old_oid.hash : NULL,
|
2015-02-17 17:00:15 +00:00
|
|
|
0, msg, &err))
|
2014-04-28 20:49:07 +00:00
|
|
|
goto fail;
|
|
|
|
|
|
|
|
ret = ref_transaction_commit(transaction, &err);
|
|
|
|
if (ret) {
|
|
|
|
df_conflict = (ret == TRANSACTION_NAME_CONFLICT);
|
|
|
|
goto fail;
|
|
|
|
}
|
|
|
|
|
|
|
|
ref_transaction_free(transaction);
|
|
|
|
strbuf_release(&err);
|
2007-09-11 03:03:25 +00:00
|
|
|
return 0;
|
2014-04-28 20:49:07 +00:00
|
|
|
fail:
|
|
|
|
ref_transaction_free(transaction);
|
|
|
|
error("%s", err.buf);
|
|
|
|
strbuf_release(&err);
|
|
|
|
return df_conflict ? STORE_REF_ERROR_DF_CONFLICT
|
|
|
|
: STORE_REF_ERROR_OTHER;
|
2007-09-11 03:03:25 +00:00
|
|
|
}
|
|
|
|
|
2016-07-01 16:03:30 +00:00
|
|
|
static int refcol_width = 10;
|
2016-07-01 16:03:31 +00:00
|
|
|
static int compact_format;
|
2016-07-01 16:03:30 +00:00
|
|
|
|
|
|
|
static void adjust_refcol_width(const struct ref *ref)
|
|
|
|
{
|
|
|
|
int max, rlen, llen, len;
|
|
|
|
|
|
|
|
/* uptodate lines are only shown on high verbosity level */
|
|
|
|
if (!verbosity && !oidcmp(&ref->peer_ref->old_oid, &ref->old_oid))
|
|
|
|
return;
|
|
|
|
|
|
|
|
max = term_columns();
|
|
|
|
rlen = utf8_strwidth(prettify_refname(ref->name));
|
2016-07-01 16:03:31 +00:00
|
|
|
|
2016-07-01 16:03:30 +00:00
|
|
|
llen = utf8_strwidth(prettify_refname(ref->peer_ref->name));
|
|
|
|
|
|
|
|
/*
|
|
|
|
* rough estimation to see if the output line is too long and
|
|
|
|
* should not be counted (we can't do precise calculation
|
|
|
|
* anyway because we don't know if the error explanation part
|
|
|
|
* will be printed in update_local_ref)
|
|
|
|
*/
|
2016-07-01 16:03:31 +00:00
|
|
|
if (compact_format) {
|
|
|
|
llen = 0;
|
|
|
|
max = max * 2 / 3;
|
|
|
|
}
|
2016-07-01 16:03:30 +00:00
|
|
|
len = 21 /* flag and summary */ + rlen + 4 /* -> */ + llen;
|
|
|
|
if (len >= max)
|
|
|
|
return;
|
|
|
|
|
2016-07-01 16:03:31 +00:00
|
|
|
/*
|
|
|
|
* Not precise calculation for compact mode because '*' can
|
|
|
|
* appear on the left hand side of '->' and shrink the column
|
|
|
|
* back.
|
|
|
|
*/
|
2016-07-01 16:03:30 +00:00
|
|
|
if (refcol_width < rlen)
|
|
|
|
refcol_width = rlen;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void prepare_format_display(struct ref *ref_map)
|
|
|
|
{
|
|
|
|
struct ref *rm;
|
2016-07-01 16:03:31 +00:00
|
|
|
const char *format = "full";
|
|
|
|
|
|
|
|
git_config_get_string_const("fetch.output", &format);
|
|
|
|
if (!strcasecmp(format, "full"))
|
|
|
|
compact_format = 0;
|
|
|
|
else if (!strcasecmp(format, "compact"))
|
|
|
|
compact_format = 1;
|
|
|
|
else
|
|
|
|
die(_("configuration fetch.output contains invalid value %s"),
|
|
|
|
format);
|
2016-07-01 16:03:30 +00:00
|
|
|
|
|
|
|
for (rm = ref_map; rm; rm = rm->next) {
|
|
|
|
if (rm->status == REF_STATUS_REJECT_SHALLOW ||
|
|
|
|
!rm->peer_ref ||
|
|
|
|
!strcmp(rm->name, "HEAD"))
|
|
|
|
continue;
|
|
|
|
|
|
|
|
adjust_refcol_width(rm);
|
|
|
|
}
|
|
|
|
}
|
2007-11-03 05:32:48 +00:00
|
|
|
|
2016-07-01 16:03:31 +00:00
|
|
|
static void print_remote_to_local(struct strbuf *display,
|
|
|
|
const char *remote, const char *local)
|
|
|
|
{
|
|
|
|
strbuf_addf(display, "%-*s -> %s", refcol_width, remote, local);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int find_and_replace(struct strbuf *haystack,
|
|
|
|
const char *needle,
|
|
|
|
const char *placeholder)
|
|
|
|
{
|
|
|
|
const char *p = strstr(haystack->buf, needle);
|
|
|
|
int plen, nlen;
|
|
|
|
|
|
|
|
if (!p)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
if (p > haystack->buf && p[-1] != '/')
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
plen = strlen(p);
|
|
|
|
nlen = strlen(needle);
|
|
|
|
if (plen > nlen && p[nlen] != '/')
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
strbuf_splice(haystack, p - haystack->buf, nlen,
|
|
|
|
placeholder, strlen(placeholder));
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void print_compact(struct strbuf *display,
|
|
|
|
const char *remote, const char *local)
|
|
|
|
{
|
|
|
|
struct strbuf r = STRBUF_INIT;
|
|
|
|
struct strbuf l = STRBUF_INIT;
|
|
|
|
|
|
|
|
if (!strcmp(remote, local)) {
|
|
|
|
strbuf_addf(display, "%-*s -> *", refcol_width, remote);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
strbuf_addstr(&r, remote);
|
|
|
|
strbuf_addstr(&l, local);
|
|
|
|
|
|
|
|
if (!find_and_replace(&r, local, "*"))
|
|
|
|
find_and_replace(&l, remote, "*");
|
|
|
|
print_remote_to_local(display, r.buf, l.buf);
|
|
|
|
|
|
|
|
strbuf_release(&r);
|
|
|
|
strbuf_release(&l);
|
|
|
|
}
|
|
|
|
|
2016-06-26 05:58:07 +00:00
|
|
|
static void format_display(struct strbuf *display, char code,
|
|
|
|
const char *summary, const char *error,
|
2016-10-21 22:22:55 +00:00
|
|
|
const char *remote, const char *local,
|
|
|
|
int summary_width)
|
2016-06-26 05:58:07 +00:00
|
|
|
{
|
2016-10-21 22:22:55 +00:00
|
|
|
int width = (summary_width + strlen(summary) - gettext_width(summary));
|
|
|
|
|
|
|
|
strbuf_addf(display, "%c %-*s ", code, width, summary);
|
2016-07-01 16:03:31 +00:00
|
|
|
if (!compact_format)
|
|
|
|
print_remote_to_local(display, remote, local);
|
|
|
|
else
|
|
|
|
print_compact(display, remote, local);
|
2016-06-26 05:58:07 +00:00
|
|
|
if (error)
|
|
|
|
strbuf_addf(display, " (%s)", error);
|
|
|
|
}
|
2007-11-03 05:32:48 +00:00
|
|
|
|
2007-09-11 03:03:25 +00:00
|
|
|
static int update_local_ref(struct ref *ref,
|
2007-11-03 05:32:48 +00:00
|
|
|
const char *remote,
|
2012-04-16 22:08:49 +00:00
|
|
|
const struct ref *remote_ref,
|
2016-10-21 22:22:55 +00:00
|
|
|
struct strbuf *display,
|
|
|
|
int summary_width)
|
2007-09-11 03:03:25 +00:00
|
|
|
{
|
|
|
|
struct commit *current = NULL, *updated;
|
|
|
|
enum object_type type;
|
|
|
|
struct branch *current_branch = branch_get(NULL);
|
2009-05-13 21:22:04 +00:00
|
|
|
const char *pretty_ref = prettify_refname(ref->name);
|
2007-09-11 03:03:25 +00:00
|
|
|
|
2015-11-10 02:22:20 +00:00
|
|
|
type = sha1_object_info(ref->new_oid.hash, NULL);
|
2007-09-11 03:03:25 +00:00
|
|
|
if (type < 0)
|
2015-11-10 02:22:20 +00:00
|
|
|
die(_("object %s not found"), oid_to_hex(&ref->new_oid));
|
2007-09-11 03:03:25 +00:00
|
|
|
|
2015-11-10 02:22:20 +00:00
|
|
|
if (!oidcmp(&ref->old_oid, &ref->new_oid)) {
|
2008-11-15 00:14:24 +00:00
|
|
|
if (verbosity > 0)
|
2016-06-26 05:58:07 +00:00
|
|
|
format_display(display, '=', _("[up to date]"), NULL,
|
2016-10-21 22:22:55 +00:00
|
|
|
remote, pretty_ref, summary_width);
|
2007-09-11 03:03:25 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2007-09-16 06:31:26 +00:00
|
|
|
if (current_branch &&
|
|
|
|
!strcmp(ref->name, current_branch->name) &&
|
2007-09-11 03:03:25 +00:00
|
|
|
!(update_head_ok || is_bare_repository()) &&
|
2015-11-10 02:22:20 +00:00
|
|
|
!is_null_oid(&ref->old_oid)) {
|
2007-09-11 03:03:25 +00:00
|
|
|
/*
|
|
|
|
* If this is the head, and it's not okay to update
|
|
|
|
* the head, and the old value of the head isn't empty...
|
|
|
|
*/
|
2016-06-26 05:58:07 +00:00
|
|
|
format_display(display, '!', _("[rejected]"),
|
|
|
|
_("can't fetch in current branch"),
|
2016-10-21 22:22:55 +00:00
|
|
|
remote, pretty_ref, summary_width);
|
2007-09-11 03:03:25 +00:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2015-11-10 02:22:20 +00:00
|
|
|
if (!is_null_oid(&ref->old_oid) &&
|
2013-11-30 20:55:40 +00:00
|
|
|
starts_with(ref->name, "refs/tags/")) {
|
2008-06-27 03:59:50 +00:00
|
|
|
int r;
|
|
|
|
r = s_update_ref("updating tag", ref, 0);
|
2016-06-26 05:58:08 +00:00
|
|
|
format_display(display, r ? '!' : 't', _("[tag update]"),
|
2016-06-26 05:58:07 +00:00
|
|
|
r ? _("unable to update local ref") : NULL,
|
2016-10-21 22:22:55 +00:00
|
|
|
remote, pretty_ref, summary_width);
|
2008-06-27 03:59:50 +00:00
|
|
|
return r;
|
2007-09-11 03:03:25 +00:00
|
|
|
}
|
|
|
|
|
2015-11-10 02:22:20 +00:00
|
|
|
current = lookup_commit_reference_gently(ref->old_oid.hash, 1);
|
|
|
|
updated = lookup_commit_reference_gently(ref->new_oid.hash, 1);
|
2007-09-11 03:03:25 +00:00
|
|
|
if (!current || !updated) {
|
2007-11-03 05:32:48 +00:00
|
|
|
const char *msg;
|
|
|
|
const char *what;
|
2008-06-27 03:59:50 +00:00
|
|
|
int r;
|
2012-04-16 22:08:50 +00:00
|
|
|
/*
|
|
|
|
* Nicely describe the new ref we're fetching.
|
|
|
|
* Base this on the remote's ref name, as it's
|
|
|
|
* more likely to follow a standard layout.
|
|
|
|
*/
|
|
|
|
const char *name = remote_ref ? remote_ref->name : "";
|
2013-11-30 20:55:40 +00:00
|
|
|
if (starts_with(name, "refs/tags/")) {
|
2007-09-11 03:03:25 +00:00
|
|
|
msg = "storing tag";
|
2011-02-22 23:41:53 +00:00
|
|
|
what = _("[new tag]");
|
2013-11-30 20:55:40 +00:00
|
|
|
} else if (starts_with(name, "refs/heads/")) {
|
2007-09-11 03:03:25 +00:00
|
|
|
msg = "storing head";
|
2011-02-22 23:41:53 +00:00
|
|
|
what = _("[new branch]");
|
2012-04-16 22:08:50 +00:00
|
|
|
} else {
|
|
|
|
msg = "storing ref";
|
|
|
|
what = _("[new ref]");
|
2007-11-03 05:32:48 +00:00
|
|
|
}
|
|
|
|
|
2012-04-13 16:25:16 +00:00
|
|
|
if ((recurse_submodules != RECURSE_SUBMODULES_OFF) &&
|
|
|
|
(recurse_submodules != RECURSE_SUBMODULES_ON))
|
2015-11-10 02:22:20 +00:00
|
|
|
check_for_new_submodule_commits(ref->new_oid.hash);
|
2008-06-27 03:59:50 +00:00
|
|
|
r = s_update_ref(msg, ref, 0);
|
2016-06-26 05:58:07 +00:00
|
|
|
format_display(display, r ? '!' : '*', what,
|
|
|
|
r ? _("unable to update local ref") : NULL,
|
2016-10-21 22:22:55 +00:00
|
|
|
remote, pretty_ref, summary_width);
|
2008-06-27 03:59:50 +00:00
|
|
|
return r;
|
2007-09-11 03:03:25 +00:00
|
|
|
}
|
|
|
|
|
2012-08-27 21:46:01 +00:00
|
|
|
if (in_merge_bases(current, updated)) {
|
2015-09-24 21:07:40 +00:00
|
|
|
struct strbuf quickref = STRBUF_INIT;
|
2008-06-27 03:59:50 +00:00
|
|
|
int r;
|
2015-11-10 02:22:29 +00:00
|
|
|
strbuf_add_unique_abbrev(&quickref, current->object.oid.hash, DEFAULT_ABBREV);
|
2015-09-24 21:07:40 +00:00
|
|
|
strbuf_addstr(&quickref, "..");
|
2015-11-10 02:22:20 +00:00
|
|
|
strbuf_add_unique_abbrev(&quickref, ref->new_oid.hash, DEFAULT_ABBREV);
|
2011-03-06 22:10:46 +00:00
|
|
|
if ((recurse_submodules != RECURSE_SUBMODULES_OFF) &&
|
|
|
|
(recurse_submodules != RECURSE_SUBMODULES_ON))
|
2015-11-10 02:22:20 +00:00
|
|
|
check_for_new_submodule_commits(ref->new_oid.hash);
|
2009-10-24 08:31:32 +00:00
|
|
|
r = s_update_ref("fast-forward", ref, 1);
|
2016-06-26 05:58:07 +00:00
|
|
|
format_display(display, r ? '!' : ' ', quickref.buf,
|
|
|
|
r ? _("unable to update local ref") : NULL,
|
2016-10-21 22:22:55 +00:00
|
|
|
remote, pretty_ref, summary_width);
|
2015-09-24 21:07:40 +00:00
|
|
|
strbuf_release(&quickref);
|
2008-06-27 03:59:50 +00:00
|
|
|
return r;
|
2007-11-03 05:32:48 +00:00
|
|
|
} else if (force || ref->force) {
|
2015-09-24 21:07:40 +00:00
|
|
|
struct strbuf quickref = STRBUF_INIT;
|
2008-06-27 03:59:50 +00:00
|
|
|
int r;
|
2015-11-10 02:22:29 +00:00
|
|
|
strbuf_add_unique_abbrev(&quickref, current->object.oid.hash, DEFAULT_ABBREV);
|
2015-09-24 21:07:40 +00:00
|
|
|
strbuf_addstr(&quickref, "...");
|
2015-11-10 02:22:20 +00:00
|
|
|
strbuf_add_unique_abbrev(&quickref, ref->new_oid.hash, DEFAULT_ABBREV);
|
2011-03-06 22:10:46 +00:00
|
|
|
if ((recurse_submodules != RECURSE_SUBMODULES_OFF) &&
|
|
|
|
(recurse_submodules != RECURSE_SUBMODULES_ON))
|
2015-11-10 02:22:20 +00:00
|
|
|
check_for_new_submodule_commits(ref->new_oid.hash);
|
2008-06-27 03:59:50 +00:00
|
|
|
r = s_update_ref("forced-update", ref, 1);
|
2016-06-26 05:58:07 +00:00
|
|
|
format_display(display, r ? '!' : '+', quickref.buf,
|
|
|
|
r ? _("unable to update local ref") : _("forced update"),
|
2016-10-21 22:22:55 +00:00
|
|
|
remote, pretty_ref, summary_width);
|
2015-09-24 21:07:40 +00:00
|
|
|
strbuf_release(&quickref);
|
2008-06-27 03:59:50 +00:00
|
|
|
return r;
|
2007-11-03 05:32:48 +00:00
|
|
|
} else {
|
2016-06-26 05:58:07 +00:00
|
|
|
format_display(display, '!', _("[rejected]"), _("non-fast-forward"),
|
2016-10-21 22:22:55 +00:00
|
|
|
remote, pretty_ref, summary_width);
|
2007-09-11 03:03:25 +00:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-09-02 23:22:47 +00:00
|
|
|
static int iterate_ref_map(void *cb_data, unsigned char sha1[20])
|
2011-09-01 22:43:35 +00:00
|
|
|
{
|
2011-09-02 23:22:47 +00:00
|
|
|
struct ref **rm = cb_data;
|
|
|
|
struct ref *ref = *rm;
|
2011-09-01 22:43:35 +00:00
|
|
|
|
2013-12-05 13:02:40 +00:00
|
|
|
while (ref && ref->status == REF_STATUS_REJECT_SHALLOW)
|
|
|
|
ref = ref->next;
|
2011-09-02 23:22:47 +00:00
|
|
|
if (!ref)
|
|
|
|
return -1; /* end of the list */
|
|
|
|
*rm = ref->next;
|
2015-11-10 02:22:20 +00:00
|
|
|
hashcpy(sha1, ref->old_oid.hash);
|
2011-09-02 23:22:47 +00:00
|
|
|
return 0;
|
2011-09-01 22:43:35 +00:00
|
|
|
}
|
|
|
|
|
2009-04-17 08:20:11 +00:00
|
|
|
static int store_updated_refs(const char *raw_url, const char *remote_name,
|
2008-06-27 04:01:41 +00:00
|
|
|
struct ref *ref_map)
|
2007-09-11 03:03:25 +00:00
|
|
|
{
|
|
|
|
FILE *fp;
|
|
|
|
struct commit *commit;
|
2014-01-03 02:28:51 +00:00
|
|
|
int url_len, i, rc = 0;
|
2011-12-08 08:43:19 +00:00
|
|
|
struct strbuf note = STRBUF_INIT;
|
2007-09-11 03:03:25 +00:00
|
|
|
const char *what, *kind;
|
|
|
|
struct ref *rm;
|
2014-11-30 08:24:27 +00:00
|
|
|
char *url;
|
memoize common git-path "constant" files
One of the most common uses of git_path() is to pass a
constant, like git_path("MERGE_MSG"). This has two
drawbacks:
1. The return value is a static buffer, and the lifetime
is dependent on other calls to git_path, etc.
2. There's no compile-time checking of the pathname. This
is OK for a one-off (after all, we have to spell it
correctly at least once), but many of these constant
strings appear throughout the code.
This patch introduces a series of functions to "memoize"
these strings, which are essentially globals for the
lifetime of the program. We compute the value once, take
ownership of the buffer, and return the cached value for
subsequent calls. cache.h provides a helper macro for
defining these functions as one-liners, and defines a few
common ones for global use.
Using a macro is a little bit gross, but it does nicely
document the purpose of the functions. If we need to touch
them all later (e.g., because we learned how to change the
git_dir variable at runtime, and need to invalidate all of
the stored values), it will be much easier to have the
complete list.
Note that the shared-global functions have separate, manual
declarations. We could do something clever with the macros
(e.g., expand it to a declaration in some places, and a
declaration _and_ a definition in path.c). But there aren't
that many, and it's probably better to stay away from
too-magical macros.
Likewise, if we abandon the C preprocessor in favor of
generating these with a script, we could get much fancier.
E.g., normalizing "FOO/BAR-BAZ" into "git_path_foo_bar_baz".
But the small amount of saved typing is probably not worth
the resulting confusion to readers who want to grep for the
function's definition.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2015-08-10 09:38:57 +00:00
|
|
|
const char *filename = dry_run ? "/dev/null" : git_path_fetch_head();
|
2013-05-11 16:15:59 +00:00
|
|
|
int want_status;
|
2016-10-21 22:28:07 +00:00
|
|
|
int summary_width = transport_summary_width(ref_map);
|
2007-09-11 03:03:25 +00:00
|
|
|
|
2007-11-22 22:22:23 +00:00
|
|
|
fp = fopen(filename, "a");
|
|
|
|
if (!fp)
|
2016-05-08 09:47:26 +00:00
|
|
|
return error_errno(_("cannot open %s"), filename);
|
2009-04-17 08:20:11 +00:00
|
|
|
|
2009-11-18 01:42:22 +00:00
|
|
|
if (raw_url)
|
|
|
|
url = transport_anonymize_url(raw_url);
|
|
|
|
else
|
|
|
|
url = xstrdup("foreign");
|
2011-09-01 22:43:35 +00:00
|
|
|
|
2011-09-02 23:22:47 +00:00
|
|
|
rm = ref_map;
|
check_everything_connected: use a struct with named options
The number of variants of check_everything_connected has
grown over the years, so that the "real" function takes
several possibly-zero, possibly-NULL arguments. We hid the
complexity behind some wrapper functions, but this doesn't
scale well when we want to add new options.
If we add more wrapper variants to handle the new options,
then we can get a combinatorial explosion when those options
might be used together (right now nobody wants to use both
"shallow" and "transport" together, so we get by with just a
few wrappers).
If instead we add new parameters to each function, each of
which can have a default value, then callers who want the
defaults end up with confusing invocations like:
check_everything_connected(fn, 0, data, -1, 0, NULL);
where it is unclear which parameter is which (and every
caller needs updated when we add new options).
Instead, let's add a struct to hold all of the optional
parameters. This is a little more verbose for the callers
(who have to declare the struct and fill it in), but it
makes their code much easier to follow, because every option
is named as it is set (and unused options do not have to be
mentioned at all).
Note that we could also stick the iteration function and its
callback data into the option struct, too. But since those
are required for each call, by avoiding doing so, we can let
very simple callers just pass "NULL" for the options and not
worry about the struct at all.
While we're touching each site, let's also rename the
function to check_connected(). The existing name was quite
long, and not all of the wrappers even used the full name.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2016-07-15 10:30:40 +00:00
|
|
|
if (check_connected(iterate_ref_map, &rm, NULL)) {
|
2011-10-07 07:40:22 +00:00
|
|
|
rc = error(_("%s did not send all necessary objects\n"), url);
|
|
|
|
goto abort;
|
|
|
|
}
|
2011-09-01 22:43:35 +00:00
|
|
|
|
2016-07-01 16:03:30 +00:00
|
|
|
prepare_format_display(ref_map);
|
|
|
|
|
2011-12-26 16:16:56 +00:00
|
|
|
/*
|
2013-05-11 16:15:59 +00:00
|
|
|
* We do a pass for each fetch_head_status type in their enum order, so
|
|
|
|
* merged entries are written before not-for-merge. That lets readers
|
|
|
|
* use FETCH_HEAD as a refname to refer to the ref to be merged.
|
2011-12-26 16:16:56 +00:00
|
|
|
*/
|
2013-05-11 16:15:59 +00:00
|
|
|
for (want_status = FETCH_HEAD_MERGE;
|
|
|
|
want_status <= FETCH_HEAD_IGNORE;
|
|
|
|
want_status++) {
|
2011-12-26 16:16:56 +00:00
|
|
|
for (rm = ref_map; rm; rm = rm->next) {
|
|
|
|
struct ref *ref = NULL;
|
2013-05-11 16:15:59 +00:00
|
|
|
const char *merge_status_marker = "";
|
2011-12-26 16:16:56 +00:00
|
|
|
|
2013-12-05 13:02:40 +00:00
|
|
|
if (rm->status == REF_STATUS_REJECT_SHALLOW) {
|
|
|
|
if (want_status == FETCH_HEAD_MERGE)
|
|
|
|
warning(_("reject %s because shallow roots are not allowed to be updated"),
|
|
|
|
rm->peer_ref ? rm->peer_ref->name : rm->name);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2015-11-10 02:22:20 +00:00
|
|
|
commit = lookup_commit_reference_gently(rm->old_oid.hash, 1);
|
2011-12-26 16:16:56 +00:00
|
|
|
if (!commit)
|
2013-05-11 16:15:59 +00:00
|
|
|
rm->fetch_head_status = FETCH_HEAD_NOT_FOR_MERGE;
|
2011-12-26 16:16:56 +00:00
|
|
|
|
2013-05-11 16:15:59 +00:00
|
|
|
if (rm->fetch_head_status != want_status)
|
2011-12-26 16:16:56 +00:00
|
|
|
continue;
|
|
|
|
|
|
|
|
if (rm->peer_ref) {
|
2015-09-24 21:08:09 +00:00
|
|
|
ref = alloc_ref(rm->peer_ref->name);
|
2015-11-10 02:22:20 +00:00
|
|
|
oidcpy(&ref->old_oid, &rm->peer_ref->old_oid);
|
|
|
|
oidcpy(&ref->new_oid, &rm->old_oid);
|
2011-12-26 16:16:56 +00:00
|
|
|
ref->force = rm->peer_ref->force;
|
|
|
|
}
|
2007-09-11 03:03:25 +00:00
|
|
|
|
|
|
|
|
2011-12-26 16:16:56 +00:00
|
|
|
if (!strcmp(rm->name, "HEAD")) {
|
|
|
|
kind = "";
|
|
|
|
what = "";
|
|
|
|
}
|
2013-11-30 20:55:40 +00:00
|
|
|
else if (starts_with(rm->name, "refs/heads/")) {
|
2011-12-26 16:16:56 +00:00
|
|
|
kind = "branch";
|
|
|
|
what = rm->name + 11;
|
|
|
|
}
|
2013-11-30 20:55:40 +00:00
|
|
|
else if (starts_with(rm->name, "refs/tags/")) {
|
2011-12-26 16:16:56 +00:00
|
|
|
kind = "tag";
|
|
|
|
what = rm->name + 10;
|
|
|
|
}
|
2013-11-30 20:55:40 +00:00
|
|
|
else if (starts_with(rm->name, "refs/remotes/")) {
|
2011-12-26 16:16:56 +00:00
|
|
|
kind = "remote-tracking branch";
|
|
|
|
what = rm->name + 13;
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
kind = "";
|
|
|
|
what = rm->name;
|
|
|
|
}
|
2007-09-11 03:03:25 +00:00
|
|
|
|
2011-12-26 16:16:56 +00:00
|
|
|
url_len = strlen(url);
|
|
|
|
for (i = url_len - 1; url[i] == '/' && 0 <= i; i--)
|
|
|
|
;
|
|
|
|
url_len = i + 1;
|
|
|
|
if (4 < i && !strncmp(".git", url + i - 3, 4))
|
|
|
|
url_len = i - 3;
|
|
|
|
|
|
|
|
strbuf_reset(¬e);
|
|
|
|
if (*what) {
|
|
|
|
if (*kind)
|
|
|
|
strbuf_addf(¬e, "%s ", kind);
|
|
|
|
strbuf_addf(¬e, "'%s' of ", what);
|
|
|
|
}
|
2013-05-11 16:15:59 +00:00
|
|
|
switch (rm->fetch_head_status) {
|
|
|
|
case FETCH_HEAD_NOT_FOR_MERGE:
|
|
|
|
merge_status_marker = "not-for-merge";
|
|
|
|
/* fall-through */
|
|
|
|
case FETCH_HEAD_MERGE:
|
|
|
|
fprintf(fp, "%s\t%s\t%s",
|
2015-11-10 02:22:20 +00:00
|
|
|
oid_to_hex(&rm->old_oid),
|
2013-05-11 16:15:59 +00:00
|
|
|
merge_status_marker,
|
|
|
|
note.buf);
|
|
|
|
for (i = 0; i < url_len; ++i)
|
|
|
|
if ('\n' == url[i])
|
|
|
|
fputs("\\n", fp);
|
|
|
|
else
|
|
|
|
fputc(url[i], fp);
|
|
|
|
fputc('\n', fp);
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
/* do not write anything to FETCH_HEAD */
|
|
|
|
break;
|
|
|
|
}
|
2011-12-26 16:16:56 +00:00
|
|
|
|
|
|
|
strbuf_reset(¬e);
|
|
|
|
if (ref) {
|
2016-10-21 22:22:55 +00:00
|
|
|
rc |= update_local_ref(ref, what, rm, ¬e,
|
|
|
|
summary_width);
|
2011-12-26 16:16:56 +00:00
|
|
|
free(ref);
|
|
|
|
} else
|
2016-06-26 05:58:07 +00:00
|
|
|
format_display(¬e, '*',
|
|
|
|
*kind ? kind : "branch", NULL,
|
|
|
|
*what ? what : "HEAD",
|
2016-10-21 22:22:55 +00:00
|
|
|
"FETCH_HEAD", summary_width);
|
2011-12-26 16:16:56 +00:00
|
|
|
if (note.len) {
|
|
|
|
if (verbosity >= 0 && !shown_url) {
|
|
|
|
fprintf(stderr, _("From %.*s\n"),
|
|
|
|
url_len, url);
|
|
|
|
shown_url = 1;
|
|
|
|
}
|
|
|
|
if (verbosity >= 0)
|
|
|
|
fprintf(stderr, " %s\n", note.buf);
|
2007-11-03 05:32:48 +00:00
|
|
|
}
|
|
|
|
}
|
2007-09-11 03:03:25 +00:00
|
|
|
}
|
2011-10-07 07:40:22 +00:00
|
|
|
|
2009-05-25 10:40:54 +00:00
|
|
|
if (rc & STORE_REF_ERROR_DF_CONFLICT)
|
2011-02-22 23:41:51 +00:00
|
|
|
error(_("some local refs could not be updated; try running\n"
|
2008-06-27 04:01:41 +00:00
|
|
|
" 'git remote prune %s' to remove any old, conflicting "
|
2011-02-22 23:41:51 +00:00
|
|
|
"branches"), remote_name);
|
2011-10-07 07:40:22 +00:00
|
|
|
|
|
|
|
abort:
|
2011-12-08 08:43:19 +00:00
|
|
|
strbuf_release(¬e);
|
2011-10-07 07:40:22 +00:00
|
|
|
free(url);
|
|
|
|
fclose(fp);
|
2008-05-28 15:29:36 +00:00
|
|
|
return rc;
|
2007-09-11 03:03:25 +00:00
|
|
|
}
|
|
|
|
|
2007-11-11 07:29:47 +00:00
|
|
|
/*
|
|
|
|
* We would want to bypass the object transfer altogether if
|
quickfetch(): Prevent overflow of the rev-list command line
quickfetch() calls rev-list to check whether the objects we are about to
fetch are already present in the repo (if so, we can skip the object fetch).
However, when there are many (~1000) refs to be fetched, the rev-list
command line grows larger than the maximum command line size on some systems
(32K in Windows). This causes rev-list to fail, making quickfetch() return
non-zero, which unnecessarily triggers the transport machinery. This somehow
causes fetch to fail with an exit code.
By using the --stdin option to rev-list (and feeding the object list to its
standard input), we prevent the overflow of the rev-list command line,
which causes quickfetch(), and subsequently the overall fetch, to succeed.
However, using rev-list --stdin is not entirely straightforward: rev-list
terminates immediately when encountering an unknown object, which can
trigger SIGPIPE if we are still writing object's to its standard input.
We therefore temporarily ignore SIGPIPE so that the fetch process is not
terminated.
The patch also contains a testcase to verify the fix (note that before
the patch, the testcase would only fail on msysGit).
Signed-off-by: Johan Herland <johan@herland.net>
Improved-by: Johannes Sixt <j6t@kdbg.org>
Improved-by: Alex Riesen <raa.lkml@gmail.com>
Tested-by: Peter Krefting <peter@softwolves.pp.se>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2009-07-09 23:52:30 +00:00
|
|
|
* everything we are going to fetch already exists and is connected
|
2007-11-11 07:29:47 +00:00
|
|
|
* locally.
|
|
|
|
*/
|
|
|
|
static int quickfetch(struct ref *ref_map)
|
|
|
|
{
|
2011-09-02 23:22:47 +00:00
|
|
|
struct ref *rm = ref_map;
|
check_everything_connected: use a struct with named options
The number of variants of check_everything_connected has
grown over the years, so that the "real" function takes
several possibly-zero, possibly-NULL arguments. We hid the
complexity behind some wrapper functions, but this doesn't
scale well when we want to add new options.
If we add more wrapper variants to handle the new options,
then we can get a combinatorial explosion when those options
might be used together (right now nobody wants to use both
"shallow" and "transport" together, so we get by with just a
few wrappers).
If instead we add new parameters to each function, each of
which can have a default value, then callers who want the
defaults end up with confusing invocations like:
check_everything_connected(fn, 0, data, -1, 0, NULL);
where it is unclear which parameter is which (and every
caller needs updated when we add new options).
Instead, let's add a struct to hold all of the optional
parameters. This is a little more verbose for the callers
(who have to declare the struct and fill it in), but it
makes their code much easier to follow, because every option
is named as it is set (and unused options do not have to be
mentioned at all).
Note that we could also stick the iteration function and its
callback data into the option struct, too. But since those
are required for each call, by avoiding doing so, we can let
very simple callers just pass "NULL" for the options and not
worry about the struct at all.
While we're touching each site, let's also rename the
function to check_connected(). The existing name was quite
long, and not all of the wrappers even used the full name.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2016-07-15 10:30:40 +00:00
|
|
|
struct check_connected_options opt = CHECK_CONNECTED_INIT;
|
2011-09-02 23:22:47 +00:00
|
|
|
|
2007-11-11 07:29:47 +00:00
|
|
|
/*
|
|
|
|
* If we are deepening a shallow clone we already have these
|
|
|
|
* objects reachable. Running rev-list here will return with
|
|
|
|
* a good (0) exit status and we'll bypass the fetch that we
|
|
|
|
* really need to perform. Claiming failure now will ensure
|
|
|
|
* we perform the network exchange to deepen our history.
|
|
|
|
*/
|
2016-06-12 10:53:59 +00:00
|
|
|
if (deepen)
|
2007-11-11 07:29:47 +00:00
|
|
|
return -1;
|
check_everything_connected: use a struct with named options
The number of variants of check_everything_connected has
grown over the years, so that the "real" function takes
several possibly-zero, possibly-NULL arguments. We hid the
complexity behind some wrapper functions, but this doesn't
scale well when we want to add new options.
If we add more wrapper variants to handle the new options,
then we can get a combinatorial explosion when those options
might be used together (right now nobody wants to use both
"shallow" and "transport" together, so we get by with just a
few wrappers).
If instead we add new parameters to each function, each of
which can have a default value, then callers who want the
defaults end up with confusing invocations like:
check_everything_connected(fn, 0, data, -1, 0, NULL);
where it is unclear which parameter is which (and every
caller needs updated when we add new options).
Instead, let's add a struct to hold all of the optional
parameters. This is a little more verbose for the callers
(who have to declare the struct and fill it in), but it
makes their code much easier to follow, because every option
is named as it is set (and unused options do not have to be
mentioned at all).
Note that we could also stick the iteration function and its
callback data into the option struct, too. But since those
are required for each call, by avoiding doing so, we can let
very simple callers just pass "NULL" for the options and not
worry about the struct at all.
While we're touching each site, let's also rename the
function to check_connected(). The existing name was quite
long, and not all of the wrappers even used the full name.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2016-07-15 10:30:40 +00:00
|
|
|
opt.quiet = 1;
|
|
|
|
return check_connected(iterate_ref_map, &rm, &opt);
|
2007-11-11 07:29:47 +00:00
|
|
|
}
|
|
|
|
|
2007-09-11 03:03:25 +00:00
|
|
|
static int fetch_refs(struct transport *transport, struct ref *ref_map)
|
|
|
|
{
|
2007-11-11 07:29:47 +00:00
|
|
|
int ret = quickfetch(ref_map);
|
|
|
|
if (ret)
|
|
|
|
ret = transport_fetch_refs(transport, ref_map);
|
2007-09-11 03:03:25 +00:00
|
|
|
if (!ret)
|
2008-06-27 04:01:41 +00:00
|
|
|
ret |= store_updated_refs(transport->url,
|
|
|
|
transport->remote->name,
|
|
|
|
ref_map);
|
2007-09-14 07:31:23 +00:00
|
|
|
transport_unlock_pack(transport);
|
2007-09-11 03:03:25 +00:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2014-01-03 02:28:51 +00:00
|
|
|
static int prune_refs(struct refspec *refs, int ref_count, struct ref *ref_map,
|
|
|
|
const char *raw_url)
|
2009-11-10 08:15:47 +00:00
|
|
|
{
|
2014-01-03 02:28:51 +00:00
|
|
|
int url_len, i, result = 0;
|
2011-10-15 05:04:25 +00:00
|
|
|
struct ref *ref, *stale_refs = get_stale_heads(refs, ref_count, ref_map);
|
2014-01-03 02:28:51 +00:00
|
|
|
char *url;
|
2016-10-21 22:28:07 +00:00
|
|
|
int summary_width = transport_summary_width(stale_refs);
|
2009-11-10 08:15:47 +00:00
|
|
|
const char *dangling_msg = dry_run
|
2012-04-23 12:30:25 +00:00
|
|
|
? _(" (%s will become dangling)")
|
|
|
|
: _(" (%s has become dangling)");
|
2009-11-10 08:15:47 +00:00
|
|
|
|
2014-01-03 02:28:51 +00:00
|
|
|
if (raw_url)
|
|
|
|
url = transport_anonymize_url(raw_url);
|
|
|
|
else
|
|
|
|
url = xstrdup("foreign");
|
|
|
|
|
|
|
|
url_len = strlen(url);
|
|
|
|
for (i = url_len - 1; url[i] == '/' && 0 <= i; i--)
|
|
|
|
;
|
|
|
|
|
|
|
|
url_len = i + 1;
|
|
|
|
if (4 < i && !strncmp(".git", url + i - 3, 4))
|
|
|
|
url_len = i - 3;
|
|
|
|
|
2015-06-22 14:02:59 +00:00
|
|
|
if (!dry_run) {
|
|
|
|
struct string_list refnames = STRING_LIST_INIT_NODUP;
|
|
|
|
|
|
|
|
for (ref = stale_refs; ref; ref = ref->next)
|
|
|
|
string_list_append(&refnames, ref->name);
|
|
|
|
|
2016-06-18 04:15:10 +00:00
|
|
|
result = delete_refs(&refnames, 0);
|
2015-06-22 14:02:59 +00:00
|
|
|
string_list_clear(&refnames, 0);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (verbosity >= 0) {
|
|
|
|
for (ref = stale_refs; ref; ref = ref->next) {
|
2016-06-26 05:58:07 +00:00
|
|
|
struct strbuf sb = STRBUF_INIT;
|
2015-06-22 14:02:59 +00:00
|
|
|
if (!shown_url) {
|
|
|
|
fprintf(stderr, _("From %.*s\n"), url_len, url);
|
|
|
|
shown_url = 1;
|
|
|
|
}
|
2016-06-26 05:58:08 +00:00
|
|
|
format_display(&sb, '-', _("[deleted]"), NULL,
|
2016-10-21 22:22:55 +00:00
|
|
|
_("(none)"), prettify_refname(ref->name),
|
|
|
|
summary_width);
|
2016-06-26 05:58:07 +00:00
|
|
|
fprintf(stderr, " %s\n",sb.buf);
|
|
|
|
strbuf_release(&sb);
|
2009-11-10 08:15:47 +00:00
|
|
|
warn_dangling_symref(stderr, dangling_msg, ref->name);
|
|
|
|
}
|
|
|
|
}
|
2015-06-22 14:02:59 +00:00
|
|
|
|
2014-01-03 02:28:51 +00:00
|
|
|
free(url);
|
2009-11-10 08:15:47 +00:00
|
|
|
free_refs(stale_refs);
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
2008-10-13 09:36:52 +00:00
|
|
|
static void check_not_current_branch(struct ref *ref_map)
|
|
|
|
{
|
|
|
|
struct branch *current_branch = branch_get(NULL);
|
|
|
|
|
|
|
|
if (is_bare_repository() || !current_branch)
|
|
|
|
return;
|
|
|
|
|
|
|
|
for (; ref_map; ref_map = ref_map->next)
|
|
|
|
if (ref_map->peer_ref && !strcmp(current_branch->refname,
|
|
|
|
ref_map->peer_ref->name))
|
2011-02-22 23:41:51 +00:00
|
|
|
die(_("Refusing to fetch into current branch %s "
|
|
|
|
"of non-bare repository"), current_branch->refname);
|
2008-10-13 09:36:52 +00:00
|
|
|
}
|
|
|
|
|
2010-02-24 19:02:05 +00:00
|
|
|
static int truncate_fetch_head(void)
|
|
|
|
{
|
memoize common git-path "constant" files
One of the most common uses of git_path() is to pass a
constant, like git_path("MERGE_MSG"). This has two
drawbacks:
1. The return value is a static buffer, and the lifetime
is dependent on other calls to git_path, etc.
2. There's no compile-time checking of the pathname. This
is OK for a one-off (after all, we have to spell it
correctly at least once), but many of these constant
strings appear throughout the code.
This patch introduces a series of functions to "memoize"
these strings, which are essentially globals for the
lifetime of the program. We compute the value once, take
ownership of the buffer, and return the cached value for
subsequent calls. cache.h provides a helper macro for
defining these functions as one-liners, and defines a few
common ones for global use.
Using a macro is a little bit gross, but it does nicely
document the purpose of the functions. If we need to touch
them all later (e.g., because we learned how to change the
git_dir variable at runtime, and need to invalidate all of
the stored values), it will be much easier to have the
complete list.
Note that the shared-global functions have separate, manual
declarations. We could do something clever with the macros
(e.g., expand it to a declaration in some places, and a
declaration _and_ a definition in path.c). But there aren't
that many, and it's probably better to stay away from
too-magical macros.
Likewise, if we abandon the C preprocessor in favor of
generating these with a script, we could get much fancier.
E.g., normalizing "FOO/BAR-BAZ" into "git_path_foo_bar_baz".
But the small amount of saved typing is probably not worth
the resulting confusion to readers who want to grep for the
function's definition.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2015-08-10 09:38:57 +00:00
|
|
|
const char *filename = git_path_fetch_head();
|
Handle more file writes correctly in shared repos
In shared repositories, we have to be careful when writing files whose
permissions do not allow users other than the owner to write them.
In particular, we force the marks file of fast-export and the FETCH_HEAD
when fetching to be rewritten from scratch.
This commit does not touch other calls to fopen() that want to
write files:
- commands that write to working tree files (core.sharedRepository
does not affect permission bits of working tree files),
e.g. .rej file created by "apply --reject", result of applying a
previous conflict resolution by "rerere", "git merge-file".
- git am, when splitting mails (git-am correctly cleans up its directory
after finishing, so there is no need to share those files between users)
- git submodule clone, when writing the .git file, because the file
will not be overwritten
- git_terminal_prompt() in compat/terminal.c, because it is not writing to
a file at all
- git diff --output, because the output file is clearly not intended to be
shared between the users of the current repository
- git fast-import, when writing a crash report, because the reports' file
names are unique due to an embedded process ID
- mailinfo() in mailinfo.c, because the output is clearly not intended to
be shared between the users of the current repository
- check_or_regenerate_marks() in remote-testsvn.c, because this is only
used for Git's internal testing
- git fsck, when writing lost&found blobs (this should probably be
changed, but left as a low-hanging fruit for future contributors).
Note that this patch does not touch callers of write_file() and
write_file_gently(), which would benefit from the same scrutiny as
to usage in shared repositories. Most notable users are branch,
daemon, submodule & worktree, and a worrisome call in transport.c
when updating one ref (which ignores the shared flag).
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2016-01-11 18:35:54 +00:00
|
|
|
FILE *fp = fopen_for_writing(filename);
|
2010-02-24 19:02:05 +00:00
|
|
|
|
|
|
|
if (!fp)
|
2016-05-08 09:47:26 +00:00
|
|
|
return error_errno(_("cannot open %s"), filename);
|
2010-02-24 19:02:05 +00:00
|
|
|
fclose(fp);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2013-08-07 21:43:20 +00:00
|
|
|
static void set_option(struct transport *transport, const char *name, const char *value)
|
|
|
|
{
|
|
|
|
int r = transport_set_option(transport, name, value);
|
|
|
|
if (r < 0)
|
|
|
|
die(_("Option \"%s\" value \"%s\" is not valid for %s"),
|
|
|
|
name, value, transport->url);
|
|
|
|
if (r > 0)
|
|
|
|
warning(_("Option \"%s\" is ignored for %s\n"),
|
|
|
|
name, transport->url);
|
|
|
|
}
|
|
|
|
|
2016-06-12 10:53:59 +00:00
|
|
|
static struct transport *prepare_transport(struct remote *remote, int deepen)
|
2013-08-07 21:43:20 +00:00
|
|
|
{
|
|
|
|
struct transport *transport;
|
|
|
|
transport = transport_get(remote, NULL);
|
|
|
|
transport_set_verbosity(transport, verbosity, progress);
|
2016-02-03 04:09:14 +00:00
|
|
|
transport->family = family;
|
2013-08-07 21:43:20 +00:00
|
|
|
if (upload_pack)
|
|
|
|
set_option(transport, TRANS_OPT_UPLOADPACK, upload_pack);
|
|
|
|
if (keep)
|
|
|
|
set_option(transport, TRANS_OPT_KEEP, "yes");
|
|
|
|
if (depth)
|
|
|
|
set_option(transport, TRANS_OPT_DEPTH, depth);
|
2016-06-12 10:53:59 +00:00
|
|
|
if (deepen && deepen_since)
|
|
|
|
set_option(transport, TRANS_OPT_DEEPEN_SINCE, deepen_since);
|
2016-06-12 10:54:04 +00:00
|
|
|
if (deepen && deepen_not.nr)
|
|
|
|
set_option(transport, TRANS_OPT_DEEPEN_NOT,
|
|
|
|
(const char *)&deepen_not);
|
fetch, upload-pack: --deepen=N extends shallow boundary by N commits
In git-fetch, --depth argument is always relative with the latest
remote refs. This makes it a bit difficult to cover this use case,
where the user wants to make the shallow history, say 3 levels
deeper. It would work if remote refs have not moved yet, but nobody
can guarantee that, especially when that use case is performed a
couple months after the last clone or "git fetch --depth". Also,
modifying shallow boundary using --depth does not work well with
clones created by --since or --not.
This patch fixes that. A new argument --deepen=<N> will add <N> more (*)
parent commits to the current history regardless of where remote refs
are.
Have/Want negotiation is still respected. So if remote refs move, the
server will send two chunks: one between "have" and "want" and another
to extend shallow history. In theory, the client could send no "want"s
in order to get the second chunk only. But the protocol does not allow
that. Either you send no want lines, which means ls-remote; or you
have to send at least one want line that carries deep-relative to the
server..
The main work was done by Dongcan Jiang. I fixed it up here and there.
And of course all the bugs belong to me.
(*) We could even support --deepen=<N> where <N> is negative. In that
case we can cut some history from the shallow clone. This operation
(and --depth=<shorter depth>) does not require interaction with remote
side (and more complicated to implement as a result).
Helped-by: Duy Nguyen <pclouds@gmail.com>
Helped-by: Eric Sunshine <sunshine@sunshineco.com>
Helped-by: Junio C Hamano <gitster@pobox.com>
Signed-off-by: Dongcan Jiang <dongcan.jiang@gmail.com>
Signed-off-by: Nguyễn Thái Ngọc Duy <pclouds@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2016-06-12 10:54:09 +00:00
|
|
|
if (deepen_relative)
|
|
|
|
set_option(transport, TRANS_OPT_DEEPEN_RELATIVE, "yes");
|
2013-12-05 13:02:42 +00:00
|
|
|
if (update_shallow)
|
|
|
|
set_option(transport, TRANS_OPT_UPDATE_SHALLOW, "yes");
|
2013-08-07 21:43:20 +00:00
|
|
|
return transport;
|
|
|
|
}
|
|
|
|
|
2013-08-07 22:14:45 +00:00
|
|
|
static void backfill_tags(struct transport *transport, struct ref *ref_map)
|
|
|
|
{
|
2016-06-12 10:53:59 +00:00
|
|
|
int cannot_reuse;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Once we have set TRANS_OPT_DEEPEN_SINCE, we can't unset it
|
|
|
|
* when remote helper is used (setting it to an empty string
|
|
|
|
* is not unsetting). We could extend the remote helper
|
|
|
|
* protocol for that, but for now, just force a new connection
|
2016-06-12 10:54:04 +00:00
|
|
|
* without deepen-since. Similar story for deepen-not.
|
2016-06-12 10:53:59 +00:00
|
|
|
*/
|
2016-06-12 10:54:04 +00:00
|
|
|
cannot_reuse = transport->cannot_reuse ||
|
|
|
|
deepen_since || deepen_not.nr;
|
2016-06-12 10:53:59 +00:00
|
|
|
if (cannot_reuse) {
|
|
|
|
gsecondary = prepare_transport(transport->remote, 0);
|
fetch: work around "transport-take-over" hack
A Git-aware "connect" transport allows the "transport_take_over" to
redirect generic transport requests like fetch(), push_refs() and
get_refs_list() to the native Git transport handling methods. The
take-over process replaces transport->data with a fake data that
these method implementations understand.
While this hack works OK for a single request, it breaks when the
transport needs to make more than one requests. transport->data
that used to hold necessary information for the specific helper to
work correctly is destroyed during the take-over process.
One codepath that this matters is "git fetch" in auto-follow mode;
when it does not get all the tags that ought to point at the history
it got (which can be determined by looking at the peeled tags in the
initial advertisement) from the primary transfer, it internally
makes a second request to complete the fetch. Because "take-over"
hack has already destroyed the data necessary to talk to the
transport helper by the time this happens, the second request cannot
make a request to the helper to make another connection to fetch
these additional tags.
Mark such a transport as "cannot_reuse", and use a separate
transport to perform the backfill fetch in order to work around
this breakage.
Note that this problem does not manifest itself when running t5802,
because our upload-pack gives you all the necessary auto-followed
tags during the primary transfer. You would need to step through
"git fetch" in a debugger, stop immediately after the primary
transfer finishes and writes these auto-followed tags, remove the
tag references and repack/prune the repository to convince the
"find-non-local-tags" procedure that the primary transfer failed to
give us all the necessary tags, and then let it continue, in order
to trigger the bug in the secondary transfer this patch fixes.
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2013-08-07 22:47:18 +00:00
|
|
|
transport = gsecondary;
|
|
|
|
}
|
|
|
|
|
2013-08-07 22:14:45 +00:00
|
|
|
transport_set_option(transport, TRANS_OPT_FOLLOWTAGS, NULL);
|
|
|
|
transport_set_option(transport, TRANS_OPT_DEPTH, "0");
|
fetch, upload-pack: --deepen=N extends shallow boundary by N commits
In git-fetch, --depth argument is always relative with the latest
remote refs. This makes it a bit difficult to cover this use case,
where the user wants to make the shallow history, say 3 levels
deeper. It would work if remote refs have not moved yet, but nobody
can guarantee that, especially when that use case is performed a
couple months after the last clone or "git fetch --depth". Also,
modifying shallow boundary using --depth does not work well with
clones created by --since or --not.
This patch fixes that. A new argument --deepen=<N> will add <N> more (*)
parent commits to the current history regardless of where remote refs
are.
Have/Want negotiation is still respected. So if remote refs move, the
server will send two chunks: one between "have" and "want" and another
to extend shallow history. In theory, the client could send no "want"s
in order to get the second chunk only. But the protocol does not allow
that. Either you send no want lines, which means ls-remote; or you
have to send at least one want line that carries deep-relative to the
server..
The main work was done by Dongcan Jiang. I fixed it up here and there.
And of course all the bugs belong to me.
(*) We could even support --deepen=<N> where <N> is negative. In that
case we can cut some history from the shallow clone. This operation
(and --depth=<shorter depth>) does not require interaction with remote
side (and more complicated to implement as a result).
Helped-by: Duy Nguyen <pclouds@gmail.com>
Helped-by: Eric Sunshine <sunshine@sunshineco.com>
Helped-by: Junio C Hamano <gitster@pobox.com>
Signed-off-by: Dongcan Jiang <dongcan.jiang@gmail.com>
Signed-off-by: Nguyễn Thái Ngọc Duy <pclouds@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2016-06-12 10:54:09 +00:00
|
|
|
transport_set_option(transport, TRANS_OPT_DEEPEN_RELATIVE, NULL);
|
2013-08-07 22:14:45 +00:00
|
|
|
fetch_refs(transport, ref_map);
|
fetch: work around "transport-take-over" hack
A Git-aware "connect" transport allows the "transport_take_over" to
redirect generic transport requests like fetch(), push_refs() and
get_refs_list() to the native Git transport handling methods. The
take-over process replaces transport->data with a fake data that
these method implementations understand.
While this hack works OK for a single request, it breaks when the
transport needs to make more than one requests. transport->data
that used to hold necessary information for the specific helper to
work correctly is destroyed during the take-over process.
One codepath that this matters is "git fetch" in auto-follow mode;
when it does not get all the tags that ought to point at the history
it got (which can be determined by looking at the peeled tags in the
initial advertisement) from the primary transfer, it internally
makes a second request to complete the fetch. Because "take-over"
hack has already destroyed the data necessary to talk to the
transport helper by the time this happens, the second request cannot
make a request to the helper to make another connection to fetch
these additional tags.
Mark such a transport as "cannot_reuse", and use a separate
transport to perform the backfill fetch in order to work around
this breakage.
Note that this problem does not manifest itself when running t5802,
because our upload-pack gives you all the necessary auto-followed
tags during the primary transfer. You would need to step through
"git fetch" in a debugger, stop immediately after the primary
transfer finishes and writes these auto-followed tags, remove the
tag references and repack/prune the repository to convince the
"find-non-local-tags" procedure that the primary transfer failed to
give us all the necessary tags, and then let it continue, in order
to trigger the bug in the secondary transfer this patch fixes.
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2013-08-07 22:47:18 +00:00
|
|
|
|
|
|
|
if (gsecondary) {
|
|
|
|
transport_disconnect(gsecondary);
|
|
|
|
gsecondary = NULL;
|
|
|
|
}
|
2013-08-07 22:14:45 +00:00
|
|
|
}
|
|
|
|
|
2007-09-11 03:03:25 +00:00
|
|
|
static int do_fetch(struct transport *transport,
|
|
|
|
struct refspec *refs, int ref_count)
|
|
|
|
{
|
2013-05-25 09:08:01 +00:00
|
|
|
struct string_list existing_refs = STRING_LIST_INIT_DUP;
|
2008-03-03 02:34:43 +00:00
|
|
|
struct ref *ref_map;
|
2007-09-11 03:03:25 +00:00
|
|
|
struct ref *rm;
|
|
|
|
int autotags = (transport->remote->fetch_tags == 1);
|
2013-05-25 09:08:16 +00:00
|
|
|
int retcode = 0;
|
2009-10-25 21:28:12 +00:00
|
|
|
|
2015-05-25 18:38:35 +00:00
|
|
|
for_each_ref(add_existing, &existing_refs);
|
2009-10-25 21:28:12 +00:00
|
|
|
|
2010-08-11 22:57:20 +00:00
|
|
|
if (tags == TAGS_DEFAULT) {
|
|
|
|
if (transport->remote->fetch_tags == 2)
|
|
|
|
tags = TAGS_SET;
|
|
|
|
if (transport->remote->fetch_tags == -1)
|
|
|
|
tags = TAGS_UNSET;
|
|
|
|
}
|
2007-09-11 03:03:25 +00:00
|
|
|
|
2007-09-19 04:49:31 +00:00
|
|
|
if (!transport->get_refs_list || !transport->fetch)
|
2011-02-22 23:41:51 +00:00
|
|
|
die(_("Don't know how to fetch from %s"), transport->url);
|
2007-09-11 03:03:25 +00:00
|
|
|
|
|
|
|
/* if not appending, truncate FETCH_HEAD */
|
2009-11-10 08:19:43 +00:00
|
|
|
if (!append && !dry_run) {
|
2013-05-25 09:08:16 +00:00
|
|
|
retcode = truncate_fetch_head();
|
|
|
|
if (retcode)
|
|
|
|
goto cleanup;
|
2007-11-22 22:22:23 +00:00
|
|
|
}
|
2007-09-11 03:03:25 +00:00
|
|
|
|
|
|
|
ref_map = get_ref_map(transport, refs, ref_count, tags, &autotags);
|
2008-10-13 09:36:52 +00:00
|
|
|
if (!update_head_ok)
|
|
|
|
check_not_current_branch(ref_map);
|
2007-09-11 03:03:25 +00:00
|
|
|
|
|
|
|
for (rm = ref_map; rm; rm = rm->next) {
|
2009-10-25 21:28:12 +00:00
|
|
|
if (rm->peer_ref) {
|
2013-05-25 09:08:15 +00:00
|
|
|
struct string_list_item *peer_item =
|
|
|
|
string_list_lookup(&existing_refs,
|
|
|
|
rm->peer_ref->name);
|
2015-05-25 18:38:35 +00:00
|
|
|
if (peer_item) {
|
|
|
|
struct object_id *old_oid = peer_item->util;
|
2015-11-10 02:22:20 +00:00
|
|
|
oidcpy(&rm->peer_ref->old_oid, old_oid);
|
2015-05-25 18:38:35 +00:00
|
|
|
}
|
2009-10-25 21:28:12 +00:00
|
|
|
}
|
2007-09-11 03:03:25 +00:00
|
|
|
}
|
|
|
|
|
2008-03-04 03:27:40 +00:00
|
|
|
if (tags == TAGS_DEFAULT && autotags)
|
|
|
|
transport_set_option(transport, TRANS_OPT_FOLLOWTAGS, "1");
|
2011-10-15 05:04:25 +00:00
|
|
|
if (prune) {
|
fetch --prune: prune only based on explicit refspecs
The old behavior of "fetch --prune" was to prune whatever was being
fetched. In particular, "fetch --prune --tags" caused tags not only
to be fetched, but also to be pruned. This is inappropriate because
there is only one tags namespace that is shared among the local
repository and all remotes. Therefore, if the user defines a local
tag and then runs "git fetch --prune --tags", then the local tag is
deleted. Moreover, "--prune" and "--tags" can also be configured via
fetch.prune / remote.<name>.prune and remote.<name>.tagopt, making it
even less obvious that an invocation of "git fetch" could result in
tag lossage.
Since the command "git remote update" invokes "git fetch", it had the
same problem.
The command "git remote prune", on the other hand, disregarded the
setting of remote.<name>.tagopt, and so its behavior was inconsistent
with that of the other commands.
So the old behavior made it too easy to lose tags. To fix this
problem, change "fetch --prune" to prune references based only on
refspecs specified explicitly by the user, either on the command line
or via remote.<name>.fetch. Thus, tags are no longer made subject to
pruning by the --tags option or the remote.<name>.tagopt setting.
However, tags *are* still subject to pruning if they are fetched as
part of a refspec, and that is good. For example:
* On the command line,
git fetch --prune 'refs/tags/*:refs/tags/*'
causes tags, and only tags, to be fetched and pruned, and is
therefore a simple way for the user to get the equivalent of the old
behavior of "--prune --tag".
* For a remote that was configured with the "--mirror" option, the
configuration is set to include
[remote "name"]
fetch = +refs/*:refs/*
, which causes tags to be subject to pruning along with all other
references. This is the behavior that will typically be desired for
a mirror.
Signed-off-by: Michael Haggerty <mhagger@alum.mit.edu>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2013-10-30 05:33:00 +00:00
|
|
|
/*
|
|
|
|
* We only prune based on refspecs specified
|
|
|
|
* explicitly (via command line or configuration); we
|
|
|
|
* don't care whether --tags was specified.
|
|
|
|
*/
|
2013-10-30 05:32:59 +00:00
|
|
|
if (ref_count) {
|
2014-01-03 02:28:51 +00:00
|
|
|
prune_refs(refs, ref_count, ref_map, transport->url);
|
2011-10-15 05:04:26 +00:00
|
|
|
} else {
|
fetch --prune: prune only based on explicit refspecs
The old behavior of "fetch --prune" was to prune whatever was being
fetched. In particular, "fetch --prune --tags" caused tags not only
to be fetched, but also to be pruned. This is inappropriate because
there is only one tags namespace that is shared among the local
repository and all remotes. Therefore, if the user defines a local
tag and then runs "git fetch --prune --tags", then the local tag is
deleted. Moreover, "--prune" and "--tags" can also be configured via
fetch.prune / remote.<name>.prune and remote.<name>.tagopt, making it
even less obvious that an invocation of "git fetch" could result in
tag lossage.
Since the command "git remote update" invokes "git fetch", it had the
same problem.
The command "git remote prune", on the other hand, disregarded the
setting of remote.<name>.tagopt, and so its behavior was inconsistent
with that of the other commands.
So the old behavior made it too easy to lose tags. To fix this
problem, change "fetch --prune" to prune references based only on
refspecs specified explicitly by the user, either on the command line
or via remote.<name>.fetch. Thus, tags are no longer made subject to
pruning by the --tags option or the remote.<name>.tagopt setting.
However, tags *are* still subject to pruning if they are fetched as
part of a refspec, and that is good. For example:
* On the command line,
git fetch --prune 'refs/tags/*:refs/tags/*'
causes tags, and only tags, to be fetched and pruned, and is
therefore a simple way for the user to get the equivalent of the old
behavior of "--prune --tag".
* For a remote that was configured with the "--mirror" option, the
configuration is set to include
[remote "name"]
fetch = +refs/*:refs/*
, which causes tags to be subject to pruning along with all other
references. This is the behavior that will typically be desired for
a mirror.
Signed-off-by: Michael Haggerty <mhagger@alum.mit.edu>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2013-10-30 05:33:00 +00:00
|
|
|
prune_refs(transport->remote->fetch,
|
|
|
|
transport->remote->fetch_refspec_nr,
|
2014-01-03 02:28:51 +00:00
|
|
|
ref_map,
|
|
|
|
transport->url);
|
2011-10-15 05:04:26 +00:00
|
|
|
}
|
2011-10-15 05:04:25 +00:00
|
|
|
}
|
2014-01-03 02:28:52 +00:00
|
|
|
if (fetch_refs(transport, ref_map)) {
|
|
|
|
free_refs(ref_map);
|
|
|
|
retcode = 1;
|
|
|
|
goto cleanup;
|
|
|
|
}
|
2008-03-03 02:34:43 +00:00
|
|
|
free_refs(ref_map);
|
2007-09-11 03:03:25 +00:00
|
|
|
|
|
|
|
/* if neither --no-tags nor --tags was specified, do automated tag
|
|
|
|
* following ... */
|
2007-12-04 07:25:47 +00:00
|
|
|
if (tags == TAGS_DEFAULT && autotags) {
|
2008-03-03 02:35:00 +00:00
|
|
|
struct ref **tail = &ref_map;
|
|
|
|
ref_map = NULL;
|
|
|
|
find_non_local_tags(transport, &ref_map, &tail);
|
2013-08-07 22:14:45 +00:00
|
|
|
if (ref_map)
|
|
|
|
backfill_tags(transport, ref_map);
|
2007-09-11 03:03:25 +00:00
|
|
|
free_refs(ref_map);
|
|
|
|
}
|
|
|
|
|
2013-05-25 09:08:16 +00:00
|
|
|
cleanup:
|
2013-05-25 09:08:17 +00:00
|
|
|
string_list_clear(&existing_refs, 1);
|
2013-05-25 09:08:16 +00:00
|
|
|
return retcode;
|
2007-09-11 03:03:25 +00:00
|
|
|
}
|
|
|
|
|
2009-11-09 20:09:56 +00:00
|
|
|
static int get_one_remote_for_fetch(struct remote *remote, void *priv)
|
|
|
|
{
|
|
|
|
struct string_list *list = priv;
|
2009-11-09 20:11:06 +00:00
|
|
|
if (!remote->skip_default_update)
|
2010-06-25 23:41:38 +00:00
|
|
|
string_list_append(list, remote->name);
|
2009-11-09 20:09:56 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
struct remote_group_data {
|
|
|
|
const char *name;
|
|
|
|
struct string_list *list;
|
|
|
|
};
|
|
|
|
|
|
|
|
static int get_remote_group(const char *key, const char *value, void *priv)
|
|
|
|
{
|
|
|
|
struct remote_group_data *g = priv;
|
|
|
|
|
2015-07-28 21:08:21 +00:00
|
|
|
if (skip_prefix(key, "remotes.", &key) && !strcmp(key, g->name)) {
|
2009-11-09 20:09:56 +00:00
|
|
|
/* split list by white space */
|
|
|
|
while (*value) {
|
2015-07-28 21:08:20 +00:00
|
|
|
size_t wordlen = strcspn(value, " \t\n");
|
|
|
|
|
2015-07-28 21:08:19 +00:00
|
|
|
if (wordlen >= 1)
|
2016-06-14 18:28:56 +00:00
|
|
|
string_list_append_nodup(g->list,
|
2015-07-28 21:08:19 +00:00
|
|
|
xstrndup(value, wordlen));
|
|
|
|
value += wordlen + (value[wordlen] != '\0');
|
2009-11-09 20:09:56 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int add_remote_or_group(const char *name, struct string_list *list)
|
|
|
|
{
|
|
|
|
int prev_nr = list->nr;
|
2010-05-14 09:31:33 +00:00
|
|
|
struct remote_group_data g;
|
|
|
|
g.name = name; g.list = list;
|
2009-11-09 20:09:56 +00:00
|
|
|
|
|
|
|
git_config(get_remote_group, &g);
|
|
|
|
if (list->nr == prev_nr) {
|
2016-02-16 09:47:50 +00:00
|
|
|
struct remote *remote = remote_get(name);
|
2017-01-19 21:20:02 +00:00
|
|
|
if (!remote_is_configured(remote, 0))
|
2009-11-09 20:09:56 +00:00
|
|
|
return 0;
|
2010-06-25 23:41:38 +00:00
|
|
|
string_list_append(list, remote->name);
|
2009-11-09 20:09:56 +00:00
|
|
|
}
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2012-09-01 11:27:35 +00:00
|
|
|
static void add_options_to_argv(struct argv_array *argv)
|
2009-11-09 20:09:56 +00:00
|
|
|
{
|
2009-11-10 08:19:43 +00:00
|
|
|
if (dry_run)
|
2012-09-01 11:27:35 +00:00
|
|
|
argv_array_push(argv, "--dry-run");
|
2013-10-30 05:33:04 +00:00
|
|
|
if (prune != -1)
|
|
|
|
argv_array_push(argv, prune ? "--prune" : "--no-prune");
|
2010-02-24 18:22:06 +00:00
|
|
|
if (update_head_ok)
|
2012-09-01 11:27:35 +00:00
|
|
|
argv_array_push(argv, "--update-head-ok");
|
2010-02-24 18:22:06 +00:00
|
|
|
if (force)
|
2012-09-01 11:27:35 +00:00
|
|
|
argv_array_push(argv, "--force");
|
2010-02-24 18:22:06 +00:00
|
|
|
if (keep)
|
2012-09-01 11:27:35 +00:00
|
|
|
argv_array_push(argv, "--keep");
|
2010-11-10 23:55:02 +00:00
|
|
|
if (recurse_submodules == RECURSE_SUBMODULES_ON)
|
2012-09-01 11:27:35 +00:00
|
|
|
argv_array_push(argv, "--recurse-submodules");
|
2011-03-06 22:11:21 +00:00
|
|
|
else if (recurse_submodules == RECURSE_SUBMODULES_ON_DEMAND)
|
2012-09-01 11:27:35 +00:00
|
|
|
argv_array_push(argv, "--recurse-submodules=on-demand");
|
2012-09-05 21:22:19 +00:00
|
|
|
if (tags == TAGS_SET)
|
|
|
|
argv_array_push(argv, "--tags");
|
|
|
|
else if (tags == TAGS_UNSET)
|
|
|
|
argv_array_push(argv, "--no-tags");
|
2009-11-09 20:09:56 +00:00
|
|
|
if (verbosity >= 2)
|
2012-09-01 11:27:35 +00:00
|
|
|
argv_array_push(argv, "-v");
|
2009-11-09 20:09:56 +00:00
|
|
|
if (verbosity >= 1)
|
2012-09-01 11:27:35 +00:00
|
|
|
argv_array_push(argv, "-v");
|
2009-11-09 20:09:56 +00:00
|
|
|
else if (verbosity < 0)
|
2012-09-01 11:27:35 +00:00
|
|
|
argv_array_push(argv, "-q");
|
2010-11-12 12:54:52 +00:00
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
static int fetch_multiple(struct string_list *list)
|
|
|
|
{
|
|
|
|
int i, result = 0;
|
2012-09-01 11:27:35 +00:00
|
|
|
struct argv_array argv = ARGV_ARRAY_INIT;
|
2009-11-09 20:09:56 +00:00
|
|
|
|
2010-02-24 19:02:05 +00:00
|
|
|
if (!append && !dry_run) {
|
|
|
|
int errcode = truncate_fetch_head();
|
|
|
|
if (errcode)
|
|
|
|
return errcode;
|
|
|
|
}
|
|
|
|
|
2012-09-01 11:27:35 +00:00
|
|
|
argv_array_pushl(&argv, "fetch", "--append", NULL);
|
|
|
|
add_options_to_argv(&argv);
|
|
|
|
|
2009-11-09 20:09:56 +00:00
|
|
|
for (i = 0; i < list->nr; i++) {
|
|
|
|
const char *name = list->items[i].string;
|
2012-09-01 11:27:35 +00:00
|
|
|
argv_array_push(&argv, name);
|
2009-11-09 20:09:56 +00:00
|
|
|
if (verbosity >= 0)
|
2011-02-22 23:41:51 +00:00
|
|
|
printf(_("Fetching %s\n"), name);
|
2012-09-01 11:27:35 +00:00
|
|
|
if (run_command_v_opt(argv.argv, RUN_GIT_CMD)) {
|
2011-02-22 23:41:51 +00:00
|
|
|
error(_("Could not fetch %s"), name);
|
2009-11-09 20:09:56 +00:00
|
|
|
result = 1;
|
|
|
|
}
|
2012-09-01 11:27:35 +00:00
|
|
|
argv_array_pop(&argv);
|
2009-11-09 20:09:56 +00:00
|
|
|
}
|
|
|
|
|
2012-09-01 11:27:35 +00:00
|
|
|
argv_array_clear(&argv);
|
2009-11-09 20:09:56 +00:00
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int fetch_one(struct remote *remote, int argc, const char **argv)
|
2007-09-11 03:03:25 +00:00
|
|
|
{
|
|
|
|
static const char **refs = NULL;
|
2011-06-08 20:06:33 +00:00
|
|
|
struct refspec *refspec;
|
2007-09-11 03:03:25 +00:00
|
|
|
int ref_nr = 0;
|
2008-04-28 20:23:35 +00:00
|
|
|
int exit_code;
|
2007-09-11 03:03:25 +00:00
|
|
|
|
Give error when no remote is configured
When there's no explicitly-named remote, we use the remote specified
for the current branch, which in turn defaults to "origin". But it
this case should require the remote to actually be configured, and not
fall back to the path "origin".
Possibly, the config file's "remote = something" should require the
something to be a configured remote instead of a bare repository URL,
but we actually test with a bare repository URL.
In fetch, we were giving the sensible error message when coming up
with a URL failed, but this wasn't actually reachable, so move that
error up and use it when appropriate.
In push, we need a new error message, because the old one (formerly
unreachable without a lot of help) used the repo name, which was NULL.
Signed-off-by: Daniel Barkalow <barkalow@iabervon.org>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2009-03-11 05:47:20 +00:00
|
|
|
if (!remote)
|
2011-02-22 23:41:51 +00:00
|
|
|
die(_("No remote repository specified. Please, specify either a URL or a\n"
|
|
|
|
"remote name from which new revisions should be fetched."));
|
Give error when no remote is configured
When there's no explicitly-named remote, we use the remote specified
for the current branch, which in turn defaults to "origin". But it
this case should require the remote to actually be configured, and not
fall back to the path "origin".
Possibly, the config file's "remote = something" should require the
something to be a configured remote instead of a bare repository URL,
but we actually test with a bare repository URL.
In fetch, we were giving the sensible error message when coming up
with a URL failed, but this wasn't actually reachable, so move that
error up and use it when appropriate.
In push, we need a new error message, because the old one (formerly
unreachable without a lot of help) used the repo name, which was NULL.
Signed-off-by: Daniel Barkalow <barkalow@iabervon.org>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2009-03-11 05:47:20 +00:00
|
|
|
|
2016-06-12 10:53:59 +00:00
|
|
|
gtransport = prepare_transport(remote, 1);
|
2013-07-13 09:36:24 +00:00
|
|
|
|
|
|
|
if (prune < 0) {
|
|
|
|
/* no command line request */
|
2013-09-09 21:50:37 +00:00
|
|
|
if (0 <= gtransport->remote->prune)
|
|
|
|
prune = gtransport->remote->prune;
|
2013-07-13 09:36:24 +00:00
|
|
|
else if (0 <= fetch_prune_config)
|
|
|
|
prune = fetch_prune_config;
|
|
|
|
else
|
|
|
|
prune = PRUNE_BY_DEFAULT;
|
|
|
|
}
|
|
|
|
|
2009-11-09 20:09:56 +00:00
|
|
|
if (argc > 0) {
|
2007-09-11 03:03:25 +00:00
|
|
|
int j = 0;
|
2014-01-29 16:54:16 +00:00
|
|
|
int i;
|
2016-02-22 22:44:35 +00:00
|
|
|
refs = xcalloc(st_add(argc, 1), sizeof(const char *));
|
2009-11-09 20:09:56 +00:00
|
|
|
for (i = 0; i < argc; i++) {
|
2007-09-11 03:03:25 +00:00
|
|
|
if (!strcmp(argv[i], "tag")) {
|
|
|
|
i++;
|
2008-04-05 18:28:53 +00:00
|
|
|
if (i >= argc)
|
2011-02-22 23:41:51 +00:00
|
|
|
die(_("You need to specify a tag name."));
|
2014-06-19 21:26:56 +00:00
|
|
|
refs[j++] = xstrfmt("refs/tags/%s:refs/tags/%s",
|
|
|
|
argv[i], argv[i]);
|
2007-09-11 03:03:25 +00:00
|
|
|
} else
|
|
|
|
refs[j++] = argv[i];
|
|
|
|
}
|
|
|
|
refs[j] = NULL;
|
|
|
|
ref_nr = j;
|
|
|
|
}
|
|
|
|
|
2009-01-22 06:03:08 +00:00
|
|
|
sigchain_push_common(unlock_pack_on_signal);
|
2007-09-14 07:31:25 +00:00
|
|
|
atexit(unlock_pack);
|
2011-06-08 20:06:33 +00:00
|
|
|
refspec = parse_fetch_refspec(ref_nr, refs);
|
2013-08-07 22:38:45 +00:00
|
|
|
exit_code = do_fetch(gtransport, refspec, ref_nr);
|
2011-10-07 22:51:06 +00:00
|
|
|
free_refspec(ref_nr, refspec);
|
2013-08-07 22:38:45 +00:00
|
|
|
transport_disconnect(gtransport);
|
|
|
|
gtransport = NULL;
|
2008-04-28 20:23:35 +00:00
|
|
|
return exit_code;
|
2007-09-11 03:03:25 +00:00
|
|
|
}
|
2009-11-09 20:09:56 +00:00
|
|
|
|
|
|
|
int cmd_fetch(int argc, const char **argv, const char *prefix)
|
|
|
|
{
|
|
|
|
int i;
|
2016-06-14 18:28:56 +00:00
|
|
|
struct string_list list = STRING_LIST_INIT_DUP;
|
2009-11-09 20:09:56 +00:00
|
|
|
struct remote *remote;
|
|
|
|
int result = 0;
|
2014-08-16 01:19:27 +00:00
|
|
|
struct argv_array argv_gc_auto = ARGV_ARRAY_INIT;
|
2009-11-09 20:09:56 +00:00
|
|
|
|
2011-02-24 14:30:19 +00:00
|
|
|
packet_trace_identity("fetch");
|
|
|
|
|
2009-11-09 20:09:56 +00:00
|
|
|
/* Record the command line for the reflog */
|
|
|
|
strbuf_addstr(&default_rla, "fetch");
|
|
|
|
for (i = 1; i < argc; i++)
|
|
|
|
strbuf_addf(&default_rla, " %s", argv[i]);
|
|
|
|
|
2013-07-13 09:36:24 +00:00
|
|
|
git_config(git_fetch_config, NULL);
|
|
|
|
|
2009-11-09 20:09:56 +00:00
|
|
|
argc = parse_options(argc, argv, prefix,
|
|
|
|
builtin_fetch_options, builtin_fetch_usage, 0);
|
|
|
|
|
fetch, upload-pack: --deepen=N extends shallow boundary by N commits
In git-fetch, --depth argument is always relative with the latest
remote refs. This makes it a bit difficult to cover this use case,
where the user wants to make the shallow history, say 3 levels
deeper. It would work if remote refs have not moved yet, but nobody
can guarantee that, especially when that use case is performed a
couple months after the last clone or "git fetch --depth". Also,
modifying shallow boundary using --depth does not work well with
clones created by --since or --not.
This patch fixes that. A new argument --deepen=<N> will add <N> more (*)
parent commits to the current history regardless of where remote refs
are.
Have/Want negotiation is still respected. So if remote refs move, the
server will send two chunks: one between "have" and "want" and another
to extend shallow history. In theory, the client could send no "want"s
in order to get the second chunk only. But the protocol does not allow
that. Either you send no want lines, which means ls-remote; or you
have to send at least one want line that carries deep-relative to the
server..
The main work was done by Dongcan Jiang. I fixed it up here and there.
And of course all the bugs belong to me.
(*) We could even support --deepen=<N> where <N> is negative. In that
case we can cut some history from the shallow clone. This operation
(and --depth=<shorter depth>) does not require interaction with remote
side (and more complicated to implement as a result).
Helped-by: Duy Nguyen <pclouds@gmail.com>
Helped-by: Eric Sunshine <sunshine@sunshineco.com>
Helped-by: Junio C Hamano <gitster@pobox.com>
Signed-off-by: Dongcan Jiang <dongcan.jiang@gmail.com>
Signed-off-by: Nguyễn Thái Ngọc Duy <pclouds@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2016-06-12 10:54:09 +00:00
|
|
|
if (deepen_relative) {
|
|
|
|
if (deepen_relative < 0)
|
|
|
|
die(_("Negative depth in --deepen is not supported"));
|
|
|
|
if (depth)
|
|
|
|
die(_("--deepen and --depth are mutually exclusive"));
|
|
|
|
depth = xstrfmt("%d", deepen_relative);
|
|
|
|
}
|
2013-01-11 09:05:46 +00:00
|
|
|
if (unshallow) {
|
|
|
|
if (depth)
|
|
|
|
die(_("--depth and --unshallow cannot be used together"));
|
|
|
|
else if (!is_repository_shallow())
|
|
|
|
die(_("--unshallow on a complete repository does not make sense"));
|
2015-09-24 21:07:07 +00:00
|
|
|
else
|
|
|
|
depth = xstrfmt("%d", INFINITE_DEPTH);
|
2013-01-11 09:05:46 +00:00
|
|
|
}
|
|
|
|
|
2013-12-05 03:31:11 +00:00
|
|
|
/* no need to be strict, transport_set_option() will validate it again */
|
|
|
|
if (depth && atoi(depth) < 1)
|
|
|
|
die(_("depth %s is not a positive number"), depth);
|
2016-06-12 10:54:04 +00:00
|
|
|
if (depth || deepen_since || deepen_not.nr)
|
2016-06-12 10:53:59 +00:00
|
|
|
deepen = 1;
|
2013-12-05 03:31:11 +00:00
|
|
|
|
2011-09-09 18:22:03 +00:00
|
|
|
if (recurse_submodules != RECURSE_SUBMODULES_OFF) {
|
|
|
|
if (recurse_submodules_default) {
|
|
|
|
int arg = parse_fetch_recurse_submodules_arg("--recurse-submodules-default", recurse_submodules_default);
|
|
|
|
set_config_fetch_recurse_submodules(arg);
|
|
|
|
}
|
|
|
|
gitmodules_config();
|
|
|
|
git_config(submodule_config, NULL);
|
|
|
|
}
|
|
|
|
|
2009-11-09 20:09:56 +00:00
|
|
|
if (all) {
|
|
|
|
if (argc == 1)
|
2011-02-22 23:41:51 +00:00
|
|
|
die(_("fetch --all does not take a repository argument"));
|
2009-11-09 20:09:56 +00:00
|
|
|
else if (argc > 1)
|
2011-02-22 23:41:51 +00:00
|
|
|
die(_("fetch --all does not make sense with refspecs"));
|
2009-11-09 20:09:56 +00:00
|
|
|
(void) for_each_remote(get_one_remote_for_fetch, &list);
|
|
|
|
result = fetch_multiple(&list);
|
|
|
|
} else if (argc == 0) {
|
|
|
|
/* No arguments -- use default remote */
|
|
|
|
remote = remote_get(NULL);
|
|
|
|
result = fetch_one(remote, argc, argv);
|
2009-11-09 20:10:32 +00:00
|
|
|
} else if (multiple) {
|
|
|
|
/* All arguments are assumed to be remotes or groups */
|
|
|
|
for (i = 0; i < argc; i++)
|
|
|
|
if (!add_remote_or_group(argv[i], &list))
|
2011-02-22 23:41:51 +00:00
|
|
|
die(_("No such remote or remote group: %s"), argv[i]);
|
2009-11-09 20:10:32 +00:00
|
|
|
result = fetch_multiple(&list);
|
2009-11-09 20:09:56 +00:00
|
|
|
} else {
|
|
|
|
/* Single remote or group */
|
|
|
|
(void) add_remote_or_group(argv[0], &list);
|
|
|
|
if (list.nr > 1) {
|
|
|
|
/* More than one remote */
|
|
|
|
if (argc > 1)
|
2011-02-22 23:41:51 +00:00
|
|
|
die(_("Fetching a group and specifying refspecs does not make sense"));
|
2009-11-09 20:09:56 +00:00
|
|
|
result = fetch_multiple(&list);
|
|
|
|
} else {
|
|
|
|
/* Zero or one remotes */
|
|
|
|
remote = remote_get(argv[0]);
|
|
|
|
result = fetch_one(remote, argc-1, argv+1);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-11-10 23:55:02 +00:00
|
|
|
if (!result && (recurse_submodules != RECURSE_SUBMODULES_OFF)) {
|
2012-09-01 11:27:35 +00:00
|
|
|
struct argv_array options = ARGV_ARRAY_INIT;
|
|
|
|
|
|
|
|
add_options_to_argv(&options);
|
2012-09-01 15:27:06 +00:00
|
|
|
result = fetch_populated_submodules(&options,
|
2010-11-12 12:54:52 +00:00
|
|
|
submodule_prefix,
|
2011-03-06 22:11:21 +00:00
|
|
|
recurse_submodules,
|
2015-12-16 00:04:12 +00:00
|
|
|
verbosity < 0,
|
|
|
|
max_children);
|
2012-09-01 11:27:35 +00:00
|
|
|
argv_array_clear(&options);
|
2010-11-12 12:54:52 +00:00
|
|
|
}
|
|
|
|
|
2009-11-09 20:09:56 +00:00
|
|
|
string_list_clear(&list, 0);
|
|
|
|
|
2016-01-13 17:20:11 +00:00
|
|
|
close_all_packs();
|
|
|
|
|
2014-08-16 01:19:27 +00:00
|
|
|
argv_array_pushl(&argv_gc_auto, "gc", "--auto", NULL);
|
2014-08-16 01:19:28 +00:00
|
|
|
if (verbosity < 0)
|
|
|
|
argv_array_push(&argv_gc_auto, "--quiet");
|
2014-08-16 01:19:27 +00:00
|
|
|
run_command_v_opt(argv_gc_auto.argv, RUN_GIT_CMD);
|
|
|
|
argv_array_clear(&argv_gc_auto);
|
2013-01-26 22:40:38 +00:00
|
|
|
|
2009-11-09 20:09:56 +00:00
|
|
|
return result;
|
|
|
|
}
|