2007-09-11 03:03:25 +00:00
|
|
|
/*
|
|
|
|
* "git fetch"
|
|
|
|
*/
|
|
|
|
#include "cache.h"
|
2017-06-14 18:07:36 +00:00
|
|
|
#include "config.h"
|
2017-12-12 19:53:52 +00:00
|
|
|
#include "repository.h"
|
2007-09-11 03:03:25 +00:00
|
|
|
#include "refs.h"
|
2018-05-16 22:57:48 +00:00
|
|
|
#include "refspec.h"
|
2018-05-15 23:42:15 +00:00
|
|
|
#include "object-store.h"
|
2007-09-11 03:03:25 +00:00
|
|
|
#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"
|
2017-08-18 22:20:21 +00:00
|
|
|
#include "packfile.h"
|
2017-12-08 15:58:44 +00:00
|
|
|
#include "list-objects-filter-options.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: add a --prune-tags option and fetch.pruneTags config
Add a --prune-tags option to git-fetch, along with fetch.pruneTags
config option and a -P shorthand (-p is --prune). This allows for
doing any of:
git fetch -p -P
git fetch --prune --prune-tags
git fetch -p -P origin
git fetch --prune --prune-tags origin
Or simply:
git config fetch.prune true &&
git config fetch.pruneTags true &&
git fetch
Instead of the much more verbose:
git fetch --prune origin 'refs/tags/*:refs/tags/*' '+refs/heads/*:refs/remotes/origin/*'
Before this feature it was painful to support the use-case of pulling
from a repo which is having both its branches *and* tags deleted
regularly, and have our local references to reflect upstream.
At work we create deployment tags in the repo for each rollout, and
there's *lots* of those, so they're archived within weeks for
performance reasons.
Without this change it's hard to centrally configure such repos in
/etc/gitconfig (on servers that are only used for working with
them). You need to set fetch.prune=true globally, and then for each
repo:
git -C {} config --replace-all remote.origin.fetch "refs/tags/*:refs/tags/*" "^\+*refs/tags/\*:refs/tags/\*$"
Now I can simply set fetch.pruneTags=true in /etc/gitconfig as well,
and users running "git pull" will automatically get the pruning
semantics I want.
Even though "git remote" has corresponding "prune" and "update
--prune" subcommands I'm intentionally not adding a corresponding
prune-tags or "update --prune --prune-tags" mode to that command.
It's advertised (as noted in my recent "git remote doc: correct
dangerous lies about what prune does") as only modifying remote
tracking references, whereas any --prune-tags option is always going
to modify what from the user's perspective is a local copy of the tag,
since there's no such thing as a remote tracking tag.
Ideally add_prune_tags_to_fetch_refspec() would be something that
would use ALLOC_GROW() to grow the 'fetch` member of the 'remote'
struct. Instead I'm realloc-ing remote->fetch and adding the
tag_refspec to the end.
The reason is that parse_{fetch,push}_refspec which allocate the
refspec (ultimately remote->fetch) struct are called many places that
don't have access to a 'remote' struct. It would be hard to change all
their callsites to be amenable to carry around the bookkeeping
variables required for dynamic allocation.
All the other callers of the API first incrementally construct the
string version of the refspec in remote->fetch_refspec via
add_fetch_refspec(), before finally calling parse_fetch_refspec() via
some variation of remote_get().
It's less of a pain to deal with the one special case that needs to
modify already constructed refspecs than to chase down and change all
the other callsites. The API I'm adding is intentionally not
generalized because if we add more of these we'd probably want to
re-visit how this is done.
See my "Re: [BUG] git remote prune removes local tags, depending on
fetch config" (87po6ahx87.fsf@evledraar.gmail.com;
https://public-inbox.org/git/87po6ahx87.fsf@evledraar.gmail.com/) for
more background info.
Signed-off-by: Ævar Arnfjörð Bjarmason <avarab@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2018-02-09 20:32:15 +00:00
|
|
|
static int fetch_prune_tags_config = -1; /* unspecified */
|
|
|
|
static int prune_tags = -1; /* unspecified */
|
|
|
|
#define PRUNE_TAGS_BY_DEFAULT 0 /* do we prune tags 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;
|
2017-06-23 19:13:01 +00:00
|
|
|
static int progress = -1;
|
2016-06-12 10:53:59 +00:00
|
|
|
static int tags = TAGS_DEFAULT, unshallow, update_shallow, deepen;
|
2017-08-02 19:49:18 +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 = "";
|
2017-06-23 19:13:01 +00:00
|
|
|
static int recurse_submodules = RECURSE_SUBMODULES_DEFAULT;
|
2017-06-27 21:31:59 +00:00
|
|
|
static int recurse_submodules_default = RECURSE_SUBMODULES_ON_DEMAND;
|
2014-01-03 02:28:51 +00:00
|
|
|
static int shown_url = 0;
|
2018-05-16 22:58:05 +00:00
|
|
|
static struct refspec refmap = REFSPEC_INIT_FETCH;
|
2017-12-08 15:58:44 +00:00
|
|
|
static struct list_objects_filter_options filter_options;
|
2018-04-23 22:46:24 +00:00
|
|
|
static struct string_list server_options = STRING_LIST_INIT_DUP;
|
2018-07-02 22:39:44 +00:00
|
|
|
static struct string_list negotiation_tip = STRING_LIST_INIT_NODUP;
|
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;
|
|
|
|
}
|
2017-06-01 00:30:50 +00:00
|
|
|
|
fetch: add a --prune-tags option and fetch.pruneTags config
Add a --prune-tags option to git-fetch, along with fetch.pruneTags
config option and a -P shorthand (-p is --prune). This allows for
doing any of:
git fetch -p -P
git fetch --prune --prune-tags
git fetch -p -P origin
git fetch --prune --prune-tags origin
Or simply:
git config fetch.prune true &&
git config fetch.pruneTags true &&
git fetch
Instead of the much more verbose:
git fetch --prune origin 'refs/tags/*:refs/tags/*' '+refs/heads/*:refs/remotes/origin/*'
Before this feature it was painful to support the use-case of pulling
from a repo which is having both its branches *and* tags deleted
regularly, and have our local references to reflect upstream.
At work we create deployment tags in the repo for each rollout, and
there's *lots* of those, so they're archived within weeks for
performance reasons.
Without this change it's hard to centrally configure such repos in
/etc/gitconfig (on servers that are only used for working with
them). You need to set fetch.prune=true globally, and then for each
repo:
git -C {} config --replace-all remote.origin.fetch "refs/tags/*:refs/tags/*" "^\+*refs/tags/\*:refs/tags/\*$"
Now I can simply set fetch.pruneTags=true in /etc/gitconfig as well,
and users running "git pull" will automatically get the pruning
semantics I want.
Even though "git remote" has corresponding "prune" and "update
--prune" subcommands I'm intentionally not adding a corresponding
prune-tags or "update --prune --prune-tags" mode to that command.
It's advertised (as noted in my recent "git remote doc: correct
dangerous lies about what prune does") as only modifying remote
tracking references, whereas any --prune-tags option is always going
to modify what from the user's perspective is a local copy of the tag,
since there's no such thing as a remote tracking tag.
Ideally add_prune_tags_to_fetch_refspec() would be something that
would use ALLOC_GROW() to grow the 'fetch` member of the 'remote'
struct. Instead I'm realloc-ing remote->fetch and adding the
tag_refspec to the end.
The reason is that parse_{fetch,push}_refspec which allocate the
refspec (ultimately remote->fetch) struct are called many places that
don't have access to a 'remote' struct. It would be hard to change all
their callsites to be amenable to carry around the bookkeeping
variables required for dynamic allocation.
All the other callers of the API first incrementally construct the
string version of the refspec in remote->fetch_refspec via
add_fetch_refspec(), before finally calling parse_fetch_refspec() via
some variation of remote_get().
It's less of a pain to deal with the one special case that needs to
modify already constructed refspecs than to chase down and change all
the other callsites. The API I'm adding is intentionally not
generalized because if we add more of these we'd probably want to
re-visit how this is done.
See my "Re: [BUG] git remote prune removes local tags, depending on
fetch config" (87po6ahx87.fsf@evledraar.gmail.com;
https://public-inbox.org/git/87po6ahx87.fsf@evledraar.gmail.com/) for
more background info.
Signed-off-by: Ævar Arnfjörð Bjarmason <avarab@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2018-02-09 20:32:15 +00:00
|
|
|
if (!strcmp(k, "fetch.prunetags")) {
|
|
|
|
fetch_prune_tags_config = git_config_bool(k, v);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2017-06-01 00:30:50 +00:00
|
|
|
if (!strcmp(k, "submodule.recurse")) {
|
|
|
|
int r = git_config_bool(k, v) ?
|
|
|
|
RECURSE_SUBMODULES_ON : RECURSE_SUBMODULES_OFF;
|
|
|
|
recurse_submodules = r;
|
|
|
|
}
|
|
|
|
|
2017-08-02 19:49:18 +00:00
|
|
|
if (!strcmp(k, "submodule.fetchjobs")) {
|
|
|
|
max_children = parse_submodule_fetchjobs(k, v);
|
|
|
|
return 0;
|
2017-08-02 19:49:19 +00:00
|
|
|
} else if (!strcmp(k, "fetch.recursesubmodules")) {
|
|
|
|
recurse_submodules = parse_fetch_recurse_submodules_arg(k, v);
|
|
|
|
return 0;
|
2017-08-02 19:49:18 +00:00
|
|
|
}
|
|
|
|
|
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)
|
|
|
|
{
|
|
|
|
/*
|
|
|
|
* "git fetch --refmap='' origin foo"
|
|
|
|
* can be used to tell the command not to store anywhere
|
|
|
|
*/
|
2018-05-16 22:58:05 +00:00
|
|
|
refspec_append(&refmap, arg);
|
|
|
|
|
2014-05-29 22:21:31 +00:00
|
|
|
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")),
|
2018-02-09 11:01:42 +00:00
|
|
|
OPT__FORCE(&force, N_("force overwrite of local branch"), 0),
|
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")),
|
fetch: add a --prune-tags option and fetch.pruneTags config
Add a --prune-tags option to git-fetch, along with fetch.pruneTags
config option and a -P shorthand (-p is --prune). This allows for
doing any of:
git fetch -p -P
git fetch --prune --prune-tags
git fetch -p -P origin
git fetch --prune --prune-tags origin
Or simply:
git config fetch.prune true &&
git config fetch.pruneTags true &&
git fetch
Instead of the much more verbose:
git fetch --prune origin 'refs/tags/*:refs/tags/*' '+refs/heads/*:refs/remotes/origin/*'
Before this feature it was painful to support the use-case of pulling
from a repo which is having both its branches *and* tags deleted
regularly, and have our local references to reflect upstream.
At work we create deployment tags in the repo for each rollout, and
there's *lots* of those, so they're archived within weeks for
performance reasons.
Without this change it's hard to centrally configure such repos in
/etc/gitconfig (on servers that are only used for working with
them). You need to set fetch.prune=true globally, and then for each
repo:
git -C {} config --replace-all remote.origin.fetch "refs/tags/*:refs/tags/*" "^\+*refs/tags/\*:refs/tags/\*$"
Now I can simply set fetch.pruneTags=true in /etc/gitconfig as well,
and users running "git pull" will automatically get the pruning
semantics I want.
Even though "git remote" has corresponding "prune" and "update
--prune" subcommands I'm intentionally not adding a corresponding
prune-tags or "update --prune --prune-tags" mode to that command.
It's advertised (as noted in my recent "git remote doc: correct
dangerous lies about what prune does") as only modifying remote
tracking references, whereas any --prune-tags option is always going
to modify what from the user's perspective is a local copy of the tag,
since there's no such thing as a remote tracking tag.
Ideally add_prune_tags_to_fetch_refspec() would be something that
would use ALLOC_GROW() to grow the 'fetch` member of the 'remote'
struct. Instead I'm realloc-ing remote->fetch and adding the
tag_refspec to the end.
The reason is that parse_{fetch,push}_refspec which allocate the
refspec (ultimately remote->fetch) struct are called many places that
don't have access to a 'remote' struct. It would be hard to change all
their callsites to be amenable to carry around the bookkeeping
variables required for dynamic allocation.
All the other callers of the API first incrementally construct the
string version of the refspec in remote->fetch_refspec via
add_fetch_refspec(), before finally calling parse_fetch_refspec() via
some variation of remote_get().
It's less of a pain to deal with the one special case that needs to
modify already constructed refspecs than to chase down and change all
the other callsites. The API I'm adding is intentionally not
generalized because if we add more of these we'd probably want to
re-visit how this is done.
See my "Re: [BUG] git remote prune removes local tags, depending on
fetch config" (87po6ahx87.fsf@evledraar.gmail.com;
https://public-inbox.org/git/87po6ahx87.fsf@evledraar.gmail.com/) for
more background info.
Signed-off-by: Ævar Arnfjörð Bjarmason <avarab@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2018-02-09 20:32:15 +00:00
|
|
|
OPT_BOOL('P', "prune-tags", &prune_tags,
|
|
|
|
N_("prune local tags no longer on remote and clobber changed tags")),
|
2017-06-23 19:13:00 +00:00
|
|
|
{ OPTION_CALLBACK, 0, "recurse-submodules", &recurse_submodules, N_("on-demand"),
|
2012-08-20 12:32:09 +00:00
|
|
|
N_("control recursive fetching of submodules"),
|
2017-06-23 19:13:00 +00:00
|
|
|
PARSE_OPT_OPTARG, option_fetch_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")),
|
2018-05-20 15:42:58 +00:00
|
|
|
OPT_SET_INT_F(0, "unshallow", &unshallow,
|
|
|
|
N_("convert to a complete repository"),
|
|
|
|
1, PARSE_OPT_NONEG),
|
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 },
|
2017-06-23 19:13:01 +00:00
|
|
|
{ OPTION_CALLBACK, 0, "recurse-submodules-default",
|
|
|
|
&recurse_submodules_default, N_("on-demand"),
|
|
|
|
N_("default for recursive fetching of submodules "
|
|
|
|
"(lower priority than config files)"),
|
|
|
|
PARSE_OPT_HIDDEN, option_fetch_parse_recurse_submodules },
|
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 },
|
2018-04-23 22:46:24 +00:00
|
|
|
OPT_STRING_LIST('o', "server-option", &server_options, N_("server-specific"), N_("option to transmit")),
|
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),
|
2018-07-02 22:39:44 +00:00
|
|
|
OPT_STRING_LIST(0, "negotiation-tip", &negotiation_tip, N_("revision"),
|
|
|
|
N_("report that we have only objects reachable from this object")),
|
2017-12-08 15:58:44 +00:00
|
|
|
OPT_PARSE_LIST_OBJECTS_FILTER(&filter_options),
|
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;
|
2018-05-16 22:57:49 +00:00
|
|
|
struct refspec_item refspec;
|
2007-09-18 08:54:53 +00:00
|
|
|
|
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2018-06-27 22:30:21 +00:00
|
|
|
static void find_non_local_tags(const struct ref *refs,
|
|
|
|
struct ref **head,
|
|
|
|
struct ref ***tail)
|
2013-10-30 05:32:55 +00:00
|
|
|
{
|
|
|
|
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);
|
2018-06-27 22:30:21 +00:00
|
|
|
for (ref = refs; 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 &&
|
2017-06-22 00:40:24 +00:00
|
|
|
!has_object_file_with_flags(&ref->old_oid,
|
|
|
|
OBJECT_INFO_QUICK) &&
|
2015-11-10 02:22:20 +00:00
|
|
|
!will_fetch(head, ref->old_oid.hash) &&
|
2017-06-22 00:40:24 +00:00
|
|
|
!has_sha1_file_with_flags(item->util,
|
|
|
|
OBJECT_INFO_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 &&
|
2017-06-22 00:40:24 +00:00
|
|
|
!has_sha1_file_with_flags(item->util, OBJECT_INFO_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 &&
|
2017-06-22 00:40:24 +00:00
|
|
|
!has_sha1_file_with_flags(item->util, OBJECT_INFO_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
|
|
|
|
2018-06-27 22:30:21 +00:00
|
|
|
static struct ref *get_ref_map(struct remote *remote,
|
|
|
|
const struct ref *remote_refs,
|
2018-05-16 22:58:08 +00:00
|
|
|
struct refspec *rs,
|
2013-10-23 15:50:38 +00:00
|
|
|
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
|
|
|
|
2018-06-27 22:30:19 +00:00
|
|
|
struct string_list existing_refs = STRING_LIST_INIT_DUP;
|
2013-05-11 16:16:52 +00:00
|
|
|
|
2018-05-16 22:58:08 +00:00
|
|
|
if (rs->nr) {
|
2014-05-29 22:21:31 +00:00
|
|
|
struct refspec *fetch_refspec;
|
|
|
|
|
2018-05-16 22:58:08 +00:00
|
|
|
for (i = 0; i < rs->nr; i++) {
|
|
|
|
get_fetch_map(remote_refs, &rs->items[i], &tail, 0);
|
|
|
|
if (rs->items[i].dst && rs->items[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
|
|
|
*/
|
2018-05-16 22:58:08 +00:00
|
|
|
if (refmap.nr)
|
|
|
|
fetch_refspec = &refmap;
|
|
|
|
else
|
2018-06-27 22:30:21 +00:00
|
|
|
fetch_refspec = &remote->fetch;
|
2014-05-29 22:21:31 +00:00
|
|
|
|
2018-05-16 22:58:08 +00:00
|
|
|
for (i = 0; i < fetch_refspec->nr; i++)
|
|
|
|
get_fetch_map(ref_map, &fetch_refspec->items[i], &oref_tail, 1);
|
2018-05-16 22:58:05 +00:00
|
|
|
} else if (refmap.nr) {
|
2014-05-29 22:21:31 +00:00
|
|
|
die("--refmap option is only meaningful with command-line refspec(s).");
|
2007-09-11 03:03:25 +00:00
|
|
|
} else {
|
|
|
|
/* Use the defaults */
|
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 &&
|
2018-05-16 22:58:01 +00:00
|
|
|
(remote->fetch.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)))) {
|
2018-05-16 22:58:01 +00:00
|
|
|
for (i = 0; i < remote->fetch.nr; i++) {
|
|
|
|
get_fetch_map(remote_refs, &remote->fetch.items[i], &tail, 0);
|
|
|
|
if (remote->fetch.items[i].dst &&
|
|
|
|
remote->fetch.items[i].dst[0])
|
2007-09-11 03:03:25 +00:00
|
|
|
*autotags = 1;
|
2007-09-18 08:54:53 +00:00
|
|
|
if (!i && !has_merge && ref_map &&
|
2018-05-16 22:58:01 +00:00
|
|
|
!remote->fetch.items[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)
|
2018-06-27 22:30:21 +00:00
|
|
|
find_non_local_tags(remote_refs, &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;
|
|
|
|
}
|
|
|
|
|
2018-06-27 22:30:19 +00:00
|
|
|
ref_map = ref_remove_duplicates(ref_map);
|
|
|
|
|
|
|
|
for_each_ref(add_existing, &existing_refs);
|
|
|
|
for (rm = ref_map; rm; rm = rm->next) {
|
|
|
|
if (rm->peer_ref) {
|
|
|
|
struct string_list_item *peer_item =
|
|
|
|
string_list_lookup(&existing_refs,
|
|
|
|
rm->peer_ref->name);
|
|
|
|
if (peer_item) {
|
|
|
|
struct object_id *old_oid = peer_item->util;
|
|
|
|
oidcpy(&rm->peer_ref->old_oid, old_oid);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
string_list_clear(&existing_refs, 1);
|
|
|
|
|
|
|
|
return 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)
|
|
|
|
{
|
2017-03-28 19:46:26 +00:00
|
|
|
char *msg;
|
2007-09-11 03:03:25 +00:00
|
|
|
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;
|
2017-03-28 19:46:26 +00:00
|
|
|
msg = xstrfmt("%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,
|
2017-10-15 22:06:53 +00:00
|
|
|
&ref->new_oid,
|
|
|
|
check_old ? &ref->old_oid : 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);
|
2017-03-28 19:46:26 +00:00
|
|
|
free(msg);
|
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);
|
2017-03-28 19:46:26 +00:00
|
|
|
free(msg);
|
2014-04-28 20:49:07 +00:00
|
|
|
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
|
|
|
|
2018-04-25 18:20:59 +00:00
|
|
|
type = oid_object_info(the_repository, &ref->new_oid, 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
|
|
|
}
|
|
|
|
|
2018-06-29 01:21:57 +00:00
|
|
|
current = lookup_commit_reference_gently(the_repository,
|
|
|
|
&ref->old_oid, 1);
|
|
|
|
updated = lookup_commit_reference_gently(the_repository,
|
|
|
|
&ref->new_oid, 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))
|
2017-03-26 16:01:35 +00:00
|
|
|
check_for_new_submodule_commits(&ref->new_oid);
|
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;
|
strbuf: convert strbuf_add_unique_abbrev to use struct object_id
Convert the declaration and definition of strbuf_add_unique_abbrev to
make it take a pointer to struct object_id. Predeclare the struct in
strbuf.h, as cache.h includes strbuf.h before it declares the struct,
and otherwise the struct declaration would have the wrong scope.
Apply the following semantic patch, along with the standard object_id
transforms, to adjust the callers:
@@
expression E1, E2, E3;
@@
- strbuf_add_unique_abbrev(E1, E2.hash, E3);
+ strbuf_add_unique_abbrev(E1, &E2, E3);
@@
expression E1, E2, E3;
@@
- strbuf_add_unique_abbrev(E1, E2->hash, E3);
+ strbuf_add_unique_abbrev(E1, E2, E3);
Signed-off-by: brian m. carlson <sandals@crustytoothpaste.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2018-03-12 02:27:28 +00:00
|
|
|
strbuf_add_unique_abbrev(&quickref, ¤t->object.oid, DEFAULT_ABBREV);
|
2015-09-24 21:07:40 +00:00
|
|
|
strbuf_addstr(&quickref, "..");
|
strbuf: convert strbuf_add_unique_abbrev to use struct object_id
Convert the declaration and definition of strbuf_add_unique_abbrev to
make it take a pointer to struct object_id. Predeclare the struct in
strbuf.h, as cache.h includes strbuf.h before it declares the struct,
and otherwise the struct declaration would have the wrong scope.
Apply the following semantic patch, along with the standard object_id
transforms, to adjust the callers:
@@
expression E1, E2, E3;
@@
- strbuf_add_unique_abbrev(E1, E2.hash, E3);
+ strbuf_add_unique_abbrev(E1, &E2, E3);
@@
expression E1, E2, E3;
@@
- strbuf_add_unique_abbrev(E1, E2->hash, E3);
+ strbuf_add_unique_abbrev(E1, E2, E3);
Signed-off-by: brian m. carlson <sandals@crustytoothpaste.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2018-03-12 02:27:28 +00:00
|
|
|
strbuf_add_unique_abbrev(&quickref, &ref->new_oid, DEFAULT_ABBREV);
|
2011-03-06 22:10:46 +00:00
|
|
|
if ((recurse_submodules != RECURSE_SUBMODULES_OFF) &&
|
|
|
|
(recurse_submodules != RECURSE_SUBMODULES_ON))
|
2017-03-26 16:01:35 +00:00
|
|
|
check_for_new_submodule_commits(&ref->new_oid);
|
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;
|
strbuf: convert strbuf_add_unique_abbrev to use struct object_id
Convert the declaration and definition of strbuf_add_unique_abbrev to
make it take a pointer to struct object_id. Predeclare the struct in
strbuf.h, as cache.h includes strbuf.h before it declares the struct,
and otherwise the struct declaration would have the wrong scope.
Apply the following semantic patch, along with the standard object_id
transforms, to adjust the callers:
@@
expression E1, E2, E3;
@@
- strbuf_add_unique_abbrev(E1, E2.hash, E3);
+ strbuf_add_unique_abbrev(E1, &E2, E3);
@@
expression E1, E2, E3;
@@
- strbuf_add_unique_abbrev(E1, E2->hash, E3);
+ strbuf_add_unique_abbrev(E1, E2, E3);
Signed-off-by: brian m. carlson <sandals@crustytoothpaste.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2018-03-12 02:27:28 +00:00
|
|
|
strbuf_add_unique_abbrev(&quickref, ¤t->object.oid, DEFAULT_ABBREV);
|
2015-09-24 21:07:40 +00:00
|
|
|
strbuf_addstr(&quickref, "...");
|
strbuf: convert strbuf_add_unique_abbrev to use struct object_id
Convert the declaration and definition of strbuf_add_unique_abbrev to
make it take a pointer to struct object_id. Predeclare the struct in
strbuf.h, as cache.h includes strbuf.h before it declares the struct,
and otherwise the struct declaration would have the wrong scope.
Apply the following semantic patch, along with the standard object_id
transforms, to adjust the callers:
@@
expression E1, E2, E3;
@@
- strbuf_add_unique_abbrev(E1, E2.hash, E3);
+ strbuf_add_unique_abbrev(E1, &E2, E3);
@@
expression E1, E2, E3;
@@
- strbuf_add_unique_abbrev(E1, E2->hash, E3);
+ strbuf_add_unique_abbrev(E1, E2, E3);
Signed-off-by: brian m. carlson <sandals@crustytoothpaste.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2018-03-12 02:27:28 +00:00
|
|
|
strbuf_add_unique_abbrev(&quickref, &ref->new_oid, DEFAULT_ABBREV);
|
2011-03-06 22:10:46 +00:00
|
|
|
if ((recurse_submodules != RECURSE_SUBMODULES_OFF) &&
|
|
|
|
(recurse_submodules != RECURSE_SUBMODULES_ON))
|
2017-03-26 16:01:35 +00:00
|
|
|
check_for_new_submodule_commits(&ref->new_oid);
|
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;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-10-15 22:06:54 +00:00
|
|
|
static int iterate_ref_map(void *cb_data, struct object_id *oid)
|
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;
|
2017-10-15 22:06:54 +00:00
|
|
|
oidcpy(oid, &ref->old_oid);
|
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,
|
fetch-pack: write shallow, then check connectivity
When fetching, connectivity is checked after the shallow file is
updated. There are 2 issues with this: (1) the connectivity check is
only performed up to ancestors of existing refs (which is not thorough
enough if we were deepening an existing ref in the first place), and (2)
there is no rollback of the shallow file if the connectivity check
fails.
To solve (1), update the connectivity check to check the ancestry chain
completely in the case of a deepening fetch by refraining from passing
"--not --all" when invoking rev-list in connected.c.
To solve (2), have fetch_pack() perform its own connectivity check
before updating the shallow file. To support existing use cases in which
"git fetch-pack" is used to download objects without much regard as to
the connectivity of the resulting objects with respect to the existing
repository, the connectivity check is only done if necessary (that is,
the fetch is not a clone, and the fetch involves shallow/deepen
functionality). "git fetch" still performs its own connectivity check,
preserving correctness but sometimes performing redundant work. This
redundancy is mitigated by the fact that fetch_pack() reports if it has
performed a connectivity check itself, and if the transport supports
connect or stateless-connect, it will bubble up that report so that "git
fetch" knows not to perform the connectivity check in such a case.
This was noticed when a user tried to deepen an existing repository by
fetching with --no-shallow from a server that did not send all necessary
objects - the connectivity check as run by "git fetch" succeeded, but a
subsequent "git fsck" failed.
Signed-off-by: Jonathan Tan <jonathantanmy@google.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2018-07-02 22:08:43 +00:00
|
|
|
int connectivity_checked, 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;
|
2018-05-17 22:51:51 +00:00
|
|
|
const char *filename = dry_run ? "/dev/null" : git_path_fetch_head(the_repository);
|
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
|
|
|
|
fetch-pack: write shallow, then check connectivity
When fetching, connectivity is checked after the shallow file is
updated. There are 2 issues with this: (1) the connectivity check is
only performed up to ancestors of existing refs (which is not thorough
enough if we were deepening an existing ref in the first place), and (2)
there is no rollback of the shallow file if the connectivity check
fails.
To solve (1), update the connectivity check to check the ancestry chain
completely in the case of a deepening fetch by refraining from passing
"--not --all" when invoking rev-list in connected.c.
To solve (2), have fetch_pack() perform its own connectivity check
before updating the shallow file. To support existing use cases in which
"git fetch-pack" is used to download objects without much regard as to
the connectivity of the resulting objects with respect to the existing
repository, the connectivity check is only done if necessary (that is,
the fetch is not a clone, and the fetch involves shallow/deepen
functionality). "git fetch" still performs its own connectivity check,
preserving correctness but sometimes performing redundant work. This
redundancy is mitigated by the fact that fetch_pack() reports if it has
performed a connectivity check itself, and if the transport supports
connect or stateless-connect, it will bubble up that report so that "git
fetch" knows not to perform the connectivity check in such a case.
This was noticed when a user tried to deepen an existing repository by
fetching with --no-shallow from a server that did not send all necessary
objects - the connectivity check as run by "git fetch" succeeded, but a
subsequent "git fsck" failed.
Signed-off-by: Jonathan Tan <jonathantanmy@google.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2018-07-02 22:08:43 +00:00
|
|
|
if (!connectivity_checked) {
|
|
|
|
rm = ref_map;
|
|
|
|
if (check_connected(iterate_ref_map, &rm, NULL)) {
|
|
|
|
rc = error(_("%s did not send all necessary objects\n"), url);
|
|
|
|
goto abort;
|
|
|
|
}
|
2011-10-07 07:40:22 +00:00
|
|
|
}
|
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;
|
|
|
|
}
|
|
|
|
|
2018-06-29 01:21:57 +00:00
|
|
|
commit = lookup_commit_reference_gently(the_repository,
|
|
|
|
&rm->old_oid,
|
Convert lookup_commit* to struct object_id
Convert lookup_commit, lookup_commit_or_die,
lookup_commit_reference, and lookup_commit_reference_gently to take
struct object_id arguments.
Introduce a temporary in parse_object buffer in order to convert this
function. This is required since in order to convert parse_object and
parse_object_buffer, lookup_commit_reference_gently and
lookup_commit_or_die would need to be converted. Not introducing a
temporary would therefore require that lookup_commit_or_die take a
struct object_id *, but lookup_commit would take unsigned char *,
leaving a confusing and hard-to-use interface.
parse_object_buffer will lose this temporary in a later patch.
This commit was created with manual changes to commit.c, commit.h, and
object.c, plus the following semantic patch:
@@
expression E1, E2;
@@
- lookup_commit_reference_gently(E1.hash, E2)
+ lookup_commit_reference_gently(&E1, E2)
@@
expression E1, E2;
@@
- lookup_commit_reference_gently(E1->hash, E2)
+ lookup_commit_reference_gently(E1, E2)
@@
expression E1;
@@
- lookup_commit_reference(E1.hash)
+ lookup_commit_reference(&E1)
@@
expression E1;
@@
- lookup_commit_reference(E1->hash)
+ lookup_commit_reference(E1)
@@
expression E1;
@@
- lookup_commit(E1.hash)
+ lookup_commit(&E1)
@@
expression E1;
@@
- lookup_commit(E1->hash)
+ lookup_commit(E1)
@@
expression E1, E2;
@@
- lookup_commit_or_die(E1.hash, E2)
+ lookup_commit_or_die(&E1, E2)
@@
expression E1, E2;
@@
- lookup_commit_or_die(E1->hash, E2)
+ lookup_commit_or_die(E1, E2)
Signed-off-by: brian m. carlson <sandals@crustytoothpaste.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2017-05-06 22:10:10 +00:00
|
|
|
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
|
|
|
}
|
|
|
|
|
fetch-pack: unify ref in and out param
When a user fetches:
- at least one up-to-date ref and at least one non-up-to-date ref,
- using HTTP with protocol v0 (or something else that uses the fetch
command of a remote helper)
some refs might not be updated after the fetch.
This bug was introduced in commit 989b8c4452 ("fetch-pack: put shallow
info in output parameter", 2018-06-28) which allowed transports to
report the refs that they have fetched in a new out-parameter
"fetched_refs". If they do so, transport_fetch_refs() makes this
information available to its caller.
Users of "fetched_refs" rely on the following 3 properties:
(1) it is the complete list of refs that was passed to
transport_fetch_refs(),
(2) it has shallow information (REF_STATUS_REJECT_SHALLOW set if
relevant), and
(3) it has updated OIDs if ref-in-want was used (introduced after
989b8c4452).
In an effort to satisfy (1), whenever transport_fetch_refs()
filters the refs sent to the transport, it re-adds the filtered refs to
whatever the transport supplies before returning it to the user.
However, the implementation in 989b8c4452 unconditionally re-adds the
filtered refs without checking if the transport refrained from reporting
anything in "fetched_refs" (which it is allowed to do), resulting in an
incomplete list, no longer satisfying (1).
An earlier effort to resolve this [1] solved the issue by readding the
filtered refs only if the transport did not refrain from reporting in
"fetched_refs", but after further discussion, it seems that the better
solution is to revert the API change that introduced "fetched_refs".
This API change was first suggested as part of a ref-in-want
implementation that allowed for ref patterns and, thus, there could be
drastic differences between the input refs and the refs actually fetched
[2]; we eventually decided to only allow exact ref names, but this API
change remained even though its necessity was decreased.
Therefore, revert this API change by reverting commit 989b8c4452, and
make receive_wanted_refs() update the OIDs in the sought array (like how
update_shallow() updates shallow information in the sought array)
instead. A test is also included to show that the user-visible bug
discussed at the beginning of this commit message no longer exists.
[1] https://public-inbox.org/git/20180801171806.GA122458@google.com/
[2] https://public-inbox.org/git/86a128c5fb710a41791e7183207c4d64889f9307.1485381677.git.jonathantanmy@google.com/
Signed-off-by: Jonathan Tan <jonathantanmy@google.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2018-08-01 20:13:20 +00:00
|
|
|
static int fetch_refs(struct transport *transport, struct ref *ref_map)
|
2007-09-11 03:03:25 +00:00
|
|
|
{
|
2007-11-11 07:29:47 +00:00
|
|
|
int ret = quickfetch(ref_map);
|
|
|
|
if (ret)
|
fetch-pack: unify ref in and out param
When a user fetches:
- at least one up-to-date ref and at least one non-up-to-date ref,
- using HTTP with protocol v0 (or something else that uses the fetch
command of a remote helper)
some refs might not be updated after the fetch.
This bug was introduced in commit 989b8c4452 ("fetch-pack: put shallow
info in output parameter", 2018-06-28) which allowed transports to
report the refs that they have fetched in a new out-parameter
"fetched_refs". If they do so, transport_fetch_refs() makes this
information available to its caller.
Users of "fetched_refs" rely on the following 3 properties:
(1) it is the complete list of refs that was passed to
transport_fetch_refs(),
(2) it has shallow information (REF_STATUS_REJECT_SHALLOW set if
relevant), and
(3) it has updated OIDs if ref-in-want was used (introduced after
989b8c4452).
In an effort to satisfy (1), whenever transport_fetch_refs()
filters the refs sent to the transport, it re-adds the filtered refs to
whatever the transport supplies before returning it to the user.
However, the implementation in 989b8c4452 unconditionally re-adds the
filtered refs without checking if the transport refrained from reporting
anything in "fetched_refs" (which it is allowed to do), resulting in an
incomplete list, no longer satisfying (1).
An earlier effort to resolve this [1] solved the issue by readding the
filtered refs only if the transport did not refrain from reporting in
"fetched_refs", but after further discussion, it seems that the better
solution is to revert the API change that introduced "fetched_refs".
This API change was first suggested as part of a ref-in-want
implementation that allowed for ref patterns and, thus, there could be
drastic differences between the input refs and the refs actually fetched
[2]; we eventually decided to only allow exact ref names, but this API
change remained even though its necessity was decreased.
Therefore, revert this API change by reverting commit 989b8c4452, and
make receive_wanted_refs() update the OIDs in the sought array (like how
update_shallow() updates shallow information in the sought array)
instead. A test is also included to show that the user-visible bug
discussed at the beginning of this commit message no longer exists.
[1] https://public-inbox.org/git/20180801171806.GA122458@google.com/
[2] https://public-inbox.org/git/86a128c5fb710a41791e7183207c4d64889f9307.1485381677.git.jonathantanmy@google.com/
Signed-off-by: Jonathan Tan <jonathantanmy@google.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2018-08-01 20:13:20 +00:00
|
|
|
ret = transport_fetch_refs(transport, ref_map);
|
2007-09-11 03:03:25 +00:00
|
|
|
if (!ret)
|
2018-06-27 22:30:20 +00:00
|
|
|
/*
|
|
|
|
* Keep the new pack's ".keep" file around to allow the caller
|
|
|
|
* time to update refs to reference the new objects.
|
|
|
|
*/
|
|
|
|
return 0;
|
|
|
|
transport_unlock_pack(transport);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Update local refs based on the ref values fetched from a remote */
|
|
|
|
static int consume_refs(struct transport *transport, struct ref *ref_map)
|
|
|
|
{
|
fetch-pack: write shallow, then check connectivity
When fetching, connectivity is checked after the shallow file is
updated. There are 2 issues with this: (1) the connectivity check is
only performed up to ancestors of existing refs (which is not thorough
enough if we were deepening an existing ref in the first place), and (2)
there is no rollback of the shallow file if the connectivity check
fails.
To solve (1), update the connectivity check to check the ancestry chain
completely in the case of a deepening fetch by refraining from passing
"--not --all" when invoking rev-list in connected.c.
To solve (2), have fetch_pack() perform its own connectivity check
before updating the shallow file. To support existing use cases in which
"git fetch-pack" is used to download objects without much regard as to
the connectivity of the resulting objects with respect to the existing
repository, the connectivity check is only done if necessary (that is,
the fetch is not a clone, and the fetch involves shallow/deepen
functionality). "git fetch" still performs its own connectivity check,
preserving correctness but sometimes performing redundant work. This
redundancy is mitigated by the fact that fetch_pack() reports if it has
performed a connectivity check itself, and if the transport supports
connect or stateless-connect, it will bubble up that report so that "git
fetch" knows not to perform the connectivity check in such a case.
This was noticed when a user tried to deepen an existing repository by
fetching with --no-shallow from a server that did not send all necessary
objects - the connectivity check as run by "git fetch" succeeded, but a
subsequent "git fsck" failed.
Signed-off-by: Jonathan Tan <jonathantanmy@google.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2018-07-02 22:08:43 +00:00
|
|
|
int connectivity_checked = transport->smart_options
|
|
|
|
? transport->smart_options->connectivity_checked : 0;
|
2018-06-27 22:30:20 +00:00
|
|
|
int ret = store_updated_refs(transport->url,
|
|
|
|
transport->remote->name,
|
fetch-pack: write shallow, then check connectivity
When fetching, connectivity is checked after the shallow file is
updated. There are 2 issues with this: (1) the connectivity check is
only performed up to ancestors of existing refs (which is not thorough
enough if we were deepening an existing ref in the first place), and (2)
there is no rollback of the shallow file if the connectivity check
fails.
To solve (1), update the connectivity check to check the ancestry chain
completely in the case of a deepening fetch by refraining from passing
"--not --all" when invoking rev-list in connected.c.
To solve (2), have fetch_pack() perform its own connectivity check
before updating the shallow file. To support existing use cases in which
"git fetch-pack" is used to download objects without much regard as to
the connectivity of the resulting objects with respect to the existing
repository, the connectivity check is only done if necessary (that is,
the fetch is not a clone, and the fetch involves shallow/deepen
functionality). "git fetch" still performs its own connectivity check,
preserving correctness but sometimes performing redundant work. This
redundancy is mitigated by the fact that fetch_pack() reports if it has
performed a connectivity check itself, and if the transport supports
connect or stateless-connect, it will bubble up that report so that "git
fetch" knows not to perform the connectivity check in such a case.
This was noticed when a user tried to deepen an existing repository by
fetching with --no-shallow from a server that did not send all necessary
objects - the connectivity check as run by "git fetch" succeeded, but a
subsequent "git fsck" failed.
Signed-off-by: Jonathan Tan <jonathantanmy@google.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2018-07-02 22:08:43 +00:00
|
|
|
connectivity_checked,
|
2018-06-27 22:30:20 +00:00
|
|
|
ref_map);
|
2007-09-14 07:31:23 +00:00
|
|
|
transport_unlock_pack(transport);
|
2007-09-11 03:03:25 +00:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2018-05-16 22:58:09 +00:00
|
|
|
static int prune_refs(struct refspec *rs, 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;
|
2018-05-16 22:58:10 +00:00
|
|
|
struct ref *ref, *stale_refs = get_stale_heads(rs, 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);
|
|
|
|
|
2017-05-22 14:17:38 +00:00
|
|
|
result = delete_refs("fetch: prune", &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)
|
|
|
|
{
|
2018-05-17 22:51:51 +00:00
|
|
|
const char *filename = git_path_fetch_head(the_repository);
|
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);
|
|
|
|
}
|
|
|
|
|
2018-07-02 22:39:44 +00:00
|
|
|
|
|
|
|
static int add_oid(const char *refname, const struct object_id *oid, int flags,
|
|
|
|
void *cb_data)
|
|
|
|
{
|
|
|
|
struct oid_array *oids = cb_data;
|
|
|
|
|
|
|
|
oid_array_append(oids, oid);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void add_negotiation_tips(struct git_transport_options *smart_options)
|
|
|
|
{
|
|
|
|
struct oid_array *oids = xcalloc(1, sizeof(*oids));
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i = 0; i < negotiation_tip.nr; i++) {
|
|
|
|
const char *s = negotiation_tip.items[i].string;
|
|
|
|
int old_nr;
|
|
|
|
if (!has_glob_specials(s)) {
|
|
|
|
struct object_id oid;
|
|
|
|
if (get_oid(s, &oid))
|
|
|
|
die("%s is not a valid object", s);
|
|
|
|
oid_array_append(oids, &oid);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
old_nr = oids->nr;
|
|
|
|
for_each_glob_ref(add_oid, s, oids);
|
|
|
|
if (old_nr == oids->nr)
|
|
|
|
warning("Ignoring --negotiation-tip=%s because it does not match any refs",
|
|
|
|
s);
|
|
|
|
}
|
|
|
|
smart_options->negotiation_tips = oids;
|
|
|
|
}
|
|
|
|
|
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");
|
2017-12-08 15:58:44 +00:00
|
|
|
if (filter_options.choice) {
|
|
|
|
set_option(transport, TRANS_OPT_LIST_OBJECTS_FILTER,
|
|
|
|
filter_options.filter_spec);
|
|
|
|
set_option(transport, TRANS_OPT_FROM_PROMISOR, "1");
|
|
|
|
}
|
2018-07-02 22:39:44 +00:00
|
|
|
if (negotiation_tip.nr) {
|
|
|
|
if (transport->smart_options)
|
|
|
|
add_negotiation_tips(transport->smart_options);
|
|
|
|
else
|
|
|
|
warning("Ignoring --negotiation-tip because the protocol does not support it.");
|
|
|
|
}
|
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);
|
fetch-pack: unify ref in and out param
When a user fetches:
- at least one up-to-date ref and at least one non-up-to-date ref,
- using HTTP with protocol v0 (or something else that uses the fetch
command of a remote helper)
some refs might not be updated after the fetch.
This bug was introduced in commit 989b8c4452 ("fetch-pack: put shallow
info in output parameter", 2018-06-28) which allowed transports to
report the refs that they have fetched in a new out-parameter
"fetched_refs". If they do so, transport_fetch_refs() makes this
information available to its caller.
Users of "fetched_refs" rely on the following 3 properties:
(1) it is the complete list of refs that was passed to
transport_fetch_refs(),
(2) it has shallow information (REF_STATUS_REJECT_SHALLOW set if
relevant), and
(3) it has updated OIDs if ref-in-want was used (introduced after
989b8c4452).
In an effort to satisfy (1), whenever transport_fetch_refs()
filters the refs sent to the transport, it re-adds the filtered refs to
whatever the transport supplies before returning it to the user.
However, the implementation in 989b8c4452 unconditionally re-adds the
filtered refs without checking if the transport refrained from reporting
anything in "fetched_refs" (which it is allowed to do), resulting in an
incomplete list, no longer satisfying (1).
An earlier effort to resolve this [1] solved the issue by readding the
filtered refs only if the transport did not refrain from reporting in
"fetched_refs", but after further discussion, it seems that the better
solution is to revert the API change that introduced "fetched_refs".
This API change was first suggested as part of a ref-in-want
implementation that allowed for ref patterns and, thus, there could be
drastic differences between the input refs and the refs actually fetched
[2]; we eventually decided to only allow exact ref names, but this API
change remained even though its necessity was decreased.
Therefore, revert this API change by reverting commit 989b8c4452, and
make receive_wanted_refs() update the OIDs in the sought array (like how
update_shallow() updates shallow information in the sought array)
instead. A test is also included to show that the user-visible bug
discussed at the beginning of this commit message no longer exists.
[1] https://public-inbox.org/git/20180801171806.GA122458@google.com/
[2] https://public-inbox.org/git/86a128c5fb710a41791e7183207c4d64889f9307.1485381677.git.jonathantanmy@google.com/
Signed-off-by: Jonathan Tan <jonathantanmy@google.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2018-08-01 20:13:20 +00:00
|
|
|
if (!fetch_refs(transport, ref_map))
|
2018-06-27 22:30:20 +00:00
|
|
|
consume_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,
|
2018-05-16 22:58:07 +00:00
|
|
|
struct refspec *rs)
|
2007-09-11 03:03:25 +00:00
|
|
|
{
|
2008-03-03 02:34:43 +00:00
|
|
|
struct ref *ref_map;
|
2007-09-11 03:03:25 +00:00
|
|
|
int autotags = (transport->remote->fetch_tags == 1);
|
2013-05-25 09:08:16 +00:00
|
|
|
int retcode = 0;
|
2018-06-27 22:30:21 +00:00
|
|
|
const struct ref *remote_refs;
|
|
|
|
struct argv_array ref_prefixes = ARGV_ARRAY_INIT;
|
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
|
|
|
|
|
|
|
/* 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
|
|
|
|
2018-06-27 22:30:21 +00:00
|
|
|
if (rs->nr)
|
|
|
|
refspec_ref_prefixes(rs, &ref_prefixes);
|
|
|
|
else if (transport->remote && transport->remote->fetch.nr)
|
|
|
|
refspec_ref_prefixes(&transport->remote->fetch, &ref_prefixes);
|
2007-09-11 03:03:25 +00:00
|
|
|
|
2018-06-27 22:30:21 +00:00
|
|
|
if (ref_prefixes.argc &&
|
2018-08-15 22:08:25 +00:00
|
|
|
(tags == TAGS_SET || (tags == TAGS_DEFAULT))) {
|
2018-06-27 22:30:21 +00:00
|
|
|
argv_array_push(&ref_prefixes, "refs/tags/");
|
2007-09-11 03:03:25 +00:00
|
|
|
}
|
|
|
|
|
2018-06-27 22:30:21 +00:00
|
|
|
remote_refs = transport_get_remote_refs(transport, &ref_prefixes);
|
|
|
|
argv_array_clear(&ref_prefixes);
|
|
|
|
|
|
|
|
ref_map = get_ref_map(transport->remote, remote_refs, rs,
|
|
|
|
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
|
|
|
|
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.
|
|
|
|
*/
|
2018-05-16 22:58:07 +00:00
|
|
|
if (rs->nr) {
|
2018-05-16 22:58:09 +00:00
|
|
|
prune_refs(rs, ref_map, transport->url);
|
2011-10-15 05:04:26 +00:00
|
|
|
} else {
|
2018-05-16 22:58:09 +00:00
|
|
|
prune_refs(&transport->remote->fetch,
|
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
|
|
|
}
|
fetch-pack: unify ref in and out param
When a user fetches:
- at least one up-to-date ref and at least one non-up-to-date ref,
- using HTTP with protocol v0 (or something else that uses the fetch
command of a remote helper)
some refs might not be updated after the fetch.
This bug was introduced in commit 989b8c4452 ("fetch-pack: put shallow
info in output parameter", 2018-06-28) which allowed transports to
report the refs that they have fetched in a new out-parameter
"fetched_refs". If they do so, transport_fetch_refs() makes this
information available to its caller.
Users of "fetched_refs" rely on the following 3 properties:
(1) it is the complete list of refs that was passed to
transport_fetch_refs(),
(2) it has shallow information (REF_STATUS_REJECT_SHALLOW set if
relevant), and
(3) it has updated OIDs if ref-in-want was used (introduced after
989b8c4452).
In an effort to satisfy (1), whenever transport_fetch_refs()
filters the refs sent to the transport, it re-adds the filtered refs to
whatever the transport supplies before returning it to the user.
However, the implementation in 989b8c4452 unconditionally re-adds the
filtered refs without checking if the transport refrained from reporting
anything in "fetched_refs" (which it is allowed to do), resulting in an
incomplete list, no longer satisfying (1).
An earlier effort to resolve this [1] solved the issue by readding the
filtered refs only if the transport did not refrain from reporting in
"fetched_refs", but after further discussion, it seems that the better
solution is to revert the API change that introduced "fetched_refs".
This API change was first suggested as part of a ref-in-want
implementation that allowed for ref patterns and, thus, there could be
drastic differences between the input refs and the refs actually fetched
[2]; we eventually decided to only allow exact ref names, but this API
change remained even though its necessity was decreased.
Therefore, revert this API change by reverting commit 989b8c4452, and
make receive_wanted_refs() update the OIDs in the sought array (like how
update_shallow() updates shallow information in the sought array)
instead. A test is also included to show that the user-visible bug
discussed at the beginning of this commit message no longer exists.
[1] https://public-inbox.org/git/20180801171806.GA122458@google.com/
[2] https://public-inbox.org/git/86a128c5fb710a41791e7183207c4d64889f9307.1485381677.git.jonathantanmy@google.com/
Signed-off-by: Jonathan Tan <jonathantanmy@google.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2018-08-01 20:13:20 +00:00
|
|
|
if (fetch_refs(transport, ref_map) || consume_refs(transport, ref_map)) {
|
2014-01-03 02:28:52 +00:00
|
|
|
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;
|
2018-06-27 22:30:21 +00:00
|
|
|
find_non_local_tags(remote_refs, &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:
|
|
|
|
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");
|
fetch: add a --prune-tags option and fetch.pruneTags config
Add a --prune-tags option to git-fetch, along with fetch.pruneTags
config option and a -P shorthand (-p is --prune). This allows for
doing any of:
git fetch -p -P
git fetch --prune --prune-tags
git fetch -p -P origin
git fetch --prune --prune-tags origin
Or simply:
git config fetch.prune true &&
git config fetch.pruneTags true &&
git fetch
Instead of the much more verbose:
git fetch --prune origin 'refs/tags/*:refs/tags/*' '+refs/heads/*:refs/remotes/origin/*'
Before this feature it was painful to support the use-case of pulling
from a repo which is having both its branches *and* tags deleted
regularly, and have our local references to reflect upstream.
At work we create deployment tags in the repo for each rollout, and
there's *lots* of those, so they're archived within weeks for
performance reasons.
Without this change it's hard to centrally configure such repos in
/etc/gitconfig (on servers that are only used for working with
them). You need to set fetch.prune=true globally, and then for each
repo:
git -C {} config --replace-all remote.origin.fetch "refs/tags/*:refs/tags/*" "^\+*refs/tags/\*:refs/tags/\*$"
Now I can simply set fetch.pruneTags=true in /etc/gitconfig as well,
and users running "git pull" will automatically get the pruning
semantics I want.
Even though "git remote" has corresponding "prune" and "update
--prune" subcommands I'm intentionally not adding a corresponding
prune-tags or "update --prune --prune-tags" mode to that command.
It's advertised (as noted in my recent "git remote doc: correct
dangerous lies about what prune does") as only modifying remote
tracking references, whereas any --prune-tags option is always going
to modify what from the user's perspective is a local copy of the tag,
since there's no such thing as a remote tracking tag.
Ideally add_prune_tags_to_fetch_refspec() would be something that
would use ALLOC_GROW() to grow the 'fetch` member of the 'remote'
struct. Instead I'm realloc-ing remote->fetch and adding the
tag_refspec to the end.
The reason is that parse_{fetch,push}_refspec which allocate the
refspec (ultimately remote->fetch) struct are called many places that
don't have access to a 'remote' struct. It would be hard to change all
their callsites to be amenable to carry around the bookkeeping
variables required for dynamic allocation.
All the other callers of the API first incrementally construct the
string version of the refspec in remote->fetch_refspec via
add_fetch_refspec(), before finally calling parse_fetch_refspec() via
some variation of remote_get().
It's less of a pain to deal with the one special case that needs to
modify already constructed refspecs than to chase down and change all
the other callsites. The API I'm adding is intentionally not
generalized because if we add more of these we'd probably want to
re-visit how this is done.
See my "Re: [BUG] git remote prune removes local tags, depending on
fetch config" (87po6ahx87.fsf@evledraar.gmail.com;
https://public-inbox.org/git/87po6ahx87.fsf@evledraar.gmail.com/) for
more background info.
Signed-off-by: Ævar Arnfjörð Bjarmason <avarab@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2018-02-09 20:32:15 +00:00
|
|
|
if (prune_tags != -1)
|
|
|
|
argv_array_push(argv, prune_tags ? "--prune-tags" : "--no-prune-tags");
|
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;
|
|
|
|
}
|
|
|
|
|
2017-12-08 15:58:50 +00:00
|
|
|
/*
|
|
|
|
* Fetching from the promisor remote should use the given filter-spec
|
|
|
|
* or inherit the default filter-spec from the config.
|
|
|
|
*/
|
|
|
|
static inline void fetch_one_setup_partial(struct remote *remote)
|
|
|
|
{
|
|
|
|
/*
|
|
|
|
* Explicit --no-filter argument overrides everything, regardless
|
|
|
|
* of any prior partial clones and fetches.
|
|
|
|
*/
|
|
|
|
if (filter_options.no_filter)
|
|
|
|
return;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If no prior partial clone/fetch and the current fetch DID NOT
|
|
|
|
* request a partial-fetch, do a normal fetch.
|
|
|
|
*/
|
|
|
|
if (!repository_format_partial_clone && !filter_options.choice)
|
|
|
|
return;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If this is the FIRST partial-fetch request, we enable partial
|
|
|
|
* on this repo and remember the given filter-spec as the default
|
|
|
|
* for subsequent fetches to this remote.
|
|
|
|
*/
|
|
|
|
if (!repository_format_partial_clone && filter_options.choice) {
|
|
|
|
partial_clone_register(remote->name, &filter_options);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* We are currently limited to only ONE promisor remote and only
|
|
|
|
* allow partial-fetches from the promisor remote.
|
|
|
|
*/
|
|
|
|
if (strcmp(remote->name, repository_format_partial_clone)) {
|
|
|
|
if (filter_options.choice)
|
|
|
|
die(_("--filter can only be used with the remote configured in core.partialClone"));
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Do a partial-fetch from the promisor remote using either the
|
|
|
|
* explicitly given filter-spec or inherit the filter-spec from
|
|
|
|
* the config.
|
|
|
|
*/
|
|
|
|
if (!filter_options.choice)
|
|
|
|
partial_clone_get_default_filter_spec(&filter_options);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
fetch: add a --prune-tags option and fetch.pruneTags config
Add a --prune-tags option to git-fetch, along with fetch.pruneTags
config option and a -P shorthand (-p is --prune). This allows for
doing any of:
git fetch -p -P
git fetch --prune --prune-tags
git fetch -p -P origin
git fetch --prune --prune-tags origin
Or simply:
git config fetch.prune true &&
git config fetch.pruneTags true &&
git fetch
Instead of the much more verbose:
git fetch --prune origin 'refs/tags/*:refs/tags/*' '+refs/heads/*:refs/remotes/origin/*'
Before this feature it was painful to support the use-case of pulling
from a repo which is having both its branches *and* tags deleted
regularly, and have our local references to reflect upstream.
At work we create deployment tags in the repo for each rollout, and
there's *lots* of those, so they're archived within weeks for
performance reasons.
Without this change it's hard to centrally configure such repos in
/etc/gitconfig (on servers that are only used for working with
them). You need to set fetch.prune=true globally, and then for each
repo:
git -C {} config --replace-all remote.origin.fetch "refs/tags/*:refs/tags/*" "^\+*refs/tags/\*:refs/tags/\*$"
Now I can simply set fetch.pruneTags=true in /etc/gitconfig as well,
and users running "git pull" will automatically get the pruning
semantics I want.
Even though "git remote" has corresponding "prune" and "update
--prune" subcommands I'm intentionally not adding a corresponding
prune-tags or "update --prune --prune-tags" mode to that command.
It's advertised (as noted in my recent "git remote doc: correct
dangerous lies about what prune does") as only modifying remote
tracking references, whereas any --prune-tags option is always going
to modify what from the user's perspective is a local copy of the tag,
since there's no such thing as a remote tracking tag.
Ideally add_prune_tags_to_fetch_refspec() would be something that
would use ALLOC_GROW() to grow the 'fetch` member of the 'remote'
struct. Instead I'm realloc-ing remote->fetch and adding the
tag_refspec to the end.
The reason is that parse_{fetch,push}_refspec which allocate the
refspec (ultimately remote->fetch) struct are called many places that
don't have access to a 'remote' struct. It would be hard to change all
their callsites to be amenable to carry around the bookkeeping
variables required for dynamic allocation.
All the other callers of the API first incrementally construct the
string version of the refspec in remote->fetch_refspec via
add_fetch_refspec(), before finally calling parse_fetch_refspec() via
some variation of remote_get().
It's less of a pain to deal with the one special case that needs to
modify already constructed refspecs than to chase down and change all
the other callsites. The API I'm adding is intentionally not
generalized because if we add more of these we'd probably want to
re-visit how this is done.
See my "Re: [BUG] git remote prune removes local tags, depending on
fetch config" (87po6ahx87.fsf@evledraar.gmail.com;
https://public-inbox.org/git/87po6ahx87.fsf@evledraar.gmail.com/) for
more background info.
Signed-off-by: Ævar Arnfjörð Bjarmason <avarab@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2018-02-09 20:32:15 +00:00
|
|
|
static int fetch_one(struct remote *remote, int argc, const char **argv, int prune_tags_ok)
|
2007-09-11 03:03:25 +00:00
|
|
|
{
|
2018-05-16 22:58:04 +00:00
|
|
|
struct refspec rs = REFSPEC_INIT_FETCH;
|
|
|
|
int i;
|
2008-04-28 20:23:35 +00:00
|
|
|
int exit_code;
|
2018-02-09 20:32:16 +00:00
|
|
|
int maybe_prune_tags;
|
|
|
|
int remote_via_config = remote_is_configured(remote, 0);
|
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 */
|
2018-02-09 20:32:02 +00:00
|
|
|
if (0 <= remote->prune)
|
|
|
|
prune = 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;
|
|
|
|
}
|
|
|
|
|
fetch: add a --prune-tags option and fetch.pruneTags config
Add a --prune-tags option to git-fetch, along with fetch.pruneTags
config option and a -P shorthand (-p is --prune). This allows for
doing any of:
git fetch -p -P
git fetch --prune --prune-tags
git fetch -p -P origin
git fetch --prune --prune-tags origin
Or simply:
git config fetch.prune true &&
git config fetch.pruneTags true &&
git fetch
Instead of the much more verbose:
git fetch --prune origin 'refs/tags/*:refs/tags/*' '+refs/heads/*:refs/remotes/origin/*'
Before this feature it was painful to support the use-case of pulling
from a repo which is having both its branches *and* tags deleted
regularly, and have our local references to reflect upstream.
At work we create deployment tags in the repo for each rollout, and
there's *lots* of those, so they're archived within weeks for
performance reasons.
Without this change it's hard to centrally configure such repos in
/etc/gitconfig (on servers that are only used for working with
them). You need to set fetch.prune=true globally, and then for each
repo:
git -C {} config --replace-all remote.origin.fetch "refs/tags/*:refs/tags/*" "^\+*refs/tags/\*:refs/tags/\*$"
Now I can simply set fetch.pruneTags=true in /etc/gitconfig as well,
and users running "git pull" will automatically get the pruning
semantics I want.
Even though "git remote" has corresponding "prune" and "update
--prune" subcommands I'm intentionally not adding a corresponding
prune-tags or "update --prune --prune-tags" mode to that command.
It's advertised (as noted in my recent "git remote doc: correct
dangerous lies about what prune does") as only modifying remote
tracking references, whereas any --prune-tags option is always going
to modify what from the user's perspective is a local copy of the tag,
since there's no such thing as a remote tracking tag.
Ideally add_prune_tags_to_fetch_refspec() would be something that
would use ALLOC_GROW() to grow the 'fetch` member of the 'remote'
struct. Instead I'm realloc-ing remote->fetch and adding the
tag_refspec to the end.
The reason is that parse_{fetch,push}_refspec which allocate the
refspec (ultimately remote->fetch) struct are called many places that
don't have access to a 'remote' struct. It would be hard to change all
their callsites to be amenable to carry around the bookkeeping
variables required for dynamic allocation.
All the other callers of the API first incrementally construct the
string version of the refspec in remote->fetch_refspec via
add_fetch_refspec(), before finally calling parse_fetch_refspec() via
some variation of remote_get().
It's less of a pain to deal with the one special case that needs to
modify already constructed refspecs than to chase down and change all
the other callsites. The API I'm adding is intentionally not
generalized because if we add more of these we'd probably want to
re-visit how this is done.
See my "Re: [BUG] git remote prune removes local tags, depending on
fetch config" (87po6ahx87.fsf@evledraar.gmail.com;
https://public-inbox.org/git/87po6ahx87.fsf@evledraar.gmail.com/) for
more background info.
Signed-off-by: Ævar Arnfjörð Bjarmason <avarab@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2018-02-09 20:32:15 +00:00
|
|
|
if (prune_tags < 0) {
|
|
|
|
/* no command line request */
|
|
|
|
if (0 <= remote->prune_tags)
|
|
|
|
prune_tags = remote->prune_tags;
|
|
|
|
else if (0 <= fetch_prune_tags_config)
|
|
|
|
prune_tags = fetch_prune_tags_config;
|
|
|
|
else
|
|
|
|
prune_tags = PRUNE_TAGS_BY_DEFAULT;
|
|
|
|
}
|
|
|
|
|
2018-02-09 20:32:16 +00:00
|
|
|
maybe_prune_tags = prune_tags_ok && prune_tags;
|
|
|
|
if (maybe_prune_tags && remote_via_config)
|
2018-05-16 22:58:02 +00:00
|
|
|
refspec_append(&remote->fetch, TAG_REFSPEC);
|
fetch: add a --prune-tags option and fetch.pruneTags config
Add a --prune-tags option to git-fetch, along with fetch.pruneTags
config option and a -P shorthand (-p is --prune). This allows for
doing any of:
git fetch -p -P
git fetch --prune --prune-tags
git fetch -p -P origin
git fetch --prune --prune-tags origin
Or simply:
git config fetch.prune true &&
git config fetch.pruneTags true &&
git fetch
Instead of the much more verbose:
git fetch --prune origin 'refs/tags/*:refs/tags/*' '+refs/heads/*:refs/remotes/origin/*'
Before this feature it was painful to support the use-case of pulling
from a repo which is having both its branches *and* tags deleted
regularly, and have our local references to reflect upstream.
At work we create deployment tags in the repo for each rollout, and
there's *lots* of those, so they're archived within weeks for
performance reasons.
Without this change it's hard to centrally configure such repos in
/etc/gitconfig (on servers that are only used for working with
them). You need to set fetch.prune=true globally, and then for each
repo:
git -C {} config --replace-all remote.origin.fetch "refs/tags/*:refs/tags/*" "^\+*refs/tags/\*:refs/tags/\*$"
Now I can simply set fetch.pruneTags=true in /etc/gitconfig as well,
and users running "git pull" will automatically get the pruning
semantics I want.
Even though "git remote" has corresponding "prune" and "update
--prune" subcommands I'm intentionally not adding a corresponding
prune-tags or "update --prune --prune-tags" mode to that command.
It's advertised (as noted in my recent "git remote doc: correct
dangerous lies about what prune does") as only modifying remote
tracking references, whereas any --prune-tags option is always going
to modify what from the user's perspective is a local copy of the tag,
since there's no such thing as a remote tracking tag.
Ideally add_prune_tags_to_fetch_refspec() would be something that
would use ALLOC_GROW() to grow the 'fetch` member of the 'remote'
struct. Instead I'm realloc-ing remote->fetch and adding the
tag_refspec to the end.
The reason is that parse_{fetch,push}_refspec which allocate the
refspec (ultimately remote->fetch) struct are called many places that
don't have access to a 'remote' struct. It would be hard to change all
their callsites to be amenable to carry around the bookkeeping
variables required for dynamic allocation.
All the other callers of the API first incrementally construct the
string version of the refspec in remote->fetch_refspec via
add_fetch_refspec(), before finally calling parse_fetch_refspec() via
some variation of remote_get().
It's less of a pain to deal with the one special case that needs to
modify already constructed refspecs than to chase down and change all
the other callsites. The API I'm adding is intentionally not
generalized because if we add more of these we'd probably want to
re-visit how this is done.
See my "Re: [BUG] git remote prune removes local tags, depending on
fetch config" (87po6ahx87.fsf@evledraar.gmail.com;
https://public-inbox.org/git/87po6ahx87.fsf@evledraar.gmail.com/) for
more background info.
Signed-off-by: Ævar Arnfjörð Bjarmason <avarab@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2018-02-09 20:32:15 +00:00
|
|
|
|
2018-05-16 22:58:04 +00:00
|
|
|
if (maybe_prune_tags && (argc || !remote_via_config))
|
|
|
|
refspec_append(&rs, TAG_REFSPEC);
|
2018-02-09 20:32:16 +00:00
|
|
|
|
2018-05-16 22:58:04 +00:00
|
|
|
for (i = 0; i < argc; i++) {
|
|
|
|
if (!strcmp(argv[i], "tag")) {
|
|
|
|
char *tag;
|
|
|
|
i++;
|
|
|
|
if (i >= argc)
|
|
|
|
die(_("You need to specify a tag name."));
|
|
|
|
|
|
|
|
tag = xstrfmt("refs/tags/%s:refs/tags/%s",
|
|
|
|
argv[i], argv[i]);
|
|
|
|
refspec_append(&rs, tag);
|
|
|
|
free(tag);
|
|
|
|
} else {
|
|
|
|
refspec_append(&rs, argv[i]);
|
2007-09-11 03:03:25 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-04-23 22:46:24 +00:00
|
|
|
if (server_options.nr)
|
|
|
|
gtransport->server_options = &server_options;
|
|
|
|
|
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);
|
2018-05-16 22:58:07 +00:00
|
|
|
exit_code = do_fetch(gtransport, &rs);
|
2018-05-16 22:58:04 +00:00
|
|
|
refspec_clear(&rs);
|
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;
|
2017-12-08 15:58:43 +00:00
|
|
|
struct remote *remote = NULL;
|
2009-11-09 20:09:56 +00:00
|
|
|
int result = 0;
|
2018-03-06 22:54:01 +00:00
|
|
|
int prune_tags_ok = 1;
|
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");
|
|
|
|
|
2017-12-08 15:58:44 +00:00
|
|
|
fetch_if_missing = 0;
|
|
|
|
|
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]);
|
|
|
|
|
2018-06-26 10:47:06 +00:00
|
|
|
fetch_config_from_gitmodules(&max_children, &recurse_submodules);
|
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"));
|
2018-05-17 22:51:46 +00:00
|
|
|
else if (!is_repository_shallow(the_repository))
|
2013-01-11 09:05:46 +00:00
|
|
|
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
|
|
|
|
2017-12-08 15:58:44 +00:00
|
|
|
if (filter_options.choice && !repository_format_partial_clone)
|
|
|
|
die("--filter can only be used when extensions.partialClone is set");
|
|
|
|
|
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);
|
|
|
|
} else if (argc == 0) {
|
|
|
|
/* No arguments -- use default remote */
|
|
|
|
remote = remote_get(NULL);
|
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: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
|
|
|
} else {
|
|
|
|
/* Zero or one remotes */
|
|
|
|
remote = remote_get(argv[0]);
|
2018-03-06 22:54:01 +00:00
|
|
|
prune_tags_ok = (argc == 1);
|
2017-12-08 15:58:43 +00:00
|
|
|
argc--;
|
|
|
|
argv++;
|
2009-11-09 20:09:56 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-12-08 15:58:44 +00:00
|
|
|
if (remote) {
|
2017-12-08 15:58:50 +00:00
|
|
|
if (filter_options.choice || repository_format_partial_clone)
|
|
|
|
fetch_one_setup_partial(remote);
|
2018-03-06 22:54:01 +00:00
|
|
|
result = fetch_one(remote, argc, argv, prune_tags_ok);
|
2017-12-08 15:58:44 +00:00
|
|
|
} else {
|
|
|
|
if (filter_options.choice)
|
|
|
|
die(_("--filter can only be used with the remote configured in core.partialClone"));
|
2017-12-08 15:58:50 +00:00
|
|
|
/* TODO should this also die if we have a previous partial-clone? */
|
2017-12-08 15:58:43 +00:00
|
|
|
result = fetch_multiple(&list);
|
2017-12-08 15:58:44 +00:00
|
|
|
}
|
2017-12-08 15:58:43 +00:00
|
|
|
|
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);
|
2017-12-12 19:53:52 +00:00
|
|
|
result = fetch_populated_submodules(the_repository,
|
|
|
|
&options,
|
2010-11-12 12:54:52 +00:00
|
|
|
submodule_prefix,
|
2011-03-06 22:11:21 +00:00
|
|
|
recurse_submodules,
|
2017-08-02 19:49:19 +00:00
|
|
|
recurse_submodules_default,
|
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);
|
|
|
|
|
2018-03-23 17:21:00 +00:00
|
|
|
close_all_packs(the_repository->objects);
|
2016-01-13 17:20:11 +00:00
|
|
|
|
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;
|
|
|
|
}
|