2007-05-12 15:45:53 +00:00
|
|
|
#ifndef REMOTE_H
|
|
|
|
#define REMOTE_H
|
|
|
|
|
remote.c: add command line option parser for "--force-with-lease"
Update "git push" and "git send-pack" to parse this commnd line
option.
The intended sematics is:
* "--force-with-lease" alone, without specifying the details, will
protect _all_ remote refs that are going to be updated by
requiring their current value to be the same as some reasonable
default, unless otherwise specified;
* "--force-with-lease=refname", without specifying the expected
value, will protect that refname, if it is going to be updated,
by requiring its current value to be the same as some reasonable
default.
* "--force-with-lease=refname:value" will protect that refname, if
it is going to be updated, by requiring its current value to be
the same as the specified value; and
* "--no-force-with-lease" will cancel all the previous --force-with-lease on the
command line.
For now, "some reasonable default" is tentatively defined as "the
value of the remote-tracking branch we have for the ref of the
remote being updated", and it is an error if we do not have such a
remote-tracking branch. But this is known to be fragile, its use is
not yet recommended, and hopefully we will find more reasonable
default as we gain experience with this feature. The manual marks
the feature as experimental unless the expected value is specified
explicitly for this reason.
Because the command line options are parsed _before_ we know which
remote we are pushing to, there needs further processing to the
parsed data after we instantiate the transport object to:
* expand "refname" given by the user to a full refname to be
matched with the list of "struct ref" used in match_push_refs()
and set_ref_status_for_push(); and
* learning the actual local ref that is the remote-tracking branch
for the specified remote ref.
Further, some processing need to be deferred until we find the set
of remote refs and match_push_refs() returns in order to find the
ones that need to be checked after explicit ones have been processed
for "--force-with-lease" (no specific details).
These post-processing will be the topic of the next patch.
This option was originally called "cas" (for "compare and swap"),
the name which nobody liked because it was too technical. The
second attempt called it "lockref" (because it is conceptually like
pushing after taking a lock) but the word "lock" was hated because
it implied that it may reject push by others, which is not the way
this option works. This round calls it "force-with-lease". You
assume you took the lease on the ref when you fetched to decide what
the rebased history should be, and you can push back only if the
lease has not been broken.
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2013-07-08 22:34:36 +00:00
|
|
|
#include "parse-options.h"
|
2014-07-29 14:43:39 +00:00
|
|
|
#include "hashmap.h"
|
remote.c: add command line option parser for "--force-with-lease"
Update "git push" and "git send-pack" to parse this commnd line
option.
The intended sematics is:
* "--force-with-lease" alone, without specifying the details, will
protect _all_ remote refs that are going to be updated by
requiring their current value to be the same as some reasonable
default, unless otherwise specified;
* "--force-with-lease=refname", without specifying the expected
value, will protect that refname, if it is going to be updated,
by requiring its current value to be the same as some reasonable
default.
* "--force-with-lease=refname:value" will protect that refname, if
it is going to be updated, by requiring its current value to be
the same as the specified value; and
* "--no-force-with-lease" will cancel all the previous --force-with-lease on the
command line.
For now, "some reasonable default" is tentatively defined as "the
value of the remote-tracking branch we have for the ref of the
remote being updated", and it is an error if we do not have such a
remote-tracking branch. But this is known to be fragile, its use is
not yet recommended, and hopefully we will find more reasonable
default as we gain experience with this feature. The manual marks
the feature as experimental unless the expected value is specified
explicitly for this reason.
Because the command line options are parsed _before_ we know which
remote we are pushing to, there needs further processing to the
parsed data after we instantiate the transport object to:
* expand "refname" given by the user to a full refname to be
matched with the list of "struct ref" used in match_push_refs()
and set_ref_status_for_push(); and
* learning the actual local ref that is the remote-tracking branch
for the specified remote ref.
Further, some processing need to be deferred until we find the set
of remote refs and match_push_refs() returns in order to find the
ones that need to be checked after explicit ones have been processed
for "--force-with-lease" (no specific details).
These post-processing will be the topic of the next patch.
This option was originally called "cas" (for "compare and swap"),
the name which nobody liked because it was too technical. The
second attempt called it "lockref" (because it is conceptually like
pushing after taking a lock) but the word "lock" was hated because
it implied that it may reject push by others, which is not the way
this option works. This round calls it "force-with-lease". You
assume you took the lease on the ref when you fetched to decide what
the rebased history should be, and you can push back only if the
lease has not been broken.
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2013-07-08 22:34:36 +00:00
|
|
|
|
2008-11-10 20:43:00 +00:00
|
|
|
enum {
|
2016-02-16 09:47:50 +00:00
|
|
|
REMOTE_UNCONFIGURED = 0,
|
2008-11-10 20:43:00 +00:00
|
|
|
REMOTE_CONFIG,
|
|
|
|
REMOTE_REMOTES,
|
|
|
|
REMOTE_BRANCHES
|
|
|
|
};
|
|
|
|
|
2007-05-12 15:45:53 +00:00
|
|
|
struct remote {
|
2014-07-29 14:43:39 +00:00
|
|
|
struct hashmap_entry ent; /* must be first */
|
|
|
|
|
2007-05-12 15:45:53 +00:00
|
|
|
const char *name;
|
2017-01-19 21:20:02 +00:00
|
|
|
int origin, configured_in_repo;
|
2007-05-12 15:45:53 +00:00
|
|
|
|
2009-11-18 01:42:25 +00:00
|
|
|
const char *foreign_vcs;
|
|
|
|
|
2007-09-19 04:49:27 +00:00
|
|
|
const char **url;
|
|
|
|
int url_nr;
|
2008-02-19 04:41:41 +00:00
|
|
|
int url_alloc;
|
2007-05-12 15:45:53 +00:00
|
|
|
|
2009-06-09 16:01:34 +00:00
|
|
|
const char **pushurl;
|
|
|
|
int pushurl_nr;
|
|
|
|
int pushurl_alloc;
|
|
|
|
|
2007-05-12 15:45:53 +00:00
|
|
|
const char **push_refspec;
|
2007-05-12 15:45:59 +00:00
|
|
|
struct refspec *push;
|
2007-05-12 15:45:53 +00:00
|
|
|
int push_refspec_nr;
|
2008-02-19 04:41:41 +00:00
|
|
|
int push_refspec_alloc;
|
2007-05-12 15:45:53 +00:00
|
|
|
|
2007-05-12 15:46:03 +00:00
|
|
|
const char **fetch_refspec;
|
|
|
|
struct refspec *fetch;
|
|
|
|
int fetch_refspec_nr;
|
2008-02-19 04:41:41 +00:00
|
|
|
int fetch_refspec_alloc;
|
2007-05-12 15:46:03 +00:00
|
|
|
|
2007-09-11 03:03:08 +00:00
|
|
|
/*
|
|
|
|
* -1 to never fetch tags
|
|
|
|
* 0 to auto-follow tags on heuristic (default)
|
|
|
|
* 1 to always auto-follow tags
|
|
|
|
* 2 to always fetch tags
|
|
|
|
*/
|
|
|
|
int fetch_tags;
|
2008-02-29 01:45:45 +00:00
|
|
|
int skip_default_update;
|
2008-04-17 11:17:20 +00:00
|
|
|
int mirror;
|
2013-07-13 09:36:24 +00:00
|
|
|
int 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
|
|
|
int prune_tags;
|
2007-09-11 03:03:08 +00:00
|
|
|
|
2007-05-12 15:45:53 +00:00
|
|
|
const char *receivepack;
|
2007-09-11 03:02:51 +00:00
|
|
|
const char *uploadpack;
|
2007-12-03 21:48:54 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* for curl remotes only
|
|
|
|
*/
|
|
|
|
char *http_proxy;
|
2016-01-26 13:02:47 +00:00
|
|
|
char *http_proxy_authmethod;
|
2007-05-12 15:45:53 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
struct remote *remote_get(const char *name);
|
remote.c: introduce a way to have different remotes for fetch/push
Currently, do_push() in push.c calls remote_get(), which gets the
configured remote for fetching and pushing. Replace this call with a
call to pushremote_get() instead, a new function that will return the
remote configured specifically for pushing. This function tries to
work with the string pushremote_name, before falling back to the
codepath of remote_get(). This patch has no visible impact, but
serves to enable future patches to introduce configuration variables
to set pushremote_name. For example, you can now do the following in
handle_config():
if (!strcmp(key, "remote.pushdefault"))
git_config_string(&pushremote_name, key, value);
Then, pushes will automatically go to the remote specified by
remote.pushdefault.
Signed-off-by: Ramkumar Ramachandra <artagnon@gmail.com>
Reviewed-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2013-04-02 07:40:32 +00:00
|
|
|
struct remote *pushremote_get(const char *name);
|
2017-01-19 21:20:02 +00:00
|
|
|
int remote_is_configured(struct remote *remote, int in_repo);
|
2007-05-12 15:45:53 +00:00
|
|
|
|
2007-07-10 17:48:40 +00:00
|
|
|
typedef int each_remote_fn(struct remote *remote, void *priv);
|
|
|
|
int for_each_remote(each_remote_fn fn, void *priv);
|
|
|
|
|
2007-09-19 04:49:27 +00:00
|
|
|
int remote_has_url(struct remote *remote, const char *url);
|
2007-05-12 15:46:03 +00:00
|
|
|
|
2007-05-12 15:45:59 +00:00
|
|
|
struct refspec {
|
|
|
|
unsigned force : 1;
|
|
|
|
unsigned pattern : 1;
|
2008-04-28 15:32:12 +00:00
|
|
|
unsigned matching : 1;
|
2013-01-29 22:02:15 +00:00
|
|
|
unsigned exact_sha1 : 1;
|
2007-05-12 15:45:59 +00:00
|
|
|
|
2007-07-10 17:48:40 +00:00
|
|
|
char *src;
|
2007-05-12 15:45:59 +00:00
|
|
|
char *dst;
|
|
|
|
};
|
|
|
|
|
2008-04-17 23:32:35 +00:00
|
|
|
extern const struct refspec *tag_refspec;
|
|
|
|
|
2013-07-08 20:56:53 +00:00
|
|
|
struct ref {
|
|
|
|
struct ref *next;
|
2015-11-10 02:22:20 +00:00
|
|
|
struct object_id old_oid;
|
|
|
|
struct object_id new_oid;
|
|
|
|
struct object_id old_oid_expect; /* used by expect-old */
|
2013-07-08 20:56:53 +00:00
|
|
|
char *symref;
|
|
|
|
unsigned int
|
|
|
|
force:1,
|
|
|
|
forced_update:1,
|
2013-07-09 18:01:06 +00:00
|
|
|
expect_old_sha1:1,
|
2017-02-22 16:05:57 +00:00
|
|
|
deletion:1;
|
|
|
|
|
|
|
|
enum {
|
|
|
|
REF_NOT_MATCHED = 0, /* initial value */
|
|
|
|
REF_MATCHED,
|
|
|
|
REF_UNADVERTISED_NOT_ALLOWED
|
|
|
|
} match_status;
|
2013-07-08 20:56:53 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Order is important here, as we write to FETCH_HEAD
|
|
|
|
* in numeric order. And the default NOT_FOR_MERGE
|
|
|
|
* should be 0, so that xcalloc'd structures get it
|
|
|
|
* by default.
|
|
|
|
*/
|
|
|
|
enum {
|
|
|
|
FETCH_HEAD_MERGE = -1,
|
|
|
|
FETCH_HEAD_NOT_FOR_MERGE = 0,
|
|
|
|
FETCH_HEAD_IGNORE = 1
|
|
|
|
} fetch_head_status;
|
|
|
|
|
|
|
|
enum {
|
|
|
|
REF_STATUS_NONE = 0,
|
|
|
|
REF_STATUS_OK,
|
|
|
|
REF_STATUS_REJECT_NONFASTFORWARD,
|
|
|
|
REF_STATUS_REJECT_ALREADY_EXISTS,
|
|
|
|
REF_STATUS_REJECT_NODELETE,
|
|
|
|
REF_STATUS_REJECT_FETCH_FIRST,
|
|
|
|
REF_STATUS_REJECT_NEEDS_FORCE,
|
2013-07-08 21:42:40 +00:00
|
|
|
REF_STATUS_REJECT_STALE,
|
2013-12-05 13:02:40 +00:00
|
|
|
REF_STATUS_REJECT_SHALLOW,
|
2013-07-08 20:56:53 +00:00
|
|
|
REF_STATUS_UPTODATE,
|
|
|
|
REF_STATUS_REMOTE_REJECT,
|
2015-01-08 03:23:22 +00:00
|
|
|
REF_STATUS_EXPECTING_REPORT,
|
|
|
|
REF_STATUS_ATOMIC_PUSH_FAILED
|
2013-07-08 20:56:53 +00:00
|
|
|
} status;
|
|
|
|
char *remote_status;
|
|
|
|
struct ref *peer_ref; /* when renaming */
|
|
|
|
char name[FLEX_ARRAY]; /* more */
|
|
|
|
};
|
|
|
|
|
|
|
|
#define REF_NORMAL (1u << 0)
|
|
|
|
#define REF_HEADS (1u << 1)
|
|
|
|
#define REF_TAGS (1u << 2)
|
|
|
|
|
|
|
|
extern struct ref *find_ref_by_name(const struct ref *list, const char *name);
|
|
|
|
|
2008-10-18 08:44:18 +00:00
|
|
|
struct ref *alloc_ref(const char *name);
|
2011-06-07 23:03:03 +00:00
|
|
|
struct ref *copy_ref(const struct ref *ref);
|
2007-10-30 01:05:40 +00:00
|
|
|
struct ref *copy_ref_list(const struct ref *ref);
|
2012-05-21 22:19:28 +00:00
|
|
|
void sort_ref_list(struct ref **, int (*cmp)(const void *, const void *));
|
push: use remote.$name.push as a refmap
Since f2690487 (fetch: opportunistically update tracking refs,
2013-05-11), we stopped taking a non-storing refspec given on the
command line of "git fetch" literally, and instead started mapping
it via remote.$name.fetch refspecs. This allows
$ git fetch origin master
from the 'origin' repository, which is configured with
[remote "origin"]
fetch = +refs/heads/*:refs/remotes/origin/*
to update refs/remotes/origin/master with the result, as if the
command line were
$ git fetch origin +master:refs/remotes/origin/master
to reduce surprises and improve usability. Before that change, a
refspec on the command line without a colon was only to fetch the
history and leave the result in FETCH_HEAD, without updating the
remote-tracking branches.
When you are simulating a fetch from you by your mothership with a
push by you into your mothership, instead of having:
[remote "satellite"]
fetch = +refs/heads/*:refs/remotes/satellite/*
on the mothership repository and running:
mothership$ git fetch satellite
you would have:
[remote "mothership"]
push = +refs/heads/*:refs/remotes/satellite/*
on your satellite machine, and run:
satellite$ git push mothership
Because we so far did not make the corresponding change to the push
side, this command:
satellite$ git push mothership master
does _not_ allow you on the satellite to only push 'master' out but
still to the usual destination (i.e. refs/remotes/satellite/master).
Implement the logic to map an unqualified refspec given on the
command line via the remote.$name.push refspec. This will bring a
bit more symmetry between "fetch" and "push".
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2013-12-03 23:41:15 +00:00
|
|
|
extern int count_refspec_match(const char *, struct ref *refs, struct ref **matched_ref);
|
2012-05-21 22:19:28 +00:00
|
|
|
int ref_compare_name(const void *, const void *);
|
2007-10-30 01:05:40 +00:00
|
|
|
|
|
|
|
int check_ref_type(const struct ref *ref, int flags);
|
|
|
|
|
2007-07-10 04:47:23 +00:00
|
|
|
/*
|
|
|
|
* Frees the entire list and peers of elements.
|
|
|
|
*/
|
|
|
|
void free_refs(struct ref *ref);
|
|
|
|
|
2017-03-31 01:40:00 +00:00
|
|
|
struct oid_array;
|
2013-07-08 20:56:53 +00:00
|
|
|
extern struct ref **get_remote_heads(int in, char *src_buf, size_t src_len,
|
|
|
|
struct ref **list, unsigned int flags,
|
2017-03-31 01:40:00 +00:00
|
|
|
struct oid_array *extra_have,
|
|
|
|
struct oid_array *shallow);
|
2013-07-08 20:56:53 +00:00
|
|
|
|
2008-04-26 19:53:12 +00:00
|
|
|
int resolve_remote_symref(struct ref *ref, struct ref *list);
|
2015-11-10 02:22:25 +00:00
|
|
|
int ref_newer(const struct object_id *new_oid, const struct object_id *old_oid);
|
2008-04-26 19:53:12 +00:00
|
|
|
|
2007-10-08 04:25:07 +00:00
|
|
|
/*
|
2013-10-30 05:33:09 +00:00
|
|
|
* Remove and free all but the first of any entries in the input list
|
|
|
|
* that map the same remote reference to the same local reference. If
|
|
|
|
* there are two entries that map different remote references to the
|
|
|
|
* same local reference, emit an error message and die. Return a
|
|
|
|
* pointer to the head of the resulting list.
|
2007-10-08 04:25:07 +00:00
|
|
|
*/
|
2013-10-30 05:33:09 +00:00
|
|
|
struct ref *ref_remove_duplicates(struct ref *ref_map);
|
2007-10-08 04:25:07 +00:00
|
|
|
|
2008-04-13 09:56:54 +00:00
|
|
|
int valid_fetch_refspec(const char *refspec);
|
remote.c: Fix overtight refspec validation
We tightened the refspec validation code in an earlier commit ef00d15
(Tighten refspec processing, 2008-03-17) per my suggestion, but the
suggestion was misguided to begin with and it broke this usage:
$ git push origin HEAD~12:master
The syntax of push refspecs and fetch refspecs are similar in that they
are both colon separated LHS and RHS (possibly prefixed with a + to
force), but the similarity ends there. For example, LHS in a push refspec
can be anything that evaluates to a valid object name at runtime (except
when colon and RHS is missing, or it is a glob), while it must be a
valid-looking refname in a fetch refspec. To validate them correctly, the
caller needs to be able to say which kind of refspecs they are. It is
unreasonable to keep a single interface that cannot tell which kind it is
dealing with, and ask it to behave sensibly.
This commit separates the parsing of the two into different functions, and
clarifies the code to implement the parsing proper (i.e. splitting into
two parts, making sure both sides are wildcard or neither side is).
This happens to also allow pushing a commit named with the esoteric "look
for that string" syntax:
$ git push ../test.git ':/remote.c: Fix overtight refspec:master'
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2008-03-21 06:34:37 +00:00
|
|
|
struct refspec *parse_fetch_refspec(int nr_refspec, const char **refspec);
|
2017-04-05 17:47:17 +00:00
|
|
|
extern struct refspec *parse_push_refspec(int nr_refspec, const char **refspec);
|
2007-09-11 03:03:08 +00:00
|
|
|
|
2009-11-18 01:42:28 +00:00
|
|
|
void free_refspec(int nr_refspec, struct refspec *refspec);
|
|
|
|
|
push: use remote.$name.push as a refmap
Since f2690487 (fetch: opportunistically update tracking refs,
2013-05-11), we stopped taking a non-storing refspec given on the
command line of "git fetch" literally, and instead started mapping
it via remote.$name.fetch refspecs. This allows
$ git fetch origin master
from the 'origin' repository, which is configured with
[remote "origin"]
fetch = +refs/heads/*:refs/remotes/origin/*
to update refs/remotes/origin/master with the result, as if the
command line were
$ git fetch origin +master:refs/remotes/origin/master
to reduce surprises and improve usability. Before that change, a
refspec on the command line without a colon was only to fetch the
history and leave the result in FETCH_HEAD, without updating the
remote-tracking branches.
When you are simulating a fetch from you by your mothership with a
push by you into your mothership, instead of having:
[remote "satellite"]
fetch = +refs/heads/*:refs/remotes/satellite/*
on the mothership repository and running:
mothership$ git fetch satellite
you would have:
[remote "mothership"]
push = +refs/heads/*:refs/remotes/satellite/*
on your satellite machine, and run:
satellite$ git push mothership
Because we so far did not make the corresponding change to the push
side, this command:
satellite$ git push mothership master
does _not_ allow you on the satellite to only push 'master' out but
still to the usual destination (i.e. refs/remotes/satellite/master).
Implement the logic to map an unqualified refspec given on the
command line via the remote.$name.push refspec. This will bring a
bit more symmetry between "fetch" and "push".
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2013-12-03 23:41:15 +00:00
|
|
|
extern int query_refspecs(struct refspec *specs, int nr, struct refspec *query);
|
2009-11-18 01:42:28 +00:00
|
|
|
char *apply_refspecs(struct refspec *refspecs, int nr_refspec,
|
|
|
|
const char *name);
|
|
|
|
|
2014-03-05 19:04:54 +00:00
|
|
|
int check_push_refs(struct ref *src, int nr_refspec, const char **refspec);
|
2011-09-09 18:54:58 +00:00
|
|
|
int match_push_refs(struct ref *src, struct ref **dst,
|
|
|
|
int nr_refspec, const char **refspec, int all);
|
2010-01-08 02:12:42 +00:00
|
|
|
void set_ref_status_for_push(struct ref *remote_refs, int send_mirror,
|
|
|
|
int force_update);
|
2007-05-12 15:45:59 +00:00
|
|
|
|
2007-09-11 03:03:08 +00:00
|
|
|
/*
|
|
|
|
* Given a list of the remote refs and the specification of things to
|
|
|
|
* fetch, makes a (separate) list of the refs to fetch and the local
|
|
|
|
* refs to store into.
|
|
|
|
*
|
|
|
|
* *tail is the pointer to the tail pointer of the list of results
|
|
|
|
* beforehand, and will be set to the tail pointer of the list of
|
|
|
|
* results afterward.
|
2007-10-27 06:09:48 +00:00
|
|
|
*
|
|
|
|
* missing_ok is usually false, but when we are adding branch.$name.merge
|
|
|
|
* it is Ok if the branch is not at the remote anymore.
|
2007-09-11 03:03:08 +00:00
|
|
|
*/
|
2007-10-30 01:05:40 +00:00
|
|
|
int get_fetch_map(const struct ref *remote_refs, const struct refspec *refspec,
|
2007-10-27 06:09:48 +00:00
|
|
|
struct ref ***tail, int missing_ok);
|
2007-09-11 03:03:08 +00:00
|
|
|
|
2007-10-30 01:05:40 +00:00
|
|
|
struct ref *get_remote_ref(const struct ref *remote_refs, const char *name);
|
2007-09-11 03:03:08 +00:00
|
|
|
|
2007-05-12 15:46:03 +00:00
|
|
|
/*
|
|
|
|
* For the given remote, reads the refspec's src and sets the other fields.
|
|
|
|
*/
|
|
|
|
int remote_find_tracking(struct remote *remote, struct refspec *refspec);
|
|
|
|
|
2007-09-11 03:02:56 +00:00
|
|
|
struct branch {
|
|
|
|
const char *name;
|
|
|
|
const char *refname;
|
|
|
|
|
|
|
|
const char *remote_name;
|
2015-05-21 04:45:20 +00:00
|
|
|
const char *pushremote_name;
|
2007-09-11 03:02:56 +00:00
|
|
|
|
|
|
|
const char **merge_name;
|
|
|
|
struct refspec **merge;
|
|
|
|
int merge_nr;
|
2008-02-19 04:41:41 +00:00
|
|
|
int merge_alloc;
|
2015-05-21 04:45:36 +00:00
|
|
|
|
|
|
|
const char *push_tracking_ref;
|
2007-09-11 03:02:56 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
struct branch *branch_get(const char *name);
|
2015-05-21 04:45:16 +00:00
|
|
|
const char *remote_for_branch(struct branch *branch, int *explicit);
|
2015-05-21 04:45:20 +00:00
|
|
|
const char *pushremote_for_branch(struct branch *branch, int *explicit);
|
2017-11-07 16:31:08 +00:00
|
|
|
const char *remote_ref_for_branch(struct branch *branch, int for_push,
|
|
|
|
int *explicit);
|
2007-09-11 03:02:56 +00:00
|
|
|
|
|
|
|
int branch_has_merge_config(struct branch *branch);
|
2007-09-18 08:54:53 +00:00
|
|
|
int branch_merge_matches(struct branch *, int n, const char *);
|
2007-09-11 03:02:56 +00:00
|
|
|
|
2015-05-21 04:45:28 +00:00
|
|
|
/**
|
|
|
|
* Return the fully-qualified refname of the tracking branch for `branch`.
|
|
|
|
* I.e., what "branch@{upstream}" would give you. Returns NULL if no
|
|
|
|
* upstream is defined.
|
2015-05-21 04:45:32 +00:00
|
|
|
*
|
|
|
|
* If `err` is not NULL and no upstream is defined, a more specific error
|
|
|
|
* message is recorded there (if the function does not return NULL, then
|
|
|
|
* `err` is not touched).
|
2015-05-21 04:45:28 +00:00
|
|
|
*/
|
2015-05-21 04:45:32 +00:00
|
|
|
const char *branch_get_upstream(struct branch *branch, struct strbuf *err);
|
2015-05-21 04:45:28 +00:00
|
|
|
|
2015-05-21 04:45:36 +00:00
|
|
|
/**
|
|
|
|
* Return the tracking branch that corresponds to the ref we would push to
|
|
|
|
* given a bare `git push` while `branch` is checked out.
|
|
|
|
*
|
|
|
|
* The return value and `err` conventions match those of `branch_get_upstream`.
|
|
|
|
*/
|
|
|
|
const char *branch_get_push(struct branch *branch, struct strbuf *err);
|
|
|
|
|
2007-11-09 23:32:10 +00:00
|
|
|
/* Flags to match_refs. */
|
|
|
|
enum match_refs_flags {
|
|
|
|
MATCH_REFS_NONE = 0,
|
|
|
|
MATCH_REFS_ALL = (1 << 0),
|
2012-02-22 22:43:41 +00:00
|
|
|
MATCH_REFS_MIRROR = (1 << 1),
|
2013-03-04 20:09:50 +00:00
|
|
|
MATCH_REFS_PRUNE = (1 << 2),
|
|
|
|
MATCH_REFS_FOLLOW_TAGS = (1 << 3)
|
2007-11-09 23:32:10 +00:00
|
|
|
};
|
|
|
|
|
2018-01-09 18:50:15 +00:00
|
|
|
/* Flags for --ahead-behind option. */
|
|
|
|
enum ahead_behind_flags {
|
2018-01-09 18:50:16 +00:00
|
|
|
AHEAD_BEHIND_UNSPECIFIED = -1,
|
|
|
|
AHEAD_BEHIND_QUICK = 0, /* just eq/neq reporting */
|
|
|
|
AHEAD_BEHIND_FULL = 1, /* traditional a/b reporting */
|
2018-01-09 18:50:15 +00:00
|
|
|
};
|
|
|
|
|
2008-07-02 07:51:18 +00:00
|
|
|
/* Reporting of tracking info */
|
2015-05-22 00:49:11 +00:00
|
|
|
int stat_tracking_info(struct branch *branch, int *num_ours, int *num_theirs,
|
2018-01-09 18:50:15 +00:00
|
|
|
const char **upstream_name, enum ahead_behind_flags abf);
|
2018-01-09 18:50:18 +00:00
|
|
|
int format_tracking_info(struct branch *branch, struct strbuf *sb,
|
|
|
|
enum ahead_behind_flags abf);
|
2008-07-02 07:51:18 +00:00
|
|
|
|
2009-02-25 08:32:11 +00:00
|
|
|
struct ref *get_local_heads(void);
|
2009-02-25 08:32:13 +00:00
|
|
|
/*
|
2009-02-27 19:10:05 +00:00
|
|
|
* Find refs from a list which are likely to be pointed to by the given HEAD
|
|
|
|
* ref. If 'all' is false, returns the most likely ref; otherwise, returns a
|
|
|
|
* list of all candidate refs. If no match is found (or 'head' is NULL),
|
|
|
|
* returns NULL. All returns are newly allocated and should be freed.
|
2009-02-25 08:32:13 +00:00
|
|
|
*/
|
2009-02-27 19:10:05 +00:00
|
|
|
struct ref *guess_remote_head(const struct ref *head,
|
|
|
|
const struct ref *refs,
|
|
|
|
int all);
|
|
|
|
|
2009-11-10 05:03:31 +00:00
|
|
|
/* Return refs which no longer exist on remote */
|
2011-10-15 05:04:25 +00:00
|
|
|
struct ref *get_stale_heads(struct refspec *refs, int ref_count, struct ref *fetch_map);
|
2009-11-10 05:03:31 +00:00
|
|
|
|
remote.c: add command line option parser for "--force-with-lease"
Update "git push" and "git send-pack" to parse this commnd line
option.
The intended sematics is:
* "--force-with-lease" alone, without specifying the details, will
protect _all_ remote refs that are going to be updated by
requiring their current value to be the same as some reasonable
default, unless otherwise specified;
* "--force-with-lease=refname", without specifying the expected
value, will protect that refname, if it is going to be updated,
by requiring its current value to be the same as some reasonable
default.
* "--force-with-lease=refname:value" will protect that refname, if
it is going to be updated, by requiring its current value to be
the same as the specified value; and
* "--no-force-with-lease" will cancel all the previous --force-with-lease on the
command line.
For now, "some reasonable default" is tentatively defined as "the
value of the remote-tracking branch we have for the ref of the
remote being updated", and it is an error if we do not have such a
remote-tracking branch. But this is known to be fragile, its use is
not yet recommended, and hopefully we will find more reasonable
default as we gain experience with this feature. The manual marks
the feature as experimental unless the expected value is specified
explicitly for this reason.
Because the command line options are parsed _before_ we know which
remote we are pushing to, there needs further processing to the
parsed data after we instantiate the transport object to:
* expand "refname" given by the user to a full refname to be
matched with the list of "struct ref" used in match_push_refs()
and set_ref_status_for_push(); and
* learning the actual local ref that is the remote-tracking branch
for the specified remote ref.
Further, some processing need to be deferred until we find the set
of remote refs and match_push_refs() returns in order to find the
ones that need to be checked after explicit ones have been processed
for "--force-with-lease" (no specific details).
These post-processing will be the topic of the next patch.
This option was originally called "cas" (for "compare and swap"),
the name which nobody liked because it was too technical. The
second attempt called it "lockref" (because it is conceptually like
pushing after taking a lock) but the word "lock" was hated because
it implied that it may reject push by others, which is not the way
this option works. This round calls it "force-with-lease". You
assume you took the lease on the ref when you fetched to decide what
the rebased history should be, and you can push back only if the
lease has not been broken.
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2013-07-08 22:34:36 +00:00
|
|
|
/*
|
|
|
|
* Compare-and-swap
|
|
|
|
*/
|
|
|
|
#define CAS_OPT_NAME "force-with-lease"
|
|
|
|
|
|
|
|
struct push_cas_option {
|
|
|
|
unsigned use_tracking_for_rest:1;
|
|
|
|
struct push_cas {
|
2017-07-13 23:49:21 +00:00
|
|
|
struct object_id expect;
|
remote.c: add command line option parser for "--force-with-lease"
Update "git push" and "git send-pack" to parse this commnd line
option.
The intended sematics is:
* "--force-with-lease" alone, without specifying the details, will
protect _all_ remote refs that are going to be updated by
requiring their current value to be the same as some reasonable
default, unless otherwise specified;
* "--force-with-lease=refname", without specifying the expected
value, will protect that refname, if it is going to be updated,
by requiring its current value to be the same as some reasonable
default.
* "--force-with-lease=refname:value" will protect that refname, if
it is going to be updated, by requiring its current value to be
the same as the specified value; and
* "--no-force-with-lease" will cancel all the previous --force-with-lease on the
command line.
For now, "some reasonable default" is tentatively defined as "the
value of the remote-tracking branch we have for the ref of the
remote being updated", and it is an error if we do not have such a
remote-tracking branch. But this is known to be fragile, its use is
not yet recommended, and hopefully we will find more reasonable
default as we gain experience with this feature. The manual marks
the feature as experimental unless the expected value is specified
explicitly for this reason.
Because the command line options are parsed _before_ we know which
remote we are pushing to, there needs further processing to the
parsed data after we instantiate the transport object to:
* expand "refname" given by the user to a full refname to be
matched with the list of "struct ref" used in match_push_refs()
and set_ref_status_for_push(); and
* learning the actual local ref that is the remote-tracking branch
for the specified remote ref.
Further, some processing need to be deferred until we find the set
of remote refs and match_push_refs() returns in order to find the
ones that need to be checked after explicit ones have been processed
for "--force-with-lease" (no specific details).
These post-processing will be the topic of the next patch.
This option was originally called "cas" (for "compare and swap"),
the name which nobody liked because it was too technical. The
second attempt called it "lockref" (because it is conceptually like
pushing after taking a lock) but the word "lock" was hated because
it implied that it may reject push by others, which is not the way
this option works. This round calls it "force-with-lease". You
assume you took the lease on the ref when you fetched to decide what
the rebased history should be, and you can push back only if the
lease has not been broken.
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2013-07-08 22:34:36 +00:00
|
|
|
unsigned use_tracking:1;
|
|
|
|
char *refname;
|
|
|
|
} *entry;
|
|
|
|
int nr;
|
|
|
|
int alloc;
|
|
|
|
};
|
|
|
|
|
|
|
|
extern int parseopt_push_cas_option(const struct option *, const char *arg, int unset);
|
|
|
|
|
2013-07-09 18:01:06 +00:00
|
|
|
extern int is_empty_cas(const struct push_cas_option *);
|
|
|
|
void apply_push_cas(struct push_cas_option *, struct remote *, struct ref *);
|
|
|
|
|
2018-02-09 20:32:03 +00:00
|
|
|
#define TAG_REFSPEC "refs/tags/*:refs/tags/*"
|
|
|
|
|
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
|
|
|
void add_prune_tags_to_fetch_refspec(struct remote *remote);
|
|
|
|
|
2007-05-12 15:45:53 +00:00
|
|
|
#endif
|