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"
|
2018-05-16 22:58:00 +00:00
|
|
|
#include "refspec.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
|
|
|
|
2021-02-05 20:48:48 +00:00
|
|
|
struct transport_ls_refs_options;
|
|
|
|
|
2019-11-17 21:04:45 +00:00
|
|
|
/**
|
|
|
|
* The API gives access to the configuration related to remotes. It handles
|
|
|
|
* all three configuration mechanisms historically and currently used by Git,
|
|
|
|
* and presents the information in a uniform fashion. Note that the code also
|
|
|
|
* handles plain URLs without any configuration, giving them just the default
|
|
|
|
* information.
|
|
|
|
*/
|
|
|
|
|
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
|
|
|
|
};
|
|
|
|
|
2021-11-18 00:53:22 +00:00
|
|
|
struct rewrite {
|
|
|
|
const char *base;
|
|
|
|
size_t baselen;
|
|
|
|
struct counted_string *instead_of;
|
|
|
|
int instead_of_nr;
|
|
|
|
int instead_of_alloc;
|
|
|
|
};
|
|
|
|
|
|
|
|
struct rewrites {
|
|
|
|
struct rewrite **rewrite;
|
|
|
|
int rewrite_alloc;
|
|
|
|
int rewrite_nr;
|
|
|
|
};
|
|
|
|
|
|
|
|
struct remote_state {
|
|
|
|
struct remote **remotes;
|
|
|
|
int remotes_alloc;
|
|
|
|
int remotes_nr;
|
|
|
|
struct hashmap remotes_hash;
|
|
|
|
|
2021-11-18 00:53:25 +00:00
|
|
|
struct hashmap branches_hash;
|
2021-11-18 00:53:22 +00:00
|
|
|
|
|
|
|
struct branch *current_branch;
|
|
|
|
const char *pushremote_name;
|
|
|
|
|
|
|
|
struct rewrites rewrites;
|
|
|
|
struct rewrites rewrites_push;
|
2021-11-18 00:53:23 +00:00
|
|
|
|
|
|
|
int initialized;
|
2021-11-18 00:53:22 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
void remote_state_clear(struct remote_state *remote_state);
|
|
|
|
struct remote_state *remote_state_new(void);
|
|
|
|
|
2007-05-12 15:45:53 +00:00
|
|
|
struct remote {
|
2019-10-06 23:30:43 +00:00
|
|
|
struct hashmap_entry ent;
|
2014-07-29 14:43:39 +00:00
|
|
|
|
2019-11-17 21:04:45 +00:00
|
|
|
/* The user's nickname for the remote */
|
2007-05-12 15:45:53 +00:00
|
|
|
const char *name;
|
2019-11-17 21:04:45 +00:00
|
|
|
|
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;
|
|
|
|
|
2019-11-17 21:04:45 +00:00
|
|
|
/* An array of all of the url_nr URLs configured for the remote */
|
2007-09-19 04:49:27 +00:00
|
|
|
const char **url;
|
2019-11-17 21:04:45 +00:00
|
|
|
|
2007-09-19 04:49:27 +00:00
|
|
|
int url_nr;
|
2008-02-19 04:41:41 +00:00
|
|
|
int url_alloc;
|
2007-05-12 15:45:53 +00:00
|
|
|
|
2019-11-17 21:04:45 +00:00
|
|
|
/* An array of all of the pushurl_nr push URLs configured for the remote */
|
2009-06-09 16:01:34 +00:00
|
|
|
const char **pushurl;
|
2019-11-17 21:04:45 +00:00
|
|
|
|
2009-06-09 16:01:34 +00:00
|
|
|
int pushurl_nr;
|
|
|
|
int pushurl_alloc;
|
|
|
|
|
2018-05-16 22:58:00 +00:00
|
|
|
struct refspec push;
|
2007-05-12 15:45:53 +00:00
|
|
|
|
2018-05-16 22:58:01 +00:00
|
|
|
struct refspec fetch;
|
2007-05-12 15:46:03 +00:00
|
|
|
|
2007-09-11 03:03:08 +00:00
|
|
|
/*
|
2019-11-17 21:04:45 +00:00
|
|
|
* The setting for whether to fetch tags (as a separate rule from the
|
|
|
|
* configured refspecs);
|
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;
|
2019-11-17 21:04:45 +00:00
|
|
|
|
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
|
|
|
|
2019-11-17 21:04:45 +00:00
|
|
|
/**
|
|
|
|
* The configured helper programs to run on the remote side, for
|
|
|
|
* Git-native protocols.
|
|
|
|
*/
|
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
|
|
|
|
2019-11-17 21:04:45 +00:00
|
|
|
/* The proxy to use for curl (http, https, ftp, etc.) URLs. */
|
2007-12-03 21:48:54 +00:00
|
|
|
char *http_proxy;
|
2019-11-17 21:04:45 +00:00
|
|
|
|
|
|
|
/* The method used for authenticating against `http_proxy`. */
|
2016-01-26 13:02:47 +00:00
|
|
|
char *http_proxy_authmethod;
|
2007-05-12 15:45:53 +00:00
|
|
|
};
|
|
|
|
|
2019-11-17 21:04:45 +00:00
|
|
|
/**
|
|
|
|
* struct remotes can be found by name with remote_get().
|
|
|
|
* remote_get(NULL) will return the default remote, given the current branch
|
|
|
|
* and configuration.
|
|
|
|
*/
|
2007-05-12 15:45:53 +00:00
|
|
|
struct remote *remote_get(const char *name);
|
2019-11-17 21:04:45 +00:00
|
|
|
|
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);
|
2019-11-17 21:04:45 +00:00
|
|
|
|
|
|
|
/* iterate through struct remotes */
|
2007-07-10 17:48:40 +00:00
|
|
|
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
|
|
|
|
receive-pack: add new proc-receive hook
Git calls an internal `execute_commands` function to handle commands
sent from client to `git-receive-pack`. Regardless of what references
the user pushes, git creates or updates the corresponding references if
the user has write-permission. A contributor who has no
write-permission, cannot push to the repository directly. So, the
contributor has to write commits to an alternate location, and sends
pull request by emails or by other ways. We call this workflow as a
distributed workflow.
It would be more convenient to work in a centralized workflow like what
Gerrit provided for some cases. For example, a read-only user who
cannot push to a branch directly can run the following `git push`
command to push commits to a pseudo reference (has a prefix "refs/for/",
not "refs/heads/") to create a code review.
git push origin \
HEAD:refs/for/<branch-name>/<session>
The `<branch-name>` in the above example can be as simple as "master",
or a more complicated branch name like "foo/bar". The `<session>` in
the above example command can be the local branch name of the client
side, such as "my/topic".
We cannot implement a centralized workflow elegantly by using
"pre-receive" + "post-receive", because Git will call the internal
function "execute_commands" to create references (even the special
pseudo reference) between these two hooks. Even though we can delete
the temporarily created pseudo reference via the "post-receive" hook,
having a temporary reference is not safe for concurrent pushes.
So, add a filter and a new handler to support this kind of workflow.
The filter will check the prefix of the reference name, and if the
command has a special reference name, the filter will turn a specific
field (`run_proc_receive`) on for the command. Commands with this filed
turned on will be executed by a new handler (a hook named
"proc-receive") instead of the internal `execute_commands` function.
We can use this "proc-receive" command to create pull requests or send
emails for code review.
Suggested by Junio, this "proc-receive" hook reads the commands,
push-options (optional), and send result using a protocol in pkt-line
format. In the following example, the letter "S" stands for
"receive-pack" and letter "H" stands for the hook.
# Version and features negotiation.
S: PKT-LINE(version=1\0push-options atomic...)
S: flush-pkt
H: PKT-LINE(version=1\0push-options...)
H: flush-pkt
# Send commands from server to the hook.
S: PKT-LINE(<old-oid> <new-oid> <ref>)
S: ... ...
S: flush-pkt
# Send push-options only if the 'push-options' feature is enabled.
S: PKT-LINE(push-option)
S: ... ...
S: flush-pkt
# Receive result from the hook.
# OK, run this command successfully.
H: PKT-LINE(ok <ref>)
# NO, I reject it.
H: PKT-LINE(ng <ref> <reason>)
# Fall through, let 'receive-pack' to execute it.
H: PKT-LINE(ok <ref>)
H: PKT-LINE(option fall-through)
# OK, but has an alternate reference. The alternate reference name
# and other status can be given in options
H: PKT-LINE(ok <ref>)
H: PKT-LINE(option refname <refname>)
H: PKT-LINE(option old-oid <old-oid>)
H: PKT-LINE(option new-oid <new-oid>)
H: PKT-LINE(option forced-update)
H: ... ...
H: flush-pkt
After receiving a command, the hook will execute the command, and may
create/update different reference. For example, a command for a pseudo
reference "refs/for/master/topic" may create/update different reference
such as "refs/pull/123/head". The alternate reference name and other
status are given in option lines.
The list of commands returned from "proc-receive" will replace the
relevant commands that are sent from user to "receive-pack", and
"receive-pack" will continue to run the "execute_commands" function and
other routines. Finally, the result of the execution of these commands
will be reported to end user.
The reporting function from "receive-pack" to "send-pack" will be
extended in latter commit just like what the "proc-receive" hook reports
to "receive-pack".
Signed-off-by: Jiang Xin <zhiyou.jx@alibaba-inc.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2020-08-27 15:45:44 +00:00
|
|
|
struct ref_push_report {
|
|
|
|
const char *ref_name;
|
|
|
|
struct object_id *old_oid;
|
|
|
|
struct object_id *new_oid;
|
|
|
|
unsigned int forced_update:1;
|
|
|
|
struct ref_push_report *next;
|
|
|
|
};
|
|
|
|
|
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;
|
2020-10-03 12:10:44 +00:00
|
|
|
char *tracking_ref;
|
2013-07-08 20:56:53 +00:00
|
|
|
unsigned int
|
|
|
|
force:1,
|
|
|
|
forced_update:1,
|
2013-07-09 18:01:06 +00:00
|
|
|
expect_old_sha1:1,
|
2018-06-27 22:30:23 +00:00
|
|
|
exact_oid:1,
|
2020-10-03 12:10:44 +00:00
|
|
|
deletion:1,
|
|
|
|
/* Need to check if local reflog reaches the remote tip. */
|
|
|
|
check_reachable:1,
|
|
|
|
/*
|
|
|
|
* Store the result of the check enabled by "check_reachable";
|
|
|
|
* implies the local reflog does not reach the remote tip.
|
|
|
|
*/
|
|
|
|
unreachable:1;
|
2017-02-22 16:05:57 +00:00
|
|
|
|
|
|
|
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.
|
|
|
|
*/
|
2021-01-12 12:27:35 +00:00
|
|
|
enum fetch_head_status {
|
2013-07-08 20:56:53 +00:00
|
|
|
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,
|
2020-10-03 12:10:44 +00:00
|
|
|
REF_STATUS_REJECT_REMOTE_UPDATED,
|
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;
|
2020-08-27 15:45:46 +00:00
|
|
|
struct ref_push_report *report;
|
2013-07-08 20:56:53 +00:00
|
|
|
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)
|
|
|
|
|
2019-04-29 08:28:14 +00:00
|
|
|
struct ref *find_ref_by_name(const struct ref *list, const char *name);
|
2013-07-08 20:56:53 +00:00
|
|
|
|
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);
|
2019-04-29 08:28:14 +00:00
|
|
|
int count_refspec_match(const char *, struct ref *refs, struct ref **matched_ref);
|
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
|
|
|
/*
|
2019-04-13 05:54:31 +00:00
|
|
|
* Free a single ref and its peer, or an entire list of refs and their peers,
|
|
|
|
* respectively.
|
2007-07-10 04:47:23 +00:00
|
|
|
*/
|
2019-04-13 05:54:31 +00:00
|
|
|
void free_one_ref(struct ref *ref);
|
2007-07-10 04:47:23 +00:00
|
|
|
void free_refs(struct ref *ref);
|
|
|
|
|
2017-03-31 01:40:00 +00:00
|
|
|
struct oid_array;
|
2018-03-14 18:31:45 +00:00
|
|
|
struct packet_reader;
|
argv-array: rename to strvec
The name "argv-array" isn't very good, because it describes what the
data type can be used for (program argument arrays), not what it
actually is (a dynamically-growing string array that maintains a
NULL-terminator invariant). This leads to people being hesitant to use
it for other cases where it would actually be a good fit. The existing
name is also clunky to use. It's overly long, and the name often leads
to saying things like "argv.argv" (i.e., the field names overlap with
variable names, since they're describing the use, not the type). Let's
give it a more neutral name.
I settled on "strvec" because "vector" is the name for a dynamic array
type in many programming languages. "strarray" would work, too, but it's
longer and a bit more awkward to say (and don't we all say these things
in our mind as we type them?).
A more extreme direction would be a generic data structure which stores
a NULL-terminated of _any_ type. That would be easy to do with void
pointers, but we'd lose some type safety for the existing cases. Plus it
raises questions about memory allocation and ownership. So I limited
myself here to changing names only, and not semantics. If we do find a
use for that more generic data type, we could perhaps implement it at a
lower level and then provide type-safe wrappers around it for strings.
But that can come later.
This patch does the minimum to convert the struct and function names in
the header and implementation, leaving a few things for follow-on
patches:
- files retain their original names for now
- struct field names are retained for now
- there's a preprocessor compat layer that lets most users remain the
same for now. The exception is headers which made a manual forward
declaration of the struct. I've converted them (and their dependent
function declarations) here.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2020-07-28 20:23:25 +00:00
|
|
|
struct strvec;
|
2018-04-23 22:46:23 +00:00
|
|
|
struct string_list;
|
2019-04-29 08:28:14 +00:00
|
|
|
struct ref **get_remote_heads(struct packet_reader *reader,
|
2019-04-29 08:28:23 +00:00
|
|
|
struct ref **list, unsigned int flags,
|
|
|
|
struct oid_array *extra_have,
|
|
|
|
struct oid_array *shallow_points);
|
2013-07-08 20:56:53 +00:00
|
|
|
|
2018-03-15 17:31:21 +00:00
|
|
|
/* Used for protocol v2 in order to retrieve refs from a remote */
|
2019-04-29 08:28:14 +00:00
|
|
|
struct ref **get_remote_refs(int fd_out, struct packet_reader *reader,
|
2019-04-29 08:28:23 +00:00
|
|
|
struct ref **list, int for_push,
|
2021-02-05 20:48:48 +00:00
|
|
|
struct transport_ls_refs_options *transport_options,
|
2020-05-19 10:54:00 +00:00
|
|
|
const struct string_list *server_options,
|
|
|
|
int stateless_rpc);
|
2013-07-08 20:56:53 +00:00
|
|
|
|
2022-12-22 15:14:09 +00:00
|
|
|
/* Used for protocol v2 in order to retrieve refs from a remote */
|
|
|
|
struct bundle_list;
|
|
|
|
int get_remote_bundle_uri(int fd_out, struct packet_reader *reader,
|
|
|
|
struct bundle_list *bundles, int stateless_rpc);
|
|
|
|
|
2008-04-26 19:53:12 +00:00
|
|
|
int resolve_remote_symref(struct ref *ref, struct ref *list);
|
|
|
|
|
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
|
|
|
|
2022-06-17 00:20:31 +00:00
|
|
|
/*
|
|
|
|
* Check whether a name matches any negative refspec in rs. Returns 1 if the
|
|
|
|
* name matches at least one negative refspec, and 0 otherwise.
|
|
|
|
*/
|
|
|
|
int omit_name_by_refspec(const char *name, struct refspec *rs);
|
|
|
|
|
refspec: add support for negative refspecs
Both fetch and push support pattern refspecs which allow fetching or
pushing references that match a specific pattern. Because these patterns
are globs, they have somewhat limited ability to express more complex
situations.
For example, suppose you wish to fetch all branches from a remote except
for a specific one. To allow this, you must setup a set of refspecs
which match only the branches you want. Because refspecs are either
explicit name matches, or simple globs, many patterns cannot be
expressed.
Add support for a new type of refspec, referred to as "negative"
refspecs. These are prefixed with a '^' and mean "exclude any ref
matching this refspec". They can only have one "side" which always
refers to the source. During a fetch, this refers to the name of the ref
on the remote. During a push, this refers to the name of the ref on the
local side.
With negative refspecs, users can express more complex patterns. For
example:
git fetch origin refs/heads/*:refs/remotes/origin/* ^refs/heads/dontwant
will fetch all branches on origin into remotes/origin, but will exclude
fetching the branch named dontwant.
Refspecs today are commutative, meaning that order doesn't expressly
matter. Rather than forcing an implied order, negative refspecs will
always be applied last. That is, in order to match, a ref must match at
least one positive refspec, and match none of the negative refspecs.
This is similar to how negative pathspecs work.
Signed-off-by: Jacob Keller <jacob.keller@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2020-09-30 21:25:29 +00:00
|
|
|
/*
|
|
|
|
* Remove all entries in the input list which match any negative refspec in
|
|
|
|
* the refspec list.
|
|
|
|
*/
|
|
|
|
struct ref *apply_negative_refspecs(struct ref *ref_map, struct refspec *rs);
|
|
|
|
|
2018-05-16 22:58:12 +00:00
|
|
|
int query_refspecs(struct refspec *rs, struct refspec_item *query);
|
2018-05-16 22:58:11 +00:00
|
|
|
char *apply_refspecs(struct refspec *rs, const char *name);
|
2007-09-11 03:03:08 +00:00
|
|
|
|
2018-05-16 22:58:22 +00:00
|
|
|
int check_push_refs(struct ref *src, struct refspec *rs);
|
2011-09-09 18:54:58 +00:00
|
|
|
int match_push_refs(struct ref *src, struct ref **dst,
|
2018-05-16 22:58:21 +00:00
|
|
|
struct refspec *rs, int flags);
|
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
|
refspec: add support for negative refspecs
Both fetch and push support pattern refspecs which allow fetching or
pushing references that match a specific pattern. Because these patterns
are globs, they have somewhat limited ability to express more complex
situations.
For example, suppose you wish to fetch all branches from a remote except
for a specific one. To allow this, you must setup a set of refspecs
which match only the branches you want. Because refspecs are either
explicit name matches, or simple globs, many patterns cannot be
expressed.
Add support for a new type of refspec, referred to as "negative"
refspecs. These are prefixed with a '^' and mean "exclude any ref
matching this refspec". They can only have one "side" which always
refers to the source. During a fetch, this refers to the name of the ref
on the remote. During a push, this refers to the name of the ref on the
local side.
With negative refspecs, users can express more complex patterns. For
example:
git fetch origin refs/heads/*:refs/remotes/origin/* ^refs/heads/dontwant
will fetch all branches on origin into remotes/origin, but will exclude
fetching the branch named dontwant.
Refspecs today are commutative, meaning that order doesn't expressly
matter. Rather than forcing an implied order, negative refspecs will
always be applied last. That is, in order to match, a ref must match at
least one positive refspec, and match none of the negative refspecs.
This is similar to how negative pathspecs work.
Signed-off-by: Jacob Keller <jacob.keller@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2020-09-30 21:25:29 +00:00
|
|
|
* refs to store into. Note that negative refspecs are ignored here, and
|
|
|
|
* should be handled separately.
|
2007-09-11 03:03:08 +00:00
|
|
|
*
|
|
|
|
* *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
|
|
|
*/
|
2018-05-16 22:57:49 +00:00
|
|
|
int get_fetch_map(const struct ref *remote_refs, const struct refspec_item *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.
|
|
|
|
*/
|
2018-05-16 22:57:49 +00:00
|
|
|
int remote_find_tracking(struct remote *remote, struct refspec_item *refspec);
|
2007-05-12 15:46:03 +00:00
|
|
|
|
2019-11-17 21:04:45 +00:00
|
|
|
/**
|
|
|
|
* struct branch holds the configuration for a branch. It can be looked up with
|
|
|
|
* branch_get(name) for "refs/heads/{name}", or with branch_get(NULL) for HEAD.
|
|
|
|
*/
|
2007-09-11 03:02:56 +00:00
|
|
|
struct branch {
|
2021-11-18 00:53:25 +00:00
|
|
|
struct hashmap_entry ent;
|
2019-11-17 21:04:45 +00:00
|
|
|
|
|
|
|
/* The short name of the branch. */
|
2007-09-11 03:02:56 +00:00
|
|
|
const char *name;
|
2019-11-17 21:04:45 +00:00
|
|
|
|
|
|
|
/* The full path for the branch ref. */
|
2007-09-11 03:02:56 +00:00
|
|
|
const char *refname;
|
|
|
|
|
2019-11-17 21:04:45 +00:00
|
|
|
/* The name of the remote listed in the configuration. */
|
2007-09-11 03:02:56 +00:00
|
|
|
const char *remote_name;
|
2019-11-17 21:04:45 +00:00
|
|
|
|
2015-05-21 04:45:20 +00:00
|
|
|
const char *pushremote_name;
|
2007-09-11 03:02:56 +00:00
|
|
|
|
2019-11-17 21:04:45 +00:00
|
|
|
/* An array of the "merge" lines in the configuration. */
|
2007-09-11 03:02:56 +00:00
|
|
|
const char **merge_name;
|
2019-11-17 21:04:45 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* An array of the struct refspecs used for the merge lines. That is,
|
|
|
|
* merge[i]->dst is a local tracking ref which should be merged into this
|
|
|
|
* branch by default.
|
|
|
|
*/
|
2018-05-16 22:57:49 +00:00
|
|
|
struct refspec_item **merge;
|
2019-11-17 21:04:45 +00:00
|
|
|
|
|
|
|
/* The number of merge configurations */
|
2007-09-11 03:02:56 +00:00
|
|
|
int merge_nr;
|
2019-11-17 21:04:45 +00:00
|
|
|
|
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);
|
2020-03-03 16:12:22 +00:00
|
|
|
const char *remote_ref_for_branch(struct branch *branch, int for_push);
|
2007-09-11 03:02:56 +00:00
|
|
|
|
2019-11-17 21:04:45 +00:00
|
|
|
/* returns true if the given branch has merge configuration given. */
|
2007-09-11 03:02:56 +00:00
|
|
|
int branch_has_merge_config(struct branch *branch);
|
2019-11-17 21:04:45 +00:00
|
|
|
|
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,
|
2019-04-16 12:16:46 +00:00
|
|
|
const char **upstream_name, int for_push,
|
|
|
|
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 */
|
2018-05-16 22:58:10 +00:00
|
|
|
struct ref *get_stale_heads(struct refspec *rs, 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;
|
2020-10-03 12:10:44 +00:00
|
|
|
unsigned use_force_if_includes:1;
|
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
|
|
|
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;
|
|
|
|
};
|
|
|
|
|
2019-04-29 08:28:14 +00:00
|
|
|
int parseopt_push_cas_option(const struct option *, const char *arg, int unset);
|
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
|
|
|
|
2019-04-29 08:28:14 +00:00
|
|
|
int is_empty_cas(const struct push_cas_option *);
|
2013-07-09 18:01:06 +00:00
|
|
|
void apply_push_cas(struct push_cas_option *, struct remote *, struct ref *);
|
|
|
|
|
2022-05-16 20:11:03 +00:00
|
|
|
/*
|
|
|
|
* The `url` argument is the URL that navigates to the submodule origin
|
|
|
|
* repo. When relative, this URL is relative to the superproject origin
|
|
|
|
* URL repo. The `up_path` argument, if specified, is the relative
|
|
|
|
* path that navigates from the submodule working tree to the superproject
|
|
|
|
* working tree. Returns the origin URL of the submodule.
|
|
|
|
*
|
|
|
|
* Return either an absolute URL or filesystem path (if the superproject
|
|
|
|
* origin URL is an absolute URL or filesystem path, respectively) or a
|
|
|
|
* relative file system path (if the superproject origin URL is a relative
|
|
|
|
* file system path).
|
|
|
|
*
|
|
|
|
* When the output is a relative file system path, the path is either
|
|
|
|
* relative to the submodule working tree, if up_path is specified, or to
|
|
|
|
* the superproject working tree otherwise.
|
|
|
|
*
|
|
|
|
* NEEDSWORK: This works incorrectly on the domain and protocol part.
|
|
|
|
* remote_url url outcome expectation
|
|
|
|
* http://a.com/b ../c http://a.com/c as is
|
|
|
|
* http://a.com/b/ ../c http://a.com/c same as previous line, but
|
|
|
|
* ignore trailing slash in url
|
|
|
|
* http://a.com/b ../../c http://c error out
|
|
|
|
* http://a.com/b ../../../c http:/c error out
|
|
|
|
* http://a.com/b ../../../../c http:c error out
|
|
|
|
* http://a.com/b ../../../../../c .:c error out
|
2022-05-16 20:11:04 +00:00
|
|
|
* http://a.com/b http://d.org/e http://d.org/e as is
|
2022-05-16 20:11:03 +00:00
|
|
|
* NEEDSWORK: Given how chop_last_dir() works, this function is broken
|
|
|
|
* when a local part has a colon in its path component, too.
|
|
|
|
*/
|
|
|
|
char *relative_url(const char *remote_url, const char *url,
|
|
|
|
const char *up_path);
|
|
|
|
|
2007-05-12 15:45:53 +00:00
|
|
|
#endif
|